box2d-ruby 1.0.0

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

@@ -0,0 +1,238 @@
+// SPDX-FileCopyrightText: 2023 Erin Catto
+// SPDX-License-Identifier: MIT
+
+#include "table.h"
+
+#include "atomic.h"
+#include "core.h"
+#include "ctz.h"
+
+#include <stdbool.h>
+#include <string.h>
+
+#if B2_SNOOP_TABLE_COUNTERS
+b2AtomicInt b2_findCount;
+b2AtomicInt b2_probeCount;
+#endif
+
+// todo compare with https://github.com/skeeto/scratch/blob/master/set32/set32.h
+
+b2HashSet b2CreateSet( int capacity )
+{
+	b2HashSet set = { 0 };
+
+	// Capacity must be a power of 2
+	if ( capacity > 16 )
+	{
+		set.capacity = b2RoundUpPowerOf2( capacity );
+	}
+	else
+	{
+		set.capacity = 16;
+	}
+
+	set.count = 0;
+	set.items = b2Alloc( capacity * sizeof( b2SetItem ) );
+	memset( set.items, 0, capacity * sizeof( b2SetItem ) );
+
+	return set;
+}
+
+void b2DestroySet( b2HashSet* set )
+{
+	b2Free( set->items, set->capacity * sizeof( b2SetItem ) );
+	set->items = NULL;
+	set->count = 0;
+	set->capacity = 0;
+}
+
+void b2ClearSet( b2HashSet* set )
+{
+	set->count = 0;
+	memset( set->items, 0, set->capacity * sizeof( b2SetItem ) );
+}
+
+// I need a good hash because the keys are built from pairs of increasing integers.
+// A simple hash like hash = (integer1 XOR integer2) has many collisions.
+// https://lemire.me/blog/2018/08/15/fast-strongly-universal-64-bit-hashing-everywhere/
+// https://preshing.com/20130107/this-hash-set-is-faster-than-a-judy-array/
+// todo try: https://www.jandrewrogers.com/2019/02/12/fast-perfect-hashing/
+// todo try: https://probablydance.com/2018/06/16/fibonacci-hashing-the-optimization-that-the-world-forgot-or-a-better-alternative-to-integer-modulo/
+static uint32_t b2KeyHash( uint64_t key )
+{
+	// Murmur hash
+	uint64_t h = key;
+	h ^= h >> 33;
+	h *= 0xff51afd7ed558ccduLL;
+	h ^= h >> 33;
+	h *= 0xc4ceb9fe1a85ec53uLL;
+	h ^= h >> 33;
+
+	return (uint32_t)h;
+}
+
+static int b2FindSlot( const b2HashSet* set, uint64_t key, uint32_t hash )
+{
+#if B2_SNOOP_TABLE_COUNTERS 
+		b2AtomicFetchAddInt( &b2_findCount, 1 );
+#endif
+
+	uint32_t capacity = set->capacity;
+	int index = hash & ( capacity - 1 );
+	const b2SetItem* items = set->items;
+	while ( items[index].hash != 0 && items[index].key != key )
+	{
+#if B2_SNOOP_TABLE_COUNTERS
+		b2AtomicFetchAddInt( &b2_probeCount, 1 );
+#endif
+		index = ( index + 1 ) & ( capacity - 1 );
+	}
+
+	return index;
+}
+
+static void b2AddKeyHaveCapacity( b2HashSet* set, uint64_t key, uint32_t hash )
+{
+	int index = b2FindSlot( set, key, hash );
+	b2SetItem* items = set->items;
+	B2_ASSERT( items[index].hash == 0 );
+
+	items[index].key = key;
+	items[index].hash = hash;
+	set->count += 1;
+}
+
+static void b2GrowTable( b2HashSet* set )
+{
+	uint32_t oldCount = set->count;
+	B2_UNUSED( oldCount );
+
+	uint32_t oldCapacity = set->capacity;
+	b2SetItem* oldItems = set->items;
+
+	set->count = 0;
+	// Capacity must be a power of 2
+	set->capacity = 2 * oldCapacity;
+	set->items = b2Alloc( set->capacity * sizeof( b2SetItem ) );
+	memset( set->items, 0, set->capacity * sizeof( b2SetItem ) );
+
+	// Transfer items into new array
+	for ( uint32_t i = 0; i < oldCapacity; ++i )
+	{
+		b2SetItem* item = oldItems + i;
+		if ( item->hash == 0 )
+		{
+			// this item was empty
+			continue;
+		}
+
+		b2AddKeyHaveCapacity( set, item->key, item->hash );
+	}
+
+	B2_ASSERT( set->count == oldCount );
+
+	b2Free( oldItems, oldCapacity * sizeof( b2SetItem ) );
+}
+
+bool b2ContainsKey( const b2HashSet* set, uint64_t key )
+{
+	// key of zero is a sentinel
+	B2_ASSERT( key != 0 );
+	uint32_t hash = b2KeyHash( key );
+	int index = b2FindSlot( set, key, hash );
+	return set->items[index].key == key;
+}
+
+int b2GetHashSetBytes( b2HashSet* set )
+{
+	return set->capacity * (int)sizeof( b2SetItem );
+}
+
+bool b2AddKey( b2HashSet* set, uint64_t key )
+{
+	// key of zero is a sentinel
+	B2_ASSERT( key != 0 );
+
+	uint32_t hash = b2KeyHash( key );
+	B2_ASSERT( hash != 0 );
+
+	int index = b2FindSlot( set, key, hash );
+	if ( set->items[index].hash != 0 )
+	{
+		// Already in set
+		B2_ASSERT( set->items[index].hash == hash && set->items[index].key == key );
+		return true;
+	}
+
+	if ( 2 * set->count >= set->capacity )
+	{
+		b2GrowTable( set );
+	}
+
+	b2AddKeyHaveCapacity( set, key, hash );
+	return false;
+}
+
+// See https://en.wikipedia.org/wiki/Open_addressing
+bool b2RemoveKey( b2HashSet* set, uint64_t key )
+{
+	uint32_t hash = b2KeyHash( key );
+	int i = b2FindSlot( set, key, hash );
+	b2SetItem* items = set->items;
+	if ( items[i].hash == 0 )
+	{
+		// Not in set
+		return false;
+	}
+
+	// Mark item i as unoccupied
+	items[i].key = 0;
+	items[i].hash = 0;
+
+	B2_ASSERT( set->count > 0 );
+	set->count -= 1;
+
+	// Attempt to fill item i
+	int j = i;
+	uint32_t capacity = set->capacity;
+	for ( ;; )
+	{
+		j = ( j + 1 ) & ( capacity - 1 );
+		if ( items[j].hash == 0 )
+		{
+			break;
+		}
+
+		// k is the first item for the hash of j
+		int k = items[j].hash & ( capacity - 1 );
+
+		// determine if k lies cyclically in (i,j]
+		// i <= j: | i..k..j |
+		// i > j: |.k..j  i....| or |....j     i..k.|
+		if ( i <= j )
+		{
+			if ( i < k && k <= j )
+			{
+				continue;
+			}
+		}
+		else
+		{
+			if ( i < k || k <= j )
+			{
+				continue;
+			}
+		}
+
+		// Move j into i
+		items[i] = items[j];
+
+		// Mark item j as unoccupied
+		items[j].key = 0;
+		items[j].hash = 0;
+
+		i = j;
+	}
+
+	return true;
+}

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

