[upstream] Kinematic perf (erincatto/box2d#970)

Kinematic perf (erincatto/box2d#970)

- b2Shape_SetMaterial -> b2Shape_SetUserMaterial
- Reworked surface material access on chain shapes
- Removed mouse joint. Functionality is now covered by the motor joint.
- Added b2DynamicTree_QueryAll to support debug draw for shapes that
don't collide
- The user material id is now a 64 bits
- Fixed crash when samples app is minimized
- Added kinematic washer sample
- Fix erincatto/box2d#967
- #968 - draw shapes with 0 category bits and draw sleeping contacts
- Kinematic bodies no longer enter graph coloring
- The joint and contact solvers no longer write the state of kinematic
bodies
- Large kinematic bodies touching many dynamic bodies now has better
multithreaded scaling
- Joints between two non-dynamic bodies no longer simulate
- Minor island splitting optimization suggested by Dirk, use the island
id instead of a bool mark
- Joints now have a constraint damping ratio of 2.0 instead of 0.
Intended to reduce overshoot when limits are violated.
- Restored island debug draw

Author: ikpil

src/.DS_Store

@@ -100,9 +100,17 @@ public void BuildProjectionMatrix(Span<float> m, float zBias)
 
     public B2AABB GetViewBounds()
     {
-        B2AABB bounds;
-        bounds.lowerBound = ConvertScreenToWorld(new B2Vec2(0.0f, (float)m_height));
-        bounds.upperBound = ConvertScreenToWorld(new B2Vec2((float)m_width, 0.0f));
-        return bounds;
+        if (m_height == 0.0f || m_width == 0.0f)
+        {
+            B2AABB bounds = new B2AABB(b2Vec2_zero, b2Vec2_zero);
+            return bounds;
+        }
+
+        {
+            B2AABB bounds;
+            bounds.lowerBound = ConvertScreenToWorld(new B2Vec2(0.0f, (float)m_height));
+            bounds.upperBound = ConvertScreenToWorld(new B2Vec2((float)m_width, 0.0f));
+            return bounds;
+        }
     }
 }

src/Box2D.NET.Samples/Camera.cs

@@ -84,15 +84,15 @@ public BenchmarkSensor(SampleContext context) : base(context)
 
             float yStart = 10.0f;
             m_filterRow = m_rowCount >> 1;
-            
+
             for (int j = 0; j < m_rowCount; ++j)
             {
                 m_passiveSensors[j] = new ShapeUserData();
                 m_passiveSensors[j].row = j;
                 m_passiveSensors[j].active = false;
                 shapeDef.userData = m_passiveSensors[j];
-                
-                if ( j == m_filterRow )
+
+                if (j == m_filterRow)
                 {
                     shapeDef.enableCustomFiltering = true;
                     shapeDef.material.customColor = (uint)B2HexColor.b2_colorFuchsia;
@@ -199,7 +199,7 @@ public override void Step()
                 // Modify color while overlapped with a sensor
                 B2SurfaceMaterial surfaceMaterial = b2Shape_GetSurfaceMaterial(@event.visitorShapeId);
                 surfaceMaterial.customColor = (uint)B2HexColor.b2_colorLime;
-                b2Shape_SetSurfaceMaterial(@event.visitorShapeId, surfaceMaterial);
+                b2Shape_SetSurfaceMaterial(@event.visitorShapeId, ref surfaceMaterial);
             }
         }
 
@@ -215,7 +215,7 @@ public override void Step()
             // Restore color to default
             B2SurfaceMaterial surfaceMaterial = b2Shape_GetSurfaceMaterial(@event.visitorShapeId);
             surfaceMaterial.customColor = 0;
-            b2Shape_SetSurfaceMaterial(@event.visitorShapeId, surfaceMaterial);
+            b2Shape_SetSurfaceMaterial(@event.visitorShapeId, ref surfaceMaterial);
         }
 
         foreach (B2BodyId bodyId in zombies)

