v1.5.0

Highlights

• Implement "Geometric Contact Potential" [Huang et al. 2025] by @Huangzizhou in #191
• Implement "Offset Geometric Contact" [Chen et al. 2025] by @zfergus in #192
• Implement fully parallel LBVH Broad Phase by @zfergus in #188
• Add geometry utilities for collision normals, signed distances, and dihedral angles with gradients and Hessians.

What's Changed

New Formulations

• Geometric Contact Potential (GCP) by @Huangzizhou in #191
  • The implementation includes the collision and friction potential with gradients and Hessians.
  • Tutorial available here.
• Offset Geometric Contact (OGC) by @zfergus in #192
  • OGC is a penetration-free contact model that replaces continuous collision detection (CCD) with a trust-region-based approach.
  • New Namespace: Introduced ipc::ogc to encapsulate OGC-specific functionality.
  • Trust Region Implementation:
    • Added TrustRegion class (trust_region.hpp, trust_region.cpp) to manage per-vertex conservative bounds.
    • Implemented warm_start_time_step to initialize the trust region and handle initial predictions.
    • Implemented filter_step to scale optimization steps ensuring vertices stay within safe bounds.
    • Implemented update and update_if_needed to dynamically resize trust regions based on motion.
  • Feasible Region Logic:
    • Added feasible_region.hpp and feasible_region.cpp containing geometric predicates (e.g., check_vertex_feasible_region, is_edge_edge_feasible) to verify if primitives are within valid non-penetrating regions.
    • Integrated feasible region checks into the NormalCollisions class to filter out invalid collision candidates. Enabled via set_collision_set_type(NormalCollisions::CollisionSetType::OGC).
  • Step Scaling: Unlike the original paper's projection method, TrustRegion::filter_step scales the descent direction $\beta$ to keep vertices on the trust region boundary. This preserves the descent direction, ensuring compatibility with line-search-based solvers.
  • Tutorial available here.

Broad Phase

• Parallel CPU LBVH implementation by @zfergus in #188
  • New broad phase collision detection method with memory optimizations on the AABB structure.
  • LBVH Broad Phase:
    • Implemented LBVH class in src/ipc/broad_phase/lbvh.hpp, providing a Linear Bounding Volume Hierarchy method for broad phase collision detection.
    • Fully parallel build and traversal routines using Intel TBB.
    • SIMD optimizations for AABB overlap tests.
    • Faster than the existing BVH method and all other broad phase methods in IPC Toolkit for large scenes.
      • More than 3x faster to build.
      • Up to 1.5x faster for candidate detection.
      • Detailed performance charts available below.
    • Added python/examples/lbvh.py to demonstrate usage and visualization.
  • ⚡ Enhancements
    • Performance Optimizations:
      • Added DefaultInitAllocator to reduce overhead when allocating large arrays of POD types.
      • Replaced std::vector<AABB> with std::vector<AABB, DefaultInitAllocator<AABB>>.
    • Memory Optimization:
      • Switched AABB::min and AABB::max from ArrayMax3d to Eigen::Array3d.
      • Result: Reduces sizeof(AABB) from 76 to 64 bytes, allowing AABB to fit into a single cache line (assuming 64-byte lines).
    • Replaced hardware rounding in AABB::conservative_inflation with software rounding using std::nextafter.
  • 💥 Breaking Changes
    • API & Structural Changes:
      • Moved dimension variable: Removed dim from AABB and moved it to BroadPhase to handle 2D/3D data more cleanly. dim is now set in BroadPhase::build.
      • Handle 2D data by setting AABB's z-components to zero.
      • Constructor Removal: Removed the AABB default constructor and the initialization of AABB::vertex_ids.
      • Type Change: Changed to_3D in ipc/utils/eigen_ext.hpp to operate on Eigen::Array types instead of Eigen::Vector.
    • Deprecated BVH class in favor of the new LBVH class for better performance on large scenes.
