box2d-ruby 1.0.0

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

@@ -0,0 +1,54 @@
+// SPDX-FileCopyrightText: 2023 Erin Catto
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include "solver.h"
+
+typedef struct b2ContactSim b2ContactSim;
+
+typedef struct b2ContactConstraintPoint
+{
+	b2Vec2 anchorA, anchorB;
+	float baseSeparation;
+	float relativeVelocity;
+	float normalImpulse;
+	float tangentImpulse;
+	float totalNormalImpulse;
+	float normalMass;
+	float tangentMass;
+} b2ContactConstraintPoint;
+
+typedef struct b2ContactConstraint
+{
+	int indexA;
+	int indexB;
+	b2ContactConstraintPoint points[2];
+	b2Vec2 normal;
+	float invMassA, invMassB;
+	float invIA, invIB;
+	float friction;
+	float restitution;
+	float tangentSpeed;
+	float rollingResistance;
+	float rollingMass;
+	float rollingImpulse;
+	b2Softness softness;
+	int pointCount;
+} b2ContactConstraint;
+
+int b2GetContactConstraintSIMDByteCount( void );
+
+// Overflow contacts don't fit into the constraint graph coloring
+void b2PrepareOverflowContacts( b2StepContext* context );
+void b2WarmStartOverflowContacts( b2StepContext* context );
+void b2SolveOverflowContacts( b2StepContext* context, bool useBias );
+void b2ApplyOverflowRestitution( b2StepContext* context );
+void b2StoreOverflowImpulses( b2StepContext* context );
+
+// Contacts that live within the constraint graph coloring
+void b2PrepareContactsTask( int startIndex, int endIndex, b2StepContext* context );
+void b2WarmStartContactsTask( int startIndex, int endIndex, b2StepContext* context, int colorIndex );
+void b2SolveContactsTask( int startIndex, int endIndex, b2StepContext* context, int colorIndex, bool useBias );
+void b2ApplyRestitutionTask( int startIndex, int endIndex, b2StepContext* context, int colorIndex );
+void b2StoreImpulsesTask( int startIndex, int endIndex, b2StepContext* context );

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