src/Box2D.NET.Samples/Samples/Benchmarks/BenchmarkSensor.cs

@@ -9,6 +9,7 @@
 using static Box2D.NET.B2Shapes;
 using static Box2D.NET.B2Timers;
 using static Box2D.NET.B2Diagnostics;
+using static Box2D.NET.B2Joints;
 
 namespace Box2D.NET.Samples.Samples.Benchmarks;
 
@@ -22,11 +23,8 @@ public class BenchmarkSleep : Sample
     private B2BodyId[] m_bodies = new B2BodyId[e_maxBodyCount];
     private int m_bodyCount;
     private int m_baseCount;
-    private int m_iterations;
     private float m_wakeTotal;
     private float m_sleepTotal;
-    private int m_wakeCount;
-    private int m_sleepCount;
     private bool m_awake;
 
 
@@ -44,36 +42,20 @@ public BenchmarkSleep(SampleContext context) : base(context)
             m_camera.m_zoom = 25.0f * 2.2f;
         }
 
-        float groundSize = 100.0f;
-
-        B2BodyDef bodyDef = b2DefaultBodyDef();
-        B2BodyId groundId = b2CreateBody(m_worldId, ref bodyDef);
+        {
+            float groundSize = 100.0f;
 
-        B2Polygon box = b2MakeBox(groundSize, 1.0f);
-        B2ShapeDef shapeDef = b2DefaultShapeDef();
-        b2CreatePolygonShape(groundId, ref shapeDef, ref box);
+            B2BodyDef bodyDef = b2DefaultBodyDef();
+            B2BodyId groundId = b2CreateBody(m_worldId, ref bodyDef);
 
-        for (int i = 0; i < e_maxBodyCount; ++i)
-        {
-            m_bodies[i] = b2_nullBodyId;
+            B2Polygon box = b2MakeBox(groundSize, 1.0f);
+            B2ShapeDef shapeDef = b2DefaultShapeDef();
+            b2CreatePolygonShape(groundId, ref shapeDef, ref box);
         }
 
         m_baseCount = m_isDebug ? 40 : 100;
-        m_iterations = m_isDebug ? 1 : 41;
         m_bodyCount = 0;
-        m_awake = false;
-
-        m_wakeTotal = 0.0f;
-        m_wakeCount = 0;
-
-        m_sleepTotal = 0.0f;
-        m_sleepCount = 0;
-
-        CreateScene();
-    }
 
