< Summary

Information
Class: Gravitas.Queries.SweptSphereQueryWorker
Assembly: Gravitas
File(s): /home/runner/work/Gravitas/Gravitas/src/Gravitas/Queries/3D/Sweeps/SweptSphereQueryWorker.cs
Line coverage
100%
Covered lines: 296
Uncovered lines: 0
Coverable lines: 296
Total lines: 521
Line coverage: 100%
Branch coverage
100%
Covered branches: 64
Total branches: 64
Branch coverage: 100%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.cctor()100%11100%
.ctor()100%11100%
Prepare(...)100%66100%
TrySweep(...)100%2222100%
TrySweepSphere(...)100%11100%
TrySweepSphere(...)100%22100%
TrySweepCapsule(...)100%22100%
TrySweepCylinder(...)100%11100%
TrySweepCone(...)100%11100%
TrySweepCanonicalFiniteAxis(...)100%44100%
TrySweepCuboid(...)100%22100%
TrySweepMesh(...)100%88100%
TrySweepCompound(...)100%22100%
TrySweepTriangle(...)100%22100%
TrySweepTriangleFace(...)100%88100%
TrySweepTriangleEdge(...)100%22100%
BuildFiniteAxisSweepHit(...)100%11100%
TryKeepEarlierSweep(...)100%44100%
CreateSweepBounds(...)100%11100%

File(s)

/home/runner/work/Gravitas/Gravitas/src/Gravitas/Queries/3D/Sweeps/SweptSphereQueryWorker.cs

