Update from upstream

.github/release.yml

@@ -0,0 +1,34 @@
+# .github/release.yml
+
+changelog:
+  exclude:
+    labels:
+      - ignore-for-release
+    authors:
+      - dependabot
+  categories:
+    - title: 💥 Breaking Changes
+      labels:
+        - breaking-change
+    - title: 🎉 New Features
+      labels:
+        - enhancement
+        - new-feature
+    - title: 🚀 Performance
+      labels:
+        - performance
+    - title: 🧠 Fiddling
+      labels:
+        - fiddling
+    - title: 🎮 Demos App
+      labels:
+        - demos
+    - title: 🪲 Bug Fixes
+      labels:
+        - bug
+    - title: 📄 Documentation
+      labels:
+        - documentation
+    - title: 💪 Other Changes
+      labels:
+        - "*"

.github/workflows/bepu-docs-github.yml

@@ -0,0 +1,45 @@
+# More GitHub Actions for Azure: https://github.com/Azure/actions
+
+name: Build Bepu Docs for GitHub Pages
+
+env:
+  COMMON_SETTINGS_PATH: Documentation/docfx.json
+
+on:
+  workflow_dispatch:
+
+jobs:
+  publish-docs:
+    runs-on: windows-latest
+
+    steps:
+    - name: .NET SDK Setup
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: 9.x
+
+    - name: Checkout Bepu
+      uses: actions/checkout@v4
+
+    - name: Install DocFX
+      # This installs the latest version of DocFX and may introduce breaking changes
+      # run: dotnet tool update -g docfx
+      # This installs a specific, tested version of DocFX.
+      run: dotnet tool update -g docfx --version 2.78.2
+
+    - name: Build Bepu API Docs
+      run: docfx metadata ${{ env.COMMON_SETTINGS_PATH }}
+
+    - name: Build Bepu Docs
+      run: docfx build ${{ env.COMMON_SETTINGS_PATH }}
+
+    - name: Fix Documentation Links
+      run: powershell -File Documentation/fix-links.ps1 -sitePath "Documentation/_site" -repoUrl "https://github.com/bepu/bepuphysics2/blob/master"
+
+    - name: Deploy
+      uses: peaceiris/actions-gh-pages@v4.0.0
+      with:
+        github_token: ${{ secrets.GITHUB_TOKEN }}
+        publish_dir: Documentation/_site
+        publish_branch: gh-pages
+        cname: docs.bepuphysics.com

.github/workflows/dotnet-core-publish.yml

@@ -0,0 +1,56 @@
+name: .NET Core - Publish NuGet Packages
+
+env:
+  COMMON_SETTINGS_PATH: CommonSettings.props
+  BASE_RUN_NUMBER: 23
+
+on: [workflow_dispatch]
+
+jobs:
+  build:
+
+    runs-on: windows-latest
+
+    steps:
+    - name: Print run_number
+      run: echo ${{ github.run_number }}
+    - name: Set version number
+      run: |
+        $version = "2.5.0-beta.$(${{ github.run_number }} + $env:BASE_RUN_NUMBER)"
+        echo "VERSION=$version" >> $env:GITHUB_ENV
+      shell: powershell
+    - name: Print VERSION
+      run: echo "VERSION is $env:VERSION"
+    - uses: actions/checkout@v4
+    - uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: '9.x'
+        include-prerelease: true
+    - name: Set Version in CommonSettings.props
+      run: |
+        $settingsContent = Get-Content -Path ${{ env.COMMON_SETTINGS_PATH }} -Raw
+        $updatedContent = $settingsContent -replace '<Version>.*?</Version>', "<Version>${{ env.VERSION }}</Version>"
+        Set-Content -Path ${{ env.COMMON_SETTINGS_PATH }} -Value $updatedContent
+    - name: Install dependencies
+      run: |
+        dotnet restore DemoContentBuilder
+        dotnet restore Demos
+    - name: Build
+      run: |
+        dotnet build DemoContentBuilder --configuration Release --no-restore /p:Platform=x64
+        dotnet build Demos --configuration Release --no-restore
+    - name: Test
+      run: dotnet test DemoTests -c Release --verbosity normal
+    - name: Publish
+      if: github.event_name != 'pull_request'
+      run: |
+        dotnet nuget add source "https://nuget.pkg.github.com/bepu/index.json" --name "github" --username "rossnordby" --password "${{secrets.GITHUB_TOKEN}}"
+        dotnet pack "BepuPhysics" -c Release
+        dotnet pack "BepuUtilities" -c Release
+        dotnet nuget push "**/*.nupkg" -s "github" -k "${{secrets.GITHUB_TOKEN}}" --skip-duplicate
+        dotnet nuget push "**/*.nupkg" -s "https://api.nuget.org/v3/index.json" -k "${{secrets.NUGET_KEY}}" --skip-duplicate
+    - name: Create GitHub Release Draft
+      run: |
+        gh release create ${{ env.VERSION }} --title "v${{ env.VERSION }}" --notes "Release notes for ${{ env.VERSION }}" --draft
+      env:
+        GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/dotnet-core.yml

