box2d-ruby 1.0.0

data/ext/box2d/vendor/box2d/src/array.h

@@ -0,0 +1,179 @@
+// SPDX-FileCopyrightText: 2023 Erin Catto
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include "core.h"
+
+// Macro generated functions for dynamic arrays
+// Pros
+// - type safe
+// - array data debuggable (visible count and capacity)
+// - bounds checking
+// - forward declaration
+// - simple implementation
+// - generates functions (like C++ templates)
+// - functions have https://en.wikipedia.org/wiki/Sequence_point
+// - avoids stretchy buffer dropped pointer update bugs
+// Cons
+// - cannot debug
+// - breaks code navigation
+
+// todo_erin consider code-gen: https://github.com/IbrahimHindawi/haikal
+
+// Array declaration that doesn't need the type T to be defined
+#define B2_ARRAY_DECLARE( T, PREFIX )                                                                                            \
+	typedef struct                                                                                                               \
+	{                                                                                                                            \
+		struct T* data;                                                                                                          \
+		int count;                                                                                                               \
+		int capacity;                                                                                                            \
+	} PREFIX##Array;                                                                                                             \
+	PREFIX##Array PREFIX##Array_Create( int capacity );                                                                          \
+	void PREFIX##Array_Reserve( PREFIX##Array* a, int newCapacity );                                                             \
+	void PREFIX##Array_Destroy( PREFIX##Array* a )
+
+#define B2_DECLARE_ARRAY_NATIVE( T, PREFIX )                                                                                     \
+	typedef struct                                                                                                               \
+	{                                                                                                                            \
+		T* data;                                                                                                                 \
+		int count;                                                                                                               \
+		int capacity;                                                                                                            \
+	} PREFIX##Array;                                                                                                             \
+	/* Create array with initial capacity. Zero initialization is also supported */                                              \
+	PREFIX##Array PREFIX##Array_Create( int capacity );                                                                          \
+	void PREFIX##Array_Reserve( PREFIX##Array* a, int newCapacity );                                                             \
+	void PREFIX##Array_Destroy( PREFIX##Array* a )
+
+// Inline array functions that need the type T to be defined
+#define B2_ARRAY_INLINE( T, PREFIX )                                                                                             \
+	/* Resize */                                                                                                                 \
+	static inline void PREFIX##Array_Resize( PREFIX##Array* a, int count )                                                       \
+	{                                                                                                                            \
+		PREFIX##Array_Reserve( a, count );                                                                                       \
+		a->count = count;                                                                                                        \
+	}                                                                                                                            \
+	/* Get */                                                                                                                    \
+	static inline T* PREFIX##Array_Get( PREFIX##Array* a, int index )                                                            \
+	{                                                                                                                            \
+		B2_ASSERT( 0 <= index && index < a->count );                                                                             \
+		return a->data + index;                                                                                                  \
+	}                                                                                                                            \
+	/* Add */                                                                                                                    \
+	static inline T* PREFIX##Array_Add( PREFIX##Array* a )                                                                       \
+	{                                                                                                                            \
+		if ( a->count == a->capacity )                                                                                           \
+		{                                                                                                                        \
+			int newCapacity = a->capacity < 2 ? 2 : a->capacity + ( a->capacity >> 1 );                                          \
+			PREFIX##Array_Reserve( a, newCapacity );                                                                             \
+		}                                                                                                                        \
+		a->count += 1;                                                                                                           \
+		return a->data + ( a->count - 1 );                                                                                       \
+	}                                                                                                                            \
+	/* Push */                                                                                                                   \
+	static inline void PREFIX##Array_Push( PREFIX##Array* a, T value )                                                           \
+	{                                                                                                                            \
+		if ( a->count == a->capacity )                                                                                           \
+		{                                                                                                                        \
+			int newCapacity = a->capacity < 2 ? 2 : a->capacity + ( a->capacity >> 1 );                                          \
+			PREFIX##Array_Reserve( a, newCapacity );                                                                             \
+		}                                                                                                                        \
+		a->data[a->count] = value;                                                                                               \
+		a->count += 1;                                                                                                           \
+	}                                                                                                                            \
+	/* Set */                                                                                                                    \
+	static inline void PREFIX##Array_Set( PREFIX##Array* a, int index, T value )                                                 \
+	{                                                                                                                            \
+		B2_ASSERT( 0 <= index && index < a->count );                                                                             \
+		a->data[index] = value;                                                                                                  \
+	}                                                                                                                            \
+	/* RemoveSwap */                                                                                                             \
+	static inline int PREFIX##Array_RemoveSwap( PREFIX##Array* a, int index )                                                    \
+	{                                                                                                                            \
+		B2_ASSERT( 0 <= index && index < a->count );                                                                             \
+		int movedIndex = B2_NULL_INDEX;                                                                                          \
+		if ( index != a->count - 1 )                                                                                             \
+		{                                                                                                                        \
+			movedIndex = a->count - 1;                                                                                           \
+			a->data[index] = a->data[movedIndex];                                                                                \
+		}                                                                                                                        \
+		a->count -= 1;                                                                                                           \
+		return movedIndex;                                                                                                       \
+	}                                                                                                                            \
+	/* Pop */                                                                                                                    \
+	static inline T PREFIX##Array_Pop( PREFIX##Array* a )                                                                        \
+	{                                                                                                                            \
+		B2_ASSERT( a->count > 0 );                                                                                               \
+		T value = a->data[a->count - 1];                                                                                         \
+		a->count -= 1;                                                                                                           \
+		return value;                                                                                                            \
+	}                                                                                                                            \
+	/* Clear */                                                                                                                  \
+	static inline void PREFIX##Array_Clear( PREFIX##Array* a )                                                                   \
+	{                                                                                                                            \
+		a->count = 0;                                                                                                            \
+	}                                                                                                                            \
+	/* ByteCount */                                                                                                              \
+	static inline int PREFIX##Array_ByteCount( PREFIX##Array* a )                                                                \
+	{                                                                                                                            \
+		return (int)( a->capacity * sizeof( T ) );                                                                               \
+	}
+
+// Array implementations to be instantiated in a source file where the type T is known
+#define B2_ARRAY_SOURCE( T, PREFIX )                                                                                             \
+	/* Create */                                                                                                                 \
+	PREFIX##Array PREFIX##Array_Create( int capacity )                                                                           \
+	{                                                                                                                            \
+		PREFIX##Array a = { 0 };                                                                                                 \
+		if ( capacity > 0 )                                                                                                      \
+		{                                                                                                                        \
+			a.data = b2Alloc( capacity * sizeof( T ) );                                                                          \
+			a.capacity = capacity;                                                                                               \
+		}                                                                                                                        \
+		return a;                                                                                                                \
+	}                                                                                                                            \
+	/* Reserve */                                                                                                                \
+	void PREFIX##Array_Reserve( PREFIX##Array* a, int newCapacity )                                                              \
+	{                                                                                                                            \
+		if ( newCapacity <= a->capacity )                                                                                        \
+		{                                                                                                                        \
+			return;                                                                                                              \
+		}                                                                                                                        \
+		a->data = b2GrowAlloc( a->data, a->capacity * sizeof( T ), newCapacity * sizeof( T ) );                                  \
+		a->capacity = newCapacity;                                                                                               \
+	}                                                                                                                            \
+	/* Destroy */                                                                                                                \
+	void PREFIX##Array_Destroy( PREFIX##Array* a )                                                                               \
+	{                                                                                                                            \
+		b2Free( a->data, a->capacity * sizeof( T ) );                                                                            \
+		a->data = NULL;                                                                                                          \
+		a->count = 0;                                                                                                            \
+		a->capacity = 0;                                                                                                         \
+	}
+
+B2_DECLARE_ARRAY_NATIVE( int, b2Int );
+B2_ARRAY_INLINE( int, b2Int )
+
+// Declare all the arrays
+B2_ARRAY_DECLARE( b2Body, b2Body );
+B2_ARRAY_DECLARE( b2BodyMoveEvent, b2BodyMoveEvent );
+B2_ARRAY_DECLARE( b2BodySim, b2BodySim );
+B2_ARRAY_DECLARE( b2BodyState, b2BodyState );
+B2_ARRAY_DECLARE( b2ChainShape, b2ChainShape );
+B2_ARRAY_DECLARE( b2Contact, b2Contact );
+B2_ARRAY_DECLARE( b2ContactBeginTouchEvent, b2ContactBeginTouchEvent );
+B2_ARRAY_DECLARE( b2ContactEndTouchEvent, b2ContactEndTouchEvent );
+B2_ARRAY_DECLARE( b2ContactHitEvent, b2ContactHitEvent );
+B2_ARRAY_DECLARE( b2ContactSim, b2ContactSim );
+B2_ARRAY_DECLARE( b2Island, b2Island );
+B2_ARRAY_DECLARE( b2IslandSim, b2IslandSim );
+B2_ARRAY_DECLARE( b2Joint, b2Joint );
+B2_ARRAY_DECLARE( b2JointSim, b2JointSim );
+B2_ARRAY_DECLARE( b2Sensor, b2Sensor );
+B2_ARRAY_DECLARE( b2SensorBeginTouchEvent, b2SensorBeginTouchEvent );
+B2_ARRAY_DECLARE( b2SensorEndTouchEvent, b2SensorEndTouchEvent );
+B2_ARRAY_DECLARE( b2SensorTaskContext, b2SensorTaskContext );
+B2_ARRAY_DECLARE( b2Shape, b2Shape );
+B2_ARRAY_DECLARE( b2ShapeRef, b2ShapeRef );
+B2_ARRAY_DECLARE( b2SolverSet, b2SolverSet );
+B2_ARRAY_DECLARE( b2TaskContext, b2TaskContext );