@@ -0,0 +1,37 @@
+// SPDX-FileCopyrightText: 2023 Erin Catto
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#define B2_SHAPE_PAIR_KEY( K1, K2 ) K1 < K2 ? (uint64_t)K1 << 32 | (uint64_t)K2 : (uint64_t)K2 << 32 | (uint64_t)K1
+
+typedef struct b2SetItem
+{
+	uint64_t key;
+	uint32_t hash;
+} b2SetItem;
+
+typedef struct b2HashSet
+{
+	b2SetItem* items;
+	uint32_t capacity;
+	uint32_t count;
+} b2HashSet;
+
+b2HashSet b2CreateSet( int capacity );
+void b2DestroySet( b2HashSet* set );
+
+void b2ClearSet( b2HashSet* set );
+
+// Returns true if key was already in set
+bool b2AddKey( b2HashSet* set, uint64_t key );
+
+// Returns true if the key was found
+bool b2RemoveKey( b2HashSet* set, uint64_t key );
+
+bool b2ContainsKey( const b2HashSet* set, uint64_t key );
+
+int b2GetHashSetBytes( b2HashSet* set );

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

@@ -0,0 +1,185 @@
+// SPDX-FileCopyrightText: 2023 Erin Catto
+// SPDX-License-Identifier: MIT
+
+#include "box2d/base.h"
+
+#include <stddef.h>
+
+#if defined( _MSC_VER )
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN 1
+#endif
+
+#include <windows.h>
+
+static double s_invFrequency = 0.0;
+
+uint64_t b2GetTicks( void )
+{
+	LARGE_INTEGER counter;
+	QueryPerformanceCounter( &counter );
+	return (uint64_t)counter.QuadPart;
+}
+
+float b2GetMilliseconds( uint64_t ticks )
+{
+	if ( s_invFrequency == 0.0 )
+	{
+		LARGE_INTEGER frequency;
+		QueryPerformanceFrequency( &frequency );
+
+		s_invFrequency = (double)frequency.QuadPart;
+		if ( s_invFrequency > 0.0 )
+		{
+			s_invFrequency = 1000.0 / s_invFrequency;
+		}
+	}
+
+	uint64_t ticksNow = b2GetTicks();
+	return (float)( s_invFrequency * ( ticksNow - ticks ) );
+}
+
+float b2GetMillisecondsAndReset( uint64_t* ticks )
+{
+	if ( s_invFrequency == 0.0 )
+	{
+		LARGE_INTEGER frequency;
+		QueryPerformanceFrequency( &frequency );
+
+		s_invFrequency = (double)frequency.QuadPart;
+		if ( s_invFrequency > 0.0 )
+		{
+			s_invFrequency = 1000.0 / s_invFrequency;
+		}
+	}
+
+	uint64_t ticksNow = b2GetTicks();
+	float ms = (float)( s_invFrequency * ( ticksNow - *ticks ) );
+	*ticks = ticksNow;
+	return ms;
+}
+
+void b2Yield( void )
+{
+	SwitchToThread();
+}
+
+#elif defined( __linux__ ) || defined( __EMSCRIPTEN__ )
+
+#include <sched.h>
+#include <time.h>
+
+uint64_t b2GetTicks( void )
+{
+	struct timespec ts;
+	clock_gettime( CLOCK_MONOTONIC, &ts );
+	return ts.tv_sec * 1000000000LL + ts.tv_nsec;
+}
+
+float b2GetMilliseconds( uint64_t ticks )
+{
+	uint64_t ticksNow = b2GetTicks();
+	return (float)( (ticksNow - ticks) / 1000000.0 );
+}
+
+float b2GetMillisecondsAndReset( uint64_t* ticks )
+{
+	uint64_t ticksNow = b2GetTicks();
+	float ms = (float)( (ticksNow - *ticks) / 1000000.0 );
+	*ticks = ticksNow;
+	return ms;
+}
+
+void b2Yield( void )
+{
+	sched_yield();
+}
+
+#elif defined( __APPLE__ )
+
+#include <mach/mach_time.h>
+#include <sched.h>
+#include <sys/time.h>
+
+static double s_invFrequency = 0.0;
+
+uint64_t b2GetTicks( void )
+{
+	return mach_absolute_time();
+}
+
+float b2GetMilliseconds( uint64_t ticks )
+{
+	if ( s_invFrequency == 0 )
+	{
+		mach_timebase_info_data_t timebase;
+		mach_timebase_info( &timebase );
+
+		// convert to ns then to ms
+		s_invFrequency = 1e-6 * (double)timebase.numer / (double)timebase.denom;
+	}
+
+	uint64_t ticksNow = b2GetTicks();
+	return (float)( s_invFrequency * (ticksNow - ticks) );
+}
+
+float b2GetMillisecondsAndReset( uint64_t* ticks )
+{
+	if ( s_invFrequency == 0 )
+	{
+		mach_timebase_info_data_t timebase;
+		mach_timebase_info( &timebase );
+
+		// convert to ns then to ms
+		s_invFrequency = 1e-6 * (double)timebase.numer / (double)timebase.denom;
+	}
+
+	uint64_t ticksNow = b2GetTicks();
+	float ms = (float)( s_invFrequency * ( ticksNow - *ticks ) );
+	*ticks = ticksNow;
+	return ms;
+}
+
+void b2Yield( void )
+{
+	sched_yield();
+}
+
+#else
+
+uint64_t b2GetTicks( void )
+{
+	return 0;
+}
+
+float b2GetMilliseconds( uint64_t ticks )
+{
+	( (void)( ticks ) );
+	return 0.0f;
+}
+
+float b2GetMillisecondsAndReset( uint64_t* ticks )
+{
+	( (void)( ticks ) );
+	return 0.0f;
+}
+
+void b2Yield( void )
+{
+}
+
+#endif
+
+// djb2 hash
+// https://en.wikipedia.org/wiki/List_of_hash_functions
+uint32_t b2Hash( uint32_t hash, const uint8_t* data, int count )
+{
+	uint32_t result = hash;
+	for ( int i = 0; i < count; i++ )
+	{
+		result = ( result << 5 ) + result + data[i];
+	}
+
+	return result;
+}

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