• Refactor BroadPhase to Build from Vertex Boxes Directly in #187
• Rename sweep_and_tiniest_queue.cpp to .cu file by @iiiian in #203
• Fix vertex id assignment by @iiiian in #204
  • Fix vertex id assignment logic in SweepAndTiniestQueue.
• Replace optional const shared_ptr<BroadPhase>& parameters with BroadPhase* in #205
  • Change make_default_broad_phase to return a unique_ptr
• Pass parameters to Scalable CCD Narrow-Phase by @antoinebou12 in #208
  • Replace hardcoded TightInclusionCCD::DEFAULT_TOLERANCE and TightInclusionCCD::DEFAULT_MAX_ITERATION with narrow_phase.tolerance and narrow_phase.tolerance if passed a TightInclusionCCD object.
  • If narrow_phase_ccd is not a TightInclusionCCD instance, we fall back to default values to preserve backward compatibility.
• Add SIMD support via xsimd library in #207
  • Cross-platform SIMD (Single Instruction, Multiple Data) support using the xsimd library in the LBVH code.
  • Update the IPC_TOOLKIT_WITH_SIMD to be enabled by default, and improve CMake logic to detect SIMD capabilities and configure the build accordingly.
  • Disable Eigen's internal vectorization to avoid crashes on Linux.

Math and Geometry Utilities

• Add normal computation and Jacobian methods for collision candidates in #182
• Collect normal utilities into geometry/normal files in #197
• Organize geometry and math utilities into geometry and math folders in #198
• Add signed distance computations for point-plane, point-line, and line-line geometries in #206
• Optimized edge_edge_mollifier.cpp with FMA operator in gradient calculations.

Miscellaneous

• Updated dependencies:
  • Bump Abseil from 20250512.1 to 20260107.0
  • Bump Catch2 from v3.8.1 to v3.12.0
  • Bump Eigen from 3.4.0 to 5.0.1
  • Bump JSON from v3.11.2 to v3.12.0
  • Bump libigl from 89267b4a80b1904de3f6f2812a2053e5e9332b7e to v2.6.0
  • Bump TBB from v2022.1.0 to v2022.3.0
  • Bump Pybind11 from v2.13.1 to v3.0.1
  • Bump robin-map from v1.4.0 to v1.4.1
  • Bump spdlog from v1.15.3 to v1.17.0
• Make most dependencies private
  • Added a figure for default dependencies of the ipc::toolkit library: https://ipctk.xyz/about/dependencies.html
  • Refactored BVH class to use unique_ptr to hide SimpleBVH
  • Updated Sweep and Prune and Sweep and Tiniest Queue classes to use a Pimpl pattern for encapsulation.
  • Mark tsl::robin_map and absl::hash as private dependencies in CMake. Update the dependency documentation accordingly.
  • Convert SpatialHash to PImpl idiom to hide tsl::robin_map and absl::hash from the public API.
• Add Clang Tidy check
  • Added a .clang-tidy configuration file with a comprehensive set of checks, exclusions, naming conventions, and options to enforce modern C++ practices and treat all warnings as errors.
  • Introduced a GitHub Actions workflow (.github/workflows/clang-tidy-check.yml) to automatically run Clang-Tidy on relevant files for every push and pull request, improving code quality and review automation.
• Simplify CMake CUDA setup by @iiiian in #201
  • Disable CUDA builds by default.
  • Bump CMake minimum version to 3.24 to support CMAKE_CUDA_ARCHITECTURES="native"
• Add performance profiling utilities in #188
  • Added a (optional) profiler utility (src/ipc/utils/profiler.hpp) to measure/record metrics with CSV output support.
  • Added Nlohmann JSON as a dependency for profiler storage.
  • Use IPC_TOOLKIT_WITH_PROFILER CMake option to enable/disable profiling.
• Refactor to use Eigen::ConstRef for vertices in #200

New Contributors

• @iiiian made their first contribution in #201

Full Changelog: v1.4.0...v1.5.0