data/ext/box2d/vendor/box2d/src/atomic.h

@@ -0,0 +1,79 @@
+// SPDX-FileCopyrightText: 2023 Erin Catto
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include "core.h"
+
+#include <stdint.h>
+
+#if defined( _MSC_VER )
+#include <intrin.h>
+#endif
+
+static inline void b2AtomicStoreInt( b2AtomicInt* a, int value )
+{
+#if defined( _MSC_VER )
+	(void)_InterlockedExchange( (long*)&a->value, value );
+#elif defined( __GNUC__ ) || defined( __clang__ )
+	__atomic_store_n( &a->value, value, __ATOMIC_SEQ_CST );
+#else
+#error "Unsupported platform"
+#endif
+}
+
+static inline int b2AtomicLoadInt( b2AtomicInt* a )
+{
+#if defined( _MSC_VER )
+	return _InterlockedOr( (long*)&a->value, 0 );
+#elif defined( __GNUC__ ) || defined( __clang__ )
+	return __atomic_load_n( &a->value, __ATOMIC_SEQ_CST );
+#else
+#error "Unsupported platform"
+#endif
+}
+
+static inline int b2AtomicFetchAddInt( b2AtomicInt* a, int increment )
+{
+#if defined( _MSC_VER )
+	return _InterlockedExchangeAdd( (long*)&a->value, (long)increment );
+#elif defined( __GNUC__ ) || defined( __clang__ )
+	return __atomic_fetch_add( &a->value, increment, __ATOMIC_SEQ_CST );
+#else
+#error "Unsupported platform"
+#endif
+}
+
+static inline bool b2AtomicCompareExchangeInt( b2AtomicInt* a, int expected, int desired )
+{
+#if defined( _MSC_VER )
+	return _InterlockedCompareExchange( (long*)&a->value, (long)desired, (long)expected ) == expected;
+#elif defined( __GNUC__ ) || defined( __clang__ )
+	// The value written to expected is ignored
+	return __atomic_compare_exchange_n( &a->value, &expected, desired, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST );
+#else
+#error "Unsupported platform"
+#endif
+}
+
+static inline void b2AtomicStoreU32( b2AtomicU32* a, uint32_t value )
+{
+#if defined( _MSC_VER )
+	(void)_InterlockedExchange( (long*)&a->value, value );
+#elif defined( __GNUC__ ) || defined( __clang__ )
+	__atomic_store_n( &a->value, value, __ATOMIC_SEQ_CST );
+#else
+#error "Unsupported platform"
+#endif
+}
+
+static inline uint32_t b2AtomicLoadU32( b2AtomicU32* a )
+{
+#if defined( _MSC_VER )
+	return (uint32_t)_InterlockedOr( (long*)&a->value, 0 );
+#elif defined( __GNUC__ ) || defined( __clang__ )
+	return __atomic_load_n( &a->value, __ATOMIC_SEQ_CST );
+#else
+#error "Unsupported platform"
+#endif
+}