@@ -1,18 +1,26 @@
-name: .NET Core
+name: .NET Core - Build and Test
 
 on:
   push:
-    branches: [ master ]
+    paths-ignore:
+      - '.github/**'
+      - 'Documentation/**'  
   pull_request:
-    branches: [ master ]
+    paths-ignore:
+      - '.github/**'
+      - 'Documentation/**'
 
 jobs:
   build:
 
     runs-on: windows-latest
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
+    - uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: '9.x'
+        include-prerelease: true
     - name: Install dependencies
       run: |
         dotnet restore DemoContentBuilder
@@ -23,10 +31,11 @@ jobs:
         dotnet build Demos --configuration Release --no-restore
     - name: Test
       run: dotnet test DemoTests -c Release --verbosity normal
-    - name: Publish
-      run: |
-        dotnet nuget add source "https://nuget.pkg.github.com/bepu/index.json" --name "github" --username "rossnordby" --password "${{secrets.GITHUB_TOKEN}}"
-        dotnet pack "BepuPhysics" -c Release
-        dotnet pack "BepuUtilities" -c Release
-        dotnet nuget push "**/*.nupkg" -s "github" -k "${{secrets.GITHUB_TOKEN}}" --skip-duplicate
-        dotnet nuget push "**/*.nupkg" -s "https://api.nuget.org/v3/index.json" -k "${{secrets.NUGET_KEY}}" --skip-duplicate
+#    - name: Publish
+#      if: github.event_name != 'pull_request'
+#      run: |
+#        dotnet nuget add source "https://nuget.pkg.github.com/bepu/index.json" --name "github" --username "rossnordby" --password "${{secrets.GITHUB_TOKEN}}"
+#        dotnet pack "BepuPhysics" -c Release
+#        dotnet pack "BepuUtilities" -c Release
+#        dotnet nuget push "**/*.nupkg" -s "github" -k "${{secrets.GITHUB_TOKEN}}" --skip-duplicate
+#        dotnet nuget push "**/*.nupkg" -s "https://api.nuget.org/v3/index.json" -k "${{secrets.NUGET_KEY}}" --skip-duplicate

.gitignore