v1.4.0

Highlights

• Add adhesion potentials for sticky interactions, allowing for more realistic simulations of contact between objects.
  • Based on the paper "Augmented Incremental Potential Contact for Sticky Interactions" by Fang et al. [2023]
• Implement new barrier functions from the literature.
  • NormalizedClampedLogBarrier: unit-less clamped log barrier function.
  • ClampedLogSqBarrier: clamped log barrier with a quadratic log term from [Huang et al. 2024]
  • CubicBarrier: cubic barrier function from [Ando 2024]
• Add support for separate static and kinetic coefficients in tangential collisions.

What's Changed

• Adhesion by @zfergus in #85
  • Implement the adhesion potentials from "Augmented Incremental Potential Contact for Sticky Interactions" [Fang et al. 2023]
  • Files moved from ipc/friction to generic ipc/tangential and ipc/collisions/tangential folders.
  • Renamed Collision classes to NormalCollision
  • Renamed FrictionCollision classes to TangentialCollision
  • Renamed DistanceBasedPotential to NormalPotential
    • Added force_magnitude and force_magnitude_gradient methods to NormalPotential
  • Added TangentialPotential parent class to FrictionPotential and TangentialAdhesionPotential
  • Tutorial added by @antoinebou12 in #144
  • Use normal potential in tangential collisions by @maxpaik16 in #142
    • Replaces the const BarrierPotential& parameter with a const NormalPotential&
    • This allows tangential adhesion to be properly set up in simulation.
• Add NormalizedClampedLogBarrier by @zfergus in #143
• Add max_iterations parameter to Additive CCD by @zfergus in #145
• Add cubic barrier with elasticity-inclusive dynamic stiffness by @zfergus in #148
  • Implement the cubic barrier and elasticity-inclusive dynamic stiffness from [Ando 2024]
  • Implement $log^2$-barrier from GIPC [Huang et al. 2024]
  • Add compute_coefficients() to CollisionStencil – computes the coefficients $\vec{c}$ s.t. $d(x) = \Vert \sum c_i x_i\Vert^2$
  • Add compute_distance() to CollisionStencil taking $V$, $E$, $F$ directly
• Replace BroadPhaseMethod enum with shared_ptr<BroadPhase> by @zfergus in #152
  • Python BroadPhase by @zfergus in #155
• Remove ContinuousCollisionCandidate inheritance by @zfergus in #156
  • Replace it with the CollisionStencil class.
• Replace const Eigen::Matrix& with Eigen::ConstRef<Matrix> by @zfergus in #157
  • This allows for more efficient passing of matrices to functions.
• Separate Static and Kinetic Coefficients of Friction by @zfergus in #177
  • Enhancements to tangential collision handling by distinguishing between static and kinetic friction coefficients (mu_s and mu_k) and implementing smooth transitions between them.
  • Updated TangentialCollision class to replace mu with separate mu_s (static friction coefficient) and mu_k (kinetic friction coefficient). This change applies to the class definition and all related methods.
  • New smooth_mu functions: Added functions to compute smooth transitions between static and kinetic friction coefficients, including derivatives and related mathematical formulations. These functions improve the modeling of friction forces at varying tangential velocities.
  • Integration with adhesion module: Incorporated smooth friction coefficient calculations into the adhesion module.
  • Tutorial added by @zfergus in #178

Python Specific

• Add faster can_collide functions to Python by @zfergus in #135
• Add PyBroadPhase and PyNarrowPhaseCCD classes to wrap the BroadPhase and NarrowPhaseCCD classes, respectively, allowing for custom implementations of these classes in Python.
• Add new constructors to candidate classes (EdgeEdgeCandidate, EdgeFaceCandidate, EdgeVertexCandidate, FaceFaceCandidate, FaceVertexCandidate, VertexVertexCandidate) that accept tuples for easier initialization.
• Include a call to std::atexit to reset the thread limiter upon program exit to ensure proper cleanup.
• ⚠️ Python NarrowPhaseCCD implementations will not work with multi-threading because of GIL locking.
• Switch from py::arg to _a literals by @zfergus in #168