#LineLine coverage
 1//=======================================================================
 2// SweptSphereQueryWorker.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;
 9using FixedMathSharp.Geometry;
 10using Gravitas.Colliders;
 11using Gravitas.CollisionHandling;
 12using SwiftCollections;
 13using SwiftCollections.Query;
 14
 15namespace Gravitas.Queries;
 16
 17/// <summary>
 18/// Performs deterministic swept-sphere checks for one prepared segment.
 19/// </summary>
 20public sealed class SweptSphereQueryWorker
 21{
 122    private static readonly Fixed64 BoundsTolerance = Fixed64.FromFraction(1, 4096);
 23
 1020124    private readonly SwiftList<int> _meshTriangleBuffer = new();
 1020125    private readonly ConvexSweepQueryWorker _finiteAxisConvexSweep = new();
 26
 27    private Vector3d _start;
 28    private Vector3d _end;
 29    private Vector3d _direction;
 30    private Vector3d _sweptBoundsMin;
 31    private Vector3d _sweptBoundsMax;
 32    private Fixed64 _length;
 33    private Fixed64 _lengthSqr;
 34    private Fixed64 _radius;
 35    private int _sweepDepth;
 36
 37    internal int LastMeshTriangleCandidateCount { get; private set; }
 38
 39    /// <summary>
 40    /// Prepares this worker for a swept sphere from <paramref name="start"/> to <paramref name="end"/>.
 41    /// </summary>
 42    public void Prepare(Vector3d start, Vector3d end, Fixed64 radius)
 43    {
 1446544        _start = start;
 1446545        _end = end;
 1446546        _radius = radius;
 47
 1446548        if (!Vector3d.TrySubtract(end, start, out Vector3d segment)
 1446549            || !Vector3d.TryGetMagnitude(segment, out _length))
 50        {
 251            _length = Fixed64.Zero;
 252            _lengthSqr = Fixed64.Zero;
 253            _direction = Vector3d.Zero;
 254            return;
 55        }
 56
 1446357        _lengthSqr = segment.MagnitudeSquared;
 1446358        _direction = _length <= Fixed64.Epsilon ? Vector3d.Zero : segment.Normalized;
 1446359        SweepBoundsUtility.CreateSweptSphereBounds(
 1446360            start,
 1446361            end,
 1446362            radius,
 1446363            BoundsTolerance,
 1446364            out _sweptBoundsMin,
 1446365            out _sweptBoundsMax);
 1446366        _finiteAxisConvexSweep.PrepareSphereSource(
 1446367            start,
 1446368            radius,
 1446369            segment);
 1446370    }
 71
 72    /// <summary>
 73    /// Checks a collider against the prepared swept sphere.
 74    /// </summary>
 75    public bool TrySweep(
 76        LSCollider collider,
 77        out Vector3d sphereCenterAtImpact,
 78        out Fixed64 impactDistance)
 79    {
 965280        if (_sweepDepth == 0)
 962381            LastMeshTriangleCandidateCount = 0;
 82
 965283        _sweepDepth++;
 965284        sphereCenterAtImpact = Vector3d.Zero;
 965285        impactDistance = Fixed64.Zero;
 86
 87        try
 88        {
 965289            if (_length <= Fixed64.Epsilon
 965290                || !SweepBoundsUtility.OverlapsInclusive(_sweptBoundsMin, _sweptBoundsMax, collider.BoundsMin, collider.
 91            {
 192492                return false;
 93            }
 94
 772895            bool found = collider switch
 772896            {
 670197                LSSphereCollider sphere => TrySweepSphere(sphere.Center, sphere.ScaledRadius, _radius, out sphereCenterA
 2498                LSCapsuleCollider capsule => TrySweepCapsule(capsule, out sphereCenterAtImpact, out impactDistance),
 65099                LSCuboidCollider cuboid => TrySweepCuboid(cuboid, out sphereCenterAtImpact, out impactDistance),
 34100                LSCylinderCollider cylinder => TrySweepCylinder(cylinder, out sphereCenterAtImpact, out impactDistance),
 19101                LSConeCollider cone => TrySweepCone(cone, out sphereCenterAtImpact, out impactDistance),
 277102                LSMeshCollider mesh => TrySweepMesh(mesh, out sphereCenterAtImpact, out impactDistance),
 18103                LSCompoundCollider compound => TrySweepCompound(compound, out sphereCenterAtImpact, out impactDistance),
 5104                _ => false
 7728105            };
 106
 7728107            if (!found)
 108            {
 90109                sphereCenterAtImpact = Vector3d.Zero;
 90110                impactDistance = Fixed64.Zero;
 111            }
 112
 7728113            return found;
 114        }
 115        finally
 116        {
 9652117            _sweepDepth--;
 9652118        }
 9652119    }
 120
 121    private bool TrySweepSphere(
 122        Vector3d center,
 123        Fixed64 radius,
 124        Fixed64 radiusExpansion,
 125        out Vector3d sphereCenterAtImpact,
 126        out Fixed64 impactDistance) =>
 6701127        TrySweepSphere(
 6701128            _start,
 6701129            _end,
 6701130            _length,
 6701131            center,
 6701132            radius,
 6701133            radiusExpansion,
 6701134            out sphereCenterAtImpact,
 6701135            out impactDistance);
 136
 137    private static bool TrySweepSphere(
 138        Vector3d start,
 139        Vector3d end,
 140        Fixed64 length,
 141        Vector3d center,
 142        Fixed64 radius,
 143        Fixed64 radiusExpansion,
 144        out Vector3d sphereCenterAtImpact,
 145        out Fixed64 impactDistance)
 146    {
 7724147        sphereCenterAtImpact = Vector3d.Zero;
 7724148        impactDistance = Fixed64.Zero;
 149
 7724150        var query = new FixedSegment(start, end);
 7724151        if (!query.TryGetSphereIntersectionDistanceInterval(
 7724152                new FixedBoundSphere(center, radius),
 7724153                radiusExpansion,
 7724154                length,
 7724155                out Fixed64 distance,
 7724156                out _,
 7724157                out _,
 7724158                out _))
 1060159            return false;
 160
 6664161        impactDistance = distance;
 6664162        sphereCenterAtImpact = query.GetPointAtDistance(distance, length);
 6664163        return true;
 164    }
 165
 166    private bool TrySweepCapsule(
 167        LSCapsuleCollider capsule,
 168        out Vector3d sphereCenterAtImpact,
 169        out Fixed64 impactDistance)
 170    {
 24171        sphereCenterAtImpact = Vector3d.Zero;
 24172        impactDistance = Fixed64.Zero;
 173
 24174        var query = new FixedSegment(_start, _end);
 24175        if (!query.TryGetCapsuleIntersectionDistanceInterval(
 24176                capsule.Center,
 24177                capsule.Rotation,
 24178                capsule.AxisLength,
 24179                capsule.ScaledRadius,
 24180                _radius,
 24181                _length,
 24182                out Fixed64 entry,
 24183                out _,
 24184                out _,
 24185                out _))
 186        {
 2187            return false;
 188        }
 189
 22190        BuildFiniteAxisSweepHit(entry, out sphereCenterAtImpact, out impactDistance);
 22191        return true;
 192    }
 193
 194    private bool TrySweepCylinder(
 195        LSCylinderCollider cylinder,
 196        out Vector3d sphereCenterAtImpact,
 197        out Fixed64 impactDistance) =>
 34198        TrySweepCanonicalFiniteAxis(
 34199            cylinder,
 34200            out sphereCenterAtImpact,
 34201            out impactDistance);
 202
 203    private bool TrySweepCone(
 204        LSConeCollider cone,
 205        out Vector3d sphereCenterAtImpact,
 206        out Fixed64 impactDistance) =>
 19207        TrySweepCanonicalFiniteAxis(
 19208            cone,
 19209            out sphereCenterAtImpact,
 19210            out impactDistance);
 211
 212    private bool TrySweepCanonicalFiniteAxis(
 213        LSCollider target,
 214        out Vector3d sphereCenterAtImpact,
 215        out Fixed64 impactDistance)
 216    {
 53217        sphereCenterAtImpact = Vector3d.Zero;
 53218        impactDistance = Fixed64.Zero;
 53219        if (!_finiteAxisConvexSweep.TrySweepPreparedSource(
 53220                target,
 53221                out Physics3DHit hit))
 222        {
 11223            return false;
 224        }
 225
 42226        Fixed64 distance = _length - hit.Distance <= BoundsTolerance
 42227            ? _length
 42228            : hit.Distance;
 42229        BuildFiniteAxisSweepHit(
 42230            distance,
 42231            out sphereCenterAtImpact,
 42232            out impactDistance);
 42233        return true;
 234    }
 235
 236    private bool TrySweepCuboid(
 237        LSCuboidCollider cuboid,
 238        out Vector3d sphereCenterAtImpact,
 239        out Fixed64 impactDistance)
 240    {
 650241        sphereCenterAtImpact = Vector3d.Zero;
 650242        impactDistance = Fixed64.Zero;
 243
 650244        var query = new FixedSegment(_start, _end);
 650245        if (!query.TryGetSweptSphereOrientedBoxIntersectionDistance(
 650246                cuboid.OrientedBox,
 650247                _radius,
 650248                _length,
 650249                out Fixed64 entry))
 250        {
 12251            return false;
 252        }
 253
 638254        BuildFiniteAxisSweepHit(entry, out sphereCenterAtImpact, out impactDistance);
 638255        return true;
 256    }
 257
 258    private bool TrySweepMesh(
 259        LSMeshCollider mesh,
 260        out Vector3d sphereCenterAtImpact,
 261        out Fixed64 impactDistance)
 262    {
 277263        sphereCenterAtImpact = Vector3d.Zero;
 277264        impactDistance = Fixed64.MaxValue;
 265
 277266        CreateSweepBounds(_start, _end, _radius, out Vector3d min, out Vector3d max);
 277267        mesh.GetTrianglesInBounds(new FixedBoundVolume(min, max), _meshTriangleBuffer);
 277268        LastMeshTriangleCandidateCount += _meshTriangleBuffer.Count;
 269
 277270        var startAnchor = new FixedPointAnchor(
 277271            _start,
 277272            FixedQuaternion.Identity,
 277273            Vector3d.Zero);
 277274        var endAnchor = new FixedPointAnchor(
 277275            _end,
 277276            FixedQuaternion.Identity,
 277277            Vector3d.Zero);
 277278        if (!startAnchor.TryGetLocalPointIn(
 277279                mesh.Mesh.Origin,
 277280                mesh.Mesh.Rotation,
 277281                out Vector3d localStart)
 277282            || !endAnchor.TryGetLocalPointIn(
 277283                mesh.Mesh.Origin,
 277284                mesh.Mesh.Rotation,
 277285                out Vector3d localEnd))
 286        {
 2287            return false;
 288        }
 289
 275290        Vector3d localDirection =
 275291            mesh.Mesh.Rotation.Inverse().Rotate(_direction);
 275292        bool found = false;
 1404293        for (int i = 0; i < _meshTriangleBuffer.Count; i++)
 294        {
 427295            int triangleIndex = _meshTriangleBuffer[i];
 427296            mesh.Mesh.GetLocalTriangleVertices(
 427297                triangleIndex,
 427298                out Vector3d first,
 427299                out Vector3d second,
 427300                out Vector3d third);
 427301            Vector3d normal = mesh.Mesh.GetScaledLocalFaceNormal(triangleIndex);
 427302            found |= TryKeepEarlierSweep(
 427303                TrySweepTriangle(
 427304                    first,
 427305                    second,
 427306                    third,
 427307                    normal,
 427308                    localStart,
 427309                    localEnd,
 427310                    localDirection,
 427311                    out Vector3d triangleHit,
 427312                    out Fixed64 triangleDistance),
 427313                triangleHit,
 427314                triangleDistance,
 427315                ref sphereCenterAtImpact,
 427316                ref impactDistance);
 317        }
 318
 275319        if (found)
 320        {
 262321            sphereCenterAtImpact = new FixedSegment(
 262322                _start,
 262323                _end).GetPointAtDistance(
 262324                    impactDistance,
 262325                    _length);
 326        }
 275327        return found;
 328    }
 329
 330    private bool TrySweepCompound(
 331        LSCompoundCollider compound,
 332        out Vector3d sphereCenterAtImpact,
 333        out Fixed64 impactDistance)
 334    {
 18335        sphereCenterAtImpact = Vector3d.Zero;
 18336        impactDistance = Fixed64.MaxValue;
 337
 18338        bool found = false;
 94339        for (int i = 0; i < compound.PartCount; i++)
 340        {
 29341            found |= TryKeepEarlierSweep(
 29342                TrySweep(compound.GetPartCollider(i), out Vector3d partHit, out Fixed64 partDistance),
 29343                partHit,
 29344                partDistance,
 29345                ref sphereCenterAtImpact,
 29346                ref impactDistance);
 347        }
 348
 18349        return found;
 350    }
 351
 352    private bool TrySweepTriangle(
 353        Vector3d first,
 354        Vector3d second,
 355        Vector3d third,
 356        Vector3d normal,
 357        Vector3d start,
 358        Vector3d end,
 359        Vector3d direction,
 360        out Vector3d sphereCenterAtImpact,
 361        out Fixed64 impactDistance)
 362    {
 427363        sphereCenterAtImpact = Vector3d.Zero;
 427364        impactDistance = Fixed64.MaxValue;
 365
 427366        var triangle = new FixedTriangle(first, second, third);
 427367        Vector3d closestAtStart = triangle.ClosestPoint(start);
 427368        if (Vector3d.DistanceSquared(start, closestAtStart) <= _radius * _radius)
 369        {
 86370            sphereCenterAtImpact = start;
 86371            impactDistance = Fixed64.Zero;
 86372            return true;
 373        }
 374
 341375        bool found = false;
 341376        found |= TryKeepEarlierSweep(
 341377            TrySweepTriangleFace(triangle, normal, _radius, start, direction, out Vector3d frontHit, out Fixed64 frontDi
 341378            frontHit,
 341379            frontDistance,
 341380            ref sphereCenterAtImpact,
 341381            ref impactDistance);
 341382        found |= TryKeepEarlierSweep(
 341383            TrySweepTriangleFace(triangle, normal, -_radius, start, direction, out Vector3d backHit, out Fixed64 backDis
 341384            backHit,
 341385            backDistance,
 341386            ref sphereCenterAtImpact,
 341387            ref impactDistance);
 341388        found |= TryKeepEarlierSweep(
 341389            TrySweepTriangleEdge(first, second, start, end, out Vector3d firstEdgeHit, out Fixed64 firstEdgeDistance),
 341390            firstEdgeHit,
 341391            firstEdgeDistance,
 341392            ref sphereCenterAtImpact,
 341393            ref impactDistance);
 341394        found |= TryKeepEarlierSweep(
 341395            TrySweepTriangleEdge(second, third, start, end, out Vector3d secondEdgeHit, out Fixed64 secondEdgeDistance),
 341396            secondEdgeHit,
 341397            secondEdgeDistance,
 341398            ref sphereCenterAtImpact,
 341399            ref impactDistance);
 341400        found |= TryKeepEarlierSweep(
 341401            TrySweepTriangleEdge(third, first, start, end, out Vector3d thirdEdgeHit, out Fixed64 thirdEdgeDistance),
 341402            thirdEdgeHit,
 341403            thirdEdgeDistance,
 341404            ref sphereCenterAtImpact,
 341405            ref impactDistance);
 341406        found |= TryKeepEarlierSweep(
 341407            TrySweepSphere(start, end, _length, first, Fixed64.Zero, _radius, out Vector3d firstVertexHit, out Fixed64 f
 341408            firstVertexHit,
 341409            firstVertexDistance,
 341410            ref sphereCenterAtImpact,
 341411            ref impactDistance);
 341412        found |= TryKeepEarlierSweep(
 341413            TrySweepSphere(start, end, _length, second, Fixed64.Zero, _radius, out Vector3d secondVertexHit, out Fixed64
 341414            secondVertexHit,
 341415            secondVertexDistance,
 341416            ref sphereCenterAtImpact,
 341417            ref impactDistance);
 341418        found |= TryKeepEarlierSweep(
 341419            TrySweepSphere(start, end, _length, third, Fixed64.Zero, _radius, out Vector3d thirdVertexHit, out Fixed64 t
 341420            thirdVertexHit,
 341421            thirdVertexDistance,
 341422            ref sphereCenterAtImpact,
 341423            ref impactDistance);
 424
 341425        return found;
 426    }
 427
 428    private bool TrySweepTriangleFace(
 429        FixedTriangle triangle,
 430        Vector3d normal,
 431        Fixed64 signedRadius,
 432        Vector3d start,
 433        Vector3d direction,
 434        out Vector3d sphereCenterAtImpact,
 435        out Fixed64 impactDistance)
 436    {
 682437        sphereCenterAtImpact = Vector3d.Zero;
 682438        impactDistance = Fixed64.Zero;
 439
 682440        Fixed64 denominator = Vector3d.Dot(direction, normal);
 682441        if (denominator.Abs() <= Fixed64.Epsilon)
 126442            return false;
 443
 556444        Fixed64 signedStartDistance = Vector3d.Dot(start - triangle.A, normal);
 556445        Fixed64 distance = (signedRadius - signedStartDistance) / denominator;
 556446        if (distance < Fixed64.Zero || distance > _length)
 45447            return false;
 448
 511449        Vector3d center = start + direction * distance;
 511450        Vector3d pointOnPlane = center - normal * signedRadius;
 511451        if (!triangle.ContainsProjection(pointOnPlane))
 17452            return false;
 453
 494454        sphereCenterAtImpact = center;
 494455        impactDistance = distance;
 494456        return true;
 457    }
 458
 459    private bool TrySweepTriangleEdge(
 460        Vector3d edgeStart,
 461        Vector3d edgeEnd,
 462        Vector3d start,
 463        Vector3d end,
 464        out Vector3d sphereCenterAtImpact,
 465        out Fixed64 impactDistance)
 466    {
 1023467        sphereCenterAtImpact = Vector3d.Zero;
 1023468        impactDistance = Fixed64.MaxValue;
 469
 1023470        var query = new FixedSegment(start, end);
 1023471        var edgeAxis = new FixedSegment(edgeStart, edgeEnd);
 1023472        if (!query.TryGetFiniteCylinderIntersectionDistanceInterval(
 1023473                edgeAxis,
 1023474                Fixed64.Zero,
 1023475                _radius,
 1023476                _length,
 1023477                out Fixed64 entry,
 1023478                out _,
 1023479                out _,
 1023480                out _))
 481        {
 886482            return false;
 483        }
 484
 137485        impactDistance = entry;
 137486        sphereCenterAtImpact = query.GetPointAtDistance(entry, _length);
 137487        return true;
 488    }
 489
 490    private void BuildFiniteAxisSweepHit(
 491        Fixed64 distance,
 492        out Vector3d sphereCenterAtImpact,
 493        out Fixed64 impactDistance)
 494    {
 702495        impactDistance = distance;
 702496        sphereCenterAtImpact = new FixedSegment(_start, _end)
 702497            .GetPointAtDistance(distance, _length);
 702498    }
 499
 500    private static bool TryKeepEarlierSweep(
 501        bool candidateFound,
 502        Vector3d candidateCenter,
 503        Fixed64 candidateDistance,
 504        ref Vector3d sphereCenterAtImpact,
 505        ref Fixed64 impactDistance)
 506    {
 3184507        if (!candidateFound || candidateDistance >= impactDistance)
 2375508            return false;
 509
 809510        sphereCenterAtImpact = candidateCenter;
 809511        impactDistance = candidateDistance;
 809512        return true;
 513    }
 514
 515    private static void CreateSweepBounds(Vector3d start, Vector3d end, Fixed64 radius, out Vector3d min, out Vector3d m
 516    {
 277517        Vector3d radiusExtents = Vector3d.One * radius;
 277518        min = Vector3d.Min(start, end) - radiusExtents;
 277519        max = Vector3d.Max(start, end) + radiusExtents;
 277520    }
 521}
Generated by: ReportGenerator 5.5.11.0
08/05/2026 - 20:00:45
GitHub | reportgenerator.io

Methods/Properties

.cctor()
.ctor()
Prepare(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64)
TrySweep(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector3d&,FixedMathSharp.Fixed64&)
TrySweepSphere(FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d&,FixedMathSharp.Fixed64&)
TrySweepSphere(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d&,FixedMathSharp.Fixed64&)
TrySweepCapsule(Gravitas.Colliders.LSCapsuleCollider,FixedMathSharp.Vector3d&,FixedMathSharp.Fixed64&)
TrySweepCylinder(Gravitas.Colliders.LSCylinderCollider,FixedMathSharp.Vector3d&,FixedMathSharp.Fixed64&)
TrySweepCone(Gravitas.Colliders.LSConeCollider,FixedMathSharp.Vector3d&,FixedMathSharp.Fixed64&)
TrySweepCanonicalFiniteAxis(Gravitas.Colliders.LSCollider,FixedMathSharp.Vector3d&,FixedMathSharp.Fixed64&)
TrySweepCuboid(Gravitas.Colliders.LSCuboidCollider,FixedMathSharp.Vector3d&,FixedMathSharp.Fixed64&)
TrySweepMesh(Gravitas.Colliders.LSMeshCollider,FixedMathSharp.Vector3d&,FixedMathSharp.Fixed64&)
TrySweepCompound(Gravitas.Colliders.LSCompoundCollider,FixedMathSharp.Vector3d&,FixedMathSharp.Fixed64&)
TrySweepTriangle(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d&,FixedMathSharp.Fixed64&)
TrySweepTriangleFace(FixedMathSharp.Geometry.FixedTriangle,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d&,FixedMathSharp.Fixed64&)
TrySweepTriangleEdge(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Vector3d&,FixedMathSharp.Fixed64&)
BuildFiniteAxisSweepHit(FixedMathSharp.Fixed64,FixedMathSharp.Vector3d&,FixedMathSharp.Fixed64&)
TryKeepEarlierSweep(System.Boolean,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d&,FixedMathSharp.Fixed64&)
CreateSweepBounds(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d&,FixedMathSharp.Vector3d&)