My customizations for consideration - Boolean Sweeps, Fast Mesh Bounds, some small API changes

BepuPhysics/BepuPhysics.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
-    <Version>2.4.0-beta6</Version>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <Version>2.4.0-neos1</Version>
     <Company>Bepu Entertainment LLC</Company>
     <Authors>Ross Nordby</Authors>
     <Description>Speedy real time physics simulation library.</Description>
@@ -10,29 +10,40 @@
     <PackageLicenseExpression>Apache-2.0</PackageLicenseExpression>
     <RepositoryUrl>https://github.com/bepu/bepuphysics2</RepositoryUrl>
     <PackageIcon>bepuphysicslogo256.png</PackageIcon>
-    <Configurations>Debug;Release;ReleaseNoProfiling</Configurations>
+    <Configurations>Debug;Release;ReleaseStrip;ReleaseStripNoProfiling</Configurations>
     <LangVersion>latest</LangVersion>
     <PackageTags>physics;3d;rigid body;real time;simulation</PackageTags>
     <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
 
     <SignAssembly>true</SignAssembly>
     <DelaySign>false</DelaySign>
     <AssemblyOriginatorKeyFile>key.snk</AssemblyOriginatorKeyFile>
+    <AssemblyVersion>2.4.0.1</AssemblyVersion>
+    <FileVersion>2.4.0.1</FileVersion>
   </PropertyGroup>
+
+  <Target Name="PostBuild" AfterTargets="PostBuildEvent">
+    <Exec Condition="'$(Configuration)'=='ReleaseStrip' Or '$(Configuration)'=='ReleaseStripNoProfiling'" Command="dotnet &quot;$(ProjectDir)..\Dependencies\ilopt\ilopt.dll&quot; &quot;$(TargetPath)&quot;" />
+  </Target>
 
   <PropertyGroup Condition="'$(Configuration)'=='Debug'">
     <Optimize>false</Optimize>
-    <DefineConstants>TRACE;DEBUG;CHECKMATH;PROFILE</DefineConstants>
+    <DefineConstants>TRACE;DEBUG;CHECKMATH;PROFILE;NETSTANDARD2_0</DefineConstants>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)'=='Release'">
     <DebugSymbols>true</DebugSymbols>
     <DebugType>embedded</DebugType>
     <Optimize>true</Optimize>
-    <DefineConstants>TRACE;RELEASE;PROFILE</DefineConstants>
+    <DefineConstants>TRACE;RELEASE;PROFILE;NETSTANDARD2_0</DefineConstants>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)'=='ReleaseStrip'">
+    <Optimize>true</Optimize>
+    <DefineConstants>TRACE;RELEASE;NETSTANDARD2_0;RELEASESTRIP;FAST_MESH_BOUNDS</DefineConstants>
   </PropertyGroup>
 
-  <PropertyGroup Condition="'$(Configuration)'=='ReleaseNoProfiling'">
+  <PropertyGroup Condition="'$(Configuration)'=='ReleaseStripNoProfiling'">
     <Optimize>true</Optimize>
     <DefineConstants>TRACE;RELEASE</DefineConstants>
   </PropertyGroup>

BepuPhysics/Collidables/BigCompound.cs

@@ -193,13 +193,11 @@ public void TestLeaf(int leafIndex, ref float maximumT)
                 Unsafe.AsRef<TOverlaps>(Overlaps).Allocate(Pool) = leafIndex;
             }
         }
-        public unsafe void FindLocalOverlaps<TOverlaps>(in Vector3 min, in Vector3 max, in Vector3 sweep, float maximumT, BufferPool pool, Shapes shapes, void* overlaps)
-            where TOverlaps : ICollisionTaskSubpairOverlaps
+
+        public unsafe void FindLocalOverlaps<TLeafTester>(in Vector3 min, in Vector3 max, in Vector3 sweep, float maximumT, BufferPool pool, Shapes shapes, ref TLeafTester leafTester)
+            where TLeafTester : ISweepLeafTester
         {
-            SweepLeafTester<TOverlaps> enumerator;
-            enumerator.Pool = pool;
-            enumerator.Overlaps = overlaps;
-            Tree.Sweep(min, max, sweep, maximumT, ref enumerator);
+            Tree.Sweep(min, max, sweep, maximumT, ref leafTester);
         }
 
         public void Dispose(BufferPool bufferPool)