@@ -0,0 +1,178 @@
+// SPDX-FileCopyrightText: 2023 Erin Catto
+// SPDX-License-Identifier: MIT
+
+#include "core.h"
+
+#if defined( B2_COMPILER_MSVC )
+#define _CRTDBG_MAP_ALLOC
+#include <crtdbg.h>
+#include <stdlib.h>
+#else
+#include <stdlib.h>
+#endif
+
+#include <stdio.h>
+#include <string.h>
+
+#ifdef BOX2D_PROFILE
+
+#include <tracy/TracyC.h>
+#define b2TracyCAlloc( ptr, size ) TracyCAlloc( ptr, size )
+#define b2TracyCFree( ptr ) TracyCFree( ptr )
+
+#else
+
+#define b2TracyCAlloc( ptr, size )
+#define b2TracyCFree( ptr )
+
+#endif
+
+#include "atomic.h"
+
+// This allows the user to change the length units at runtime
+float b2_lengthUnitsPerMeter = 1.0f;
+
+void b2SetLengthUnitsPerMeter( float lengthUnits )
+{
+	B2_ASSERT( b2IsValidFloat( lengthUnits ) && lengthUnits > 0.0f );
+	b2_lengthUnitsPerMeter = lengthUnits;
+}
+
+float b2GetLengthUnitsPerMeter( void )
+{
+	return b2_lengthUnitsPerMeter;
+}
+
+static int b2DefaultAssertFcn( const char* condition, const char* fileName, int lineNumber )
+{
+	printf( "BOX2D ASSERTION: %s, %s, line %d\n", condition, fileName, lineNumber );
+
+	// return non-zero to break to debugger
+	return 1;
+}
+
+b2AssertFcn* b2AssertHandler = b2DefaultAssertFcn;
+
+void b2SetAssertFcn( b2AssertFcn* assertFcn )
+{
+	B2_ASSERT( assertFcn != NULL );
+	b2AssertHandler = assertFcn;
+}
+
+#if !defined( NDEBUG ) || defined( B2_ENABLE_ASSERT )
+int b2InternalAssertFcn( const char* condition, const char* fileName, int lineNumber )
+{
+	return b2AssertHandler( condition, fileName, lineNumber );
+}
+#endif
+
+b2Version b2GetVersion( void )
+{
+	return (b2Version){
+		.major = 3,
+		.minor = 1,
+		.revision = 0,
+	};
+}
+
+static b2AllocFcn* b2_allocFcn = NULL;
+static b2FreeFcn* b2_freeFcn = NULL;
+
+b2AtomicInt b2_byteCount;
+
+void b2SetAllocator( b2AllocFcn* allocFcn, b2FreeFcn* freeFcn )
+{
+	b2_allocFcn = allocFcn;
+	b2_freeFcn = freeFcn;
+}
+
+// Use 32 byte alignment for everything. Works with 256bit SIMD.
+#define B2_ALIGNMENT 32
+
+void* b2Alloc( int size )
+{
+	if ( size == 0 )
+	{
+		return NULL;
+	}
+
+	// This could cause some sharing issues, however Box2D rarely calls b2Alloc.
+	b2AtomicFetchAddInt( &b2_byteCount, size );
+
+	// Allocation must be a multiple of 32 or risk a seg fault
+	// https://en.cppreference.com/w/c/memory/aligned_alloc
+	int size32 = ( ( size - 1 ) | 0x1F ) + 1;
+
+	if ( b2_allocFcn != NULL )
+	{
+		void* ptr = b2_allocFcn( size32, B2_ALIGNMENT );
+		b2TracyCAlloc( ptr, size );
+
+		B2_ASSERT( ptr != NULL );
+		B2_ASSERT( ( (uintptr_t)ptr & 0x1F ) == 0 );
+
+		return ptr;
+	}
+
+#ifdef B2_PLATFORM_WINDOWS
+	void* ptr = _aligned_malloc( size32, B2_ALIGNMENT );
+#elif defined( B2_PLATFORM_ANDROID )
+	void* ptr = NULL;
+	if ( posix_memalign( &ptr, B2_ALIGNMENT, size32 ) != 0 )
+	{
+		// allocation failed, exit the application
+		exit( EXIT_FAILURE );
+	}
+#else
+	void* ptr = aligned_alloc( B2_ALIGNMENT, size32 );
+#endif
+
+	b2TracyCAlloc( ptr, size );
+
+	B2_ASSERT( ptr != NULL );
+	B2_ASSERT( ( (uintptr_t)ptr & 0x1F ) == 0 );
+
+	return ptr;
+}
+
+void b2Free( void* mem, int size )
+{
+	if ( mem == NULL )
+	{
+		return;
+	}
+
+	b2TracyCFree( mem );
+
+	if ( b2_freeFcn != NULL )
+	{
+		b2_freeFcn( mem );
+	}
+	else
+	{
+#ifdef B2_PLATFORM_WINDOWS
+		_aligned_free( mem );
+#else
+		free( mem );
+#endif
+	}
+
+	b2AtomicFetchAddInt( &b2_byteCount, -size );
+}
+
+void* b2GrowAlloc( void* oldMem, int oldSize, int newSize )
+{
+	B2_ASSERT( newSize > oldSize );
+	void* newMem = b2Alloc( newSize );
+	if ( oldSize > 0 )
+	{
+		memcpy( newMem, oldMem, oldSize );
+		b2Free( oldMem, oldSize );
+	}
+	return newMem;
+}
+
+int b2GetByteCount( void )
+{
+	return b2AtomicLoadInt( &b2_byteCount );
+}

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