Miscellaneous

• Add /Wall and /MP compiler flags for MSVC by @zfergus in #134
• Enable CUDA by default if CUDA is detected by CMake by @zfergus in #134
• Devcontainer by @antoinebou12 in #136
• Update dependencies for CMake 4.0 by @zfergus in #158
• Organize folder structure for generated Xcode project by @zfergus in #159
  • Refactor CMake configurations and improve project structure
  • Updated CMake recipes for third-party libraries to set appropriate folder properties for IDE organization.
  • Changed the CPMAddPackage references for scalable-ccd to a more recent commit.
  • Enhanced logging functionality by adding a new log_and_throw_error function to improve error handling.
  • Improved documentation in the style guide for naming conventions.
  • Move generated config.hpp file from src/ipc to build/include/src/ipc
  • Update CUDA builds in CMakePresets.json
  • Remove virtual tag from BroadPhase::detect_collision_candidates
• Index typedef by @zfergus in #161
  • Add a index_t typedef for vertex/edge/face ids. Changes default from long to int32_t.
• Update Tight Inclusion package version to 1.0.6 by @zfergus in #165
• Fix cmake for non-top-level inclusion by @sin3point14 in #167
• Improve and clean up documentation:
  • Fix Error in Docs by @zfergus in #169
  • Update docs by @zfergus in #173
  • Update docs.yml by @zfergus in #174
  • Refactor and clean-up C++ API docs by @zfergus in #175

New Contributors

• @maxpaik16 made their first contribution in #142
• @sin3point14 made their first contribution in #167

Full Changelog: v1.3.1...v1.4.0

v1.3.1

What's Changed

• Move test data to an external repository by @zfergus in #113
  • Download test data at compile time as needed using CMake
• Bump actions/download-artifact from 3 to 4.1.7 in /.github/workflows by @dependabot in #119
• Individual convergent formulation flags by @zfergus in #120
  • Replace the use_convergent_formulation flag in Collisions with two flags: use_area_weighting and use_improved_max_approximator.
  • Move the physical barrier rescaling from collision weights into the BarrierPotential using a flag use_physcial_barrier.