data/ext/box2d/vendor/box2d/src/bitset.c

@@ -0,0 +1,67 @@
+// SPDX-FileCopyrightText: 2023 Erin Catto
+// SPDX-License-Identifier: MIT
+
+#include "bitset.h"
+
+#include <string.h>
+
+b2BitSet b2CreateBitSet( uint32_t bitCapacity )
+{
+	b2BitSet bitSet = { 0 };
+
+	bitSet.blockCapacity = ( bitCapacity + sizeof( uint64_t ) * 8 - 1 ) / ( sizeof( uint64_t ) * 8 );
+	bitSet.blockCount = 0;
+	bitSet.bits = b2Alloc( bitSet.blockCapacity * sizeof( uint64_t ) );
+	memset( bitSet.bits, 0, bitSet.blockCapacity * sizeof( uint64_t ) );
+	return bitSet;
+}
+
+void b2DestroyBitSet( b2BitSet* bitSet )
+{
+	b2Free( bitSet->bits, bitSet->blockCapacity * sizeof( uint64_t ) );
+	bitSet->blockCapacity = 0;
+	bitSet->blockCount = 0;
+	bitSet->bits = NULL;
+}
+
+void b2SetBitCountAndClear( b2BitSet* bitSet, uint32_t bitCount )
+{
+	uint32_t blockCount = ( bitCount + sizeof( uint64_t ) * 8 - 1 ) / ( sizeof( uint64_t ) * 8 );
+	if ( bitSet->blockCapacity < blockCount )
+	{
+		b2DestroyBitSet( bitSet );
+		uint32_t newBitCapacity = bitCount + ( bitCount >> 1 );
+		*bitSet = b2CreateBitSet( newBitCapacity );
+	}
+
+	bitSet->blockCount = blockCount;
+	memset( bitSet->bits, 0, bitSet->blockCount * sizeof( uint64_t ) );
+}
+
+void b2GrowBitSet( b2BitSet* bitSet, uint32_t blockCount )
+{
+	B2_ASSERT( blockCount > bitSet->blockCount );
+	if ( blockCount > bitSet->blockCapacity )
+	{
+		uint32_t oldCapacity = bitSet->blockCapacity;
+		bitSet->blockCapacity = blockCount + blockCount / 2;
+		uint64_t* newBits = b2Alloc( bitSet->blockCapacity * sizeof( uint64_t ) );
+		memset( newBits, 0, bitSet->blockCapacity * sizeof( uint64_t ) );
+		B2_ASSERT( bitSet->bits != NULL );
+		memcpy( newBits, bitSet->bits, oldCapacity * sizeof( uint64_t ) );
+		b2Free( bitSet->bits, oldCapacity * sizeof( uint64_t ) );
+		bitSet->bits = newBits;
+	}
+
+	bitSet->blockCount = blockCount;
+}
+
+void b2InPlaceUnion( b2BitSet* B2_RESTRICT setA, const b2BitSet* B2_RESTRICT setB )
+{
+	B2_ASSERT( setA->blockCount == setB->blockCount );
+	uint32_t blockCount = setA->blockCount;
+	for ( uint32_t i = 0; i < blockCount; ++i )
+	{
+		setA->bits[i] |= setB->bits[i];
+	}
+}