@@ -0,0 +1,149 @@
+// SPDX-FileCopyrightText: 2023 Erin Catto
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include "box2d/math_functions.h"
+
+// clang-format off
+
+#define B2_NULL_INDEX ( -1 )
+
+// for performance comparisons
+#define B2_RESTRICT restrict
+
+#ifdef NDEBUG
+	#define B2_DEBUG 0
+#else
+	#define B2_DEBUG 1
+#endif
+
+#if defined( BOX2D_VALIDATE ) && !defined( NDEBUG )
+	#define B2_VALIDATE 1
+#else
+	#define B2_VALIDATE 0
+#endif
+
+// Define platform
+#if defined(_WIN32) || defined(_WIN64)
+	#define B2_PLATFORM_WINDOWS
+#elif defined( __ANDROID__ )
+	#define B2_PLATFORM_ANDROID
+#elif defined( __linux__ )
+	#define B2_PLATFORM_LINUX
+#elif defined( __APPLE__ )
+	#include <TargetConditionals.h>
+	#if defined( TARGET_OS_IPHONE ) && !TARGET_OS_IPHONE
+		#define B2_PLATFORM_MACOS
+	#else
+		#define B2_PLATFORM_IOS
+	#endif
+#elif defined( __EMSCRIPTEN__ )
+	#define B2_PLATFORM_WASM
+#else
+	#define B2_PLATFORM_UNKNOWN
+#endif
+
+// Define CPU
+#if defined( __x86_64__ ) || defined( _M_X64 ) || defined( __i386__ ) || defined( _M_IX86 )
+	#define B2_CPU_X86_X64
+#elif defined( __aarch64__ ) || defined( _M_ARM64 ) || defined( __arm__ ) || defined( _M_ARM )
+	#define B2_CPU_ARM
+#elif defined( __EMSCRIPTEN__ )
+	#define B2_CPU_WASM
+#else
+	#define B2_CPU_UNKNOWN
+#endif
+
+// Define SIMD
+#if defined( BOX2D_DISABLE_SIMD )
+	#define B2_SIMD_NONE
+	// note: I tried width of 1 and got no performance change
+	#define B2_SIMD_WIDTH 4
+#else
+	#if defined( B2_CPU_X86_X64 )
+		#if defined( BOX2D_AVX2 )
+			#define B2_SIMD_AVX2
+			#define B2_SIMD_WIDTH 8
+		#else
+			#define B2_SIMD_SSE2
+			#define B2_SIMD_WIDTH 4
+		#endif
+	#elif defined( B2_CPU_ARM )
+		#define B2_SIMD_NEON
+		#define B2_SIMD_WIDTH 4
+	#elif defined( B2_CPU_WASM )
+		#define B2_CPU_WASM
+		#define B2_SIMD_SSE2
+		#define B2_SIMD_WIDTH 4
+	#else
+		#define B2_SIMD_NONE
+		#define B2_SIMD_WIDTH 4
+	#endif
+#endif
+
+// Define compiler
+#if defined( __clang__ )
+	#define B2_COMPILER_CLANG
+#elif defined( __GNUC__ )
+	#define B2_COMPILER_GCC
+#elif defined( _MSC_VER )
+	#define B2_COMPILER_MSVC
+#endif
+
+/// Tracy profiler instrumentation
+/// https://github.com/wolfpld/tracy
+#ifdef BOX2D_PROFILE
+	#include <tracy/TracyC.h>
+	#define b2TracyCZoneC( ctx, color, active ) TracyCZoneC( ctx, color, active )
+	#define b2TracyCZoneNC( ctx, name, color, active ) TracyCZoneNC( ctx, name, color, active )
+	#define b2TracyCZoneEnd( ctx ) TracyCZoneEnd( ctx )
+#else
+	#define b2TracyCZoneC( ctx, color, active )
+	#define b2TracyCZoneNC( ctx, name, color, active )
+	#define b2TracyCZoneEnd( ctx )
+#endif
+
+// clang-format on
+
+// Returns the number of elements of an array
+#define B2_ARRAY_COUNT( A ) (int)( sizeof( A ) / sizeof( A[0] ) )
+
+// Used to prevent the compiler from warning about unused variables
+#define B2_UNUSED( ... ) (void)sizeof( ( __VA_ARGS__, 0 ) )
+
+// Use to validate definitions. Do not take my cookie.
+#define B2_SECRET_COOKIE 1152023
+
+// Snoop counters. These should be disabled in optimized builds because they are expensive.
+#if defined( box2d_EXPORTS )
+#define B2_SNOOP_TABLE_COUNTERS B2_DEBUG
+#define B2_SNOOP_PAIR_COUNTERS B2_DEBUG
+#define B2_SNOOP_TOI_COUNTERS B2_DEBUG
+#else
+#define B2_SNOOP_TABLE_COUNTERS 0
+#define B2_SNOOP_PAIR_COUNTERS 0
+#define B2_SNOOP_TOI_COUNTERS 0
+#endif
+
+#define B2_CHECK_DEF( DEF ) B2_ASSERT( DEF->internalValue == B2_SECRET_COOKIE )
+
+typedef struct b2AtomicInt
+{
+	int value;
+} b2AtomicInt;
+
+typedef struct b2AtomicU32
+{
+	uint32_t value;
+} b2AtomicU32;
+
+void* b2Alloc( int size );
+#define B2_ALLOC_STRUCT( type ) b2Alloc(sizeof(type))
+#define B2_ALLOC_ARRAY( count, type ) b2Alloc(count * sizeof(type))
+
+void b2Free( void* mem, int size );
+#define B2_FREE_STRUCT( mem, type ) b2Free( mem, sizeof(type));
+#define B2_FREE_ARRAY( mem, count, type ) b2Free(mem, count * sizeof(type))
+
+void* b2GrowAlloc( void* oldMem, int oldSize, int newSize );

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