• Replace scalar tbb::enumerable_thread_specific with tbb::parallel_reduce by @zfergus in #121
• Fix missing max_iterations and tolerance variables in compute_collision_free_stepsize when using SWEEP_AND_TINIEST_QUEUE by @antoinebou12 in #123
• Add cuda.yml to test if the code compile with CUDA enabled by @zfergus in #125
• Update filib to allow shared library build by @zfergus in #122
• Fix friction_collisions.build tutorial (Issue #126) by @zfergus in #127
• Sort includes using clang-format by @zfergus in #129
• Add frequently asked questions page to the tutorial documentation
• Fix barrier API documentation
• On Apple, link Eigen against Accelerate as a BLAS/LAPACK backend
  • Requires brew install lapack to install LAPACKE headers

New Contributors

• @dependabot made their first contribution in #119
• @antoinebou12 made their first contribution in #123

Full Changelog: v1.3.0...v1.3.1

v1.3.0

Highlights

• Separated the collision set and potential computations. This allows us to more easily add new potentials in the future. This will require updating calls to compute_potential_*. See the tutorial for details.
• Add a Barrier class to enable dynamic selection of barrier function.
• Add a NarrowPhaseCCD class to enable dynamic selection of narrow-phase CCD method.

What's Changed

• Refactor potentials by @zfergus in #83
  • Replace "constraint" and "contact" names with "collision"
  • Removed compute_potential_* from Collision and Collisions
  • Add a new class hierarchy Potential which represents computing the sum of individual potentials per collision
    • Implement the barrier potential and friction dissipative potential as Potentials: BarrierPotential and FrictionPotential
  • Now, Collisions serve solely as the set of active collisions
  • Add the distance mollifier to all collisions with a is_mollified() function
    • The default mollifier is $m(x) = 1$, and only EdgeEdgeCollision overrides this
  • Remove versions of compute_distance and ccd from CollisionStencil which take the full mesh as input
    • Instead, expose the versions that take the collision stencil's vertex positions directly
• Polymorphic barrier in #84
  • Make the barrier function an object so it can be changed at runtime
  • Add a virtual class Barrier as an interface for generic barriers
  • Add ClampedLogBarrier class which implements the smoothly clamped log barrier functions from [Li et al. 2020]
  • barrier_gradient and barrier_hessian renamed to barrier_first_derivative and barrier_second_derivative respectively
  • Co-authored by @arvigj
• Update compiler warnings in #88
  • Add -Werror=enum-conversion and -Wfloat-conversion
• Fix 🐛 hash when not using Abseil in #90
• Clean-up SpatialHash Broad Phase in #91
  • Replace IPC_TOOLKIT_WITH_CORRECT_CCD with IPC_TOOLKIT_WITH_INEXACT_CCD
    • Always include Tight Inclusion CCD because it is used by Nonlinear CCD
  • Add support for face-face collision (not used anywhere but for completeness and future-proof nonlinear face-face)
  • Add and use generic functions to SpatialHash
  • Replace camelCase with snake_case in SpatialHash and HashGrid
• Update Scalable CCD in #92
  • Updated Scalable CCD (i.e., Sweep and Tiniest Queue and CUDA Tight Inclusion CCD) to the unified repository with support for generic collision pairs.
  • Renamed SWEEP_AND_TINIEST_QUEUE to SWEEP_AND_PRUNE to reflect that it is a standard implementation of the sweep and prune algorithm (see, e.g., "Real-Time Collision Detection" [Ericson 2004])
  • Renamed SWEEP_AND_TINIEST_QUEUE_GPU to SWEEP_AND_TINIEST_QUEUE to reflect that it is the only existing implementation of the sweep and tiniest queue algorithm
• Mark single argument constructors explicit in #93
  • Mark BarrierPotential(double) and FrictionPotential(double) as explicit constructors to avoid implicit conversions from double
• Fix compatibility with the latest Eigen by @teseoch in #94
• Add clang-format check action in #96
• Add new project PSD option by @Huangzizhou in #95
  • Instead of clamping the negative eigenvalues to zero, add the option to flips the sign of negative eigenvalues according to [Chen et al. 2024]
• Fix 🐛 Python bindings for Numpy 2 in #100
• Make faces an optional parameter to CollisionMesh in #105
• Fix Python documentation by @rc in #108
• Polymorphic CCD in #110
  • Add narrow phase CCD parent class; pass CCD object to choose method
  • Replace tolerance and max_iterations parameters with const NarrowPhaseCCD& narrow_phase_ccd parameter
  • NarrowPhaseCCD is a virtual class containing the CCD methods for point-point, point-edge, edge-edge, and point-triangle CCD
  • NarrowPhaseCCD is implemented by InexactCCD, TightInclusionCCD, and AdditiveCCD classes
  • [Breaking] The optional parameter order to is_step_collision_free and compute_collision_free_stepsize is changed from

    const BroadPhaseMethod broad_phase_method = DEFAULT_BROAD_PHASE_METHOD,
    const double min_distance = 0.0,
    const double tolerance = DEFAULT_CCD_TOLERANCE,
    const long max_iterations = DEFAULT_CCD_MAX_ITERATIONS);

    to

    const double min_distance = 0.0,
    const BroadPhaseMethod broad_phase_method = DEFAULT_BROAD_PHASE_METHOD,
    const NarrowPhaseCCD& narrow_phase_ccd = DEFAULT_NARROW_PHASE_CCD);

  • The inexact floating-point CCD can be enabled beside the Tight Inclusion CCD rather than replacing it

New Contributors