@@ -205,3 +205,10 @@ ModelManifest.xml
 
 # Don't ignore content files that happen to use the .obj extension.
 !Demos/Content/*.obj
+
+# JetBrains Rider
+.idea/
+
+# DocFX API Generated Pages
+Documentation/api/*
+Documentation/_site/*

BepuPhysics/BatchCompressor.cs

@@ -1,9 +1,9 @@
-using BepuUtilities;
+using BepuPhysics.Constraints;
+using BepuUtilities;
 using BepuUtilities.Collections;
 using BepuUtilities.Memory;
 using System;
 using System.Diagnostics;
-using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Threading;
 
@@ -12,7 +12,7 @@ namespace BepuPhysics
     /// <summary>
     /// Handles the movement of constraints from higher indexed batches into lower indexed batches to avoid accumulating a bunch of unnecessary ConstraintBatches.
     /// </summary>
-    public class BatchCompressor
+    public unsafe class BatchCompressor
     {
         //We want to keep removes as fast as possible. So, when removing constraints, no attempt is made to pull constraints from higher constraint batches into the revealed slot.
         //Over time, this could result in lots of extra constraint batches that ruin multithreading performance.
@@ -97,7 +97,7 @@ struct AnalysisRegion
 
 
         Action<int> analysisWorkerDelegate;
-        public BatchCompressor(Solver solver, Bodies bodies, float targetCandidateFraction = 0.01f, float maximumCompressionFraction = 0.0005f)
+        public BatchCompressor(Solver solver, Bodies bodies, float targetCandidateFraction = 0.005f, float maximumCompressionFraction = 0.0005f)
         {
             this.Solver = solver;
             this.Bodies = bodies;
@@ -107,13 +107,12 @@ public BatchCompressor(Solver solver, Bodies bodies, float targetCandidateFracti
         }
 
 
-
         void AnalysisWorker(int workerIndex)
         {
             int jobIndex;
             while ((jobIndex = Interlocked.Increment(ref analysisJobIndex)) < analysisJobs.Count)
             {
-                DoJob(ref analysisJobs[jobIndex], workerIndex, threadDispatcher.GetThreadMemoryPool(workerIndex));
+                DoJob(ref analysisJobs[jobIndex], workerIndex, threadDispatcher.WorkerPools[workerIndex]);
             }
         }
 
@@ -124,7 +123,27 @@ void AnalysisWorker(int workerIndex)
         //It'll just require some testing.
         //(The broad phase is a pretty likely candidate for this overlay- it both causes no changes in constraints and is very stally compared to most other phases.)
 
-        unsafe void DoJob(ref AnalysisRegion region, int workerIndex, BufferPool pool)
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void TryToFindBetterBatchForConstraint(
+            BufferPool pool, ref QuickList<Compression> compressions, ref TypeBatch typeBatch, int* bodyHandles, ref ActiveConstraintDynamicBodyHandleCollector handleAccumulator, TypeProcessor typeProcessor, int constraintIndex)
+        {
+            handleAccumulator.Count = 0;
+            Solver.EnumerateConnectedRawBodyReferences(ref typeBatch, constraintIndex, ref handleAccumulator);
+            var dynamicBodyHandles = new Span<int>(bodyHandles, handleAccumulator.Count);
+            for (int batchIndex = nextBatchIndex - 1; batchIndex >= 0; --batchIndex)
+            {
+                if (Solver.batchReferencedHandles[batchIndex].CanFit(dynamicBodyHandles))
+                {
+                    compressions.Add(new Compression { ConstraintHandle = typeBatch.IndexToHandle[constraintIndex], TargetBatch = batchIndex }, pool);
+                    return;
+                }
+            }
+
+        }
+
+
+        void DoJob(ref AnalysisRegion region, int workerIndex, BufferPool pool)
         {
             ref var compressions = ref this.workerCompressions[workerIndex];
             ref var batch = ref Solver.ActiveSet.Batches[nextBatchIndex];
@@ -135,27 +154,31 @@ unsafe void DoJob(ref AnalysisRegion region, int workerIndex, BufferPool pool)
             //Each job only works on a subset of a single type batch.
             var bodiesPerConstraint = typeProcessor.BodiesPerConstraint;
             var bodyHandles = stackalloc int[bodiesPerConstraint];
-            ActiveConstraintBodyHandleCollector handleAccumulator;
+            ActiveConstraintDynamicBodyHandleCollector handleAccumulator;
             handleAccumulator.Bodies = Bodies;
             handleAccumulator.Handles = bodyHandles;
-            var bodyHandlesSpan = new Span<int>(bodyHandles, bodiesPerConstraint);
-            for (int i = region.StartIndexInTypeBatch; i < region.EndIndexInTypeBatch; ++i)
+            handleAccumulator.Count = 0;
+            if (nextBatchIndex == Solver.FallbackBatchThreshold)
             {
-                //Check if this constraint can be removed.
-                handleAccumulator.Index = 0;
-                typeProcessor.EnumerateConnectedBodyIndices(ref typeBatch, i, ref handleAccumulator);
-                for (int batchIndex = 0; batchIndex < nextBatchIndex; ++batchIndex)
+                for (int i = region.StartIndexInTypeBatch; i < region.EndIndexInTypeBatch; ++i)
                 {
-                    //The batch index will never be the fallback batch, since the fallback batch is the very last batch (if it exists at all). So uses batch referenced handles is safe.
-                    if (Solver.batchReferencedHandles[batchIndex].CanFit(bodyHandlesSpan))
-                    {
-                        compressions.Add(new Compression { ConstraintHandle = typeBatch.IndexToHandle[i], TargetBatch = batchIndex }, pool);
-                        break;
-                    }
+                    //This is a fallback batch; the rules are a little different.
+                    //Not all constraint slots up to the typeBatch.ConstraintCount are guaranteed to actually exist. It's potentially sparse.
+                    //Just skip them.
+                    if (typeBatch.IndexToHandle[i].Value >= 0)
+                        TryToFindBetterBatchForConstraint(pool, ref compressions, ref typeBatch, bodyHandles, ref handleAccumulator, typeProcessor, i);
+                }
+            }
+            else
+            {
+                for (int i = region.StartIndexInTypeBatch; i < region.EndIndexInTypeBatch; ++i)
+                {
+                    TryToFindBetterBatchForConstraint(pool, ref compressions, ref typeBatch, bodyHandles, ref handleAccumulator, typeProcessor, i);
                 }
             }
         }
 
+
         struct CompressionTarget
         {
             public ushort WorkerIndex;
@@ -172,23 +195,22 @@ public int Compare(ref CompressionTarget a, ref CompressionTarget b)
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private unsafe void ApplyCompression(int sourceBatchIndex, ref ConstraintBatch sourceBatch, ref Compression compression)
+        private void ApplyCompression(int sourceBatchIndex, ref ConstraintBatch sourceBatch, ref Compression compression)
         {
-            //Careful here: this is a reference for the sake of not doing pointless copies, but you cannot rely on it having the same values after the completion of the transfer.
-            ref var constraintLocation = ref Solver.HandleToConstraint[compression.ConstraintHandle.Value];
+            var constraintLocation = Solver.HandleToConstraint[compression.ConstraintHandle.Value];
             var typeProcessor = Solver.TypeProcessors[constraintLocation.TypeId];
             if (sourceBatchIndex == Solver.FallbackBatchThreshold)
             {
                 //We're optimizing the fallback batch, so we need to be careful about compressions interfering with each other. The parallel analysis assumed each batch
                 //contained at most one instance of each body, which doesn't hold for the fallback batch.
                 //Easy enough to address: check to see if the target batch can still hold the constraint.
-                var bodyHandles = stackalloc int[typeProcessor.BodiesPerConstraint];
-                ActiveConstraintBodyHandleCollector handleAccumulator;
+                var dynamicBodyHandles = stackalloc int[typeProcessor.BodiesPerConstraint];
+                ActiveConstraintDynamicBodyHandleCollector handleAccumulator;
                 handleAccumulator.Bodies = Bodies;
-                handleAccumulator.Handles = bodyHandles;
-                handleAccumulator.Index = 0;
-                Solver.EnumerateConnectedBodies(compression.ConstraintHandle, ref handleAccumulator);
-                if (!Solver.batchReferencedHandles[compression.TargetBatch].CanFit(new Span<int>(bodyHandles, typeProcessor.BodiesPerConstraint)))
+                handleAccumulator.Handles = dynamicBodyHandles;
+                handleAccumulator.Count = 0;
+                Solver.EnumerateConnectedRawBodyReferences(compression.ConstraintHandle, ref handleAccumulator);
+                if (!Solver.batchReferencedHandles[compression.TargetBatch].CanFit(new Span<int>(dynamicBodyHandles, handleAccumulator.Count)))
                 {
                     //Another compression from the fallback batch has blocked this compression.
                     //Note that this isn't really a problem- batch compression is an incremental process. If some other compression was possible, a future frame will find it pretty quickly.
@@ -222,7 +244,7 @@ public void Compress(BufferPool pool, IThreadDispatcher threadDispatcher = null,
             for (int i = 0; i < workerCount; ++i)
             {
                 //Be careful: the jobs may require resizes on the compression count list. That requires the use of per-worker pools.
-                workerCompressions[i] = new QuickList<Compression>(Math.Max(8, maximumCompressionCount), threadDispatcher == null ? pool : threadDispatcher.GetThreadMemoryPool(i));
+                workerCompressions[i] = new QuickList<Compression>(Math.Max(8, maximumCompressionCount), threadDispatcher == null ? pool : threadDispatcher.WorkerPools[i]);
             }
 
             //In any given compression attempt, we only optimize over one ConstraintBatch.
@@ -292,7 +314,7 @@ public void Compress(BufferPool pool, IThreadDispatcher threadDispatcher = null,
             {
                 analysisJobIndex = -1;
                 this.threadDispatcher = threadDispatcher;
-                threadDispatcher.DispatchWorkers(analysisWorkerDelegate);
+                threadDispatcher.DispatchWorkers(analysisWorkerDelegate, analysisJobs.Count);
                 this.threadDispatcher = null;
             }
             else
@@ -377,11 +399,16 @@ public void Compress(BufferPool pool, IThreadDispatcher threadDispatcher = null,
             //var applyTime = 1e6 * (applyEnd - applyStart) / Stopwatch.Frequency;
             //Console.WriteLine($"Apply time (us): {applyTime}, per applied: {applyTime / compressionsApplied}, (maximum: {maximumCompressionCount})");
 
-            for (int i = 0; i < workerCount; ++i)
+            if (threadDispatcher == null)
+                workerCompressions[0].Dispose(pool);
+            else
             {
-                //Be careful: the jobs may require resizes on the compression count list. That requires the use of per-worker pools.
-                workerCompressions[i].Dispose((threadDispatcher == null ? pool : threadDispatcher.GetThreadMemoryPool(i)));
+                for (int i = 0; i < workerCount; ++i)
+                {
+                    workerCompressions[i].Dispose(threadDispatcher.WorkerPools[i]);
+                }
             }
+
             pool.Return(ref workerCompressions);
         }