Fixed bug with static shape recreation (#822)

Added translation and speed functions for prismatic joint.
Fix missing sensor end touch event for fast moving shapes.
Null joint to disable collision between two specific bodies.
World user data.
More consistent functions to make polygons.
Save and load uint64 from ids.

Author: erincatto

benchmark/CMakeLists.txt

@@ -6,6 +6,7 @@ add_executable(benchmark
     large_pyramid.c
     many_pyramids.c
     smash.c
+    spinner.c
     tumbler.c
 )
 

benchmark/main.c

@@ -30,6 +30,7 @@ extern b2WorldId JointGrid( b2WorldDef* worldDef );
 extern b2WorldId LargePyramid( b2WorldDef* worldDef );
 extern b2WorldId ManyPyramids( b2WorldDef* worldDef );
 extern b2WorldId Smash( b2WorldDef* worldDef );
+extern b2WorldId Spinner( b2WorldDef* worldDef );
 extern b2WorldId Tumbler( b2WorldDef* worldDef );
 
 typedef struct Benchmark
@@ -115,13 +116,16 @@ static void FinishTask( void* userTask, void* userContext )
 }
 
 // Box2D benchmark application. On Windows I recommend running this in an administrator command prompt. Don't use Windows Terminal.
+// Or use affinity. [0x01 0x02 0x04 0x08 0x10 0x20 0x40 0x80]
+// start /affinity 0x5555 .\build\bin\Release\benchmark.exe -t=4 -w=4
 int main( int argc, char** argv )
 {
 	Benchmark benchmarks[] = {
 		{ "joint_grid", JointGrid, 500 },
 		{ "large_pyramid", LargePyramid, 500 },
 		{ "many_pyramids", ManyPyramids, 200 },
 		{ "smash", Smash, 300 },
+		{ "spinner", Spinner, 1400 },
 		{ "tumbler", Tumbler, 750 },
 	};
 

benchmark/spinner.c

@@ -0,0 +1,112 @@
+// SPDX-FileCopyrightText: 2024 Erin Catto
+// SPDX-License-Identifier: MIT
+
+#include "box2d/box2d.h"
+#include "box2d/math_functions.h"
+
+enum
+{
+	e_count = 3038,
+	e_pointCount = 360,
+};
+
+b2WorldId Spinner( b2WorldDef* worldDef )
+{
+	b2WorldId worldId = b2CreateWorld( worldDef );
+
+		b2BodyId groundId;
+	{
+		b2BodyDef bodyDef = b2DefaultBodyDef();
+		groundId = b2CreateBody( worldId, &bodyDef );
+
+		b2Vec2 points[e_pointCount];
+
+		b2Rot q = b2MakeRot( -2.0f * b2_pi / e_pointCount );
+		b2Vec2 p = { 40.0f, 0.0f };
+		for ( int i = 0; i < e_pointCount; ++i )
+		{
+			points[i] = (b2Vec2){ p.x, p.y + 32.0f };
+			p = b2RotateVector( q, p );
+		}
+
+		b2ChainDef chainDef = b2DefaultChainDef();
+		chainDef.points = points;
+		chainDef.count = e_pointCount;
+		chainDef.isLoop = true;
+		chainDef.friction = 0.1f;
+
+		b2CreateChain( groundId, &chainDef );
+	}
+
+	{
+		b2BodyDef bodyDef = b2DefaultBodyDef();
+		bodyDef.type = b2_dynamicBody;
+		bodyDef.position = (b2Vec2){ 0.0, 12.0f };
+		bodyDef.enableSleep = false;
+
+		b2BodyId spinnerId = b2CreateBody( worldId, &bodyDef );
+
+		b2Polygon box = b2MakeRoundedBox( 0.4f, 20.0f, 0.2f );
+		b2ShapeDef shapeDef = b2DefaultShapeDef();
+		shapeDef.friction = 0.0f;
+		b2CreatePolygonShape( spinnerId, &shapeDef, &box );
+
+		float motorSpeed = 5.0f;
+		float maxMotorTorque = 40000.0f;
+		b2RevoluteJointDef jointDef = b2DefaultRevoluteJointDef();
+		jointDef.bodyIdA = groundId;
+		jointDef.bodyIdB = spinnerId;
+		jointDef.localAnchorA = bodyDef.position;
+		jointDef.enableMotor = true;
+		jointDef.motorSpeed = motorSpeed;
+		jointDef.maxMotorTorque = maxMotorTorque;
+	}
+
+	b2Capsule capsule = { { -0.25f, 0.0f }, { 0.25f, 0.0f }, 0.25f };
+	b2Circle circle = { { 0.0f, 0.0f }, 0.35f };
+	b2Polygon square = b2MakeSquare( 0.35f );
+
+	b2BodyDef bodyDef = b2DefaultBodyDef();
+	bodyDef.type = b2_dynamicBody;
+	b2ShapeDef shapeDef = b2DefaultShapeDef();
+	shapeDef.friction = 0.1f;
+	shapeDef.restitution = 0.1f;
+	shapeDef.density = 0.25f;
+
+#ifdef NDEBUG
+	int bodyCount = e_count;
+#else
+	int bodyCount = 499;
+#endif
+
+	float x = -24.0f, y = 2.0f;
+	for ( int i = 0; i < bodyCount; ++i )
+	{
+		bodyDef.position = (b2Vec2){ x, y };
+		b2BodyId bodyId = b2CreateBody( worldId, &bodyDef );
+
+		int remainder = i % 3;
+		if ( remainder == 0 )
+		{
+			b2CreateCapsuleShape( bodyId, &shapeDef, &capsule );
+		}
+		else if ( remainder == 1 )
+		{
+			b2CreateCircleShape( bodyId, &shapeDef, &circle );
+		}
+		else if ( remainder == 2 )
+		{
+			b2CreatePolygonShape( bodyId, &shapeDef, &square );
+		}
+
+		x += 1.0f;
+
+		if ( x > 24.0f )
+		{
+			x = -24.0f;
+			y += 1.0f;
+		}
+	}
+
+	return worldId;
+}

docs/simulation.md

@@ -881,7 +881,11 @@ body and you can have any mix of sensors and solid shapes. Also,
 sensors only form contacts when at least one body is dynamic, so you
 will not get sensors overlap detection for kinematic versus kinematic,
 kinematic versus static, or static versus static. Finally sensors do not
-detect other sensors. 
+detect other sensors.
+
+Sensors do not detect objects that pass through the sensor shape within 
+one time step. If you have fast moving object and/or small sensors then you
+should use a ray or shape cast to detect these events.
 
 Sensor overlap detection is achieved using events, which are described
 below.

include/box2d/box2d.h

@@ -189,6 +189,12 @@ B2_API b2Profile b2World_GetProfile( b2WorldId worldId );
 /// Get world counters and sizes
 B2_API b2Counters b2World_GetCounters( b2WorldId worldId );
 
+/// Set the user data pointer.
+B2_API void b2World_SetUserData( b2WorldId worldId, void* userData );
+
+/// Get the user data pointer.
+B2_API void* b2World_GetUserData( b2WorldId worldId );
+
 /// Dump memory stats to box2d_memory.txt
 B2_API void b2World_DumpMemoryStats( b2WorldId worldId );
 
@@ -858,6 +864,21 @@ B2_API float b2MouseJoint_GetMaxForce( b2JointId jointId );
 
 /**@}*/
 
+/**
+ * @defgroup null_joint Null Joint
+ * @brief Functions for the null joint.
+ *
+ * The null joint is used to disable collision between two bodies. As a side effect of being a joint, it also
+ * keeps the two bodies in the same simulation island.
+ * @{
+ */
+
+/// Create a null joint.
+/// @see b2NullJointDef for details
+B2_API b2JointId b2CreateNullJoint( b2WorldId worldId, const b2NullJointDef* def );
+
+/**@}*/
+
 /**
  * @defgroup prismatic_joint Prismatic Joint
  * @brief A prismatic joint allows for translation along a single axis with no rotation.
@@ -927,6 +948,12 @@ B2_API float b2PrismaticJoint_GetMaxMotorForce( b2JointId jointId );
 /// Get the prismatic joint current motor force, typically in newtons
 B2_API float b2PrismaticJoint_GetMotorForce( b2JointId jointId );
 
+/// Get the current joint translation, usually in meters.
+B2_API float b2PrismaticJoint_GetTranslation( b2JointId jointId );
+
+/// Get the current joint translation speed, usually in meters per second.
+B2_API float b2PrismaticJoint_GetSpeed( b2JointId jointId );
+
 /** @} */
 
 /**

include/box2d/collision.h

@@ -180,7 +180,11 @@ B2_API b2Polygon b2MakePolygon( const b2Hull* hull, float radius );
 
 /// Make an offset convex polygon from a convex hull. This will assert if the hull is not valid.
 /// @warning Do not manually fill in the hull data, it must come directly from b2ComputeHull
-B2_API b2Polygon b2MakeOffsetPolygon( const b2Hull* hull, float radius, b2Transform transform );
+B2_API b2Polygon b2MakeOffsetPolygon( const b2Hull* hull, b2Vec2 position, b2Rot rotation );
+
+/// Make an offset convex polygon from a convex hull. This will assert if the hull is not valid.
+/// @warning Do not manually fill in the hull data, it must come directly from b2ComputeHull
+B2_API b2Polygon b2MakeOffsetRoundedPolygon( const b2Hull* hull, b2Vec2 position, b2Rot rotation, float radius );
 
 /// Make a square polygon, bypassing the need for a convex hull.
 /// @param h the half-width
@@ -200,10 +204,18 @@ B2_API b2Polygon b2MakeRoundedBox( float hx, float hy, float radius );
 /// Make an offset box, bypassing the need for a convex hull.
 /// @param hx the half-width
 /// @param hy the half-height
-/// @param center the local position of the center of the box
+/// @param center the local center of the box
 /// @param rotation the local rotation of the box
 B2_API b2Polygon b2MakeOffsetBox( float hx, float hy, b2Vec2 center, b2Rot rotation );
 
+/// Make an offset rounded box, bypassing the need for a convex hull.
+/// @param hx the half-width
+/// @param hy the half-height
+/// @param center the local center of the box
+/// @param rotation the local rotation of the box
+/// @param radius the radius of the rounded extension
+B2_API b2Polygon b2MakeOffsetRoundedBox( float hx, float hy, b2Vec2 center, b2Rot rotation, float radius );
+
 /// Transform a polygon. This is useful for transferring a shape from one body to another.
 B2_API b2Polygon b2TransformPolygon( b2Transform transform, const b2Polygon* polygon );
 
@@ -712,7 +724,7 @@ typedef bool b2TreeQueryCallbackFcn( int32_t proxyId, int32_t userData, void* co
 /// Query an AABB for overlapping proxies. The callback class is called for each proxy that overlaps the supplied AABB.
 ///	@return performance data
 B2_API b2TreeStats b2DynamicTree_Query( const b2DynamicTree* tree, b2AABB aabb, uint64_t maskBits,
-											  b2TreeQueryCallbackFcn* callback, void* context );
+										b2TreeQueryCallbackFcn* callback, void* context );
 
 /// This function receives clipped ray cast input for a proxy. The function
 /// returns the new ray fraction.
@@ -735,7 +747,7 @@ typedef float b2TreeRayCastCallbackFcn( const b2RayCastInput* input, int32_t pro
 /// @param context user context that is passed to the callback
 ///	@return performance data
 B2_API b2TreeStats b2DynamicTree_RayCast( const b2DynamicTree* tree, const b2RayCastInput* input, uint64_t maskBits,
-												b2TreeRayCastCallbackFcn* callback, void* context );
+										  b2TreeRayCastCallbackFcn* callback, void* context );
 
 /// This function receives clipped ray cast input for a proxy. The function
 /// returns the new ray fraction.
@@ -756,7 +768,7 @@ typedef float b2TreeShapeCastCallbackFcn( const b2ShapeCastInput* input, int32_t
 /// @param context user context that is passed to the callback
 ///	@return performance data
 B2_API b2TreeStats b2DynamicTree_ShapeCast( const b2DynamicTree* tree, const b2ShapeCastInput* input, uint64_t maskBits,
-												  b2TreeShapeCastCallbackFcn* callback, void* context );
+											b2TreeShapeCastCallbackFcn* callback, void* context );
 
 /// Validate this tree. For testing.
 B2_API void b2DynamicTree_Validate( const b2DynamicTree* tree );

include/box2d/id.h

@@ -56,29 +56,29 @@ typedef struct b2ShapeId
 	uint16_t revision;
 } b2ShapeId;
 
-/// Joint id references a joint instance. This should be treated as an opaque handle.
-typedef struct b2JointId
+/// Chain id references a chain instances. This should be treated as an opaque handle.
+typedef struct b2ChainId
 {
 	int32_t index1;
 	uint16_t world0;
 	uint16_t revision;
-} b2JointId;
+} b2ChainId;
 
-/// Chain id references a chain instances. This should be treated as an opaque handle.
-typedef struct b2ChainId
+/// Joint id references a joint instance. This should be treated as an opaque handle.
+typedef struct b2JointId
 {
 	int32_t index1;
 	uint16_t world0;
 	uint16_t revision;
-} b2ChainId;
+} b2JointId;
 
 /// Use these to make your identifiers null.
 /// You may also use zero initialization to get null.
 static const b2WorldId b2_nullWorldId = B2_ZERO_INIT;
 static const b2BodyId b2_nullBodyId = B2_ZERO_INIT;
 static const b2ShapeId b2_nullShapeId = B2_ZERO_INIT;
-static const b2JointId b2_nullJointId = B2_ZERO_INIT;
 static const b2ChainId b2_nullChainId = B2_ZERO_INIT;
+static const b2JointId b2_nullJointId = B2_ZERO_INIT;
 
 /// Macro to determine if any id is null.
 #define B2_IS_NULL( id ) ( id.index1 == 0 )
@@ -89,4 +89,56 @@ static const b2ChainId b2_nullChainId = B2_ZERO_INIT;
 /// Compare two ids for equality. Doesn't work for b2WorldId.
 #define B2_ID_EQUALS( id1, id2 ) ( id1.index1 == id2.index1 && id1.world0 == id2.world0 && id1.revision == id2.revision )
 
+/// Store a body id into a uint64_t.
+B2_INLINE uint64_t b2StoreBodyId( b2BodyId id )
+{
+	return ( (uint64_t)id.index1 << 32 ) | ( (uint64_t)id.world0 ) << 16 | (uint64_t)id.revision;
+}
+
+/// Load a uint64_t into a body id.
+B2_INLINE b2BodyId b2LoadBodyId( uint64_t x )
+{
+	b2BodyId id = { (int32_t)( x >> 32 ), (uint16_t)( x >> 16 ), (uint16_t)( x ) };
+	return id;
+}
+
+/// Store a shape id into a uint64_t.
+B2_INLINE uint64_t b2StoreShapeId( b2ShapeId id )
+{
+	return ( (uint64_t)id.index1 << 32 ) | ( (uint64_t)id.world0 ) << 16 | (uint64_t)id.revision;
+}
+
+/// Load a uint64_t into a shape id.
+B2_INLINE b2ShapeId b2LoadShapeId( uint64_t x )
+{
+	b2ShapeId id = { (int32_t)( x >> 32 ), (uint16_t)( x >> 16 ), (uint16_t)( x ) };
+	return id;
+}
+
+/// Store a chain id into a uint64_t.
+B2_INLINE uint64_t b2StoreChainId( b2ChainId id )
+{
+	return ( (uint64_t)id.index1 << 32 ) | ( (uint64_t)id.world0 ) << 16 | (uint64_t)id.revision;
+}
+
+/// Load a uint64_t into a chain id.
+B2_INLINE b2ChainId b2LoadChainId( uint64_t x )
+{
+	b2ChainId id = { (int32_t)( x >> 32 ), (uint16_t)( x >> 16 ), (uint16_t)( x ) };
+	return id;
+}
+
+/// Store a joint id into a uint64_t.
+B2_INLINE uint64_t b2StoreJointId( b2JointId id )
+{
+	return ( (uint64_t)id.index1 << 32 ) | ( (uint64_t)id.world0 ) << 16 | (uint64_t)id.revision;
+}
+
+/// Load a uint64_t into a joint id.
+B2_INLINE b2JointId b2LoadJointId( uint64_t x )
+{
+	b2JointId id = { (int32_t)( x >> 32 ), (uint16_t)( x >> 16 ), (uint16_t)( x ) };
+	return id;
+}
+
 /**@}*/