• @Huangzizhou made their first contribution in #95
• @rc made their first contribution in #108

Full Changelog: v1.2.1...v1.3.0

v1.2.1

Bug fixes 🐛 :

• Update Pybind11 to support Numpy 2.0. Fixes segmentation fault as described in #102.

Full Changelog: v1.2.0...v1.2.1

v1.2.0

Various new features 🚀 and some bug fixes 🐛.

Highlights

• Implement the improved max approximator as described in [Li et al. 2023]
• Add a port of the Additive CCD method from [Li et al. 2021]
• Add a generic implementation of the nonlinear CCD (of linear geometry) algorithm from [Ferguson et al. 2021]
• Add missing codimensional collision support (point-point and point-edge)

What's Changed

• Update website URL to ipctk.xyz in #54
• Simplify tangential basis Jacobian calculation thanks to @halehOssadat and @jpanetta in #56
• Update FindSIMD.cmake to now add support for Neon (Arm/Apple Silicon SIMD instruction set) in #58
  • Credit: FindSIMD.cmake from Project CHRONO under BSD 3-Clause "New" or "Revised" License.
• Improve the max approximator used (i.e., sum over constraints) as described in [Li et al. 2023] in #55
  • Add a dtype to EE collisions to keep track of the distance type for mollified constraints
  • Initialize mesh adjacencies by default
  • Use edge length as the area weighting for codimensional edges
• Improve documentation and tutorials in #61
  • Add documentation describing the convergent formulation
  • Add documentation describing the constraint offset/minimum distance
  • Add documentation for broad- and narrow-phase CCD
  • Add documentation for High-Order IPC
  • Also, renames CollisionConstraint::minimum_distance to CollisionConstraint::dmin
• Add a port of the Additive CCD method from [Li et al. 2021] in #62
  • This is a modified version of the original open-source implementation which is under the Appache-2.0 License.
  • Modifications: remove broad phase functions, refactor code to use a single implementation of the additive_ccd algorithm, utilize our distance function rather than porting the Codim-IPC versions, return true if the initial distance is less than the minimum distance, and add an explicit tmax parameter rather than relying on the initial value of toi.
  • This is mostly for reference comparison and it is not integrated into the full code. This also includes the ability to pull the sample CCD queries and run them in a unit-test (requires GMP).
  • This adds missing feature mentioned in #63
• Add Codecov to get a report of unit test code coverage in #64
  • Add more tests to improve code coverage and fix small bugs in #65
• Fix the symmetric matrix assertion in project_to_psd and project_to_pd in #67
• Handle codim. point-point collisions in #66
  • This adds missing feature as discussed in #63
• Add tests of Python bindings using nose2 in #69
• In CCD, check the initial distance when no motion occurs in #71
• Add a generic implementation of the nonlinear CCD (of linear geometry) algorithm from [Ferguson et al. 2021] in #72
  • Generic nonlinear trajectories are specified through a NonlinearTrajectory virtual class. By default the maximum distance between the trajectory and a linearized version is computed using interval arithmetic. That is $\max_{t \in [0, 1]} \Vert p(\mathrm{lerp}(t_0, t_1, t)) - \mathrm{lerp}(p(t_0), p(t_1), t) \Vert_2 \leq \sup(\Vert p([t_0, t_1]) - \mathrm{lerp}(p(t_0), p(t_1), [0, 1]) \Vert_2)$ where $p$ is the point's position over time, $\mathrm{lerp}(a, b, t) := (b - a) t + a$ and $\sup([a,b]):=b$. Because this can be an overly conservative approximation, users can override the NonlinearTrajectory::max_distance_from_linear function to compute the max directly in closed form, if known.
  • We perform interval arithmetic using filib which has been shown to be "the only library that is correct, consistent, portable, and efficient" [Tang et al. 2022].
  • Add a nonlinear CCD tutorial to the docs in #78