-    void CreateScene()
-    {
         for (int i = 0; i < e_maxBodyCount; ++i)
         {
             if (B2_IS_NON_NULL(m_bodies[i]))
@@ -89,77 +71,73 @@ void CreateScene()
         float centerx = shift * count / 2.0f;
         float centery = shift / 2.0f + 1.0f;
 
-        B2BodyDef bodyDef = b2DefaultBodyDef();
-        bodyDef.type = B2BodyType.b2_dynamicBody;
+        {
+            B2BodyDef bodyDef = b2DefaultBodyDef();
+            bodyDef.type = B2BodyType.b2_dynamicBody;
 
-        B2ShapeDef shapeDef = b2DefaultShapeDef();
-        shapeDef.density = 1.0f;
-        shapeDef.material.friction = 0.5f;
+            B2ShapeDef shapeDef = b2DefaultShapeDef();
+            shapeDef.density = 1.0f;
+            shapeDef.material.friction = 0.5f;
 
-        float h = 0.5f;
-        B2Polygon box = b2MakeRoundedBox(h, h, 0.0f);
+            float h = 0.5f;
+            B2Polygon box = b2MakeRoundedBox(h, h, 0.0f);
 
-        int index = 0;
+            int index = 0;
 
-        for (int i = 0; i < count; ++i)
-        {
-            float y = i * shift + centery;
-
-            for (int j = i; j < count; ++j)
+            for (int i = 0; i < count; ++i)
             {
-                float x = 0.5f * i * shift + (j - i) * shift - centerx;
-                bodyDef.position = new B2Vec2(x, y);
+                float y = i * shift + centery;
+
+                for (int j = i; j < count; ++j)
+                {
+                    float x = 0.5f * i * shift + (j - i) * shift - centerx;
+                    bodyDef.position = new B2Vec2(x, y);
 
-                B2_ASSERT(index < e_maxBodyCount);
-                m_bodies[index] = b2CreateBody(m_worldId, ref bodyDef);
-                b2CreatePolygonShape(m_bodies[index], ref shapeDef, ref box);
+                    B2_ASSERT(index < e_maxBodyCount);
+                    m_bodies[index] = b2CreateBody(m_worldId, ref bodyDef);
+                    b2CreatePolygonShape(m_bodies[index], ref shapeDef, ref box);
 
-                index += 1;
+                    index += 1;
+                }
             }
-        }
 
-        m_bodyCount = index;
+            m_bodyCount = index;
+            m_wakeTotal = 0.0f;
+            m_sleepTotal = 0.0f;
+        }
     }
 
     public override void Step()
     {
-        ulong ticks = b2GetTicks();
-
-        for (int i = 0; i < m_iterations; ++i)
+        // These operations don't show up in b2Profile
+        if (m_stepCount > 20)
         {
-            b2Body_SetAwake(m_bodies[0], m_awake);
-            if (m_awake)
-            {
-                m_wakeTotal += b2GetMillisecondsAndReset(ref ticks);
-                m_wakeCount += 1;
-            }
-            else
-            {
-                m_sleepTotal += b2GetMillisecondsAndReset(ref ticks);
-                m_sleepCount += 1;
-            }
+            // Creating and destroying a joint will engage the island splitter.
+            b2FilterJointDef jointDef = b2DefaultFilterJointDef();
+            jointDef.@base.bodyIdA = m_bodies[0];
+            jointDef.@base.bodyIdB = m_bodies[1];
+            B2JointId jointId = b2CreateFilterJoint(m_worldId, ref jointDef);
 
-            m_awake = !m_awake;
-        }
+            ulong ticks = b2GetTicks();
 
+            // This will wake the island
+            b2DestroyJoint(jointId);
+            m_wakeTotal += b2GetMillisecondsAndReset(ref ticks);
+
+            // Put the island back to sleep. It must be split because a constraint was removed.
+            b2Body_SetAwake(m_bodies[0], false);
+            m_sleepTotal += b2GetMillisecondsAndReset(ref ticks);
+        }
 
         base.Step();
     }
 
     public override void Draw(Settings settings)
     {
         base.Draw(settings);
-        
-        if (m_wakeCount > 0)
-        {
-            DrawTextLine($"wake ave = {m_wakeTotal / m_wakeCount:g} ms");
-            
-        }
 
-        if (m_sleepCount > 0)
-        {
-            DrawTextLine($"sleep ave = {m_sleepTotal / m_sleepCount:g} ms");
-            
-        }
+        int count = m_stepCount - 20;
+        DrawTextLine($"wake ave = {m_wakeTotal / count:g} ms");
+        DrawTextLine($"sleep ave = {m_sleepTotal / count:g} ms");
     }
 }

src/Box2D.NET.Samples/Samples/Benchmarks/BenchmarkSleep.cs

@@ -20,7 +20,7 @@ public BenchmarkTumbler(SampleContext context) : base(context)
         if (m_context.settings.restart == false)
         {
             m_camera.m_center = new B2Vec2(1.5f, 10.0f);
-            m_camera.m_zoom = 25.0f * 0.6f;
+            m_camera.m_zoom = 15.0f;
         }
 
         CreateTumbler(m_worldId);

src/Box2D.NET.Samples/Samples/Benchmarks/BenchmarkTumbler.cs

