All notable changes to this project will be documented in this file.
Added a minimum distance optional parameter to all CCD functions (
const double min_distance = 0.0). This is placed as the first optional argument which can break calling code if optional parameters were previously used.
CollisionMesh to wrap up face and edges into a single data structure.
Support for ignoring internal vertices.
Instead, users should use the CollisionMesh to map from the full mesh to the surface mesh.
This also includes a
to_full_doffunction that can map the reduced gradient/hessian to the full mesh’s DOF
Added implicits source folder to organize point-plane collisions
Added support for point vs. (static) analytical plane contact
Changed CMake target name to
Updated the CMake system to use modern
FetchContentto download externals
Updated CCD strategy when using Tight Inclusion to only perform
no_zero_toi=truewhen there is no minimum distance
detect_edge_face_collision_candidates_brute_forcefor 3D intersection broad-phase
Added ability to save an obj of collision candidates
Added tests for has_intersection (all pass after fixes)
Fixed possible numerical rounding problems in HashGrid
Fixed HashGrid’s function for getting edge-face intersection candidates
ignore_codimensional_verticesin the brute force broad-phase method
Fixed AABB inflation in brute force and SpatialHash methods
Replaced vertex group ids with more powerful can_collide function. By default everything can collide with everything (same as before)
Reordered parameters in
update_barrier_stiffnessnow requires the
constraint_setrather than building it
update_barrier_stiffnessdropped dhat parameter
SpatialHash for 2D
initial_barrier_stiffnessthat computes the constraint set and barrier gradient because there are a lot of parameters to these functions
Select the broad-phase method for CCD and distance constraints
CCD parameters for Tight Inclusion’s tolerance and maximum iterations
construct_friction_constraint_setnow clears the given
Use TightInclusion degenerate edge-edge for point-point and point-edge CCD
dhat_epsilon_scalea default value of
:warning: Changed order of parameters to
Bug in output min distance of
Moved eigen_ext functions into ipc namespace
Renamed max size matrices with
Added utility function to check for edge-edge intersection in 2D and edge-triangle intersection in 3D.
Optionally: use GMP for exact edge-triangle intersection checks
voxel_size_heuristic.cpp which suggests a good voxel size for the SpatialHash and HashGrid
Changed HashGrid voxel size to be the average edge length not considering displacement length. This results in better performance, but can result in large memory usage.
Added TBB parallel loops to the main function (
addVerticesFromEdgesthat adds the vertices connected to edges in parallel and avoids duplicates
Changed the HashGrid to use
VectorX3to simplify the code
Fixed some parameters that were not by reference
Added the SpatialHash from the original IPC code base with some modification to get all candidates in parallel
Benchmark results indicate this SpatialHash is faster than the HashGrid with multithreading
TODO: Improve HashGrid or fully integrate SpatialHash into ipc.hpp
Switched to the correct (conservative) CCD of [Wang and Ferguson et al. 2020]
Can select Etienne Vouga’s CCD in the CMake (see README.md)
Added minimum seperation distance (thickness) to distance constraints
Added 2D friction model based on the 3D formulation.
TODO: Test this further
Added and optional parameter
construct_constraint_set(). This is similar to
F(which maps faces to vertices), but maps faces to edges. This is optional, but recommended for better performance. If not provided a simple linear search will be done per face edge!
TODO: Add a function to compute this mapping.
Replaced VectorXd and MatrixXd with static size versions for local gradient and hessians
Removed TBB parallelization form the hash grid because we get better performance without it.
TODO: Improve parallelization in the hash grid or switch to the original IPC spatial hash
Fixed multiplicity for point-triangle distance computation to avoid duplicate point-point and point-edge pairs.
Projection of the hessian to PSD. This was completely broken as the projected matrix was never used.
Mollification of EE constraints that have a distance type of PP or PE
If there is no mollification needed then the PP and PE constraints are stored with multiplicity
Set the parallel EE friction constraint threshold to eps_x like in IPC
This avoid needing the mollification for the normal force and these forces are small anyways
Point-triangle distance type by replacing it with the one used in the original IPC code
Boolean parameter in
compute_friction_potential_hessianthat controls if the hessian is projected to PSD
Parameter for vertex group IDs to exclude some collisions (e.g., self collisions)
Second version of
update_barrier_stiffness()that takes an already computed minimum distance and world bounding box diagonal
Second version of
initial_barrier_stiffness()that takes an already computed barrier gradient
average_mass > 0 && min_barrier_stiffness_scale > 0
Fixed typo in
FrictionConstraintstructures to store friction information (i.e., tangent basis, normal force magnitude, closest points, and coefficient of friction)
Unit test that compares the original IPC code’s friction components with the toolkit’s
It now takes the coefficient of friction (
It now puts all information inside of the
construct_constraint_set()the constraints are added based on distance type
Duplicate vertex-vertex and edge-vertex constraints are handled by a multiplicity multiplier
Edge-edge constraints are always line-line distances
Point-triangle constraints are always point-plane distances
Fixed a bug in the point-triangle closest points and tangent basis computed in
Fixed a bug in
edge_edge_tangent_basis()used to compute the tangent basis for friction
spdlog for logging information
Headers are now include with the prefix
Collision constraint to store distance constraint pairs
EdgeEdgeConstraintstores the edge-edge mollifier threshold (
dhat(i.e., non-squared value)
epsv_times_h(i.e., non-squared value)
construct_constraint_set()now takes the rest vertex position (
compute_barrier_potential*()no longer take the rest vertex position