• Add additional compiler warnings and resolve them to be warning-free in #73
• Add Python bindings for igl::predicate::segment_segment_intersect in #74
• Integrate SimpleBVH as a broad-phase method in #75
• Fix the shape derivative of mollified edge-edge contact in #76
  • Additionally, this makes the shape derivative computation object-oriented.
• Update Python bindings with recent changes and unified comments in #77
• Add support for collision between codimensional edges and points in 3D in #79
  • Implements missing features discussed in #63.

Full Changelog: v1.1.1...v1.2.0

New Contributors

• @halehOssadat made their first contribution in #56
• @jpanetta made their first contribution in #56

v1.1.1

What's Changed

• Logo by @zfergus in #52
• Fix vertex-vertex == and < functions to be order independent
  • This allows vertex-vertex constraints merge correctly
• Update Tight Inclusion CCD

Full Changelog: v1.1.0...v1.1.1

v1.1.0

Large refactoring to make the code more object-oriented rather than passing objects to functions. Other changes include the friction potential now being a function of velocity, bug fixes, and a new tutorial.

What's Changed

• Large Refactor in #25
  • construct_collision_candidates(..., candidates) -> candidates.build(...)
  • is_step_collision_free(candidates, ...) -> candidates.is_step_collision_free(...)
  • compute_collision_free_stepsize(candidates, ...) -> candidates.compute_collision_free_stepsize(...)
  • compute_barrier_potential*(constraints, ...) -> constraints.compute_potential*(...)
  • compute_shape_derivative(constraints, ...) -> constraints.compute_shape_derivative(...)
  • compute_minimum_distance(constraints, ...) -> constraints.compute_minimum_distance(...)
  • construct_friction_constraint_set(..., friction_constraints) -> friction_constraints.build(...)
  • compute_friction_*(..., friction_constraints, ...) -> friction_constraints.compute_*(...)
  • Generic CollisionStencil parent class to Candidates, CollisionConstraints, and FrictionConstraints.
  • Renamed Constraints to CollisionConstraints
  • Replaced single letter variable names V, E, F with vertices/positions, edges, faces
  • Renamed *_index -> *_id
  • Replaced inflation_radius = min_distance / 1.99 with inflation_radius = min_distance / 2 and use rounding mode to conservativly inflate AABBs
  • CollisionConstraints::use_convergent_formulation and are_shape_derivatives_enabled must now be accessed through getter and setter functions
  • Friction potentials are now functions of velocity. Previously V0 and V1 were passed and U = V1-V0. This limited the integration scheme to implicit Euler. Upstream this means you need to multiply the potential by 1/(dv/dx) to get the correct friction force.
    • Change input $\epsilon_vh$ to $\epsilon_v$ in #37 to reflect the fact that friction is defined in terms of velocity instead of displacement now.
• Changed default project_hessian_to_psd to false in #30
• Update website with a tutorial (#31) and version dropdown list (#34)
• Switch from templates to using Eigen::Ref in #28
• Speed up the CCD by limiting the maximum minimum distance to 1e-4 in #43
• Fix the bug pointed out in #41 in #42. Namely, to get units of distance in the barrier we should divide the original function by $\hat{d}\cdot(\hat{d} + 2d_\min)^2$ when using distance squared. Before it was being divided by $2d_\min \hat{d} + \hat{d}^2$.
• Fix build for IPC_TOOLKIT_WITH_CORRECT_CCD=OFF in #44
• Switched from FetchContent to CPM in #48. This provides better caching between builds. Additionally, made robin-map and Abseil optional dependencies.
• Add the CFL-Inspired Culling of CCD as described in Section 3 of the Technical Supplement to IPC in #50

Full Changelog: v1.0.0...v1.1.0

v1.0.0

This is the first official release. 🎉

This is a stable release of the toolkit prior to refactoring the code and making updates to the API.

New Contributors

• @danielepanozzo made their first contribution in #20
• @arvigj made their first contribution in #22

Full Changelog: https://github.com/ipc-sim/ipc-toolkit/commits/v1.0.0