data/ext/box2d/vendor/box2d/src/bitset.h

@@ -0,0 +1,65 @@
+// SPDX-FileCopyrightText: 2023 Erin Catto
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include "core.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+
+// Bit set provides fast operations on large arrays of bits.
+typedef struct b2BitSet
+{
+	uint64_t* bits;
+	uint32_t blockCapacity;
+	uint32_t blockCount;
+} b2BitSet;
+
+b2BitSet b2CreateBitSet( uint32_t bitCapacity );
+void b2DestroyBitSet( b2BitSet* bitSet );
+void b2SetBitCountAndClear( b2BitSet* bitSet, uint32_t bitCount );
+void b2InPlaceUnion( b2BitSet* setA, const b2BitSet* setB );
+void b2GrowBitSet( b2BitSet* bitSet, uint32_t blockCount );
+
+static inline void b2SetBit( b2BitSet* bitSet, uint32_t bitIndex )
+{
+	uint32_t blockIndex = bitIndex / 64;
+	B2_ASSERT( blockIndex < bitSet->blockCount );
+	bitSet->bits[blockIndex] |= ( (uint64_t)1 << bitIndex % 64 );
+}
+
+static inline void b2SetBitGrow( b2BitSet* bitSet, uint32_t bitIndex )
+{
+	uint32_t blockIndex = bitIndex / 64;
+	if ( blockIndex >= bitSet->blockCount )
+	{
+		b2GrowBitSet( bitSet, blockIndex + 1 );
+	}
+	bitSet->bits[blockIndex] |= ( (uint64_t)1 << bitIndex % 64 );
+}
+
+static inline void b2ClearBit( b2BitSet* bitSet, uint32_t bitIndex )
+{
+	uint32_t blockIndex = bitIndex / 64;
+	if ( blockIndex >= bitSet->blockCount )
+	{
+		return;
+	}
+	bitSet->bits[blockIndex] &= ~( (uint64_t)1 << bitIndex % 64 );
+}
+
+static inline bool b2GetBit( const b2BitSet* bitSet, uint32_t bitIndex )
+{
+	uint32_t blockIndex = bitIndex / 64;
+	if ( blockIndex >= bitSet->blockCount )
+	{
+		return false;
+	}
+	return ( bitSet->bits[blockIndex] & ( (uint64_t)1 << bitIndex % 64 ) ) != 0;
+}
+
+static inline int b2GetBitSetBytes( b2BitSet* bitSet )
+{
+	return bitSet->blockCapacity * sizeof( uint64_t );
+}