@@ -0,0 +1,151 @@
+// SPDX-FileCopyrightText: 2023 Erin Catto
+// SPDX-License-Identifier: MIT
+
+#include "box2d/types.h"
+
+#include "constants.h"
+#include "core.h"
+
+b2WorldDef b2DefaultWorldDef( void )
+{
+	b2WorldDef def = { 0 };
+	def.gravity.x = 0.0f;
+	def.gravity.y = -10.0f;
+	def.hitEventThreshold = 1.0f * b2_lengthUnitsPerMeter;
+	def.restitutionThreshold = 1.0f * b2_lengthUnitsPerMeter;
+	def.maxContactPushSpeed = 3.0f * b2_lengthUnitsPerMeter;
+	def.contactHertz = 30.0;
+	def.contactDampingRatio = 10.0f;
+	def.jointHertz = 60.0;
+	def.jointDampingRatio = 2.0f;
+	// 400 meters per second, faster than the speed of sound
+	def.maximumLinearSpeed = 400.0f * b2_lengthUnitsPerMeter;
+	def.enableSleep = true;
+	def.enableContinuous = true;
+	def.internalValue = B2_SECRET_COOKIE;
+	return def;
+}
+
+b2BodyDef b2DefaultBodyDef( void )
+{
+	b2BodyDef def = { 0 };
+	def.type = b2_staticBody;
+	def.rotation = b2Rot_identity;
+	def.sleepThreshold = 0.05f * b2_lengthUnitsPerMeter;
+	def.gravityScale = 1.0f;
+	def.enableSleep = true;
+	def.isAwake = true;
+	def.isEnabled = true;
+	def.internalValue = B2_SECRET_COOKIE;
+	return def;
+}
+
+b2Filter b2DefaultFilter( void )
+{
+	b2Filter filter = { B2_DEFAULT_CATEGORY_BITS, B2_DEFAULT_MASK_BITS, 0 };
+	return filter;
+}
+
+b2QueryFilter b2DefaultQueryFilter( void )
+{
+	b2QueryFilter filter = { B2_DEFAULT_CATEGORY_BITS, B2_DEFAULT_MASK_BITS };
+	return filter;
+}
+
+b2ShapeDef b2DefaultShapeDef( void )
+{
+	b2ShapeDef def = { 0 };
+	def.material.friction = 0.6f;
+	def.density = 1.0f;
+	def.filter = b2DefaultFilter();
+	def.updateBodyMass = true;
+	def.invokeContactCreation = true;
+	def.internalValue = B2_SECRET_COOKIE;
+	return def;
+}
+
+b2SurfaceMaterial b2DefaultSurfaceMaterial( void )
+{
+	b2SurfaceMaterial material = {
+		.friction = 0.6f,
+	};
+
+	return material;
+}
+
+b2ChainDef b2DefaultChainDef( void )
+{
+	static b2SurfaceMaterial defaultMaterial = {
+		.friction = 0.6f,
+	};
+
+	b2ChainDef def = { 0 };
+	def.materials = &defaultMaterial;
+	def.materialCount = 1;
+	def.filter = b2DefaultFilter();
+	def.internalValue = B2_SECRET_COOKIE;
+	return def;
+}
+
+static void b2EmptyDrawPolygon( const b2Vec2* vertices, int vertexCount, b2HexColor color, void* context )
+{
+	B2_UNUSED( vertices, vertexCount, color, context );
+}
+
+static void b2EmptyDrawSolidPolygon( b2Transform transform, const b2Vec2* vertices, int vertexCount, float radius,
+									 b2HexColor color, void* context )
+{
+	B2_UNUSED( transform, vertices, vertexCount, radius, color, context );
+}
+
+static void b2EmptyDrawCircle( b2Vec2 center, float radius, b2HexColor color, void* context )
+{
+	B2_UNUSED( center, radius, color, context );
+}
+
+static void b2EmptyDrawSolidCircle( b2Transform transform, float radius, b2HexColor color, void* context )
+{
+	B2_UNUSED( transform, radius, color, context );
+}
+
+static void b2EmptyDrawSolidCapsule( b2Vec2 p1, b2Vec2 p2, float radius, b2HexColor color, void* context )
+{
+	B2_UNUSED( p1, p2, radius, color, context );
+}
+
+static void b2EmptyDrawSegment( b2Vec2 p1, b2Vec2 p2, b2HexColor color, void* context )
+{
+	B2_UNUSED( p1, p2, color, context );
+}
+
+static void b2EmptyDrawTransform( b2Transform transform, void* context )
+{
+	B2_UNUSED( transform, context );
+}
+
+static void b2EmptyDrawPoint( b2Vec2 p, float size, b2HexColor color, void* context )
+{
+	B2_UNUSED( p, size, color, context );
+}
+
+static void b2EmptyDrawString( b2Vec2 p, const char* s, b2HexColor color, void* context )
+{
+	B2_UNUSED( p, s, color, context );
+}
+
+b2DebugDraw b2DefaultDebugDraw( void )
+{
+	b2DebugDraw draw = { 0 };
+
+	// These allow the user to skip some implementations and not hit null exceptions.
+	draw.DrawPolygonFcn = b2EmptyDrawPolygon;
+	draw.DrawSolidPolygonFcn = b2EmptyDrawSolidPolygon;
+	draw.DrawCircleFcn = b2EmptyDrawCircle;
+	draw.DrawSolidCircleFcn = b2EmptyDrawSolidCircle;
+	draw.DrawSolidCapsuleFcn = b2EmptyDrawSolidCapsule;
+	draw.DrawSegmentFcn = b2EmptyDrawSegment;
+	draw.DrawTransformFcn = b2EmptyDrawTransform;
+	draw.DrawPointFcn = b2EmptyDrawPoint;
+	draw.DrawStringFcn = b2EmptyDrawString;
+	return draw;
+}