@@ -0,0 +1,24 @@
+using static Box2D.NET.Shared.Benchmarks;
+
+namespace Box2D.NET.Samples.Samples.Benchmarks;
+
+public class BenchmarkWasher : Sample
+{
+    private static int SampleBenchmarkWasher = SampleFactory.Shared.RegisterSample("Benchmark", "Washer", Create);
+
+    private static Sample Create(SampleContext context)
+    {
+        return new BenchmarkWasher(context);
+    }
+
+    private BenchmarkWasher(SampleContext context) : base(context)
+    {
+        if (m_context.settings.restart == false)
+        {
+            m_context.camera.m_center = new B2Vec2(1.5f, 10.0f);
+            m_context.camera.m_zoom = 20.0f;
+        }
+
+        CreateWasher(m_worldId, true);
+    }
+}

src/Box2D.NET.Samples/Samples/Benchmarks/BenchmarkWasher.cs

@@ -0,0 +1,66 @@
+// SPDX-FileCopyrightText: 2025 Erin Catto
+// SPDX-FileCopyrightText: 2025 Ikpil Choi([email protected])
+// SPDX-License-Identifier: MIT
+
+using static Box2D.NET.B2Geometries;
+using static Box2D.NET.B2Types;
+using static Box2D.NET.B2Bodies;
+using static Box2D.NET.B2Shapes;
+
+
+namespace Box2D.NET.Samples.Samples.Bodies;
+
+public class SetVelocity : Sample
+{
+    private static int SampleSetVelocity = SampleFactory.Shared.RegisterSample("Bodies", "Set Velocity", Create);
+
+    private static Sample Create(SampleContext context)
+    {
+        return new SetVelocity(context);
+    }
+
+    private B2BodyId m_bodyId;
+
+    private SetVelocity(SampleContext context) : base(context)
+    {
+        if (m_context.settings.restart == false)
+        {
+            m_context.camera.m_center = new B2Vec2(0.0f, 2.5f);
+            m_context.camera.m_zoom = 3.5f;
+        }
+
+        {
+            B2BodyDef bodyDef = b2DefaultBodyDef();
+            bodyDef.position = new B2Vec2(0.0f, -0.25f);
+            B2BodyId groundId = b2CreateBody(m_worldId, ref bodyDef);
+
+            B2ShapeDef shapeDef = b2DefaultShapeDef();
+            B2Polygon box = b2MakeBox(20.0f, 0.25f);
+            b2CreatePolygonShape(groundId, ref shapeDef, ref box);
+        }
+
+        {
+            B2BodyDef bodyDef = b2DefaultBodyDef();
+            bodyDef.type = B2BodyType.b2_dynamicBody;
+
+            B2ShapeDef shapeDef = b2DefaultShapeDef();
+            B2Polygon box = b2MakeSquare(0.5f);
+            bodyDef.position = new B2Vec2(0.0f, 0.5f);
+            m_bodyId = b2CreateBody(m_worldId, ref bodyDef);
+            b2CreatePolygonShape(m_bodyId, ref shapeDef, ref box);
+        }
+    }
+
+    public override void Step()
+    {
+        base.Step();
+        b2Body_SetLinearVelocity(m_bodyId, new B2Vec2(0.0f, -20.0f));
+    }
+
+    public override void Draw(Settings settings)
+    {
+        base.Draw(settings);
+        B2Vec2 position = b2Body_GetPosition(m_bodyId);
+        DrawTextLine($"(x, y) = {position.X:G}, {position.Y:G})");
+    }
+}

src/Box2D.NET.Samples/Samples/Bodies/SetVelocity.cs

@@ -79,12 +79,12 @@ public Weeble(SampleContext context) : base(context)
         m_explosionMagnitude = 8.0f;
     }
 
-    static float FrictionCallback(float frictionA, int materialA, float frictionB, int materialB)
+    static float FrictionCallback(float frictionA, ulong materialA, float frictionB, ulong materialB)
     {
         return 0.1f;
     }
 
-    static float RestitutionCallback(float restitutionA, int materialA, float restitutionB, int materialB)
+    static float RestitutionCallback(float restitutionA, ulong materialA, float restitutionB, ulong materialB)
     {
         return 1.0f;
     }