jolt-ruby 1.0.0

data/ext/joltc/CMakeLists.txt

@@ -0,0 +1,431 @@
+cmake_minimum_required(VERSION 3.16 FATAL_ERROR)
+
+project(joltc CXX C)
+
+# Use solution folders to organize projects
+set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+
+# Requires C++ 17
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_INSTALL_MESSAGE LAZY)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+set(CMAKE_DEBUG_POSTFIX "d")
+
+set(CMAKE_OSX_DEPLOYMENT_TARGET "11" CACHE STRING "Minimum OS X deployment version")
+set(CMAKE_OSX_ARCHITECTURES "x86_64;arm64" CACHE STRING "Build architectures for OS X")
+
+# Set default symbol visibility to hidden. This prevents all Jolt's symbols to be exported on macOS. This can cause crashes if a program loads multiple shared libraries with different versions of Jolt.
+set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+
+# Determine if engine is built as a subproject (using add_subdirectory)
+# or if it is the master project.
+if (NOT DEFINED JPH_MASTER_PROJECT)
+    set(JPH_MASTER_PROJECT OFF)
+    if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+        set(JPH_MASTER_PROJECT ON)
+        message(STATUS "CMake version: ${CMAKE_VERSION}")
+    endif ()
+endif ()
+
+if (JPH_MASTER_PROJECT)
+	# Configure CMake global variables
+	set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+	set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+	set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+endif()
+
+if (MSVC AND JPH_MASTER_PROJECT)
+    if (NOT DEFINED CMAKE_MSVC_RUNTIME_LIBRARY)
+        set (CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+    endif ()
+endif ()
+
+include(GNUInstallDirs)
+include(FetchContent)
+
+# When turning this option on, the library will be compiled using assertions. By default asserts are enabled in Debug build.
+option(USE_ASSERTS "Enable asserts" OFF)
+
+# When turning this option on, the library will be compiled using doubles for positions. This allows for much bigger worlds.
+option(DOUBLE_PRECISION "Use double precision math" OFF)
+
+# When turning this option on, the library will be compiled with debug symbols
+option(GENERATE_DEBUG_SYMBOLS "Generate debug symbols" OFF)
+
+# When turning this option on, the library will override the default CMAKE_CXX_FLAGS_DEBUG/RELEASE values, otherwise they will use the platform defaults
+option(OVERRIDE_CXX_FLAGS "Override CMAKE_CXX_FLAGS_DEBUG/RELEASE" ON)
+
+# When turning this option on, the library will be compiled in such a way to attempt to keep the simulation deterministic across platforms
+option(CROSS_PLATFORM_DETERMINISTIC "Cross platform deterministic" OFF)
+
+# When turning this option on, the library will be compiled for ARM (aarch64-linux-gnu), requires compiling with clang
+option(CROSS_COMPILE_ARM "Cross compile to aarch64-linux-gnu" OFF)
+
+# When turning this on, in Debug and Release mode, the library will emit extra code to ensure that the 4th component of a 3-vector is kept the same as the 3rd component
+# and will enable floating point exceptions during simulation to detect divisions by zero.
+# Note that this currently only works using MSVC. Clang turns Float2 into a SIMD vector sometimes causing floating point exceptions (the option is ignored).
+option(FLOATING_POINT_EXCEPTIONS_ENABLED "Enable floating point exceptions" ON)
+
+# When turning this on, the library will be compiled with C++ exceptions enabled.
+# This adds some overhead and Jolt doesn't use exceptions so by default it is off.
+option(CPP_EXCEPTIONS_ENABLED "Enable C++ exceptions" OFF)
+
+# When turning this on, the library will be compiled with C++ RTTI enabled.
+# This adds some overhead and Jolt doesn't use RTTI so by default it is off.
+option(CPP_RTTI_ENABLED "Enable C++ RTTI" OFF)
+
+# Use 32-bit object layers to support more bits in ObjectLayerPairFilterMask
+set(OBJECT_LAYER_BITS 32)
+
+# Select X86 processor features to use (if everything is off it will be SSE2 compatible)
+option(USE_SSE4_1 "Enable SSE4.1" ON)
+option(USE_SSE4_2 "Enable SSE4.2" ON)
+option(USE_AVX "Enable AVX" ON)
+option(USE_AVX2 "Enable AVX2" ON)
+option(USE_AVX512 "Enable AVX512" OFF)
+option(USE_LZCNT "Enable LZCNT" ON)
+option(USE_TZCNT "Enable TZCNT" ON)
+option(USE_F16C "Enable F16C" ON)
+option(USE_FMADD "Enable FMADD" ON)
+
+# Enable SIMD for the WASM build. Note that this is currently off by default since not all browsers support this.
+# See: https://caniuse.com/?search=WebAssembly%20SIMD (Safari got support in March 2023 and was the last major browser to get support).
+option(USE_WASM_SIMD "Enable SIMD for WASM" OFF)
+
+# Enable all warnings
+option(ENABLE_ALL_WARNINGS "Enable all warnings and warnings as errors" OFF)
+
+# Setting to periodically trace broadphase stats to help determine if the broadphase layer configuration is optimal
+option(TRACK_BROADPHASE_STATS "Track Broadphase Stats" OFF)
+
+# Setting to periodically trace narrowphase stats to help determine which collision queries could be optimized
+option(TRACK_NARROWPHASE_STATS "Track Narrowphase Stats" OFF)
+
+# Enable the debug renderer in the Debug and Release builds. Note that DEBUG_RENDERER_IN_DISTRIBUTION will override this setting.
+option(DEBUG_RENDERER_IN_DEBUG_AND_RELEASE "Enable debug renderer in Debug and Release builds" ON)
+
+# Setting to enable the debug renderer in all builds.
+# Note that enabling this reduces the performance of the library even if you're not drawing anything.
+option(DEBUG_RENDERER_IN_DISTRIBUTION "Enable debug renderer in all builds" ON)
+
+# Enable the profiler in Debug and Release builds. Note that PROFILER_IN_DISTRIBUTION will override this setting.
+option(PROFILER_IN_DEBUG_AND_RELEASE "Enable the profiler in Debug and Release builds" ON)
+
+# Enable the profiler in all builds.
+# Note that enabling this reduces the performance of the library.
+option(PROFILER_IN_DISTRIBUTION "Enable the profiler in all builds" OFF)
+
+# Setting this option will force the library to use malloc/free instead of allowing the user to override the memory allocator
+option(DISABLE_CUSTOM_ALLOCATOR "Disable support for a custom memory allocator" OFF)
+
+# Setting this option will force the library to use the STL vector instead of the custom Array class
+option(USE_STD_VECTOR "Use std::vector instead of own Array class" OFF)
+
+# Setting this option will compile the ObjectStream class and RTTI attribute information
+option(ENABLE_OBJECT_STREAM "Compile the ObjectStream class and RTTI attribute information" ON)
+
+# Option to compile with DirectX 12 compute
+option(JPH_USE_DX12 "Use DirectX" ON)
+
+# Option to compile with Vulkan compute
+option(JPH_USE_VK "Use Vulkan" ON)
+
+# Option to compile with Metal compute
+option(JPH_USE_MTL "Use Metal" ON)
+
+# Option to compile with CPU fallback compute
+option(JPH_USE_CPU_COMPUTE "Use CPU Compute" ON)
+
+# Option to enable shader debug symbols
+option(JPH_SHADER_DEBUG_SYMBOLS "Shader Debug Symbols" OFF)
+
+# Option to enable shader optimizations. When this is on, the shaders will be optimized for performance, otherwise they're suitable for debugging.
+option(JPH_SHADER_OPTIMIZATION "Shader Optimization" ON)
+
+option(JPH_INSTALL "Install target" ${JPH_MASTER_PROJECT})
+option(JPH_SAMPLES "Build samples" ${JPH_MASTER_PROJECT})
+
+# Define standard configurations (Debug, Release, Distribution)
+set(CMAKE_CONFIGURATION_TYPES "Debug;Release;Distribution")
+
+# Set the default CMAKE_BUILD_TYPE to Release.
+# This should be done before the project command since the latter can set
+# CMAKE_BUILD_TYPE itself (it does so for nmake).
+if (JPH_MASTER_PROJECT AND NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE "Distribution" CACHE STRING "The default build type" FORCE)
+    set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS ${CMAKE_CONFIGURATION_TYPES})
+endif ()
+
+# Search for local JoltPhysics first
+if (DEFINED JOLT_PHYSICS_ROOT AND EXISTS "${JOLT_PHYSICS_ROOT}/Build/CMakeLists.txt")
+    message(STATUS "[JoltC] Using provided JOLT_PHYSICS_ROOT: ${JOLT_PHYSICS_ROOT}")
+    FetchContent_Declare(
+        JoltPhysics
+        SOURCE_DIR "${JOLT_PHYSICS_ROOT}"
+        SOURCE_SUBDIR "Build"
+    )
+# 2. Check for JoltPhysics nested inside JoltC
+elseif(EXISTS "${CMAKE_CURRENT_LIST_DIR}/JoltPhysics/Build/CMakeLists.txt")
+    message(STATUS "[JoltC] Using local JoltPhysics from nested directory")
+    FetchContent_Declare(
+        JoltPhysics
+        SOURCE_DIR "${CMAKE_CURRENT_LIST_DIR}/JoltPhysics"
+        SOURCE_SUBDIR "Build"
+    )
+# 3. Check for JoltPhysics side-by-side with JoltC
+elseif(EXISTS "${CMAKE_CURRENT_LIST_DIR}/../JoltPhysics/Build/CMakeLists.txt")
+    message(STATUS "[JoltC] Using local JoltPhysics from side-by-side directory")
+    FetchContent_Declare(
+        JoltPhysics
+        SOURCE_DIR "${CMAKE_CURRENT_LIST_DIR}/../JoltPhysics"
+        SOURCE_SUBDIR "Build"
+    )
+# 4. Fallback to GitHub
+else()
+    message(STATUS "[JoltC] Local Jolt not found, downloading from GitHub v5.6.0")
+    FetchContent_Declare(
+        JoltPhysics
+        GIT_REPOSITORY "https://github.com/jrouwe/JoltPhysics"
+        GIT_TAG v5.6.0
+        SOURCE_SUBDIR "Build"
+    )
+endif()
+
+FetchContent_MakeAvailable(JoltPhysics)
+
+if (XCODE)
+	# Ensure that we enable SSE4.2 for the x86_64 build, XCode builds multiple architectures
+	set_property(TARGET Jolt PROPERTY XCODE_ATTRIBUTE_OTHER_CPLUSPLUSFLAGS[arch=x86_64] "$(inherited) -msse4.2 -mpopcnt")
+endif()
+
+if (MSVC)
+	# Fill in the path to the asan libraries
+	set(CLANG_LIB_PATH "\"$(VSInstallDir)\\VC\\Tools\\Llvm\\x64\\lib\\clang\\${CMAKE_CXX_COMPILER_VERSION}\\lib\\windows\"")
+
+	# 64 bit architecture
+	set(CMAKE_VS_PLATFORM_TOOLSET_HOST_ARCHITECTURE "x64")
+
+	# Set general compiler flags
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Zc:__cplusplus /Gm- /MP /nologo /diagnostics:classic /FC /fp:except- /Zc:inline")
+
+	# Enable warnings
+	if (ENABLE_ALL_WARNINGS)
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Wall /WX")
+	endif()
+
+	# Set compiler flag for disabling RTTI
+	if (NOT CPP_RTTI_ENABLED)
+		# Set compiler flag for disabling RTTI
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /GR-")
+	else()
+		# Set compiler flag for enabling RTTI
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /GR")
+	endif()
+
+	if (NOT CPP_EXCEPTIONS_ENABLED)
+		# Remove any existing compiler flag that enables exceptions
+		string(REPLACE "/EHsc" "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+
+		# Disable warning about STL and compiler-generated types using noexcept when exceptions are disabled
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4577")
+	else()
+		# Enable exceptions
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc")
+	endif()
+
+	set(CMAKE_CXX_FLAGS_DISTRIBUTION "${CMAKE_CXX_FLAGS_RELEASE}")
+
+	# Set linker flags
+	set(CMAKE_EXE_LINKER_FLAGS "/SUBSYSTEM:WINDOWS /ignore:4221")
+	if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+		if (CROSS_PLATFORM_DETERMINISTIC)
+			set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /fp:precise")
+		else()
+			set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /fp:fast") # Clang doesn't use fast math because it cannot be turned off inside a single compilation unit
+		endif()
+	elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /showFilenames")
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Qunused-arguments") # Clang emits warnings about unused arguments such as /MP and /GL
+	endif()
+else()
+	# Enable warnings
+	if (ENABLE_ALL_WARNINGS)
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Werror")
+	endif()
+
+	# Set compiler flag for disabling RTTI
+	if (NOT CPP_RTTI_ENABLED)
+		# Set compiler flag for disabling RTTI
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti")
+	else()
+		# Set compiler flag for enabling RTTI
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -frtti")
+	endif()
+
+	# Disable exception-handling
+	if (NOT CPP_EXCEPTIONS_ENABLED)
+		# Set compiler flag for disabling exception-handling
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions")
+	else()
+		# Set compiler flag for enabling exception-handling
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fexceptions")
+	endif()
+
+	if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+		# Also disable -Wstringop-overflow or it will generate false positives that can't be disabled from code when link-time optimizations are enabled
+		# Also turn off automatic fused multiply add contractions, there doesn't seem to be a way to do this selectively through the macro JPH_PRECISE_MATH_OFF
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-stringop-overflow -ffp-contract=off")
+	else()
+		# Do not use -ffast-math since it cannot be turned off in a single compilation unit under clang, see Core.h
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ffp-model=precise")
+
+		# On clang 14 and later we can turn off float contraction through a pragma, older versions and deterministic versions need it off always, see Core.h
+		if (CMAKE_CXX_COMPILER_VERSION LESS 14 OR CROSS_PLATFORM_DETERMINISTIC)
+			set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ffp-contract=off")
+		endif()
+
+		# Cross compiler flags
+		if (CROSS_COMPILE_ARM)
+			set(CMAKE_CXX_FLAGS "--target=aarch64-linux-gnu ${CMAKE_CXX_FLAGS}")
+		endif()
+	endif()
+
+	# See https://github.com/jrouwe/JoltPhysics/issues/922. When compiling with DOUBLE_PRECISION=YES and CMAKE_OSX_DEPLOYMENT_TARGET=10.12 clang triggers a warning that we silence here.
+	if ("${CMAKE_SYSTEM_NAME}" MATCHES "Darwin" AND "${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang")
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -faligned-allocation")
+	endif()
+
+	# Set compiler flags for various configurations
+	if (OVERRIDE_CXX_FLAGS)
+		set(CMAKE_CXX_FLAGS_DEBUG "")
+		set(CMAKE_CXX_FLAGS_RELEASE "-O3")
+	endif()
+	set(CMAKE_CXX_FLAGS_DISTRIBUTION "${CMAKE_CXX_FLAGS_RELEASE}")
+
+	# Set linker flags
+	if (NOT ("${CMAKE_SYSTEM_NAME}" STREQUAL "Windows"))
+		set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pthread")
+	endif()
+endif()
+
+# Set linker flags
+set(CMAKE_EXE_LINKER_FLAGS_DISTRIBUTION "${CMAKE_EXE_LINKER_FLAGS_RELEASE}")
+set(CMAKE_SHARED_LINKER_FLAGS_DISTRIBUTION "${CMAKE_SHARED_LINKER_FLAGS_RELEASE}")
+
+SET_INTERPROCEDURAL_OPTIMIZATION()
+
+set(PHYSICS_REPO_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/src/joltc)
+set(BUILD_SHARED_LIBS OFF CACHE BOOL "Disable shared library when building Jolt" FORCE)
+
+# Options
+if (IOS OR EMSCRIPTEN)
+    set(JPH_BUILD_SHARED OFF CACHE BOOL "Always Disable shared library on (IOS, WEB)" FORCE)
+else()
+	option(JPH_BUILD_SHARED "Build a shared library" ${JPH_MASTER_PROJECT})
+endif()
+
+# Setup joltc library
+# Define target name
+if (DOUBLE_PRECISION)
+    set (TARGET_NAME joltc_double)
+else()
+    set (TARGET_NAME joltc)
+endif ()
+
+set(SOURCE_FILES
+	${CMAKE_CURRENT_SOURCE_DIR}/include/joltc.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/joltc.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/joltc_assert.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/src/joltc.c
+)
+
+if (JPH_BUILD_SHARED)
+	add_library(${TARGET_NAME} SHARED ${SOURCE_FILES})
+else()
+	add_library(${TARGET_NAME} ${SOURCE_FILES})
+endif()
+
+if(JPH_BUILD_SHARED)
+	target_compile_definitions(${TARGET_NAME} PRIVATE JPH_SHARED_LIBRARY_BUILD=1)
+endif ()
+
+target_include_directories(${TARGET_NAME} PUBLIC
+	$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+	${JoltPhysics_SOURCE_DIR}/..
+)
+target_link_libraries(${TARGET_NAME} PRIVATE Jolt)
+
+if (MSVC)
+    # Debug information
+	target_compile_options(${TARGET_NAME} PRIVATE $<$<CONFIG:Debug>:/Zi>)
+
+	# Enable full optimization in dev/release
+	target_compile_options(${TARGET_NAME} PRIVATE $<$<CONFIG:Debug>:/Od> $<$<NOT:$<CONFIG:Debug>>:/Ox>)
+
+	# Inline function expansion
+	target_compile_options(${TARGET_NAME} PRIVATE /Ob2)
+
+	 # Enable intrinsic functions in dev/release
+	target_compile_options(${TARGET_NAME} PRIVATE $<$<NOT:$<CONFIG:Debug>>:/Oi>)
+
+    # Favor fast code
+	target_compile_options(${TARGET_NAME} PRIVATE /Ot)
+
+    # Enable fiber-safe optimizations in dev/release
+	target_compile_options(${TARGET_NAME} PRIVATE $<$<NOT:$<CONFIG:Debug>>:/GT>)
+
+	# Enable string pooling
+	target_compile_options(${TARGET_NAME} PRIVATE /GF)
+
+    # Use security checks only in debug
+	target_compile_options(${TARGET_NAME} PRIVATE $<$<CONFIG:DEBUG>:/sdl> $<$<NOT:$<CONFIG:DEBUG>>:/sdl->)
+else()
+
+endif ()
+
+if (JPH_INSTALL)
+	install(
+		FILES ${CMAKE_CURRENT_SOURCE_DIR}/include/joltc.h
+		DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/Jolt
+	)
+
+	install(TARGETS ${TARGET_NAME}
+		EXPORT ${TARGET_NAME}
+		ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+		LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+		RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)
+
+	if (MSVC)
+		install(FILES $<TARGET_PDB_FILE:${TARGET_NAME}> DESTINATION bin OPTIONAL)
+	endif ()
+endif()
+ 
+if (JPH_SAMPLES)
+	add_subdirectory(samples)
+endif ()
+
+# Tests
+option(JPH_TESTS "Build tests" ${JPH_MASTER_PROJECT})
+if (JPH_TESTS)
+	add_subdirectory(tests)
+endif ()
+
+if (JPH_BUILD_SHARED)
+	message(STATUS "  Library         SHARED")
+else ()
+  	message(STATUS "  Library         STATIC")
+endif ()
+
+message(STATUS "  Samples         ${JPH_SAMPLES}")
+
+if (CMAKE_GENERATOR_PLATFORM)
+    message(STATUS "CMAKE_GENERATOR_PLATFORM: ${CMAKE_GENERATOR_PLATFORM}")
+endif()
+
+message(STATUS "CMAKE_SYSTEM_PROCESSOR: ${CMAKE_SYSTEM_PROCESSOR}")
+if (CMAKE_OSX_ARCHITECTURES)
+    message(STATUS "CMAKE_OSX_ARCHITECTURES: ${CMAKE_OSX_ARCHITECTURES}")
+endif ()

data/ext/joltc/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Amer Koleci and Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/ext/joltc/README.md

@@ -0,0 +1,10 @@
+# joltc
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://github.com/amerkoleci/joltc/blob/main/LICENSE)
+[![Build status](https://github.com/amerkoleci/joltc/workflows/Build/badge.svg)](https://github.com/amerkoleci/joltc/actions)
+
+[JoltPhysics](https://github.com/jrouwe/JoltPhysics) C interface.
+
+## Sponsors
+Please consider [SPONSOR](https://github.com/sponsors/amerkoleci) me to further help development and to allow faster issue triaging and new features to be implemented.
+**_NOTE:_** **any feature request** would require a [sponsor](https://github.com/sponsors/amerkoleci) in order to allow faster implementation and allow this project to continue.

data/ext/joltc/build/cmake_vs2026_arm64.bat

@@ -0,0 +1,3 @@
+@echo off
+cmake -B "vs2026_arm64" -S "./../" -G "Visual Studio 18 2026" -A ARM64 -DCMAKE_INSTALL_PREFIX:String="Sdk" %*
+echo Open vs2026_arm64\JoltC.sln to build the project.

data/ext/joltc/build/cmake_vs2026_clang.bat

@@ -0,0 +1,10 @@
+@echo off
+cmake -B "vs2026_clang" -S "./../" -G "Visual Studio 18 2026" -A x64 -T ClangCL -DCMAKE_INSTALL_PREFIX:String="SDK" %*
+echo:
+echo !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+echo Make sure to install:
+echo - C++ Clang Compiler for Windows 12.0.0+
+echo - C++ Clang-cl for v143+ build tools (x64/x86)
+echo Using the Visual Studio Installer
+echo !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+echo Open vs2026_clang\Alimer.sln to build the project.

data/ext/joltc/build/cmake_vs2026_x64.bat

@@ -0,0 +1,3 @@
+@echo off
+cmake -S "./../" -B "vs2026_x64" -G "Visual Studio 18 2026" -A x64 -DCMAKE_INSTALL_PREFIX:String="SDK" -DCMAKE_BUILD_TYPE:String=Distribution %*
+echo Open vs2026_x64\JoltC.sln to build the project.

data/ext/joltc/build/cmake_vs2026_x64_double.bat

@@ -0,0 +1,3 @@
+@echo off
+cmake -S "./../" -B "vs2026_x64_double" -G "Visual Studio 18 2026" -A x64 -DCMAKE_INSTALL_PREFIX:String="SDK" -DDOUBLE_PRECISION=ON %*
+echo Open vs2026_x64_double\JoltC.sln to build the project.