Merge commit '617b80e92eb4310791a722fd1cc20c902b17683f' into fix-bug

Author: Huangzizhou

.gitignore

@@ -265,7 +265,7 @@ tests/src/tests/config.hpp
 docs/_doxygen
 
 notebooks/*.[ch]pp
-tests/data/cloth_ball_bf_ccd_candidated.json
+tests/data/cloth_ball_bf_ccd_candidates.json
 python/update_bindings.py
 
 cmake-build-debug/

CMakeLists.txt

@@ -63,16 +63,21 @@ project(IPCToolkit
 
 option(IPC_TOOLKIT_BUILD_TESTS                "Build unit-tests"  ${IPC_TOOLKIT_TOPLEVEL_PROJECT})
 option(IPC_TOOLKIT_BUILD_PYTHON               "Build Python bindings"                         OFF)
-option(IPC_TOOLKIT_WITH_CORRECT_CCD           "Use Tight Inclusion CCD"                        ON)
-option(IPC_TOOLKIT_WITH_SIMD                  "Enable SIMD"                                   OFF)
 option(IPC_TOOLKIT_WITH_CUDA                  "Enable CUDA CCD"                               OFF)
 option(IPC_TOOLKIT_WITH_RATIONAL_INTERSECTION "Use rational edge-triangle intersection check" OFF)
 option(IPC_TOOLKIT_WITH_ROBIN_MAP             "Use Tessil's robin-map rather than std maps"    ON)
 option(IPC_TOOLKIT_WITH_ABSEIL                "Use Abseil's hash functions"                    ON)
 option(IPC_TOOLKIT_WITH_FILIB                 "Use filib for interval arithmetic"              ON)
+
+# Advanced options
+option(IPC_TOOLKIT_WITH_INEXACT_CCD           "Use the original inexact CCD method of IPC"    OFF)
+option(IPC_TOOLKIT_WITH_SIMD                  "Enable SIMD"                                   OFF)
 option(IPC_TOOLKIT_WITH_CODE_COVERAGE         "Enable coverage reporting"                     OFF)
 option(IPC_TOOLKIT_WITH_AUTODIFF              "Enable AutoDiff for computing derivatives"     OFF)
-mark_as_advanced(IPC_TOOLKIT_WITH_CODE_COVERAGE)
+
+mark_as_advanced(IPC_TOOLKIT_WITH_INEXACT_CCD)   # This is only for comparison purposes
+mark_as_advanced(IPC_TOOLKIT_WITH_SIMD)          # This does not work reliably
+mark_as_advanced(IPC_TOOLKIT_WITH_CODE_COVERAGE) # This is used in GitHub Actions
 
 # Set default minimum C++ standard
 if(IPC_TOOLKIT_TOPLEVEL_PROJECT)
@@ -126,14 +131,13 @@ target_compile_definitions(ipc_toolkit PUBLIC NOMINMAX)
 # Dependencies
 ################################################################################
 
-# libigl
+# Eigen
 include(eigen)
+target_link_libraries(ipc_toolkit PUBLIC Eigen3::Eigen)
+
+# libigl
 include(libigl)
-target_link_libraries(ipc_toolkit PUBLIC
-  Eigen3::Eigen
-  igl::core
-  igl::predicates
-)
+target_link_libraries(ipc_toolkit PUBLIC igl::core igl::predicates)
 
 # autodiff
 include(autodiff)
@@ -142,12 +146,16 @@ include(autodiff)
 include(onetbb)
 target_link_libraries(ipc_toolkit PUBLIC TBB::tbb)
 
+# Provably conservative CCD of [Wang and Ferguson et al. 2021]
+include(tight_inclusion)
+target_link_libraries(ipc_toolkit PUBLIC tight_inclusion::tight_inclusion)
+
+# Scalable CCD (STQ broad phase and GPU Tight Inclusion)
+include(scalable_ccd)
+target_link_libraries(ipc_toolkit PUBLIC scalable_ccd::scalable_ccd)
+
 # CCD
-if(IPC_TOOLKIT_WITH_CORRECT_CCD)
-  # Provably conservative CCD of [Wang and Ferguson et al. 2021]
-  include(tight_inclusion)
-  target_link_libraries(ipc_toolkit PUBLIC tight_inclusion::tight_inclusion)
-else()
+if(IPC_TOOLKIT_WITH_INEXACT_CCD)
   # Etienne Vouga's CTCD Library for the floating point root finding algorithm
   include(evouga_ccd)
   target_link_libraries(ipc_toolkit PUBLIC evouga::ccd)
@@ -167,17 +175,6 @@ if(IPC_TOOLKIT_WITH_RATIONAL_INTERSECTION)
   target_link_libraries(ipc_toolkit PUBLIC rational::rational)
 endif()
 
-# Sweep and Tiniest Queue and CCD
-if(IPC_TOOLKIT_WITH_CUDA)
-  include(gpu_ccd)
-  target_link_libraries(ipc_toolkit PUBLIC gpu_ccd::gpu_ccd)
-  target_link_libraries(ipc_toolkit PUBLIC STQ::CPU)
-else()
-  set(STQ_WITH_CUDA OFF CACHE BOOL "Enable CUDA Implementation" FORCE)
-  include(sweep_and_tiniest_queue)
-  target_link_libraries(ipc_toolkit PUBLIC STQ::CPU)
-endif()
-
 # Faster unordered map
 if(IPC_TOOLKIT_WITH_ROBIN_MAP)
   include(robin_map)
@@ -239,27 +236,15 @@ if(IPC_TOOLKIT_WITH_CUDA)
 
   if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.24.0")
     set(CMAKE_CUDA_ARCHITECTURES "native")
-    set_target_properties(ipc_toolkit PROPERTIES CUDA_ARCHITECTURES "native")
   else()
     include(FindCUDA/select_compute_arch)
     CUDA_DETECT_INSTALLED_GPUS(CUDA_ARCH_LIST)
     string(STRIP "${CUDA_ARCH_LIST}" CUDA_ARCH_LIST)
     string(REPLACE " " ";" CUDA_ARCH_LIST "${CUDA_ARCH_LIST}")
     string(REPLACE "." "" CUDA_ARCH_LIST "${CUDA_ARCH_LIST}")
     set(CMAKE_CUDA_ARCHITECTURES ${CUDA_ARCH_LIST})
-    set_target_properties(ipc_toolkit PROPERTIES CUDA_ARCHITECTURES "${CUDA_ARCH_LIST}")
-  endif()
-
-  if(APPLE)
-    # We need to add the path to the driver (libcuda.dylib) as an rpath,
-    # so that the static cuda runtime can find it at runtime.
-    set_property(TARGET ipc_toolkit
-                 PROPERTY
-                 BUILD_RPATH ${CMAKE_CUDA_IMPLICIT_LINK_DIRECTORIES})
   endif()
-
-  find_package(CUDAToolkit)
-  target_link_libraries(ipc_toolkit PRIVATE CUDA::cudart)
+  set_target_properties(scalable_ccd PROPERTIES CUDA_ARCHITECTURES "${CMAKE_CUDA_ARCHITECTURES}")
 endif()
 
 ################################################################################

IPCToolkitOptions.cmake.sample

@@ -30,13 +30,13 @@
 
 # option(IPC_TOOLKIT_BUILD_TESTS                "Build unit-tests"                               ON)
 # option(IPC_TOOLKIT_BUILD_PYTHON               "Build Python bindings"                         OFF)
-# option(IPC_TOOLKIT_WITH_CORRECT_CCD           "Use Tight Inclusion CCD"                        ON)
-# option(IPC_TOOLKIT_WITH_SIMD                  "Enable SIMD"                                   OFF)
 # option(IPC_TOOLKIT_WITH_CUDA                  "Enable CUDA CCD"                               OFF)
 # option(IPC_TOOLKIT_WITH_RATIONAL_INTERSECTION "Use rational edge-triangle intersection check" OFF)
 # option(IPC_TOOLKIT_WITH_ROBIN_MAP             "Use Tessil's robin-map rather than std maps"    ON)
 # option(IPC_TOOLKIT_WITH_ABSEIL                "Use Abseil's hash functions"                    ON)
 # option(IPC_TOOLKIT_WITH_FILIB                 "Use filib for interval arithmetic"              ON)
+# option(IPC_TOOLKIT_WITH_INEXACT_CCD           "Use the original inexact CCD method of IPC"    OFF)
+# option(IPC_TOOLKIT_WITH_SIMD                  "Enable SIMD"                                   OFF)
 # option(IPC_TOOLKIT_WITH_CODE_COVERAGE         "Enable coverage reporting"                     OFF)
 # option(IPC_TOOLKIT_TESTS_CCD_BENCHMARK        "Enable CCD benchmark test"                      ON)
 # set(IPC_TOOLKIT_TESTS_CCD_BENCHMARK_DIR     "" CACHE PATH "Path to the CCD benchmark directory")

README.md

@@ -17,7 +17,7 @@ IPC Toolkit is a set of reusable functions to integrate Incremental Potential Co
 ### Features
 
 * IPC barrier function and its derivatives and adaptive barrier stiffness algorithm
-* Broad-phase and narrow-phase continuous collision detection (CCD)
+* Broad- and narrow-phase continuous collision detection (CCD) of linear and nonlinear trajectories
 * Distance computation and derivatives between edges in 2D and triangles in 3D
 * Distance barrier potential and its derivatives
 * Smooth and lagged dissipative friction potential and its derivatives
@@ -32,7 +32,7 @@ This is not a full simulation library. As such it does not include any physics o
 
 The easiest way to add the toolkit to an existing CMake project is to download it through CMake.
 CMake provides functionality for doing this called [FetchContent](https://cmake.org/cmake/help/latest/module/FetchContent.html) (requires CMake ≥ 3.14).
-We use this same process to download all external dependencies.
+We use a very similar process to download all external dependencies (using [CPM](https://github.com/cpm-cmake/CPM.cmake)).
 
 For example,
 
@@ -66,12 +66,15 @@ The following libraries are used in this project:
 * [Eigen](https://eigen.tuxfamily.org/): linear algebra
 * [libigl](https://github.com/libigl/libigl): basic geometry functions and predicates
 * [oneTBB](https://github.com/oneapi-src/oneTBB): parallelism
-* [Tight-Inclusion](https://github.com/Continuous-Collision-Detection/Tight-Inclusion): correct (conservative) CCD
+* [Tight-Inclusion](https://github.com/Continuous-Collision-Detection/Tight-Inclusion): provably conservative CCD of [Wang and Ferguson et al. 2021]
 * [SimpleBVH](https://github.com/ipc-sim/SimpleBVH): a simple bounding volume hierarchy data structure
+* [Scalable-CCD](https://github.com/Continuous-Collision-Detection/Scalable-CCD): scalable (GPU) CCD of [Belgrod et al. 2023]
 * [spdlog](https://github.com/gabime/spdlog): logging information
 
 #### Optional
 
+The following dependencies are optionally used based on CMake options:
+
 * [robin-map](https://github.com/Tessil/robin-map): faster hash set/map than `std::unordered_set`/`std::unordered_map`
     * Enable by using the CMake option `IPC_TOOLKIT_WITH_ROBIN_MAP`
     * Enabled by default
@@ -86,7 +89,7 @@ The following libraries are used in this project:
     * Requires [GMP](https://gmplib.org/) to be installed at a system level
 * [Etienne Vouga's Collision Detection Library](https://github.com/evouga/collisiondetection): inexact CCD
     * Included for comparison with the original IPC library
-    * Enable by disabling the CMake option `IPC_TOOLKIT_WITH_CORRECT_CCD`
+    * Enable by using the CMake option `IPC_TOOLKIT_WITH_INEXACT_CCD`
     * Replaces the default Tight-Inclusion CCD
 
 ## Usage
@@ -96,11 +99,11 @@ See the [tutorial](https://ipctk.xyz/tutorial/getting_started.html) for a quick
 ## Unit Tests
 
 We provide unit tests to ensure the correctness of our algorithmic pieces.
-To enable the unit tests use the CMake option `IPC_TOOLKIT_BUILD_UNIT_TESTS`.
+To enable the unit tests use the CMake option `IPC_TOOLKIT_BUILD_TESTS`.
 
 ### Dependencies
 
-The following are downloaded when unit tests are enabled (`IPC_TOOLKIT_BUILD_TESTS`)
+The following are downloaded when unit tests are enabled:
 
 * [Catch2](https://github.com/catchorg/Catch2.git): testing framework
 * [finite-diff](https://github.com/zfergus/finite-diff): finite-difference comparisons

cmake/ipc_toolkit/ipc_toolkit_warnings.cmake

@@ -45,6 +45,7 @@ set(IPC_TOOLKIT_WARNING_FLAGS
   -Werror=int-to-pointer-cast
   -Werror=pointer-to-int-cast
   -Werror=inconsistent-missing-override
+  -Werror=return-stack-address
 
   -Wunused-variable
   -Wunused-but-set-variable

cmake/recipes/eigen.cmake

@@ -15,7 +15,7 @@ CPMAddPackage(
     NAME eigen
     GITLAB_REPOSITORY libeigen/eigen
     GIT_TAG 3.4.0
-    DOWNLOAD_ONLY ON
+    DOWNLOAD_ONLY YES
 )
 
 add_library(Eigen3_Eigen INTERFACE)

cmake/recipes/evouga_ccd.cmake

@@ -8,19 +8,19 @@ message(STATUS "Third-party: creating target 'evouga::ccd'")
 
 include(CPM)
 CPMAddPackage(
-    evccd
-    GIT_REPOSITORY https://github.com/evouga/collisiondetection.git
+    NAME evccd
+    GITHUB_REPOSITORY evouga/collisiondetection
     GIT_TAG e5fe5c9767207df5047e375fb20180a665ae186f
-    DOWNLOAD_ONLY ON
+    DOWNLOAD_ONLY YES
 )
 
 # file(GLOB EVOUGA_CCD_SOURCE_FILES "${evccd_SOURCE_DIR}/src/*.cpp")
 add_library(evouga_ccd
-    "${collisiondetection_SOURCE_DIR}/src/CTCD.cpp"
+    "${evccd_SOURCE_DIR}/src/CTCD.cpp"
 )
 add_library(evouga::ccd ALIAS evouga_ccd)
 
-target_include_directories(evouga_ccd PUBLIC "${collisiondetection_SOURCE_DIR}/include")
+target_include_directories(evouga_ccd PUBLIC "${evccd_SOURCE_DIR}/include")
 
 include(eigen)
 target_link_libraries(evouga_ccd PUBLIC Eigen3::Eigen)

cmake/recipes/gpu_ccd.cmake

@@ -14,13 +14,14 @@ CPMAddPackage(
     NAME nlohmann_json
     URL "https://github.com/nlohmann/json/releases/download/${NLOHMANNJSON_VERSION}/include.zip"
     URL_HASH SHA256=e5c7a9f49a16814be27e4ed0ee900ecd0092bfb7dbfca65b5a421b774dccaaed
+    DOWNLOAD_ONLY YES
 )
 
 add_library(nlohmann_json INTERFACE)
 add_library(nlohmann_json::nlohmann_json ALIAS nlohmann_json)
 
 include(GNUInstallDirs)
-target_include_directories(nlohmann_json INTERFACE
+target_include_directories(nlohmann_json SYSTEM INTERFACE
     "$<BUILD_INTERFACE:${nlohmann_json_SOURCE_DIR}>/include"
     "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
 )

cmake/recipes/json.cmake

@@ -0,0 +1,12 @@
+# Scalable-CCD (https://github.com/continuous-collision-detection/scalable-ccd)
+# License: Apache 2.0
+if(TARGET scalable_ccd::scalable_ccd)
+    return()
+endif()
+
+message(STATUS "Third-party: creating target 'scalable_ccd::scalable_ccd'")
+
+set(SCALABLE_CCD_WITH_CUDA ${IPC_TOOLKIT_WITH_CUDA} CACHE BOOL "Enable CUDA CCD" FORCE)
+
+include(CPM)
+CPMAddPackage("gh:continuous-collision-detection/scalable-ccd#60692d7cbc03390a3a198792a3ff2b869c5da05b")