diff --git a/docs/source/tutorials/getting_started.rst b/docs/source/tutorials/getting_started.rst index 4133f5bcc..1b30d11c2 100644 --- a/docs/source/tutorials/getting_started.rst +++ b/docs/source/tutorials/getting_started.rst @@ -519,9 +519,9 @@ The ``Candidates`` class represents the culled set of candidate pairs and is bui #include ipc::Candidates candidates; + ipc::HashGrid broad_phase; candidates.build( - mesh, vertices_t0, vertices_t1, /*inflation_radius=*/0.0, - /*broad_phase=*/std::make_shared()); + mesh, vertices_t0, vertices_t1, /*inflation_radius=*/0.0, broad_phase); .. md-tab-item:: Python diff --git a/python/src/candidates/candidates.cpp b/python/src/candidates/candidates.cpp index 1ba7a87af..ccab20559 100644 --- a/python/src/candidates/candidates.cpp +++ b/python/src/candidates/candidates.cpp @@ -12,8 +12,7 @@ void define_candidates(py::module_& m) "build", py::overload_cast< const CollisionMesh&, Eigen::ConstRef, - const double, const std::shared_ptr&>( - &Candidates::build), + const double, BroadPhase*>(&Candidates::build), R"ipc_Qu8mg5v7( Initialize the set of discrete collision detection candidates. @@ -24,13 +23,13 @@ void define_candidates(py::module_& m) broad_phase: Broad phase to use. )ipc_Qu8mg5v7", "mesh"_a, "vertices"_a, "inflation_radius"_a = 0, - "broad_phase"_a = make_default_broad_phase()) + "broad_phase"_a = nullptr) .def( "build", py::overload_cast< const CollisionMesh&, Eigen::ConstRef, - Eigen::ConstRef, const double, - const std::shared_ptr&>(&Candidates::build), + Eigen::ConstRef, const double, BroadPhase*>( + &Candidates::build), R"ipc_Qu8mg5v7( Initialize the set of continuous collision detection candidates. @@ -45,8 +44,7 @@ void define_candidates(py::module_& m) broad_phase: Broad phase to use. )ipc_Qu8mg5v7", "mesh"_a, "vertices_t0"_a, "vertices_t1"_a, - "inflation_radius"_a = 0, - "broad_phase"_a = make_default_broad_phase()) + "inflation_radius"_a = 0, "broad_phase"_a = nullptr) .def("__len__", &Candidates::size) .def("empty", &Candidates::empty) .def("clear", &Candidates::clear) @@ -124,8 +122,7 @@ void define_candidates(py::module_& m) narrow_phase_ccd: Narrow phase CCD algorithm to use. )ipc_Qu8mg5v7", "mesh"_a, "vertices_t0"_a, "vertices_t1"_a, "dhat"_a, - "min_distance"_a = 0.0, - "broad_phase"_a = make_default_broad_phase(), + "min_distance"_a = 0.0, "broad_phase"_a = nullptr, "narrow_phase_ccd"_a = DEFAULT_NARROW_PHASE_CCD) .def( "save_obj", &Candidates::save_obj, "filename"_a, "vertices"_a, diff --git a/python/src/collisions/normal/normal_collisions.cpp b/python/src/collisions/normal/normal_collisions.cpp index 82019f660..d4a726704 100644 --- a/python/src/collisions/normal/normal_collisions.cpp +++ b/python/src/collisions/normal/normal_collisions.cpp @@ -23,8 +23,8 @@ void define_smooth_collisions(py::module_& m, std::string name) "build", py::overload_cast< const CollisionMesh&, Eigen::ConstRef, - const SmoothContactParameters, const bool, - const std::shared_ptr&>(&SmoothCollisions::build), + const SmoothContactParameters, const bool, BroadPhase*>( + &SmoothCollisions::build), R"ipc_Qu8mg5v7( Initialize the set of collisions used to compute the barrier potential. @@ -37,7 +37,7 @@ void define_smooth_collisions(py::module_& m, std::string name) )ipc_Qu8mg5v7", py::arg("mesh"), py::arg("vertices"), py::arg("param"), py::arg("use_adaptive_dhat") = false, - py::arg("broad_phase") = make_default_broad_phase()) + py::arg("broad_phase") = nullptr) .def( "compute_minimum_distance", &SmoothCollisions::compute_minimum_distance, @@ -89,7 +89,7 @@ void define_normal_collisions(py::module_& m) "build", py::overload_cast< const CollisionMesh&, Eigen::ConstRef, - const double, const double, const std::shared_ptr&>( + const double, const double, BroadPhase*>( &NormalCollisions::build), R"ipc_Qu8mg5v7( Initialize the set of collisions used to compute the barrier potential. @@ -102,7 +102,7 @@ void define_normal_collisions(py::module_& m) broad_phase: Broad-phase to use. )ipc_Qu8mg5v7", "mesh"_a, "vertices"_a, "dhat"_a, "dmin"_a = 0, - "broad_phase"_a = make_default_broad_phase()) + "broad_phase"_a = nullptr) .def( "build", py::overload_cast< diff --git a/python/src/ipc.cpp b/python/src/ipc.cpp index eb81bcb3f..f994b3ac3 100644 --- a/python/src/ipc.cpp +++ b/python/src/ipc.cpp @@ -31,7 +31,7 @@ void define_ipc(py::module_& m) True if any collisions occur. )ipc_Qu8mg5v7", "mesh"_a, "vertices_t0"_a, "vertices_t1"_a, "min_distance"_a = 0.0, - "broad_phase"_a = make_default_broad_phase(), + "broad_phase"_a = nullptr, "narrow_phase_ccd"_a = DEFAULT_NARROW_PHASE_CCD); m.def( @@ -54,7 +54,7 @@ void define_ipc(py::module_& m) A step-size :math:`\in [0, 1]` that is collision free. A value of 1.0 if a full step and 0.0 is no step. )ipc_Qu8mg5v7", "mesh"_a, "vertices_t0"_a, "vertices_t1"_a, "min_distance"_a = 0.0, - "broad_phase"_a = make_default_broad_phase(), + "broad_phase"_a = nullptr, "narrow_phase_ccd"_a = DEFAULT_NARROW_PHASE_CCD); m.def( @@ -70,7 +70,7 @@ void define_ipc(py::module_& m) Returns: A boolean for if the mesh has intersections. )ipc_Qu8mg5v7", - "mesh"_a, "vertices"_a, "broad_phase"_a = make_default_broad_phase()); + "mesh"_a, "vertices"_a, "broad_phase"_a = nullptr); m.def( "edges", diff --git a/src/ipc/broad_phase/default_broad_phase.hpp b/src/ipc/broad_phase/default_broad_phase.hpp index 460d0e0e2..723a84c1c 100644 --- a/src/ipc/broad_phase/default_broad_phase.hpp +++ b/src/ipc/broad_phase/default_broad_phase.hpp @@ -2,11 +2,13 @@ #include +#include + namespace ipc { -inline std::shared_ptr make_default_broad_phase() +inline std::unique_ptr make_default_broad_phase() { - return std::make_shared(); + return std::make_unique(); } } // namespace ipc \ No newline at end of file diff --git a/src/ipc/candidates/candidates.cpp b/src/ipc/candidates/candidates.cpp index 548542395..f090c1c4e 100644 --- a/src/ipc/candidates/candidates.cpp +++ b/src/ipc/candidates/candidates.cpp @@ -36,9 +36,13 @@ void Candidates::build( const CollisionMesh& mesh, Eigen::ConstRef vertices, const double inflation_radius, - const std::shared_ptr& broad_phase) + BroadPhase* broad_phase) { - assert(broad_phase != nullptr); + std::unique_ptr default_broad_phase; + if (broad_phase == nullptr) { + default_broad_phase = make_default_broad_phase(); + broad_phase = default_broad_phase.get(); + } const int dim = vertices.cols(); @@ -108,9 +112,13 @@ void Candidates::build( Eigen::ConstRef vertices_t0, Eigen::ConstRef vertices_t1, const double inflation_radius, - const std::shared_ptr& broad_phase) + BroadPhase* broad_phase) { - assert(broad_phase != nullptr); + std::unique_ptr default_broad_phase; + if (broad_phase == nullptr) { + default_broad_phase = make_default_broad_phase(); + broad_phase = default_broad_phase.get(); + } const int dim = vertices_t0.cols(); @@ -301,7 +309,7 @@ double Candidates::compute_cfl_stepsize( Eigen::ConstRef vertices_t1, const double dhat, const double min_distance, - const std::shared_ptr& broad_phase, + BroadPhase* broad_phase, const NarrowPhaseCCD& narrow_phase_ccd) const { assert(vertices_t0.rows() == mesh.num_vertices()); diff --git a/src/ipc/candidates/candidates.hpp b/src/ipc/candidates/candidates.hpp index a0539e3a9..5a50abc91 100644 --- a/src/ipc/candidates/candidates.hpp +++ b/src/ipc/candidates/candidates.hpp @@ -26,8 +26,7 @@ class Candidates { const CollisionMesh& mesh, Eigen::ConstRef vertices, const double inflation_radius = 0, - const std::shared_ptr& broad_phase = - make_default_broad_phase()); + BroadPhase* broad_phase = nullptr); /// @brief Initialize the set of continuous collision detection candidates. /// @note Assumes the trajectory is linear. @@ -41,8 +40,7 @@ class Candidates { Eigen::ConstRef vertices_t0, Eigen::ConstRef vertices_t1, const double inflation_radius = 0, - const std::shared_ptr& broad_phase = - make_default_broad_phase()); + BroadPhase* broad_phase = nullptr); /// @brief Get the number of collision candidates. /// @return The number of collision candidates. @@ -120,8 +118,7 @@ class Candidates { Eigen::ConstRef vertices_t1, const double dhat, const double min_distance = 0.0, - const std::shared_ptr& broad_phase = - make_default_broad_phase(), + BroadPhase* broad_phase = nullptr, const NarrowPhaseCCD& narrow_phase_ccd = DEFAULT_NARROW_PHASE_CCD) const; diff --git a/src/ipc/collisions/normal/normal_collisions.cpp b/src/ipc/collisions/normal/normal_collisions.cpp index ae83b2752..ad28a466b 100644 --- a/src/ipc/collisions/normal/normal_collisions.cpp +++ b/src/ipc/collisions/normal/normal_collisions.cpp @@ -145,7 +145,7 @@ void NormalCollisions::build( Eigen::ConstRef vertices, const double dhat, const double dmin, - const std::shared_ptr& broad_phase) + BroadPhase* broad_phase) { assert(vertices.rows() == mesh.num_vertices()); diff --git a/src/ipc/collisions/normal/normal_collisions.hpp b/src/ipc/collisions/normal/normal_collisions.hpp index 0acb14dc5..1fbf965e7 100644 --- a/src/ipc/collisions/normal/normal_collisions.hpp +++ b/src/ipc/collisions/normal/normal_collisions.hpp @@ -34,8 +34,7 @@ class NormalCollisions { Eigen::ConstRef vertices, const double dhat, const double dmin = 0, - const std::shared_ptr& broad_phase = - make_default_broad_phase()); + BroadPhase* broad_phase = nullptr); /// @brief Initialize the set of collisions used to compute the barrier potential. /// @param candidates Distance candidates from which the collision set is built. diff --git a/src/ipc/config.hpp.in b/src/ipc/config.hpp.in index 80c9626e3..ad70e1dd3 100644 --- a/src/ipc/config.hpp.in +++ b/src/ipc/config.hpp.in @@ -22,7 +22,18 @@ namespace ipc { // Type definitions +#cmakedefine IPC_TOOLKIT_USE_64BIT_INDICES +#ifdef IPC_TOOLKIT_USE_64BIT_INDICES +using index_t = int64_t; +#else using index_t = int32_t; +#endif + +// #cmakedefine IPC_TOOLKIT_USE_DOUBLE_PRECISION +// #ifdef IPC_TOOLKIT_USE_DOUBLE_PRECISION // using scalar_t = double; +// #else +// using scalar_t = float; +// #endif } // namespace ipc \ No newline at end of file diff --git a/src/ipc/ipc.cpp b/src/ipc/ipc.cpp index 6431690ed..5b9d10e49 100644 --- a/src/ipc/ipc.cpp +++ b/src/ipc/ipc.cpp @@ -19,7 +19,7 @@ bool is_step_collision_free( Eigen::ConstRef vertices_t0, Eigen::ConstRef vertices_t1, const double min_distance, - const std::shared_ptr& broad_phase, + BroadPhase* broad_phase, const NarrowPhaseCCD& narrow_phase_ccd) { assert(vertices_t0.rows() == mesh.num_vertices()); @@ -43,13 +43,18 @@ double compute_collision_free_stepsize( Eigen::ConstRef vertices_t0, Eigen::ConstRef vertices_t1, const double min_distance, - const std::shared_ptr& broad_phase, + BroadPhase* broad_phase, const NarrowPhaseCCD& narrow_phase_ccd) { - assert(broad_phase != nullptr); assert(vertices_t0.rows() == mesh.num_vertices()); assert(vertices_t1.rows() == mesh.num_vertices()); + std::unique_ptr default_broad_phase; + if (broad_phase == nullptr) { + default_broad_phase = make_default_broad_phase(); + broad_phase = default_broad_phase.get(); + } + #ifdef IPC_TOOLKIT_WITH_CUDA if (broad_phase->name() == "SweepAndTiniestQueue") { if (vertices_t0.cols() != 3) { @@ -91,11 +96,16 @@ double compute_collision_free_stepsize( bool has_intersections( const CollisionMesh& mesh, Eigen::ConstRef vertices, - const std::shared_ptr& broad_phase) + BroadPhase* broad_phase) { - assert(broad_phase != nullptr); assert(vertices.rows() == mesh.num_vertices()); + std::unique_ptr default_broad_phase; + if (broad_phase == nullptr) { + default_broad_phase = make_default_broad_phase(); + broad_phase = default_broad_phase.get(); + } + const double conservative_inflation_radius = 1e-6 * world_bbox_diagonal_length(vertices); diff --git a/src/ipc/ipc.hpp b/src/ipc/ipc.hpp index 9bab832de..6a40fa835 100644 --- a/src/ipc/ipc.hpp +++ b/src/ipc/ipc.hpp @@ -27,7 +27,7 @@ bool is_step_collision_free( Eigen::ConstRef vertices_t0, Eigen::ConstRef vertices_t1, const double min_distance = 0.0, - const std::shared_ptr& broad_phase = make_default_broad_phase(), + BroadPhase* broad_phase = nullptr, const NarrowPhaseCCD& narrow_phase_ccd = DEFAULT_NARROW_PHASE_CCD); /// @brief Computes a maximal step size that is collision free. @@ -44,7 +44,7 @@ double compute_collision_free_stepsize( Eigen::ConstRef vertices_t0, Eigen::ConstRef vertices_t1, const double min_distance = 0.0, - const std::shared_ptr& broad_phase = make_default_broad_phase(), + BroadPhase* broad_phase = nullptr, const NarrowPhaseCCD& narrow_phase_ccd = DEFAULT_NARROW_PHASE_CCD); // ============================================================================ @@ -58,7 +58,6 @@ double compute_collision_free_stepsize( bool has_intersections( const CollisionMesh& mesh, Eigen::ConstRef vertices, - const std::shared_ptr& broad_phase = - make_default_broad_phase()); + BroadPhase* broad_phase = nullptr); } // namespace ipc diff --git a/src/ipc/potentials/barrier_potential.cpp b/src/ipc/potentials/barrier_potential.cpp index 9b52336e5..a9aeb1ddf 100644 --- a/src/ipc/potentials/barrier_potential.cpp +++ b/src/ipc/potentials/barrier_potential.cpp @@ -13,15 +13,15 @@ BarrierPotential::BarrierPotential( } BarrierPotential::BarrierPotential( - const std::shared_ptr& barrier, + std::shared_ptr barrier, const double dhat, const bool use_physical_barrier) - : m_barrier(barrier) + : m_barrier(std::move(barrier)) , m_dhat(dhat) , m_use_physical_barrier(use_physical_barrier) { assert(dhat > 0); - assert(barrier != nullptr); + assert(m_barrier != nullptr); } double BarrierPotential::force_magnitude( diff --git a/src/ipc/potentials/barrier_potential.hpp b/src/ipc/potentials/barrier_potential.hpp index 1f7d0b606..325708d46 100644 --- a/src/ipc/potentials/barrier_potential.hpp +++ b/src/ipc/potentials/barrier_potential.hpp @@ -23,7 +23,7 @@ class BarrierPotential : public NormalPotential { /// @param dhat The activation distance of the barrier. /// @param use_physical_barrier Whether to use the physical barrier. BarrierPotential( - const std::shared_ptr& barrier, + std::shared_ptr barrier, const double dhat, const bool use_physical_barrier = false); diff --git a/src/ipc/smooth_contact/smooth_collisions.cpp b/src/ipc/smooth_contact/smooth_collisions.cpp index 3042138de..3f1c349b5 100644 --- a/src/ipc/smooth_contact/smooth_collisions.cpp +++ b/src/ipc/smooth_contact/smooth_collisions.cpp @@ -22,7 +22,7 @@ void SmoothCollisions::compute_adaptive_dhat( const CollisionMesh& mesh, Eigen::ConstRef vertices, // set to zero for rest pose const SmoothContactParameters params, - const std::shared_ptr& broad_phase) + BroadPhase* broad_phase) { assert(vertices.rows() == mesh.num_vertices()); @@ -118,7 +118,7 @@ void SmoothCollisions::build( Eigen::ConstRef vertices, const SmoothContactParameters params, const bool use_adaptive_dhat, - const std::shared_ptr& broad_phase) + BroadPhase* broad_phase) { assert(vertices.rows() == mesh.num_vertices()); diff --git a/src/ipc/smooth_contact/smooth_collisions.hpp b/src/ipc/smooth_contact/smooth_collisions.hpp index 6ae16e0ac..a863ce445 100644 --- a/src/ipc/smooth_contact/smooth_collisions.hpp +++ b/src/ipc/smooth_contact/smooth_collisions.hpp @@ -28,8 +28,7 @@ class SmoothCollisions { const CollisionMesh& mesh, Eigen::ConstRef vertices, const SmoothContactParameters params, - const std::shared_ptr& broad_phase = - make_default_broad_phase()); + BroadPhase* broad_phase = nullptr); /// @brief Initialize the set of collisions used to compute the barrier potential. /// @param mesh The collision mesh. @@ -40,8 +39,7 @@ class SmoothCollisions { Eigen::ConstRef vertices, const SmoothContactParameters params, const bool use_adaptive_dhat = false, - const std::shared_ptr& broad_phase = - make_default_broad_phase()); + BroadPhase* broad_phase = nullptr); /// @brief Initialize the set of collisions used to compute the barrier potential. /// @param candidates Distance candidates from which the collision set is built. diff --git a/src/ipc/smooth_contact/smooth_collisions_builder.cpp b/src/ipc/smooth_contact/smooth_collisions_builder.cpp index 40701c969..7dcddde2e 100644 --- a/src/ipc/smooth_contact/smooth_collisions_builder.cpp +++ b/src/ipc/smooth_contact/smooth_collisions_builder.cpp @@ -12,11 +12,12 @@ namespace ipc { namespace { template void add_collision( - const std::shared_ptr& pair, + const std::shared_ptr pair, unordered_map, std::shared_ptr>& cc_to_id, std::vector>& collisions) { + assert(pair != nullptr); if (pair->is_active() && cc_to_id.find(pair->get_hash()) == cc_to_id.end()) { // New collision, so add it to the end of collisions @@ -27,9 +28,10 @@ namespace { template void add_collision( - const std::shared_ptr& pair, + const std::shared_ptr pair, std::vector>& collisions) { + assert(pair != nullptr); if (pair->is_active()) { collisions.push_back(pair); } diff --git a/tests/src/tests/broad_phase/benchmark_broad_phase.cpp b/tests/src/tests/broad_phase/benchmark_broad_phase.cpp index 58266f7df..1bbbdf61b 100644 --- a/tests/src/tests/broad_phase/benchmark_broad_phase.cpp +++ b/tests/src/tests/broad_phase/benchmark_broad_phase.cpp @@ -86,7 +86,7 @@ TEST_CASE("Benchmark broad phase", "[!benchmark][broad_phase]") BENCHMARK(fmt::format("BP {} ({})", testcase_name, broad_phase->name())) { Candidates candidates; - candidates.build(mesh, V0, V1, inflation_radius, broad_phase); + candidates.build(mesh, V0, V1, inflation_radius, broad_phase.get()); }; } } @@ -142,7 +142,7 @@ TEST_CASE( BENCHMARK(fmt::format("BP Real Data ({})", broad_phase->name())) { Candidates candidates; - candidates.build(mesh, V0, V1, inflation_radius, broad_phase); + candidates.build(mesh, V0, V1, inflation_radius, broad_phase.get()); }; } } diff --git a/tests/src/tests/broad_phase/brute_force_comparison.cpp b/tests/src/tests/broad_phase/brute_force_comparison.cpp index afaee3ec0..b71fb281a 100644 --- a/tests/src/tests/broad_phase/brute_force_comparison.cpp +++ b/tests/src/tests/broad_phase/brute_force_comparison.cpp @@ -25,8 +25,8 @@ void brute_force_comparison( Candidates bf_candidates; if (cached_bf_candidates.empty() || !load_candidates(cached_bf_candidates, bf_candidates)) { - bf_candidates.build( - mesh, V0, V1, inflation_radius, std::make_shared()); + BruteForce bf; + bf_candidates.build(mesh, V0, V1, inflation_radius, &bf); if (!cached_bf_candidates.empty()) { save_candidates(cached_bf_candidates, bf_candidates); } diff --git a/tests/src/tests/broad_phase/test_broad_phase.cpp b/tests/src/tests/broad_phase/test_broad_phase.cpp index cea066e05..b83a97d55 100644 --- a/tests/src/tests/broad_phase/test_broad_phase.cpp +++ b/tests/src/tests/broad_phase/test_broad_phase.cpp @@ -69,7 +69,7 @@ void test_broad_phase( double inflation_radius = 0; Candidates candidates; - candidates.build(mesh, V0, V1, inflation_radius, broad_phase); + candidates.build(mesh, V0, V1, inflation_radius, broad_phase.get()); if (expect_collision) { CHECK(!candidates.is_step_collision_free(mesh, V0, V1)); @@ -97,7 +97,7 @@ std::shared_ptr test_broad_phase( REQUIRE(V.rows() == mesh.num_vertices()); auto candidates = std::make_shared(); - candidates->build(mesh, V, inflation_radius, broad_phase); + candidates->build(mesh, V, inflation_radius, broad_phase.get()); if (broad_phase->name() != "BruteForce") { brute_force_comparison( diff --git a/tests/src/tests/broad_phase/test_stq.cpp b/tests/src/tests/broad_phase/test_stq.cpp index c3d326786..5fa85f03c 100644 --- a/tests/src/tests/broad_phase/test_stq.cpp +++ b/tests/src/tests/broad_phase/test_stq.cpp @@ -76,10 +76,10 @@ TEST_CASE("Puffer-Ball", "[ccd][broad_phase][stq][cuda]") CollisionMesh mesh(V0, E, F); - const auto stq = std::make_shared(); + SweepAndTiniestQueue stq; Candidates candidates; - candidates.build(mesh, V0, V1, /*inflation_radius=*/0, stq); + candidates.build(mesh, V0, V1, /*inflation_radius=*/0, &stq); CHECK(candidates.size() == 249'805'425); CHECK(candidates.vv_candidates.size() == 0); diff --git a/tests/src/tests/ccd/test_ccd.cpp b/tests/src/tests/ccd/test_ccd.cpp index 7a415f88c..dcc1aaf12 100644 --- a/tests/src/tests/ccd/test_ccd.cpp +++ b/tests/src/tests/ccd/test_ccd.cpp @@ -82,7 +82,7 @@ TEST_CASE("Repeated CCD", "[ccd][repeat]") V1 = mesh.vertices(V1); Candidates candidates; - candidates.build(mesh, V0, V1, inflation_radius, broad_phase); + candidates.build(mesh, V0, V1, inflation_radius, broad_phase.get()); bool has_collisions = !candidates.is_step_collision_free( mesh, V0, V1, MIN_DISTANCE, @@ -105,7 +105,7 @@ TEST_CASE("Repeated CCD", "[ccd][repeat]") // CHECK(!has_intersections(Vt, E, F)); if (recompute_candidates) { - candidates.build(mesh, V0, Vt, inflation_radius, broad_phase); + candidates.build(mesh, V0, Vt, inflation_radius, broad_phase.get()); } has_collisions_repeated = !candidates.is_step_collision_free( @@ -223,7 +223,7 @@ TEST_CASE("Thick Cloth CCD", "[CCD][!benchmark]") // Broad phase Candidates candidates; - candidates.build(mesh, V0, V1, min_distance / 2, broad_phase); + candidates.build(mesh, V0, V1, min_distance / 2, broad_phase.get()); const TightInclusionCCD tight_inclusion( /*tolerance=*/100 * TightInclusionCCD::DEFAULT_TOLERANCE); diff --git a/tests/src/tests/ccd/test_gpu_ccd.cpp b/tests/src/tests/ccd/test_gpu_ccd.cpp index 4f6e66746..bd06d03b3 100644 --- a/tests/src/tests/ccd/test_gpu_ccd.cpp +++ b/tests/src/tests/ccd/test_gpu_ccd.cpp @@ -44,15 +44,17 @@ TEST_CASE("GPU CCD", "[ccd][gpu]") const int max_iterations = 1e7; const double min_distance = 0; + SweepAndPrune sap; const double toi_cpu = compute_collision_free_stepsize( - mesh, V0, V1, min_distance, std::make_shared(), + mesh, V0, V1, min_distance, &sap, TightInclusionCCD(tolerance, max_iterations)); // Got this value from running the code CHECK(toi_cpu == Catch::Approx(4.76837158203125000e-06)); + SweepAndTiniestQueue stq; const double toi_gpu = compute_collision_free_stepsize( - mesh, V0, V1, min_distance, std::make_shared(), + mesh, V0, V1, min_distance, &stq, TightInclusionCCD(tolerance, max_iterations)); // Got this value from running the code diff --git a/tests/src/tests/collisions/test_normal_collisions.cpp b/tests/src/tests/collisions/test_normal_collisions.cpp index f1e02c262..d2ed1bf20 100644 --- a/tests/src/tests/collisions/test_normal_collisions.cpp +++ b/tests/src/tests/collisions/test_normal_collisions.cpp @@ -43,7 +43,7 @@ TEST_CASE("Codim. vertex-vertex collisions", "[collisions][codim]") V1.col(1) *= 0.5; Candidates candidates; - candidates.build(mesh, vertices, V1, thickness, broad_phase); + candidates.build(mesh, vertices, V1, thickness, broad_phase.get()); CHECK(!candidates.empty()); CHECK(candidates.vv_candidates.size() == candidates.size()); @@ -79,7 +79,7 @@ TEST_CASE("Codim. vertex-vertex collisions", "[collisions][codim]") use_improved_max_approximator); collisions.set_enable_shape_derivatives(enable_shape_derivatives); - collisions.build(mesh, vertices, dhat, min_distance, broad_phase); + collisions.build(mesh, vertices, dhat, min_distance, broad_phase.get()); CHECK(collisions.size() == 12); CHECK(collisions.vv_collisions.size() == 12); @@ -135,7 +135,7 @@ TEST_CASE("Codim. edge-vertex collisions", "[collisions][codim]") V1.bottomRows(3).col(1).array() -= 4; // Translate the codim vertices Candidates candidates; - candidates.build(mesh, vertices, V1, thickness, broad_phase); + candidates.build(mesh, vertices, V1, thickness, broad_phase.get()); CHECK(candidates.size() == 15); CHECK(candidates.vv_candidates.size() == 3); @@ -175,7 +175,7 @@ TEST_CASE("Codim. edge-vertex collisions", "[collisions][codim]") const double dhat = 0.25; collisions.build( - mesh, vertices, dhat, /*min_distance=*/0.8, broad_phase); + mesh, vertices, dhat, /*min_distance=*/0.8, broad_phase.get()); const int expected_num_collisions = 6 + int(use_improved_max_approximator); diff --git a/tests/src/tests/potential/test_barrier_potential.cpp b/tests/src/tests/potential/test_barrier_potential.cpp index 9ccd8131f..521b9bdcd 100644 --- a/tests/src/tests/potential/test_barrier_potential.cpp +++ b/tests/src/tests/potential/test_barrier_potential.cpp @@ -77,7 +77,7 @@ TEST_CASE( mesh = CollisionMesh::build_from_full_mesh(vertices, edges, faces); vertices = mesh.vertices(vertices); } - collisions.build(mesh, vertices, dhat, /*dmin=*/0, broad_phase); + collisions.build(mesh, vertices, dhat, /*dmin=*/0, broad_phase.get()); CAPTURE( dhat, broad_phase->name(), all_vertices_on_surface, use_area_weighting, use_improved_max_approximator); diff --git a/tests/src/tests/potential/test_smooth_potential.cpp b/tests/src/tests/potential/test_smooth_potential.cpp index 29890fa98..ca073a2c7 100644 --- a/tests/src/tests/potential/test_smooth_potential.cpp +++ b/tests/src/tests/potential/test_smooth_potential.cpp @@ -36,7 +36,7 @@ TEST_CASE("Smooth barrier potential codim", "[smooth_potential]") std::vector(vertices.rows(), false), vertices, edges, faces); SmoothContactParameters params(dhat, 0.85, 0.5, 0.95, 0.6, 2); - collisions.build(mesh, vertices, params, false, method); + collisions.build(mesh, vertices, params, false, method.get()); CAPTURE(dhat, method); CHECK(!collisions.empty()); CHECK(!has_intersections(mesh, vertices)); @@ -157,8 +157,8 @@ TEST_CASE("Smooth barrier potential full gradient and hessian 3D", tagsopt) SmoothContactParameters params(dhat, 0.85, 0.5, 0.95, 0.6, 2); params.set_adaptive_dhat_ratio(min_dist_ratio); - collisions.compute_adaptive_dhat(mesh, vertices, params, method); - collisions.build(mesh, vertices, params, adaptive_dhat, method); + collisions.compute_adaptive_dhat(mesh, vertices, params, method.get()); + collisions.build(mesh, vertices, params, adaptive_dhat, method.get()); CAPTURE(dhat, method, adaptive_dhat, all_vertices_on_surface); CHECK(!collisions.empty()); CHECK(!has_intersections(mesh, vertices)); @@ -255,8 +255,8 @@ TEST_CASE("Smooth barrier potential real sim 2D C^2", "[smooth_potential]") mesh = CollisionMesh( std::vector(vertices.rows(), true), std::vector(vertices.rows(), orientable), vertices, edges, faces); - collisions.compute_adaptive_dhat(mesh, vertices, params, method); - collisions.build(mesh, vertices, params, adaptive_dhat, method); + collisions.compute_adaptive_dhat(mesh, vertices, params, method.get()); + collisions.build(mesh, vertices, params, adaptive_dhat, method.get()); CAPTURE(dhat, method, adaptive_dhat); CHECK(!collisions.empty()); std::cout << "smooth collision candidate size " << collisions.size() @@ -343,8 +343,8 @@ TEST_CASE("Smooth barrier potential real sim 2D C^1", "[smooth_potential]") params.set_adaptive_dhat_ratio(min_dist_ratio); SmoothCollisions collisions; mesh = CollisionMesh(vertices, edges, faces); - collisions.compute_adaptive_dhat(mesh, vertices, params, method); - collisions.build(mesh, vertices, params, adaptive_dhat, method); + collisions.compute_adaptive_dhat(mesh, vertices, params, method.get()); + collisions.build(mesh, vertices, params, adaptive_dhat, method.get()); CAPTURE(dhat, method, adaptive_dhat); CHECK(!collisions.empty()); std::cout << "smooth collision candidate size " << collisions.size() diff --git a/tests/src/tests/test_has_intersections.cpp b/tests/src/tests/test_has_intersections.cpp index a1a31f298..9f611b7e8 100644 --- a/tests/src/tests/test_has_intersections.cpp +++ b/tests/src/tests/test_has_intersections.cpp @@ -95,5 +95,5 @@ TEST_CASE("Has intersections", "[intersection]") REQUIRE(success); CAPTURE(broad_phase->name()); - CHECK(has_intersections(CollisionMesh(V, E, F), V, broad_phase)); + CHECK(has_intersections(CollisionMesh(V, E, F), V, broad_phase.get())); }