box2d-ruby 1.0.0

data/ext/box2d/vendor/box2d/src/CMakeLists.txt

@@ -0,0 +1,223 @@
+include(GNUInstallDirs)
+
+set(BOX2D_SOURCE_FILES
+	aabb.c
+	aabb.h
+	arena_allocator.c
+	arena_allocator.h
+	array.c
+	array.h
+	atomic.h
+	bitset.c
+	bitset.h
+	body.c
+	body.h
+	broad_phase.c
+	broad_phase.h
+	constants.h
+	constraint_graph.c
+	constraint_graph.h
+	contact.c
+	contact.h
+	contact_solver.c
+	contact_solver.h
+	core.c
+	core.h
+	ctz.h
+	distance.c
+	distance_joint.c
+	dynamic_tree.c
+	geometry.c
+	hull.c
+	id_pool.c
+	id_pool.h
+	island.c
+	island.h
+	joint.c
+	joint.h
+	manifold.c
+	math_functions.c
+	motor_joint.c
+	mouse_joint.c
+	mover.c
+	prismatic_joint.c
+	revolute_joint.c
+	sensor.c
+	sensor.h
+	shape.c
+	shape.h
+	solver.c
+	solver.h
+	solver_set.c
+	solver_set.h
+	table.c
+	table.h
+	timer.c
+	types.c
+	weld_joint.c
+	wheel_joint.c
+	world.c
+	world.h
+)
+
+set(BOX2D_API_FILES
+	../include/box2d/base.h
+	../include/box2d/box2d.h
+	../include/box2d/collision.h
+	../include/box2d/id.h
+	../include/box2d/math_functions.h
+	../include/box2d/types.h
+)
+
+# Hide internal functions
+# https://gcc.gnu.org/wiki/Visibility
+set(CMAKE_C_VISIBILITY_PRESET hidden)
+set(CMAKE_VISIBILITY_INLINES_HIDDEN 1)
+
+add_library(box2d ${BOX2D_SOURCE_FILES} ${BOX2D_API_FILES})
+
+target_include_directories(box2d
+  PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../include>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+  PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+set(CMAKE_DEBUG_POSTFIX "d")
+
+# Box2D uses C17 for _Static_assert and anonymous unions
+set_target_properties(box2d PROPERTIES
+	C_STANDARD 17
+    C_STANDARD_REQUIRED YES
+    C_EXTENSIONS YES
+	COMPILE_WARNING_AS_ERROR ON
+    VERSION ${PROJECT_VERSION}
+    SOVERSION ${PROJECT_VERSION_MAJOR}
+	DEBUG_POSTFIX ${CMAKE_DEBUG_POSTFIX}
+)
+
+if (BOX2D_PROFILE)
+	target_compile_definitions(box2d PRIVATE BOX2D_PROFILE)
+
+	FetchContent_Declare(
+		tracy
+		GIT_REPOSITORY https://github.com/wolfpld/tracy.git
+		GIT_TAG v0.11.1
+		GIT_SHALLOW TRUE
+		GIT_PROGRESS TRUE
+	)
+	FetchContent_MakeAvailable(tracy)
+
+	target_link_libraries(box2d PUBLIC TracyClient)
+endif()
+
+if (BOX2D_VALIDATE)
+	message(STATUS "Box2D validation ON")	
+	target_compile_definitions(box2d PRIVATE BOX2D_VALIDATE)
+endif()
+
+if (BOX2D_DISABLE_SIMD)
+	message(STATUS "Box2D SIMD disabled")	
+	target_compile_definitions(box2d PRIVATE BOX2D_DISABLE_SIMD)
+endif()
+
+if (MSVC)
+	message(STATUS "Box2D on MSVC")	
+	if (BUILD_SHARED_LIBS)
+		# this is needed by DLL users to import Box2D symbols
+		target_compile_definitions(box2d INTERFACE BOX2D_DLL)
+	endif()
+
+	# Visual Studio won't load the natvis unless it is in the project
+	target_sources(box2d PRIVATE box2d.natvis)
+
+	# Enable asserts in release with debug info
+	target_compile_definitions(box2d PUBLIC "$<$<CONFIG:RELWITHDEBINFO>:B2_ENABLE_ASSERT>")
+
+	# Warnings
+	# 4710 - warn about inline functions that are not inlined
+	target_compile_options(box2d PRIVATE /Wall /wd4820 /wd5045 /wd4061 /wd4711 /wd4710)
+
+	if (BOX2D_AVX2)
+		message(STATUS "Box2D using AVX2")	
+		target_compile_definitions(box2d PRIVATE BOX2D_AVX2)
+		target_compile_options(box2d PRIVATE /arch:AVX2)
+	endif()
+
+	if (${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang")
+		target_compile_options(box2d PRIVATE -Wmissing-prototypes)
+	endif()
+
+elseif (MINGW)
+	message(STATUS "Box2D on MinGW")
+	if (BOX2D_AVX2)
+		message(STATUS "Box2D using AVX2")	
+		target_compile_definitions(box2d PRIVATE BOX2D_AVX2)
+		target_compile_options(box2d PRIVATE -mavx2)
+	else()
+	endif()
+elseif (APPLE)
+	message(STATUS "Box2D on Apple")
+	target_compile_options(box2d PRIVATE -Wmissing-prototypes -Wall -Wextra -pedantic -Werror)
+elseif (EMSCRIPTEN)
+	message(STATUS "Box2D on Emscripten")
+	if (BOX2D_DISABLE_SIMD OFF)
+		target_compile_options(box2d PRIVATE -msimd128 -msse2)
+	endif()
+elseif (UNIX)
+	message(STATUS "Box2D using Unix")
+	target_compile_options(box2d PRIVATE -Wmissing-prototypes -Wall -Wextra -pedantic -Werror -Wno-unused-value)
+	if ("${CMAKE_HOST_SYSTEM_PROCESSOR}" STREQUAL "aarch64")
+		# raspberry pi
+		# -mfpu=neon
+		# target_compile_options(box2d PRIVATE)
+	else()
+		# x64
+		if (BOX2D_AVX2)
+			message(STATUS "Box2D using AVX2")
+			# FMA -mfma -mavx -march=native
+			target_compile_definitions(box2d PRIVATE BOX2D_AVX2)
+			target_compile_options(box2d PRIVATE -mavx2)
+		else()
+		endif()
+	endif()
+endif()
+
+source_group(TREE "${CMAKE_CURRENT_SOURCE_DIR}" PREFIX "src" FILES ${BOX2D_SOURCE_FILES})
+source_group(TREE "${CMAKE_CURRENT_SOURCE_DIR}/../include" PREFIX "include" FILES ${BOX2D_API_FILES})
+
+add_library(box2d::box2d ALIAS box2d)
+
+install(
+  TARGETS box2d
+  EXPORT box2dConfig
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+)
+
+install(
+  EXPORT box2dConfig
+  NAMESPACE box2d::
+  DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/box2d"
+)
+
+install(
+  FILES ${BOX2D_API_FILES}
+  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/box2d
+)
+
+include(CMakePackageConfigHelpers)
+
+write_basic_package_version_file(
+  "${CMAKE_CURRENT_BINARY_DIR}/box2dConfigVersion.cmake"
+  VERSION ${BOX2D_VERSION}
+  COMPATIBILITY SameMajorVersion
+)
+
+install(
+  FILES "${CMAKE_CURRENT_BINARY_DIR}/box2dConfigVersion.cmake"
+  DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/box2d"
+)

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

@@ -0,0 +1,132 @@
+// SPDX-FileCopyrightText: 2023 Erin Catto
+// SPDX-License-Identifier: MIT
+
+#include "aabb.h"
+
+#include "box2d/math_functions.h"
+
+#include <float.h>
+
+bool b2IsValidAABB( b2AABB a )
+{
+	b2Vec2 d = b2Sub( a.upperBound, a.lowerBound );
+	bool valid = d.x >= 0.0f && d.y >= 0.0f;
+	valid = valid && b2IsValidVec2( a.lowerBound ) && b2IsValidVec2( a.upperBound );
+	return valid;
+}
+
+// From Real-time Collision Detection, p179.
+b2CastOutput b2AABB_RayCast( b2AABB a, b2Vec2 p1, b2Vec2 p2 )
+{
+	// Radius not handled
+	b2CastOutput output = { 0 };
+
+	float tmin = -FLT_MAX;
+	float tmax = FLT_MAX;
+
+	b2Vec2 p = p1;
+	b2Vec2 d = b2Sub( p2, p1 );
+	b2Vec2 absD = b2Abs( d );
+
+	b2Vec2 normal = b2Vec2_zero;
+
+	// x-coordinate
+	if ( absD.x < FLT_EPSILON )
+	{
+		// parallel
+		if ( p.x < a.lowerBound.x || a.upperBound.x < p.x )
+		{
+			return output;
+		}
+	}
+	else
+	{
+		float inv_d = 1.0f / d.x;
+		float t1 = ( a.lowerBound.x - p.x ) * inv_d;
+		float t2 = ( a.upperBound.x - p.x ) * inv_d;
+
+		// Sign of the normal vector.
+		float s = -1.0f;
+
+		if ( t1 > t2 )
+		{
+			float tmp = t1;
+			t1 = t2;
+			t2 = tmp;
+			s = 1.0f;
+		}
+
+		// Push the min up
+		if ( t1 > tmin )
+		{
+			normal.y = 0.0f;
+			normal.x = s;
+			tmin = t1;
+		}
+
+		// Pull the max down
+		tmax = b2MinFloat( tmax, t2 );
+
+		if ( tmin > tmax )
+		{
+			return output;
+		}
+	}
+
+	// y-coordinate
+	if ( absD.y < FLT_EPSILON )
+	{
+		// parallel
+		if ( p.y < a.lowerBound.y || a.upperBound.y < p.y )
+		{
+			return output;
+		}
+	}
+	else
+	{
+		float inv_d = 1.0f / d.y;
+		float t1 = ( a.lowerBound.y - p.y ) * inv_d;
+		float t2 = ( a.upperBound.y - p.y ) * inv_d;
+
+		// Sign of the normal vector.
+		float s = -1.0f;
+
+		if ( t1 > t2 )
+		{
+			float tmp = t1;
+			t1 = t2;
+			t2 = tmp;
+			s = 1.0f;
+		}
+
+		// Push the min up
+		if ( t1 > tmin )
+		{
+			normal.x = 0.0f;
+			normal.y = s;
+			tmin = t1;
+		}
+
+		// Pull the max down
+		tmax = b2MinFloat( tmax, t2 );
+
+		if ( tmin > tmax )
+		{
+			return output;
+		}
+	}
+
+	// Does the ray start inside the box?
+	// Does the ray intersect beyond the max fraction?
+	if ( tmin < 0.0f || 1.0f < tmin )
+	{
+		return output;
+	}
+
+	// Intersection.
+	output.fraction = tmin;
+	output.normal = normal;
+	output.point = b2Lerp( p1, p2, tmin );
+	output.hit = true;
+	return output;
+}

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

@@ -0,0 +1,56 @@
+// SPDX-FileCopyrightText: 2023 Erin Catto
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include "box2d/types.h"
+
+// Ray cast an AABB
+b2CastOutput b2AABB_RayCast( b2AABB a, b2Vec2 p1, b2Vec2 p2 );
+
+// Get surface area of an AABB (the perimeter length)
+static inline float b2Perimeter( b2AABB a )
+{
+	float wx = a.upperBound.x - a.lowerBound.x;
+	float wy = a.upperBound.y - a.lowerBound.y;
+	return 2.0f * ( wx + wy );
+}
+
+/// Enlarge a to contain b
+/// @return true if the AABB grew
+static inline bool b2EnlargeAABB( b2AABB* a, b2AABB b )
+{
+	bool changed = false;
+	if ( b.lowerBound.x < a->lowerBound.x )
+	{
+		a->lowerBound.x = b.lowerBound.x;
+		changed = true;
+	}
+
+	if ( b.lowerBound.y < a->lowerBound.y )
+	{
+		a->lowerBound.y = b.lowerBound.y;
+		changed = true;
+	}
+
+	if ( a->upperBound.x < b.upperBound.x )
+	{
+		a->upperBound.x = b.upperBound.x;
+		changed = true;
+	}
+
+	if ( a->upperBound.y < b.upperBound.y )
+	{
+		a->upperBound.y = b.upperBound.y;
+		changed = true;
+	}
+
+	return changed;
+}
+
+/// Do a and b overlap
+static inline bool b2AABB_Overlaps( b2AABB a, b2AABB b )
+{
+	return !( b.lowerBound.x > a.upperBound.x || b.lowerBound.y > a.upperBound.y || a.lowerBound.x > b.upperBound.x ||
+			  a.lowerBound.y > b.upperBound.y );
+}

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

@@ -0,0 +1,112 @@
+// SPDX-FileCopyrightText: 2023 Erin Catto
+// SPDX-License-Identifier: MIT
+
+#include "arena_allocator.h"
+
+#include "array.h"
+#include "core.h"
+
+#include <stdbool.h>
+#include <stddef.h>
+
+B2_ARRAY_SOURCE( b2ArenaEntry, b2ArenaEntry )
+
+b2ArenaAllocator b2CreateArenaAllocator( int capacity )
+{
+	B2_ASSERT( capacity >= 0 );
+	b2ArenaAllocator allocator = { 0 };
+	allocator.capacity = capacity;
+	allocator.data = b2Alloc( capacity );
+	allocator.allocation = 0;
+	allocator.maxAllocation = 0;
+	allocator.index = 0;
+	allocator.entries = b2ArenaEntryArray_Create( 32 );
+	return allocator;
+}
+
+void b2DestroyArenaAllocator( b2ArenaAllocator* allocator )
+{
+	b2ArenaEntryArray_Destroy( &allocator->entries );
+	b2Free( allocator->data, allocator->capacity );
+}
+
+void* b2AllocateArenaItem( b2ArenaAllocator* alloc, int size, const char* name )
+{
+	// ensure allocation is 32 byte aligned to support 256-bit SIMD
+	int size32 = ( ( size - 1 ) | 0x1F ) + 1;
+
+	b2ArenaEntry entry;
+	entry.size = size32;
+	entry.name = name;
+	if ( alloc->index + size32 > alloc->capacity )
+	{
+		// fall back to the heap (undesirable)
+		entry.data = b2Alloc( size32 );
+		entry.usedMalloc = true;
+
+		B2_ASSERT( ( (uintptr_t)entry.data & 0x1F ) == 0 );
+	}
+	else
+	{
+		entry.data = alloc->data + alloc->index;
+		entry.usedMalloc = false;
+		alloc->index += size32;
+
+		B2_ASSERT( ( (uintptr_t)entry.data & 0x1F ) == 0 );
+	}
+
+	alloc->allocation += size32;
+	if ( alloc->allocation > alloc->maxAllocation )
+	{
+		alloc->maxAllocation = alloc->allocation;
+	}
+
+	b2ArenaEntryArray_Push( &alloc->entries, entry );
+	return entry.data;
+}
+
+void b2FreeArenaItem( b2ArenaAllocator* alloc, void* mem )
+{
+	int entryCount = alloc->entries.count;
+	B2_ASSERT( entryCount > 0 );
+	b2ArenaEntry* entry = alloc->entries.data + ( entryCount - 1 );
+	B2_ASSERT( mem == entry->data );
+	if ( entry->usedMalloc )
+	{
+		b2Free( mem, entry->size );
+	}
+	else
+	{
+		alloc->index -= entry->size;
+	}
+	alloc->allocation -= entry->size;
+	b2ArenaEntryArray_Pop( &alloc->entries );
+}
+
+void b2GrowArena( b2ArenaAllocator* alloc )
+{
+	// Stack must not be in use
+	B2_ASSERT( alloc->allocation == 0 );
+
+	if ( alloc->maxAllocation > alloc->capacity )
+	{
+		b2Free( alloc->data, alloc->capacity );
+		alloc->capacity = alloc->maxAllocation + alloc->maxAllocation / 2;
+		alloc->data = b2Alloc( alloc->capacity );
+	}
+}
+
+int b2GetArenaCapacity( b2ArenaAllocator* alloc )
+{
+	return alloc->capacity;
+}
+
+int b2GetArenaAllocation( b2ArenaAllocator* alloc )
+{
+	return alloc->allocation;
+}
+
+int b2GetMaxArenaAllocation( b2ArenaAllocator* alloc )
+{
+	return alloc->maxAllocation;
+}

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

@@ -0,0 +1,48 @@
+// SPDX-FileCopyrightText: 2023 Erin Catto
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include "array.h"
+
+B2_ARRAY_DECLARE( b2ArenaEntry, b2ArenaEntry );
+
+typedef struct b2ArenaEntry
+{
+	char* data;
+	const char* name;
+	int size;
+	bool usedMalloc;
+} b2ArenaEntry;
+
+// This is a stack-like arena allocator used for fast per step allocations.
+// You must nest allocate/free pairs. The code will B2_ASSERT
+// if you try to interleave multiple allocate/free pairs.
+// This allocator uses the heap if space is insufficient.
+// I could remove the need to free entries individually.
+typedef struct b2ArenaAllocator
+{
+	char* data;
+	int capacity;
+	int index;
+
+	int allocation;
+	int maxAllocation;
+
+	b2ArenaEntryArray entries;
+} b2ArenaAllocator;
+
+b2ArenaAllocator b2CreateArenaAllocator( int capacity );
+void b2DestroyArenaAllocator( b2ArenaAllocator* allocator );
+
+void* b2AllocateArenaItem( b2ArenaAllocator* alloc, int size, const char* name );
+void b2FreeArenaItem( b2ArenaAllocator* alloc, void* mem );
+
+// Grow the arena based on usage
+void b2GrowArena( b2ArenaAllocator* alloc );
+
+int b2GetArenaCapacity( b2ArenaAllocator* alloc );
+int b2GetArenaAllocation( b2ArenaAllocator* alloc );
+int b2GetMaxArenaAllocation( b2ArenaAllocator* alloc );
+
+B2_ARRAY_INLINE( b2ArenaEntry, b2ArenaEntry )

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

@@ -0,0 +1,8 @@
+// SPDX-FileCopyrightText: 2023 Erin Catto
+// SPDX-License-Identifier: MIT
+
+#include "array.h"
+
+#include <stddef.h>
+
+B2_ARRAY_SOURCE( int, b2Int )