@@ -0,0 +1,112 @@
+// SPDX-FileCopyrightText: 2023 Erin Catto
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#if defined( _MSC_VER ) && !defined( __clang__ )
+	#include <intrin.h>
+
+// https://en.wikipedia.org/wiki/Find_first_set
+
+static inline uint32_t b2CTZ32( uint32_t block )
+{
+	unsigned long index;
+	_BitScanForward( &index, block );
+	return index;
+}
+
+// This function doesn't need to be fast, so using the Ivy Bridge fallback.
+static inline uint32_t b2CLZ32( uint32_t value )
+{
+	#if 1
+
+	// Use BSR (Bit Scan Reverse) which is available on Ivy Bridge
+	unsigned long index;
+	if ( _BitScanReverse( &index, value ) )
+	{
+		// BSR gives the index of the most significant 1-bit
+		// We need to invert this to get the number of leading zeros
+		return 31 - index;
+	}
+	else
+	{
+		// If x is 0, BSR sets the zero flag and doesn't modify index
+		// LZCNT should return 32 for an input of 0
+		return 32;
+	}
+
+	#else
+
+	return __lzcnt( value );
+
+	#endif
+}
+
+static inline uint32_t b2CTZ64( uint64_t block )
+{
+	unsigned long index;
+
+	#ifdef _WIN64
+	_BitScanForward64( &index, block );
+	#else
+	// 32-bit fall back
+	if ( (uint32_t)block != 0 )
+	{
+		_BitScanForward( &index, (uint32_t)block );
+	}
+	else
+	{
+		_BitScanForward( &index, (uint32_t)( block >> 32 ) );
+		index += 32;
+	}
+	#endif
+
+	return index;
+}
+
+#else
+
+static inline uint32_t b2CTZ32( uint32_t block )
+{
+	return __builtin_ctz( block );
+}
+
+static inline uint32_t b2CLZ32( uint32_t value )
+{
+	return __builtin_clz( value );
+}
+
+static inline uint32_t b2CTZ64( uint64_t block )
+{
+	return __builtin_ctzll( block );
+}
+
+#endif
+
+static inline bool b2IsPowerOf2( int x )
+{
+	return ( x & ( x - 1 ) ) == 0;
+}
+
+static inline int b2BoundingPowerOf2( int x )
+{
+	if ( x <= 1 )
+	{
+		return 1;
+	}
+
+	return 32 - (int)b2CLZ32( (uint32_t)x - 1 );
+}
+
+static inline int b2RoundUpPowerOf2( int x )
+{
+	if ( x <= 1 )
+	{
+		return 1;
+	}
+
+	return 1 << ( 32 - (int)b2CLZ32( (uint32_t)x - 1 ) );
+}