BepuPhysics/Collidables/Compound.cs

@@ -259,12 +259,11 @@ public unsafe void FindLocalOverlaps<TOverlaps, TSubpairOverlaps>(ref Buffer<Ove
             }
         }
 
-        public unsafe void FindLocalOverlaps<TOverlaps>(in Vector3 min, in Vector3 max, in Vector3 sweep, float maximumT, BufferPool pool, Shapes shapes, void* overlapsPointer)
-            where TOverlaps : ICollisionTaskSubpairOverlaps
+        public unsafe void FindLocalOverlaps<TLeafTester>(in Vector3 min, in Vector3 max, in Vector3 sweep, float maximumT, BufferPool pool, Shapes shapes, ref TLeafTester leafTester)
+            where TLeafTester : ISweepLeafTester
         {
             Tree.ConvertBoxToCentroidWithExtent(min, max, out var sweepOrigin, out var expansion);
             TreeRay.CreateFrom(sweepOrigin, sweep, maximumT, out var ray);
-            ref var overlaps = ref Unsafe.AsRef<TOverlaps>(overlapsPointer);
             for (int i = 0; i < Children.Length; ++i)
             {
                 ref var child = ref Children[i];
@@ -273,10 +272,9 @@ public unsafe void FindLocalOverlaps<TOverlaps>(in Vector3 min, in Vector3 max,
                 childMax = childMax + child.LocalPose.Position + expansion;
                 if (Tree.Intersects(childMin, childMax, &ray, out _))
                 {
-                    overlaps.Allocate(pool) = i;
+                    leafTester.TestLeaf(i, ref maximumT);
                 }
             }
-
         }
 
         public void Dispose(BufferPool bufferPool)

BepuPhysics/Collidables/ConvexHullHelper.cs

@@ -194,7 +194,7 @@ static int FindNextIndexForFaceHull(Vector2 start, Vector2 previousEdgeDirection
                 best = candidateY / candidateX;
                 bestIndex = 0;
                 bestDistanceSquared = candidateX * candidateX + candidateY * candidateY;
-                var inverseBestDistance = 1f / MathF.Sqrt(bestDistanceSquared);
+                var inverseBestDistance = 1f / (float)Math.Sqrt(bestDistanceSquared);
                 currentEdgeDirectionX = candidateX * inverseBestDistance;
                 currentEdgeDirectionY = candidateY * inverseBestDistance;
             }
@@ -216,7 +216,7 @@ static int FindNextIndexForFaceHull(Vector2 start, Vector2 previousEdgeDirection
                 //1) collinear with the previous best by the plane epsilon test BUT is more distant, or
                 //2) has a greater angle than the previous best.
                 var planeOffset = -candidateX * currentEdgeDirectionY + candidateY * currentEdgeDirectionX;
-                if (MathF.Abs(planeOffset) < planeEpsilon)
+                if (Math.Abs(planeOffset) < planeEpsilon)
                 {
                     //The candidate is collinear. Only accept it if it's further away.
                     if (candidateX * candidateX + candidateY * candidateY <= bestDistanceSquared)
@@ -231,7 +231,7 @@ static int FindNextIndexForFaceHull(Vector2 start, Vector2 previousEdgeDirection
                 }
                 best = candidateY / candidateX;
                 bestDistanceSquared = candidateX * candidateX + candidateY * candidateY;
-                var inverseBestDistance = 1f / MathF.Sqrt(bestDistanceSquared);
+                var inverseBestDistance = 1f / (float)Math.Sqrt(bestDistanceSquared);
                 currentEdgeDirectionX = candidateX * inverseBestDistance;
                 currentEdgeDirectionY = candidateY * inverseBestDistance;
                 bestIndex = i;
@@ -546,7 +546,7 @@ public static void ComputeHull(Span<Vector3> points, BufferPool pool, out HullDa
             Vector3Wide.Broadcast(initialVertex, out var initialVertexBundle);
             pool.Take<Vector<float>>(pointBundles.Length, out var projectedOnX);
             pool.Take<Vector<float>>(pointBundles.Length, out var projectedOnY);
-            var planeEpsilonNarrow = MathF.Sqrt(bestDistanceSquared) * 1e-6f;
+            var planeEpsilonNarrow = (float)Math.Sqrt(bestDistanceSquared) * 1e-6f;
             var planeEpsilon = new Vector<float>(planeEpsilonNarrow);
             var rawFaceVertexIndices = new QuickList<int>(pointBundles.Length * Vector<float>.Count, pool);
             var initialSourceEdge = new EdgeEndpoints { A = initialIndex, B = initialIndex };

BepuPhysics/Collidables/Mesh.cs

@@ -46,12 +46,39 @@ public struct Mesh : IHomogeneousCompoundShape<Triangle, TriangleWide>
         public Buffer<Triangle> Triangles;
         internal Vector3 scale;
         internal Vector3 inverseScale;
+#if FAST_MESH_BOUNDS
+        internal Vector3 boundsCenter;
+        internal Vector3 boundsHalfSize;
+
+        public Vector3 BoundsCenter
+        {
+            readonly get
+            {
+                return boundsCenter;
+            }
+            set
+            {
+                boundsCenter = value;
+            }
+        }
+        public Vector3 BoundsSize
+        {
+            readonly get
+            {
+                return boundsHalfSize * 2;
+            }
+            set
+            {
+                boundsHalfSize = value * 0.5f;
+            }
+        }
+#endif
         /// <summary>
         /// Gets or sets the scale of the mesh.
         /// </summary>
         public Vector3 Scale
         {
-            get
+            readonly get
             {
                 return scale;
             }
@@ -167,6 +194,25 @@ public readonly unsafe void GetLocalChild(int triangleIndex, ref TriangleWide ta
             Vector3Wide.WriteFirst(source.C * scale, ref target.C);
         }
 
+#if FAST_MESH_BOUNDS
+        public void ComputeBounds(in Quaternion orientation, out Vector3 min, out Vector3 max)
+        {
+            Matrix3x3.CreateFromQuaternion(orientation, out var basis);
+            var x = scale.X * boundsHalfSize.X * basis.X;
+            var y = scale.Y * boundsHalfSize.Y * basis.Y;
+            var z = scale.Z * boundsHalfSize.Z * basis.Z;
+            max = Vector3.Abs(x) + Vector3.Abs(y) + Vector3.Abs(z);
+            min = -max;
+
+            var rotatedPose = Vector3.Transform(scale * boundsCenter, orientation);
+
+            min += rotatedPose;
+            max += rotatedPose;
+
+            MathChecker.Validate(min);
+            MathChecker.Validate(max);
+        }
+#else
         public readonly void ComputeBounds(in Quaternion orientation, out Vector3 min, out Vector3 max)
         {
             Matrix3x3.CreateFromQuaternion(orientation, out var r);
@@ -191,6 +237,7 @@ public readonly void ComputeBounds(in Quaternion orientation, out Vector3 min, o
                 max = Vector3.Max(max0, max1);
             }
         }
+#endif
 
         public readonly ShapeBatch CreateShapeBatch(BufferPool pool, int initialCapacity, Shapes shapeBatches)
         {
@@ -294,17 +341,14 @@ public readonly unsafe void FindLocalOverlaps<TOverlaps, TSubpairOverlaps>(ref B
             }
         }
 
-        public readonly unsafe void FindLocalOverlaps<TOverlaps>(in Vector3 min, in Vector3 max, in Vector3 sweep, float maximumT, BufferPool pool, Shapes shapes, void* overlaps)
-            where TOverlaps : ICollisionTaskSubpairOverlaps
+        public unsafe void FindLocalOverlaps<TLeafTester>(in Vector3 min, in Vector3 max, in Vector3 sweep, float maximumT, BufferPool pool, Shapes shapes, ref TLeafTester leafTester)
+            where TLeafTester : ISweepLeafTester
         {
             var scaledMin = min * inverseScale;
             var scaledMax = max * inverseScale;
             var scaledSweep = sweep * inverseScale;
-            ShapeTreeSweepLeafTester<TOverlaps> enumerator;
-            enumerator.Pool = pool;
-            enumerator.Overlaps = overlaps;
             //Take a min/max to compensate for negative scales.
-            Tree.Sweep(Vector3.Min(scaledMin, scaledMax), Vector3.Max(scaledMin, scaledMax), scaledSweep, maximumT, ref enumerator);
+            Tree.Sweep(Vector3.Min(scaledMin, scaledMax), Vector3.Max(scaledMin, scaledMax), scaledSweep, maximumT, ref leafTester);
         }
 
         public struct MeshTriangleSource : ITriangleSource

BepuPhysics/CollisionDetection/CollisionTasks/ConvexCompoundOverlapFinder.cs

@@ -1,4 +1,5 @@
 using BepuPhysics.Collidables;
+using BepuPhysics.Trees;
 using BepuUtilities;
 using BepuUtilities.Memory;
 using System.Numerics;
@@ -19,8 +20,8 @@ unsafe void FindLocalOverlaps<TOverlaps, TSubpairOverlaps>(ref Buffer<OverlapQue
             where TOverlaps : struct, ICollisionTaskOverlaps<TSubpairOverlaps>
             where TSubpairOverlaps : struct, ICollisionTaskSubpairOverlaps;
 
-        unsafe void FindLocalOverlaps<TOverlaps>(in Vector3 min, in Vector3 max, in Vector3 sweep, float maximumT, BufferPool pool, Shapes shapes, void* overlaps)
-            where TOverlaps : ICollisionTaskSubpairOverlaps;
+        unsafe void FindLocalOverlaps<TLeafTester>(in Vector3 min, in Vector3 max, in Vector3 sweep, float maximumT, BufferPool pool, Shapes shapes, ref TLeafTester leafTester)
+            where TLeafTester : ISweepLeafTester;
     }
     public interface IOverlapTestingOptions
     {

BepuPhysics/CollisionDetection/MeshReduction.cs

@@ -236,7 +236,7 @@ public unsafe static void ReduceManifolds(ref Buffer<Triangle> continuationTrian
             //The current quadratic scaling behavior of this reduction can be explosively bad as the count rises into the thousands.
             //Ideally we'll do https://github.com/bepu/bepuphysics2/issues/66 so this will become a nonissue.
             //Until then, attempting to reduce absurdo-manifolds is likely misguided. Better to have some bumps than a multi-second hang.
-            if (count > 1024)
+            if (count > 128)
                 return;
             //Narrow the region of interest.
             continuationTriangles.Slice(start, count, out var triangles);

BepuPhysics/CollisionDetection/SweepTaskRegistry.cs

@@ -72,6 +72,20 @@ protected abstract unsafe bool PreorderedTypeSweep<TSweepFilter>(
             bool flipRequired, ref TSweepFilter filter, Shapes shapes, SweepTaskRegistry sweepTasks, BufferPool pool, out float t0, out float t1, out Vector3 hitLocation, out Vector3 hitNormal)
             where TSweepFilter : ISweepFilter;
 
+        protected virtual unsafe bool PreorderedTypeCheck<TSweepFilter>(
+            void* shapeDataA, in Quaternion orientationA, in BodyVelocity velocityA,
+            void* shapeDataB, in Vector3 offsetB, in Quaternion orientationB, in BodyVelocity velocityB, float maximumT,
+            float minimumProgression, float convergenceThreshold, int maximumIterationCount,
+            bool flipRequired, ref TSweepFilter filter, Shapes shapes, SweepTaskRegistry sweepTasks, BufferPool pool)
+            where TSweepFilter : ISweepFilter
+        {
+            // Use the Sweep by default, so each sweep task doesn't have to do this in case it doesn't need to optimize the Check over Sweep
+            return PreorderedTypeSweep(shapeDataA, orientationA, velocityA,
+                shapeDataB, offsetB, orientationB, velocityB,
+                maximumT, minimumProgression, convergenceThreshold, maximumIterationCount,
+                flipRequired, ref filter, shapes, sweepTasks, pool, out _, out _, out _, out _);
+        }
+
         public unsafe bool Sweep<TSweepFilter>(
             void* shapeDataA, int shapeTypeA, in Quaternion orientationA, in BodyVelocity velocityA,
             void* shapeDataB, int shapeTypeB, in Vector3 offsetB, in Quaternion orientationB, in BodyVelocity velocityB,
@@ -104,6 +118,34 @@ public unsafe bool Sweep<TSweepFilter>(
                     out t0, out t1, out hitLocation, out hitNormal);
             }
         }
+
+        public unsafe bool Check<TSweepFilter>(
+            void* shapeDataA, int shapeTypeA, in Quaternion orientationA, in BodyVelocity velocityA,
+            void* shapeDataB, int shapeTypeB, in Vector3 offsetB, in Quaternion orientationB, in BodyVelocity velocityB,
+            float maximumT, float minimumProgression, float convergenceThreshold, int maximumIterationCount,
+            ref TSweepFilter filter, Shapes shapes, SweepTaskRegistry sweepTasks, BufferPool pool)
+            where TSweepFilter : ISweepFilter
+        {
+            Debug.Assert((shapeTypeA == ShapeTypeIndexA && shapeTypeB == ShapeTypeIndexB) || (shapeTypeA == ShapeTypeIndexB && shapeTypeB == ShapeTypeIndexA),
+                "Types must match expected types.");
+            var flipRequired = shapeTypeB == ShapeTypeIndexA;
+            if (flipRequired)
+            {
+                return PreorderedTypeCheck(
+                    shapeDataB, orientationB, velocityB,
+                    shapeDataA, -offsetB, orientationA, velocityA,
+                    maximumT, minimumProgression, convergenceThreshold, maximumIterationCount,
+                    flipRequired, ref filter, shapes, sweepTasks, pool);
+            }
+            else
+            {
+                return PreorderedTypeCheck(
+                    shapeDataA, orientationA, velocityA,
+                    shapeDataB, offsetB, orientationB, velocityB,
+                    maximumT, minimumProgression, convergenceThreshold, maximumIterationCount,
+                    flipRequired, ref filter, shapes, sweepTasks, pool);
+            }
+        }
     }
 
     public class SweepTaskRegistry

BepuPhysics/CollisionDetection/SweepTasks/CompoundHomogeneousCompoundSweepTask.cs

@@ -69,6 +69,11 @@ protected unsafe override bool PreorderedTypeSweep<TSweepFilter>(
             return t1 < float.MaxValue;
         }
 
+        void TestChild()
+        {
+
+        }
+
         protected override unsafe bool PreorderedTypeSweep(void* shapeDataA, in RigidPose localPoseA, in Quaternion orientationA, in BodyVelocity velocityA, void* shapeDataB, in RigidPose localPoseB, in Vector3 offsetB, in Quaternion orientationB, in BodyVelocity velocityB, float maximumT, float minimumProgression, float convergenceThreshold, int maximumIterationCount, out float t0, out float t1, out Vector3 hitLocation, out Vector3 hitNormal)
         {
             throw new NotImplementedException("Compounds and meshes can never be nested; this should never be called.");

BepuPhysics/CollisionDetection/SweepTasks/CompoundPairSweepOverlapFinder.cs

@@ -32,7 +32,12 @@ public unsafe void FindOverlaps(
                     offsetB, orientationB, velocityB, maximumT, out var sweep, out var min, out var max);
                 ref var childOverlaps = ref overlaps.GetOverlapsForChild(i);
                 childOverlaps.ChildIndex = i;
-                compoundB.FindLocalOverlaps<ChildOverlapsCollection>(min, max, sweep, maximumT, pool, shapes, Unsafe.AsPointer(ref childOverlaps));
+
+                ShapeTreeSweepLeafTester<ChildOverlapsCollection> enumerator;
+                enumerator.Pool = pool;
+                enumerator.Overlaps = Unsafe.AsPointer(ref childOverlaps);
+
+                compoundB.FindLocalOverlaps(min, max, sweep, maximumT, pool, shapes, ref enumerator);
             }
         }
     }