< Summary

Line coverage
100%
Covered lines: 391
Uncovered lines: 0
Coverable lines: 391
Total lines: 712
Line coverage: 100%
Branch coverage
100%
Covered branches: 232
Total branches: 232
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/Detection/3D/Mesh/MeshTriangleContactGenerator.cs

#LineLine coverage
 1//=======================================================================
 2// MeshTriangleContactGenerator.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;
 9using System.Collections.Generic;
 10using System.Runtime.CompilerServices;
 11using FixedMathSharp;
 12using FixedMathSharp.Geometry;
 13using Gravitas.Colliders;
 14using Gravitas.Materials;
 15using SwiftCollections;
 16using SwiftCollections.Query;
 17
 18namespace Gravitas.CollisionHandling;
 19
 20/// <summary>
 21/// Builds finite mesh manifolds, retaining closed convex solids where available
 22/// and using triangle contacts for the remaining surface owners.
 23/// </summary>
 24internal static partial class MeshTriangleContactGenerator
 25{
 26
 27
 128    private static readonly IComparer<HullSample> HullSampleComparer = Comparer<HullSample>.Create(static (a, b) =>
 129    {
 130        int order = a.Contact.FirstAnchor.CompareLocalFeature(b.Contact.FirstAnchor);
 131        return order != 0 ? order : a.Contact.SecondAnchor.CompareLocalFeature(b.Contact.SecondAnchor);
 132    });
 33
 34    // True means the convex pair was handled, including separation; false requests finite triangle fallback.
 35    internal static bool TryAppendHullContacts(LSMeshCollider hull, ReadOnlySpan<Vector3d> hullVertices,
 36        ReadOnlySpan<int> hullTriangles, ReadOnlySpan<int> hullEdges, in ScaledRigidFrame3d frame, Vector3d origin,
 37        ReadOnlySpan<Vector3d> vertices, ReadOnlySpan<int> triangles, ReadOnlySpan<int> edges,
 38        ReadOnlySpan<int> satEdges, PhysicsMaterial material, ContactManifold manifold, bool reverse,
 39        int namespaceA = 0, int namespaceB = 0, ContactGroupKey group = default)
 40    {
 383141        PhysicsMesh mesh = hull.Mesh;
 42        // Select the convex-pair exit once; finite witnesses must belong to that support.
 383143        SwiftList<HullSample> samples = hull.Context.CollisionScratch.HullSamples;
 383144        samples.FastClear();
 383145        bool exact = !mesh.GeometryFrame.IsRigid || !frame.IsRigid;
 383146        if (exact)
 47        {
 3548            if (!WideOrientedBox.TryGetConvexHullPenetration(mesh.GeometryFrame, hullVertices,
 3549                    hullTriangles, hullEdges, frame, vertices, triangles, satEdges,
 4150                    out WideScaledHullPenetration penetration, skipParallelDirections: true)) return true;
 2951            WideOrientedBox.VisitConvexHullContacts(mesh.GeometryFrame, mesh.Origin, hullVertices,
 2952                hullTriangles, hullEdges, frame, origin, vertices, triangles, edges,
 2953                penetration, samples, static (pool, contact) => pool.Add(new HullSample(contact)));
 54        }
 55        else
 56        {
 379657            if (!WideOrientedBox.TryGetConvexHullPenetration(mesh.Origin, mesh.Rotation, hullVertices,
 379658                    hullTriangles, hullEdges, origin, frame.Rotation, vertices, triangles, satEdges,
 381159                    out WidePointSpanPenetration penetration, skipParallelDirections: true)) return true;
 378160            WideOrientedBox.VisitConvexHullContacts(mesh.Origin, mesh.Rotation, hullVertices,
 378161                hullTriangles, hullEdges, origin, frame.Rotation, vertices, triangles, edges,
 378162                penetration, samples, static (pool, contact) => pool.Add(new HullSample(contact)));
 63        }
 381464        if (samples.Count == 0) return false;
 380665        samples.SortInPlace(HullSampleComparer);
 380666        Span<HullSample> pool = samples.AsSpan();
 380667        int unique = 1;
 2878068        for (int index = 1; index < pool.Length; index++)
 1058469            if (pool[index].Contact.FirstAnchor.CompareLocalFeature(pool[unique - 1].Contact.FirstAnchor) != 0)
 864870                pool[unique++] = pool[index];
 380671        pool = pool[..unique];
 380672        Span<int> chosen = stackalloc int[ContactManifold.MaxContactsPerGroup];
 380673        int count = Math.Min(pool.Length, chosen.Length);
 4489374        for (int slot = 0; slot < count; slot++) chosen[slot] = slot;
 380675        if (pool.Length > chosen.Length)
 76        {
 777            Vector3d normal = pool[0].Contact.Normal;
 778            var axis = new WideAxis3(Signed320.ExtendValue(Signed192.Raw(normal.X)),
 779                Signed320.ExtendValue(Signed192.Raw(normal.Y)), Signed320.ExtendValue(Signed192.Raw(normal.Z)));
 80            // Coverage ranks final representable samples; admission and witnesses stay exact.
 81            // A 33-bit solver normal times the normalized basis fits well below 192 bits.
 782            WideAxis3 localAxis = axis;
 783            if (!exact)
 84            {
 485                WideRigidProjection.GetLocalAxisProjections(axis, new WideRationalBasis3d(mesh.Rotation),
 486                    out Signed576 x, out Signed576 y, out Signed576 z);
 487                localAxis = new WideAxis3(Signed320.NarrowValue(x), Signed320.NarrowValue(y), Signed320.NarrowValue(z));
 88            }
 789            var metrics = new WidePlaneMetrics(localAxis);
 5690            for (int slot = 1; slot < count; slot++)
 2191                chosen[slot] = MeshPlaneSampleReduction.ChooseNext<HullSample>(pool, chosen[..slot], metrics, HullSample
 92            // A support line needs only its two extreme velocity levers.
 893            if (metrics.GetAreaSquared(pool[0].Point, pool[chosen[1]].Point, pool[chosen[2]].Point).IsZero) count = 2;
 94        }
 3246295        for (int slot = 0; slot < count; slot++)
 96        {
 1242597            FixedContactAnchors contact = pool[chosen[slot]].Contact;
 1242598            manifold.AddContact(new ContactAnchor(reverse ? contact.SecondAnchor : contact.FirstAnchor),
 1242599                new ContactAnchor(reverse ? contact.FirstAnchor : contact.SecondAnchor), contact.Depth,
 12425100                reverse ? -contact.Normal : contact.Normal, reverse ? material : hull.Material,
 12425101                reverse ? hull.Material : material, contact.DepthIsClamped, namespaceA, namespaceB, group);
 102        }
 3806103        return true;
 104    }
 105
 106    public static bool TryBuildMeshSphereManifold(
 107        CollisionWorkItem pair,
 108        LSMeshCollider mesh,
 109        LSSphereCollider sphere,
 110        SwiftList<int> triangleBuffer)
 111    {
 13511112        return TryBuildRoundedAxisManifold(pair, mesh, sphere.Center, sphere.Rotation,
 13511113            Fixed64.Zero, sphere.ScaledRadius, CreateBounds(sphere.BoundsMin, sphere.BoundsMax), triangleBuffer);
 114    }
 115
 116    public static bool TryBuildMeshCapsuleManifold(
 117        CollisionWorkItem pair,
 118        LSMeshCollider mesh,
 119        LSCapsuleCollider capsule,
 120        SwiftList<int> triangleBuffer)
 121    {
 12803122        return TryBuildRoundedAxisManifold(pair, mesh, capsule.Center, capsule.Rotation,
 12803123            capsule.AxisLength, capsule.ScaledRadius, CreateBounds(capsule.BoundsMin, capsule.BoundsMax), triangleBuffer
 124    }
 125
 126    private static bool BuildJoinedRoundedManifold(CollisionWorkItem pair, LSMeshCollider collider,
 127        StaticSurface surface, Vector3d center, FixedQuaternion rotation, Fixed64 coreLength, Fixed64 radius)
 128    {
 13192129        surface.BuildRounded(center, rotation, coreLength, radius);
 13192130        MeshCapsuleFaceRegions faces = surface.Faces;
 52814131        for (int region = 0; region < faces.RegionCount; region++)
 53448132            for (int sample = 0; sample < faces.GetSampleCount(region); sample++)
 133            {
 13509134                bool found = faces.TryGetJoinedSample(region, sample, out FixedContactAnchors contact, out LSMeshCollide
 135                System.Diagnostics.Debug.Assert(found);
 136                // Selected rows belong to their supplier's pair; other overlapping members still raise events.
 13509137                if (supplier != collider) continue;
 6703138                pair.Manifold.AddContact(new ContactAnchor(contact.FirstAnchor), new ContactAnchor(contact.SecondAnchor)
 6703139                    contact.Depth, contact.Normal, collider.Material, pair.ColliderB.Material, contact.DepthIsClamped,
 6703140                    group: new ContactGroupKey(0, 0, 0, 0, region));
 141            }
 13192142        return faces.AppendJoinedBoundaries(collider, pair.ColliderB.Material, center, rotation, coreLength,
 13192143            radius, pair.Context.CollisionScratch.MeshCapsuleBoundary, pair.Manifold);
 144    }
 145
 146    private static bool TryBuildRoundedAxisManifold(CollisionWorkItem pair, LSMeshCollider collider,
 147        Vector3d center, FixedQuaternion rotation, Fixed64 coreLength, Fixed64 radius,
 148        FixedBoundVolume bounds, SwiftList<int> candidates)
 149    {
 26314150        PhysicsMesh mesh = collider.Mesh;
 151        // Zero-core capsules are spheres: body spin must not rotate their
 152        // geometry frame and introduce a rounded off-center impulse lever.
 39836153        if (coreLength == Fixed64.Zero) rotation = FixedQuaternion.Identity;
 26314154        if (collider.StaticSurface is { } staticSurface && !collider.IsTrigger && !pair.ColliderB.IsTrigger
 26314155            && staticSurface.Gather(pair.ColliderB, bounds) > 1)
 13192156            return BuildJoinedRoundedManifold(pair, collider, staticSurface, center, rotation, coreLength, radius);
 13122157        collider.GetTrianglesInBounds(bounds, candidates);
 13122158        CollisionSatScratch scratch = pair.Context.CollisionScratch;
 13122159        SwiftList<int> admitted = scratch.MeshTriangleCandidatesB;
 13122160        scratch.MeshSurfaces.Clear();
 13122161        var frame = new CapsuleFiniteSectionFrame(mesh.GeometryFrame, center, rotation, coreLength, radius);
 13122162        Span<int> singleton = stackalloc int[1];
 122332163        foreach (int triangle in candidates.AsReadOnlySpan())
 164        {
 48044165            int owner = mesh.GetManifoldSurfaceOwner(triangle);
 48044166            if (!scratch.MeshSurfaces.Add(owner)) continue;
 13113167            admitted.FastClear();
 168            // A trusted owner with no shared-edge neighbor is one triangle.
 169            // Individually owned facets therefore retain linear gathering.
 13113170            singleton[0] = triangle;
 13113171            ReadOnlySpan<int> surfaceCandidates = mesh.GetCoplanarTriangleNeighbors(triangle).IsEmpty
 13113172                ? singleton : candidates.AsReadOnlySpan();
 122410173            foreach (int candidate in surfaceCandidates)
 174            {
 48092175                if (mesh.GetManifoldSurfaceOwner(candidate) != owner) continue;
 48044176                mesh.GetGeometryTriangleVertices(candidate, out Vector3d a, out Vector3d b, out Vector3d c);
 70488177                if (CapsulePlaneRayEvents.IntersectsTriangle(frame, new FixedTriangle(a, b, c))) admitted.Add(candidate)
 178            }
 13113179            if (admitted.Count == 0) continue;
 13105180            MeshSurfaceConnectivity connectivity = scratch.MeshConnectivity;
 13105181            connectivity.BuildCapsule(mesh, triangle, frame, admitted.AsReadOnlySpan());
 13105182            MeshCapsuleFaceRegions faces = scratch.MeshCapsuleFaces;
 13105183            faces.Build(mesh, triangle, frame, center, rotation, connectivity);
 13105184            int surface = mesh.GetCanonicalSurfaceOrdinal(triangle);
 54768185            for (int region = 0; region < faces.RegionCount; region++)
 186            {
 14279187                var group = new ContactGroupKey(0, 0, surface, 0, region);
 14279188                int count = faces.GetSampleCount(region);
 66408189                for (int sample = 0; sample < count; sample++)
 190                {
 18925191                    bool found = faces.TryGetSample(region, sample, out FixedContactAnchors contact);
 192                    System.Diagnostics.Debug.Assert(found);
 18925193                    pair.Manifold.AddContact(new ContactAnchor(contact.FirstAnchor), new ContactAnchor(contact.SecondAnc
 18925194                        contact.Depth, contact.Normal, collider.Material, pair.ColliderB.Material,
 18925195                        contact.DepthIsClamped, group: group);
 196                }
 197            }
 198            // Boundary constraints retain their own feature direction. They
 199            // cannot replace or consume the region's finite face sample cap.
 13105200            if (faces.HasBoundaryIntersection)
 374201                scratch.MeshCapsuleBoundary.BuildSurfaceContacts(collider, pair.ColliderB.Material,
 374202                    center, rotation, coreLength, radius, triangle, connectivity, faces, pair.Manifold);
 203        }
 13122204        return pair.Manifold.HasContact;
 205    }
 206
 207    public static bool TryBuildMeshCuboidManifold(
 208        CollisionWorkItem pair,
 209        LSMeshCollider mesh,
 210        LSCuboidCollider cuboid,
 211        SwiftList<int> triangleBuffer)
 212    {
 213        // Declared surface ownership still applies when only one piece is near
 214        // the mover. Falling back to independent triangles exposes its internal
 215        // diagonals as pressure boundaries and changes response mid-crossing.
 4723216        if (mesh.StaticSurface is { } surface && !mesh.IsTrigger && !cuboid.IsTrigger
 4723217            && surface.GatherProjectedSupport(cuboid) > 0)
 218        {
 3580219            Vector3d half = cuboid.OrientedBox.HalfExtents;
 3580220            surface.BuildSlab(cuboid, Fixed64.Zero, half.Y, new(half.X, half.Z));
 3580221            return surface.SlabFaces.AppendJoinedContacts(mesh, cuboid.Material, pair.Context.CollisionScratch.MeshSlabB
 222        }
 1143223        mesh.GetTrianglesInBounds(CreateBounds(cuboid.BoundsMin, cuboid.BoundsMax), triangleBuffer);
 6206224        for (int i = 0; i < triangleBuffer.Count; i++)
 1960225            TryAddCuboidTriangleContact(pair, mesh, triangleBuffer[i], cuboid);
 226
 1143227        return pair.Manifold.HasContact;
 228    }
 229
 230    public static bool TryBuildMeshCylinderManifold(
 231        CollisionWorkItem pair,
 232        LSMeshCollider mesh,
 233        LSCylinderCollider cylinder,
 234        SwiftList<int> triangleBuffer)
 235    {
 4119236        if (mesh.StaticSurface is { } surface && !mesh.IsTrigger && !cylinder.IsTrigger
 4119237            && surface.GatherProjectedSupport(cylinder) > 0)
 238        {
 3530239            surface.BuildSlab(cylinder, cylinder.ScaledRadius, cylinder.Height, default);
 3530240            return surface.SlabFaces.AppendJoinedContacts(mesh, cylinder.Material, pair.Context.CollisionScratch.MeshSla
 241        }
 589242        mesh.GetTrianglesInBounds(CreateBounds(cylinder.BoundsMin, cylinder.BoundsMax), triangleBuffer);
 589243        CollisionSatScratch scratch = pair.Context.CollisionScratch;
 589244        scratch.MeshSurfaces.Clear();
 3344245        foreach (int triangle in triangleBuffer.AsReadOnlySpan())
 246        {
 247            // Isolated/declined triangles have no covered diagonal and keep
 248            // their complete finite-triangle kernel and existing warm cost.
 1083249            if (mesh.Mesh.GetCoplanarTriangleNeighbors(triangle).IsEmpty)
 250            {
 39251                TryAddCylinderTriangleContact(pair, mesh, triangle, cylinder);
 39252                continue;
 253            }
 1044254            if (!scratch.MeshSurfaces.Add(mesh.Mesh.GetManifoldSurfaceOwner(triangle))) continue;
 517255            AppendMeshCylinderSurfaceContacts(pair, mesh, triangle, cylinder, triangleBuffer.AsReadOnlySpan());
 256        }
 589257        return pair.Manifold.HasContact;
 258    }
 259
 260    // Keep the wide frame's stack storage off the isolated-triangle hot path.
 261    private static void AppendMeshCylinderSurfaceContacts(CollisionWorkItem pair, LSMeshCollider mesh,
 262        int triangle, LSCylinderCollider cylinder, ReadOnlySpan<int> candidates)
 263    {
 517264        mesh.Mesh.GetGeometryTriangleVertices(triangle, out Vector3d a, out Vector3d b, out Vector3d c);
 517265        var frame = new FiniteSlabRayFrame(new FixedTriangle(a, b, c), mesh.Mesh.GeometryFrame,
 517266            cylinder.Center, cylinder.Rotation, Fixed64.Zero, cylinder.ScaledRadius, cylinder.Height, fullHeight: true);
 517267        bool containsSection = MeshSlabFaceRegions.ContainsSection(mesh.Mesh, triangle, frame, ReadOnlySpan<Vector2d>.Em
 517268        SwiftList<int> admitted = pair.Context.CollisionScratch.MeshTriangleCandidatesB;
 517269        if (!GatherMeshSlabSurfaceTriangles(mesh.Mesh, triangle, frame.Section, ReadOnlySpan<Vector2d>.Empty,
 519270            candidates, admitted, containsSection)) return;
 515271        AppendMeshSlabSurfaceContacts(mesh, null, triangle, frame, ReadOnlySpan<Vector2d>.Empty,
 515272            admitted.AsReadOnlySpan(), containsSection, pair.Manifold, 0, 0, cylinder.Material);
 515273    }
 274
 275    internal static void AppendMeshSlabSurfaceContacts(LSMeshCollider collider, LSCollider2D? embedded,
 276        int triangle, in FiniteSlabRayFrame frame, ReadOnlySpan<Vector2d> prismOffsets,
 277        ReadOnlySpan<int> admitted, bool containsSection, ContactManifold manifold, int namespace3D, int namespace2D,
 278        PhysicsMaterial? targetMaterial = null)
 279    {
 2492280        PhysicsMesh mesh = collider.Mesh;
 2492281        CollisionSatScratch scratch = collider.Context.CollisionScratch;
 2492282        MeshSurfaceConnectivity connectivity = scratch.MeshConnectivity;
 2492283        connectivity.BuildSlab(mesh, triangle, frame.Section, embedded, admitted);
 2492284        MeshSlabFaceRegions faces = scratch.MeshSlabFaces;
 2492285        faces.Prepare(frame, prismOffsets, containsSection);
 2492286        PhysicsMaterial material = targetMaterial ?? embedded?.Material ?? collider.Material;
 2492287        int contactCount = manifold.Count;
 288        // A covered axial footprint has no intersected physical rim. Reuse
 289        // that proof rather than repeating the same exact boundary queries.
 2492290        if (!containsSection)
 1388291            scratch.MeshSlabBoundary.BuildSurfaceContacts(collider, embedded, triangle,
 1388292                connectivity, faces, manifold, namespace3D, namespace2D, material);
 2492293        faces.Build(mesh, triangle, connectivity, prismOffsets, embedded, containsSection);
 2492294        faces.AppendContacts(collider, triangle, manifold, namespace3D, namespace2D, material);
 2492295        if (manifold.Count == contactCount)
 12296            scratch.MeshSlabBoundary.AppendSupportFallback(collider, embedded, triangle, faces,
 12297                manifold, namespace3D, namespace2D, material);
 2492298    }
 299
 300    internal static bool GatherMeshSlabSurfaceTriangles(PhysicsMesh mesh, int triangle,
 301        in FiniteSlabSectionFrame section, ReadOnlySpan<Vector2d> prismOffsets,
 302        ReadOnlySpan<int> candidates, SwiftList<int> admitted, bool stopAfterFirst = false)
 303    {
 2669304        admitted.FastClear();
 2669305        int owner = mesh.GetManifoldSurfaceOwner(triangle);
 20863306        foreach (int candidate in candidates)
 307        {
 7891308            if (mesh.GetManifoldSurfaceOwner(candidate) != owner) continue;
 6569309            mesh.GetGeometryTriangleVertices(candidate, out Vector3d first, out Vector3d second, out Vector3d third);
 6569310            if (!section.IntersectsTriangle(new FixedTriangle(first, second, third), prismOffsets)) continue;
 5267311            admitted.Add(candidate);
 5267312            if (stopAfterFirst) break;
 313        }
 2669314        return admitted.Count != 0;
 315    }
 316
 317    public static bool TryBuildMeshMeshManifold(
 318        CollisionWorkItem pair,
 319        LSMeshCollider meshA,
 320        LSMeshCollider meshB,
 321        SwiftList<int> triangleBufferA,
 322        SwiftList<int> triangleBufferB)
 323    {
 6758324        CollisionSatScratch scratch = pair.Context.CollisionScratch;
 6758325        scratch.MeshSurfaces.Clear();
 6758326        LSMeshCollider? declared = meshA.StaticSurface != null ? meshA : meshB.StaticSurface != null ? meshB : null;
 6758327        LSMeshCollider mover = declared == meshA ? meshB : meshA;
 6758328        if (declared != null
 6758329            && !meshA.IsTrigger && !meshB.IsTrigger && declared.StaticSurface!.GatherProjectedSupport(mover) > 0)
 330        {
 5955331            declared.StaticSurface.BuildHull(mover);
 5955332            return declared.StaticSurface.HullContacts.Append(declared, mover, pair.Manifold, declared == meshB);
 333        }
 334        // The sole caller routes closed convex/closed convex pairs through
 335        // its solid-hull owner before entering this finite-surface manifold.
 803336        LSMeshCollider? surface = meshA.Mode == MeshColliderMode.Convex && meshA.Mesh.IsClosedSurface
 803337            && !meshB.Mesh.IsClosedSurface ? meshB
 803338            : meshB.Mode == MeshColliderMode.Convex && meshB.Mesh.IsClosedSurface
 803339                && !meshA.Mesh.IsClosedSurface ? meshA : null;
 803340        if (surface != null)
 341        {
 130342            LSMeshCollider hull = surface == meshA ? meshB : meshA;
 130343            surface.GetTrianglesInBounds(CreateBounds(hull.BoundsMin, hull.BoundsMax), triangleBufferA);
 468344            foreach (int triangle in triangleBufferA.AsReadOnlySpan())
 345            {
 104346                int owner = surface.Mesh.GetManifoldSurfaceOwner(triangle);
 104347                if (!scratch.MeshSurfaces.Add(owner)) continue;
 44348                int ordinal = surface.Mesh.GetCanonicalSurfaceOrdinal(triangle);
 44349                var group = new ContactGroupKey(0, 0, surface == meshA ? ordinal : 0, surface == meshB ? ordinal : 0);
 44350                ReadOnlySpan<int> corners = surface.Mesh.GetConvexCoplanarPatchCornerVertexIndices(triangle);
 44351                if (!corners.IsEmpty)
 352                {
 36353                    int count = corners.Length;
 70354                    if (scratch.PolyhedronVertices.Length < count) Array.Resize(ref scratch.PolyhedronVertices, count);
 70355                    if (scratch.PolyhedronTriangles.Length < 3 * (count - 2)) Array.Resize(ref scratch.PolyhedronTriangl
 70356                    if (scratch.PolyhedronEdges.Length < 2 * count) Array.Resize(ref scratch.PolyhedronEdges, 2 * count)
 36357                    Span<Vector3d> vertices = scratch.PolyhedronVertices.AsSpan(0, count);
 36358                    Span<int> triangles = scratch.PolyhedronTriangles.AsSpan(0, 3 * (count - 2));
 36359                    Span<int> edges = scratch.PolyhedronEdges.AsSpan(0, 2 * count);
 360360                    for (int index = 0; index < count; index++)
 361                    {
 144362                        vertices[index] = surface.Mesh.GeometryVertices[corners[index]];
 144363                        edges[2 * index] = index;
 144364                        edges[2 * index + 1] = (index + 1) % count;
 144365                        if (index < 2) continue;
 72366                        int face = 3 * (index - 2);
 216367                        triangles[face] = 0; triangles[face + 1] = index - 1; triangles[face + 2] = index;
 368                    }
 369                    // Use the trusted finite patch once, not its artificial triangle diagonals.
 36370                    if (TryAppendHullContacts(hull, hull.Mesh.GeometryVertices, hull.Mesh.Triangles,
 36371                        hull.Mesh.ConvexSatEdgeVertexPairs, surface.Mesh.GeometryFrame, surface.Mesh.Origin,
 36372                        vertices, triangles, edges, edges, surface.Material, pair.Manifold, hull == meshB, group: group)
 373                        continue;
 374                }
 120375                foreach (int candidate in triangleBufferA.AsReadOnlySpan())
 48376                    if (surface.Mesh.GetManifoldSurfaceOwner(candidate) == owner)
 40377                        AppendMeshTriangleContacts(pair, surface, candidate, hull, triangleBufferB,
 40378                            surface == meshB, group);
 379            }
 130380            return pair.Manifold.HasContact;
 381        }
 673382        bool reverseContact = meshA.Id > meshB.Id;
 673383        LSMeshCollider firstMesh = reverseContact ? meshB : meshA;
 673384        LSMeshCollider secondMesh = reverseContact ? meshA : meshB;
 673385        firstMesh.GetTrianglesInBounds(
 673386            CreateBounds(secondMesh.BoundsMin, secondMesh.BoundsMax),
 673387            triangleBufferA);
 16736388        for (int i = 0; i < triangleBufferA.Count; i++)
 7695389            AppendMeshTriangleContacts(pair, firstMesh, triangleBufferA[i], secondMesh, triangleBufferB, reverseContact)
 390
 673391        return pair.Manifold.HasContact;
 392    }
 393
 394    private static void AppendMeshTriangleContacts(CollisionWorkItem pair, LSMeshCollider firstMesh,
 395        int triangle, LSMeshCollider secondMesh, SwiftList<int> candidates, bool reverse,
 396        ContactGroupKey? group = null)
 397    {
 7735398        firstMesh.Mesh.GetGeometryTriangleVertices(triangle, out Vector3d a, out Vector3d b, out Vector3d c);
 7735399        var firstTriangle = new FixedTriangle(a, b, c);
 7735400        bool exact = !firstMesh.Mesh.GeometryFrame.IsRigid || !secondMesh.Mesh.GeometryFrame.IsRigid;
 7735401        if (exact)
 402        {
 24403            bool represented = firstMesh.Mesh.GeometryFrame.TryGetBoundsIn(firstTriangle.Bounds.Min, firstTriangle.Bound
 24404                secondMesh.Mesh.GeometryFrame, out FixedBoundBox bounds);
 405            // Collider admission guarantees nonzero target scale products;
 406            // the bounds owner clips only final source-chart endpoints.
 407            System.Diagnostics.Debug.Assert(represented);
 24408            secondMesh.Mesh.GetTrianglesInGeometryBounds(new FixedBoundVolume(bounds.Min, bounds.Max), candidates);
 409        }
 410        else
 411        {
 7711412            GetTriangleBoundsInFrame(firstTriangle.Bounds, firstMesh.Mesh.Origin, firstMesh.Mesh.Rotation,
 7711413                secondMesh.Mesh.Origin, secondMesh.Mesh.Rotation, out FixedBoundVolume bounds);
 7711414            secondMesh.Mesh.GetTrianglesInGeometryBounds(bounds, candidates);
 415        }
 7735416        bool canonicalReverse = firstMesh.Id > secondMesh.Id;
 77880417        for (int j = 0; j < candidates.Count; j++)
 418        {
 31205419            secondMesh.Mesh.GetGeometryTriangleVertices(candidates[j], out a, out b, out c);
 31205420            var secondTriangle = new FixedTriangle(a, b, c);
 31205421            if (exact)
 422            {
 96423                AppendExactTriangleContacts(pair, firstMesh, firstTriangle, secondMesh, secondTriangle,
 96424                    canonicalReverse, reverse, group);
 96425                continue;
 426            }
 427            FixedContactAnchors contact;
 31109428            bool intersects = canonicalReverse
 31109429                ? secondTriangle.TryGetContact(secondMesh.Mesh.Origin, secondMesh.Mesh.Rotation,
 31109430                    firstMesh.Mesh.Origin, firstMesh.Mesh.Rotation, firstTriangle, out contact)
 31109431                : firstTriangle.TryGetContact(firstMesh.Mesh.Origin, firstMesh.Mesh.Rotation,
 31109432                    secondMesh.Mesh.Origin, secondMesh.Mesh.Rotation, secondTriangle, out contact);
 31109433            if (!intersects) continue;
 434
 19872435            AddMeshTriangleContact(pair, contact, reverse != canonicalReverse, group);
 436        }
 7735437    }
 438
 439    private static void AppendExactTriangleContacts(CollisionWorkItem pair, LSMeshCollider firstMesh,
 440        in FixedTriangle first, LSMeshCollider secondMesh, in FixedTriangle second,
 441        bool canonicalReverse, bool reverse, ContactGroupKey? group)
 442    {
 96443        ref readonly ScaledRigidFrame3d firstFrame = ref (canonicalReverse
 96444            ? ref secondMesh.Mesh.GeometryFrame : ref firstMesh.Mesh.GeometryFrame);
 96445        ref readonly ScaledRigidFrame3d secondFrame = ref (canonicalReverse
 96446            ? ref firstMesh.Mesh.GeometryFrame : ref secondMesh.Mesh.GeometryFrame);
 192447        FixedTriangle primary = canonicalReverse ? second : first, secondary = canonicalReverse ? first : second;
 96448        if (WideTriangleRelations.TryGetContact(primary, firstFrame,
 96449                canonicalReverse ? secondMesh.Mesh.Origin : firstMesh.Mesh.Origin,
 96450                secondary, secondFrame, canonicalReverse ? firstMesh.Mesh.Origin : secondMesh.Mesh.Origin,
 96451                out FixedContactAnchors contact))
 60452            AddMeshTriangleContact(pair, contact, reverse != canonicalReverse, group);
 96453    }
 454
 455    private static void AddMeshTriangleContact(CollisionWorkItem pair, FixedContactAnchors contact, bool reverse,
 456        ContactGroupKey? group)
 457    {
 19932458        ContactAnchor first = new(reverse ? contact.SecondAnchor : contact.FirstAnchor);
 19932459        ContactAnchor second = new(reverse ? contact.FirstAnchor : contact.SecondAnchor);
 19932460        Vector3d normal = reverse ? -contact.Normal : contact.Normal;
 19932461        if (group.HasValue)
 116462            pair.Manifold.AddContact(first, second, contact.Depth, normal,
 116463                pair.ColliderA.Material, pair.ColliderB.Material, contact.DepthIsClamped, group: group.Value);
 19816464        else AddContact(pair, first, second, contact.Depth, normal, contact.DepthIsClamped);
 19816465    }
 466
 467    private static void TryAddCuboidTriangleContact(
 468        CollisionWorkItem pair,
 469        LSMeshCollider mesh,
 470        int triangleIndex,
 471        LSCuboidCollider cuboid)
 472    {
 1960473        mesh.Mesh.GetGeometryTriangleVertices(
 1960474            triangleIndex,
 1960475            out Vector3d first,
 1960476            out Vector3d second,
 1960477            out Vector3d third);
 1960478        var triangle = new FixedTriangle(first, second, third);
 1960479        if (!mesh.Mesh.GeometryFrame.IsRigid)
 480        {
 8481            Span<Vector3d> box = stackalloc Vector3d[8];
 8482            WideOrientedBox.GetBoxHullVertices(cuboid.OrientedBox.HalfExtents, box);
 8483            ReadOnlySpan<Vector3d> points = stackalloc Vector3d[3] { first, second, third };
 8484            ReadOnlySpan<int> face = stackalloc int[3] { 0, 1, 2 };
 8485            ReadOnlySpan<int> edges = stackalloc int[6] { 0, 1, 1, 2, 2, 0 };
 8486            var boxFrame = ScaledRigidFrame3d.Rigid(cuboid.Center, cuboid.Rotation);
 8487            if (!WideOrientedBox.TryGetConvexHullPenetration(boxFrame, box,
 8488                    WideOrientedBox.BoxHullTriangles, WideOrientedBox.BoxHullEdges,
 9489                    mesh.Mesh.GeometryFrame, points, face, edges, out var penetration)) return;
 7490            WideOrientedBox.VisitConvexHullContacts(boxFrame, cuboid.Center, box,
 7491                WideOrientedBox.BoxHullTriangles, WideOrientedBox.BoxHullEdges, mesh.Mesh.GeometryFrame,
 7492                mesh.Mesh.Origin, points, face, edges, penetration, pair,
 7493                static (state, contact) => AddReversedBoxTriangleContact(state, contact));
 7494            return;
 495        }
 1952496        Span<FixedContactLocalPoints> faceContacts =
 1952497            stackalloc FixedContactLocalPoints[4];
 1952498        if (!cuboid.OrientedBox.TryGetTriangleContact(
 1952499                mesh.Mesh.Origin,
 1952500                mesh.Mesh.Rotation,
 1952501                triangle,
 1952502                faceContacts,
 1952503                out FixedContactAnchors contact,
 1952504                out int faceContactCount))
 505        {
 454506            return;
 507        }
 508
 1498509        if (faceContactCount > 0)
 510        {
 9972511            for (int index = 0; index < faceContactCount; index++)
 512            {
 3610513                AddReversedBoxTriangleContact(
 3610514                    pair,
 3610515                    contact,
 3610516                    faceContacts[index]);
 517            }
 1376518            return;
 519        }
 520
 122521        AddReversedBoxTriangleContact(pair, contact);
 122522    }
 523
 524    private static void AddReversedBoxTriangleContact(
 525        CollisionWorkItem pair,
 526        FixedContactAnchors contact)
 527    {
 158528        AddContact(
 158529            pair,
 158530            new ContactAnchor(contact.SecondAnchor),
 158531            new ContactAnchor(contact.FirstAnchor),
 158532            contact.Depth,
 158533            -contact.Normal,
 158534            contact.DepthIsClamped);
 158535    }
 536
 537    private static void AddReversedBoxTriangleContact(
 538        CollisionWorkItem pair,
 539        FixedContactAnchors primary,
 540        FixedContactLocalPoints contact)
 541    {
 3610542        AddContact(
 3610543            pair,
 3610544            new ContactAnchor(
 3610545                primary.SecondAnchor.Origin,
 3610546                primary.SecondAnchor.Rotation,
 3610547                contact.SecondLocalPoint),
 3610548            new ContactAnchor(
 3610549                primary.FirstAnchor.Origin,
 3610550                primary.FirstAnchor.Rotation,
 3610551                contact.FirstLocalPoint),
 3610552            primary.Depth,
 3610553            -primary.Normal,
 3610554            primary.DepthIsClamped);
 3610555    }
 556
 557    private static bool TryAddCylinderTriangleContact(
 558        CollisionWorkItem pair,
 559        LSMeshCollider mesh,
 560        int triangleIndex,
 561        LSCylinderCollider cylinder)
 562    {
 39563        mesh.Mesh.GetGeometryTriangleVertices(
 39564            triangleIndex,
 39565            out Vector3d first,
 39566            out Vector3d second,
 39567            out Vector3d third);
 39568        var triangle = new FixedTriangle(first, second, third);
 39569        if (!TriangleCylinderContact.TryGetContact(triangle, mesh.Mesh.GeometryFrame,
 39570                cylinder.Center, cylinder.Rotation, Signed192.Raw(cylinder.Height), cylinder.ScaledRadius,
 39571                out FixedContactAnchors contact, out bool isCapFaceContact))
 572        {
 2573            return false;
 574        }
 575
 576        // Enrichment belongs only to a certified cap/triangle-face winner.
 577        // Nearly parallel rim contacts must retain their selected witnesses.
 37578        var group = new ContactGroupKey(0, 0, mesh.Mesh.GetCanonicalSurfaceOrdinal(triangleIndex), 0);
 37579        if (isCapFaceContact && TryAddCylinderCapTriangleContacts(
 37580                pair, mesh, triangle, cylinder, contact, group))
 581        {
 11582            return true;
 583        }
 584
 26585        pair.Manifold.AddContact(
 26586            new ContactAnchor(contact.FirstAnchor),
 26587            new ContactAnchor(contact.SecondAnchor),
 26588            contact.Depth,
 26589            contact.Normal,
 26590            mesh.Material, cylinder.Material, contact.DepthIsClamped, group: group);
 26591        return true;
 592    }
 593
 594    private static bool TryAddCylinderCapTriangleContacts(
 595        CollisionWorkItem pair,
 596        LSMeshCollider mesh,
 597        FixedTriangle triangle,
 598        LSCylinderCollider cylinder,
 599        in FixedContactAnchors primary, in ContactGroupKey group)
 600    {
 12601        Vector3d normal = primary.Normal;
 12602        CylinderContactGeometry.GetCapBasis(cylinder, out Vector3d tangentA, out Vector3d tangentB);
 603        // A valid support can be deduplicated or lose the four-contact reduction.
 604        // Geometric success must not depend on whether the manifold count grew.
 12605        bool found = TryAddCylinderCapTriangleContact(pair, mesh, triangle, cylinder, -normal + tangentA, primary, group
 12606        found |= TryAddCylinderCapTriangleContact(pair, mesh, triangle, cylinder, -normal - tangentA, primary, group);
 12607        found |= TryAddCylinderCapTriangleContact(pair, mesh, triangle, cylinder, -normal + tangentB, primary, group);
 12608        found |= TryAddCylinderCapTriangleContact(pair, mesh, triangle, cylinder, -normal - tangentB, primary, group);
 12609        return found || TryAddCylinderCapTriangleContact(pair, mesh, triangle, cylinder, -normal, primary, group);
 610    }
 611
 612    private static bool TryAddCylinderCapTriangleContact(
 613        CollisionWorkItem pair,
 614        LSMeshCollider mesh,
 615        FixedTriangle triangle,
 616        LSCylinderCollider cylinder,
 617        Vector3d supportDirection,
 618        in FixedContactAnchors primary, in ContactGroupKey group)
 619    {
 620        FixedContactAnchors contact;
 621        bool found;
 49622        if (mesh.Mesh.GeometryFrame.IsRigid)
 41623            found = triangle.TryGetCenteredFiniteCylinderSupportContact(mesh.Mesh.Origin, mesh.Mesh.Rotation,
 41624                cylinder.Center, cylinder.Rotation, cylinder.Height, cylinder.ScaledRadius,
 41625                supportDirection, primary.Normal, out contact);
 626        else
 627        {
 8628            FixedPointAnchor support = WideGeometry.GetCenteredCylinderSupportAnchor(cylinder.Center,
 8629                cylinder.Rotation, cylinder.Height, cylinder.ScaledRadius, supportDirection);
 8630            found = WideTriangleRelations.TryGetProjectedSupportContact(triangle, mesh.Mesh.GeometryFrame,
 8631                support, primary.Normal, mesh.Center, out contact);
 632        }
 54633        if (!found) return false;
 634
 635        // Parallel cap/face samples share the selected exact plane gap.
 636        // The support query rounds into the triangle frame before measuring
 637        // depth; keep it for anchors only, avoiding a second depth rounding.
 44638        pair.Manifold.AddContact(
 44639            new ContactAnchor(contact.FirstAnchor),
 44640            new ContactAnchor(contact.SecondAnchor),
 44641            primary.Depth,
 44642            primary.Normal,
 44643            mesh.Material, cylinder.Material, primary.DepthIsClamped, group: group);
 44644        return true;
 645    }
 646
 647    private static void GetTriangleBoundsInFrame(
 648        FixedBoundBox triangleBounds,
 649        Vector3d sourceOrigin,
 650        FixedQuaternion sourceRotation,
 651        Vector3d frameOrigin,
 652        FixedQuaternion frameRotation,
 653        out FixedBoundVolume bounds)
 654    {
 7711655        FixedBoundBox reframedBounds =
 7711656            FixedBoundBox.FromRelativeRotatedBoundsClippedToDomain(
 7711657                sourceOrigin,
 7711658                sourceRotation,
 7711659                triangleBounds.Min,
 7711660                triangleBounds.Max,
 7711661                frameOrigin,
 7711662                frameRotation);
 7711663        bounds = CreateBounds(reframedBounds.Min, reframedBounds.Max);
 7711664    }
 665
 666    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 667    private static FixedBoundVolume CreateBounds(Vector3d min, Vector3d max) =>
 36560668        new(min, max);
 669
 670    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 671    private static void AddContact(
 672        CollisionWorkItem pair,
 673        ContactAnchor anchorOnFirst,
 674        ContactAnchor anchorOnSecond,
 675        Fixed64 depth,
 676        Vector3d normalFirstToSecond,
 677        bool depthIsClamped)
 678    {
 23584679        pair.Manifold.AddContact(
 23584680            anchorOnFirst,
 23584681            anchorOnSecond,
 23584682            depth,
 23584683            normalFirstToSecond,
 23584684            depthIsClamped);
 23584685    }
 686
 687}

/home/runner/work/Gravitas/Gravitas/src/Gravitas/CollisionHandling/Detection/3D/Mesh/MeshTriangleContactGenerator.HullSample.cs

#LineLine coverage
 1//=======================================================================
 2// MeshTriangleContactGenerator.HullSample.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;
 10
 11namespace Gravitas.CollisionHandling;
 12
 13/// <content>Defines the nested HullSample type.</content>
 14internal static partial class MeshTriangleContactGenerator
 15{
 16    /// <summary>
 17    /// Pairs convex hull contact anchors with the local point used for planar reduction.
 18    /// </summary>
 19    internal readonly struct HullSample : IPlaneContactSample
 20    {
 1439021        internal HullSample(FixedContactAnchors contact) => Contact = contact;
 22        internal readonly FixedContactAnchors Contact;
 37623        public Vector3d Point => Contact.FirstAnchor.LocalPoint;
 24    }
 25}

Methods/Properties

.cctor()
TryAppendHullContacts(Gravitas.Colliders.LSMeshCollider,System.ReadOnlySpan`1<FixedMathSharp.Vector3d>,System.ReadOnlySpan`1<System.Int32>,System.ReadOnlySpan`1<System.Int32>,FixedMathSharp.Geometry.ScaledRigidFrame3d&,FixedMathSharp.Vector3d,System.ReadOnlySpan`1<FixedMathSharp.Vector3d>,System.ReadOnlySpan`1<System.Int32>,System.ReadOnlySpan`1<System.Int32>,System.ReadOnlySpan`1<System.Int32>,Gravitas.Materials.PhysicsMaterial,Gravitas.CollisionHandling.ContactManifold,System.Boolean,System.Int32,System.Int32,Gravitas.CollisionHandling.ContactGroupKey)
TryBuildMeshSphereManifold(Gravitas.CollisionHandling.CollisionWorkItem,Gravitas.Colliders.LSMeshCollider,Gravitas.Colliders.LSSphereCollider,SwiftCollections.SwiftList`1<System.Int32>)
TryBuildMeshCapsuleManifold(Gravitas.CollisionHandling.CollisionWorkItem,Gravitas.Colliders.LSMeshCollider,Gravitas.Colliders.LSCapsuleCollider,SwiftCollections.SwiftList`1<System.Int32>)
BuildJoinedRoundedManifold(Gravitas.CollisionHandling.CollisionWorkItem,Gravitas.Colliders.LSMeshCollider,Gravitas.StaticSurface,FixedMathSharp.Vector3d,FixedMathSharp.FixedQuaternion,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64)
TryBuildRoundedAxisManifold(Gravitas.CollisionHandling.CollisionWorkItem,Gravitas.Colliders.LSMeshCollider,FixedMathSharp.Vector3d,FixedMathSharp.FixedQuaternion,FixedMathSharp.Fixed64,FixedMathSharp.Fixed64,SwiftCollections.Query.FixedBoundVolume,SwiftCollections.SwiftList`1<System.Int32>)
TryBuildMeshCuboidManifold(Gravitas.CollisionHandling.CollisionWorkItem,Gravitas.Colliders.LSMeshCollider,Gravitas.Colliders.LSCuboidCollider,SwiftCollections.SwiftList`1<System.Int32>)
TryBuildMeshCylinderManifold(Gravitas.CollisionHandling.CollisionWorkItem,Gravitas.Colliders.LSMeshCollider,Gravitas.Colliders.LSCylinderCollider,SwiftCollections.SwiftList`1<System.Int32>)
AppendMeshCylinderSurfaceContacts(Gravitas.CollisionHandling.CollisionWorkItem,Gravitas.Colliders.LSMeshCollider,System.Int32,Gravitas.Colliders.LSCylinderCollider,System.ReadOnlySpan`1<System.Int32>)
AppendMeshSlabSurfaceContacts(Gravitas.Colliders.LSMeshCollider,Gravitas.Colliders.LSCollider2D,System.Int32,FixedMathSharp.Geometry.FiniteSlabRayFrame&,System.ReadOnlySpan`1<FixedMathSharp.Vector2d>,System.ReadOnlySpan`1<System.Int32>,System.Boolean,Gravitas.CollisionHandling.ContactManifold,System.Int32,System.Int32,System.Nullable`1<Gravitas.Materials.PhysicsMaterial>)
GatherMeshSlabSurfaceTriangles(Gravitas.Colliders.PhysicsMesh,System.Int32,FixedMathSharp.Geometry.FiniteSlabSectionFrame&,System.ReadOnlySpan`1<FixedMathSharp.Vector2d>,System.ReadOnlySpan`1<System.Int32>,SwiftCollections.SwiftList`1<System.Int32>,System.Boolean)
TryBuildMeshMeshManifold(Gravitas.CollisionHandling.CollisionWorkItem,Gravitas.Colliders.LSMeshCollider,Gravitas.Colliders.LSMeshCollider,SwiftCollections.SwiftList`1<System.Int32>,SwiftCollections.SwiftList`1<System.Int32>)
AppendMeshTriangleContacts(Gravitas.CollisionHandling.CollisionWorkItem,Gravitas.Colliders.LSMeshCollider,System.Int32,Gravitas.Colliders.LSMeshCollider,SwiftCollections.SwiftList`1<System.Int32>,System.Boolean,System.Nullable`1<Gravitas.CollisionHandling.ContactGroupKey>)
AppendExactTriangleContacts(Gravitas.CollisionHandling.CollisionWorkItem,Gravitas.Colliders.LSMeshCollider,FixedMathSharp.Geometry.FixedTriangle&,Gravitas.Colliders.LSMeshCollider,FixedMathSharp.Geometry.FixedTriangle&,System.Boolean,System.Boolean,System.Nullable`1<Gravitas.CollisionHandling.ContactGroupKey>)
AddMeshTriangleContact(Gravitas.CollisionHandling.CollisionWorkItem,FixedMathSharp.Geometry.FixedContactAnchors,System.Boolean,System.Nullable`1<Gravitas.CollisionHandling.ContactGroupKey>)
TryAddCuboidTriangleContact(Gravitas.CollisionHandling.CollisionWorkItem,Gravitas.Colliders.LSMeshCollider,System.Int32,Gravitas.Colliders.LSCuboidCollider)
AddReversedBoxTriangleContact(Gravitas.CollisionHandling.CollisionWorkItem,FixedMathSharp.Geometry.FixedContactAnchors)
AddReversedBoxTriangleContact(Gravitas.CollisionHandling.CollisionWorkItem,FixedMathSharp.Geometry.FixedContactAnchors,FixedMathSharp.Geometry.FixedContactLocalPoints)
TryAddCylinderTriangleContact(Gravitas.CollisionHandling.CollisionWorkItem,Gravitas.Colliders.LSMeshCollider,System.Int32,Gravitas.Colliders.LSCylinderCollider)
TryAddCylinderCapTriangleContacts(Gravitas.CollisionHandling.CollisionWorkItem,Gravitas.Colliders.LSMeshCollider,FixedMathSharp.Geometry.FixedTriangle,Gravitas.Colliders.LSCylinderCollider,FixedMathSharp.Geometry.FixedContactAnchors&,Gravitas.CollisionHandling.ContactGroupKey&)
TryAddCylinderCapTriangleContact(Gravitas.CollisionHandling.CollisionWorkItem,Gravitas.Colliders.LSMeshCollider,FixedMathSharp.Geometry.FixedTriangle,Gravitas.Colliders.LSCylinderCollider,FixedMathSharp.Vector3d,FixedMathSharp.Geometry.FixedContactAnchors&,Gravitas.CollisionHandling.ContactGroupKey&)
GetTriangleBoundsInFrame(FixedMathSharp.Geometry.FixedBoundBox,FixedMathSharp.Vector3d,FixedMathSharp.FixedQuaternion,FixedMathSharp.Vector3d,FixedMathSharp.FixedQuaternion,SwiftCollections.Query.FixedBoundVolume&)
CreateBounds(FixedMathSharp.Vector3d,FixedMathSharp.Vector3d)
AddContact(Gravitas.CollisionHandling.CollisionWorkItem,Gravitas.CollisionHandling.ContactAnchor,Gravitas.CollisionHandling.ContactAnchor,FixedMathSharp.Fixed64,FixedMathSharp.Vector3d,System.Boolean)
.ctor(FixedMathSharp.Geometry.FixedContactAnchors)
get_Point()