MaxContacts -> CollisionPairMaxTotalContacts

Signed-off-by: Ian Chen <[email protected]>

dartsim/src/GzOdeCollisionDetector.cc

@@ -52,7 +52,7 @@ bool GzOdeCollisionDetector::collide(
     CollisionResult *_result)
 {
   bool ret = OdeCollisionDetector::collide(_group, _option, _result);
-  this->LimitMaxContacts(_result);
+  this->LimitCollisionPairMaxTotalContacts(_result);
   return ret;
 }
 
@@ -64,24 +64,24 @@ bool GzOdeCollisionDetector::collide(
     CollisionResult *_result)
 {
   bool ret = OdeCollisionDetector::collide(_group1, _group2, _option, _result);
-  this->LimitMaxContacts(_result);
+  this->LimitCollisionPairMaxTotalContacts(_result);
   return ret;
 }
 
 /////////////////////////////////////////////////
-void GzOdeCollisionDetector::SetMaxContacts(std::size_t _maxContacts)
+void GzOdeCollisionDetector::SetCollisionPairMaxTotalContacts(std::size_t _maxContacts)
 {
   this->maxCollisionPairContacts = _maxContacts;
 }
 
 /////////////////////////////////////////////////
-std::size_t GzOdeCollisionDetector::GetMaxContacts() const
+std::size_t GzOdeCollisionDetector::GetCollisionPairMaxTotalContacts() const
 {
   return this->maxCollisionPairContacts;
 }
 
 /////////////////////////////////////////////////
-void GzOdeCollisionDetector::LimitMaxContacts(
+void GzOdeCollisionDetector::LimitCollisionPairMaxTotalContacts(
     CollisionResult *_result)
 {
   if (this->maxCollisionPairContacts ==

dartsim/src/GzOdeCollisionDetector.hh

@@ -42,12 +42,12 @@ class GzOdeCollisionDetector : public dart::collision::OdeCollisionDetector
   /// objects
   /// \param[in] _maxContacts Maximum number of contacts between a pair of
   /// collision objects.
-  public: void SetMaxContacts(std::size_t _maxContacts);
+  public: void SetCollisionPairMaxTotalContacts(std::size_t _maxContacts);
 
   /// \brief Get the maximum number of contacts between a pair of collision
   /// objects
   /// \return Maximum number of contacts between a pair of collision objects.
-  public: std::size_t GetMaxContacts() const;
+  public: std::size_t GetCollisionPairMaxTotalContacts() const;
 
 
   /// \brief Create the GzOdeCollisionDetector
@@ -60,7 +60,7 @@ class GzOdeCollisionDetector : public dart::collision::OdeCollisionDetector
   /// The function modifies the contacts vector inside the CollisionResult
   /// object to cap the number of contacts for each collision pair based on the
   /// maxCollisionPairContacts value
-  private: void LimitMaxContacts(CollisionResult *_result);
+  private: void LimitCollisionPairMaxTotalContacts(CollisionResult *_result);
 
   /// \brief Maximum number of contacts between a pair of collision objects.
   private: std::size_t maxCollisionPairContacts =

dartsim/src/WorldFeatures.cc

@@ -98,7 +98,7 @@ WorldFeatures::LinearVectorType WorldFeatures::GetWorldGravity(
 }
 
 /////////////////////////////////////////////////
-void WorldFeatures::SetWorldMaxContacts(
+void WorldFeatures::SetWorldCollisionPairMaxTotalContacts(
     const Identity &_id, std::size_t _maxContacts)
 {
   auto world = this->ReferenceInterface<dart::simulation::World>(_id);
@@ -110,7 +110,7 @@ void WorldFeatures::SetWorldMaxContacts(
     collisionDetector);
   if (odeCollisionDetector)
   {
-    odeCollisionDetector->SetMaxContacts(_maxContacts);
+    odeCollisionDetector->SetCollisionPairMaxTotalContacts(_maxContacts);
   }
   else
   {
@@ -120,7 +120,7 @@ void WorldFeatures::SetWorldMaxContacts(
 }
 
 /////////////////////////////////////////////////
-std::size_t WorldFeatures::GetWorldMaxContacts(const Identity &_id)
+std::size_t WorldFeatures::GetWorldCollisionPairMaxTotalContacts(const Identity &_id)
     const
 {
   auto world = this->ReferenceInterface<dart::simulation::World>(_id);
@@ -131,7 +131,7 @@ std::size_t WorldFeatures::GetWorldMaxContacts(const Identity &_id)
     collisionDetector);
   if (odeCollisionDetector)
   {
-    return odeCollisionDetector->GetMaxContacts();
+    return odeCollisionDetector->GetCollisionPairMaxTotalContacts();
   }
 
   return 0u;

dartsim/src/WorldFeatures.hh

@@ -30,8 +30,8 @@ namespace dartsim {
 
 struct WorldFeatureList : FeatureList<
   CollisionDetector,
+  CollisionPairMaxTotalContacts,
   Gravity,
-  MaxContacts,
   Solver
 > { };
 
@@ -55,11 +55,11 @@ class WorldFeatures :
   public: LinearVectorType GetWorldGravity(const Identity &_id) const override;
 
   // Documentation inherited
-  public: void SetWorldMaxContacts(
+  public: void SetWorldCollisionPairMaxTotalContacts(
       const Identity &_id, std::size_t _maxContacts) override;
 
   // Documentation inherited
-  public: std::size_t GetWorldMaxContacts(const Identity &_id)
+  public: std::size_t GetWorldCollisionPairMaxTotalContacts(const Identity &_id)
       const override;
 
   // Documentation inherited

include/gz/physics/World.hh

@@ -131,7 +131,8 @@ namespace gz
     };
 
     /////////////////////////////////////////////////
-    class GZ_PHYSICS_VISIBLE MaxContacts: public virtual Feature
+    class GZ_PHYSICS_VISIBLE CollisionPairMaxTotalContacts:
+        public virtual Feature
     {
       /// \brief The World API for getting and setting max contacts.
       public: template <typename PolicyT, typename FeaturesT>
@@ -140,12 +141,12 @@ namespace gz
         /// \brief Set the maximum number of contacts allowed between two
         /// entities.
         /// \param[in] _maxContacts Maximum number of contacts.
-        public: void SetMaxContacts(std::size_t _maxContacts);
+        public: void SetCollisionPairMaxTotalContacts(std::size_t _maxContacts);
 
         /// \brief Set the maximum number of contacts allowed between two
         /// entities.
         /// \return Maximum number of contacts.
-        public: std::size_t GetMaxContacts() const;
+        public: std::size_t GetCollisionPairMaxTotalContacts() const;
       };
 
       /// \private The implementation API for getting and setting max contacts.
@@ -156,14 +157,14 @@ namespace gz
         /// contacts between two entities.
         /// \param[in] _id Identity of the world.
         /// \param[in] _maxContacts Maximum number of contacts.
-        public: virtual void SetWorldMaxContacts(
+        public: virtual void SetWorldCollisionPairMaxTotalContacts(
             const Identity &_id, std::size_t _maxContacts) = 0;
 
         /// \brief Implementation API for getting the maximum number of
         /// contacts between two entities.
         /// \param[in] _id Identity of the world.
         /// \param[in] _maxContacts Maximum number of contacts.
-        public: virtual std::size_t GetWorldMaxContacts(
+        public: virtual std::size_t GetWorldCollisionPairMaxTotalContacts(
             const Identity &_id) const = 0;
       };
     };

include/gz/physics/detail/World.hh

@@ -101,20 +101,20 @@ auto Gravity::World<PolicyT, FeaturesT>::GetGravity(
 
 /////////////////////////////////////////////////
 template <typename PolicyT, typename FeaturesT>
-void MaxContacts::World<PolicyT, FeaturesT>::SetMaxContacts(
-    std::size_t _maxContacts)
+void CollisionPairMaxTotalContacts::World<PolicyT, FeaturesT
+    >::SetCollisionPairMaxTotalContacts(std::size_t _maxContacts)
 {
-  this->template Interface<MaxContacts>()
-      ->SetWorldMaxContacts(this->identity, _maxContacts);
+  this->template Interface<CollisionPairMaxTotalContacts>()
+      ->SetWorldCollisionPairMaxTotalContacts(this->identity, _maxContacts);
 }
 
 /////////////////////////////////////////////////
 template <typename PolicyT, typename FeaturesT>
-std::size_t MaxContacts::World<PolicyT, FeaturesT>::
-    GetMaxContacts() const
+std::size_t CollisionPairMaxTotalContacts::World<PolicyT, FeaturesT>::
+    GetCollisionPairMaxTotalContacts() const
 {
-  return this->template Interface<MaxContacts>()
-      ->GetWorldMaxContacts(this->identity);
+  return this->template Interface<CollisionPairMaxTotalContacts>()
+      ->GetWorldCollisionPairMaxTotalContacts(this->identity);
 }
 
 /////////////////////////////////////////////////

test/common_test/simulation_features.cc

@@ -220,49 +220,54 @@ TYPED_TEST(SimulationFeaturesContactsTest, Contacts)
 }
 
 // The features that an engine must have to be loaded by this loader.
-struct FeaturesMaxContacts : gz::physics::FeatureList<
+struct FeaturesCollisionPairMaxTotalContacts : gz::physics::FeatureList<
   gz::physics::sdf::ConstructSdfWorld,
   gz::physics::GetContactsFromLastStepFeature,
   gz::physics::ForwardStep,
-  gz::physics::MaxContacts
+  gz::physics::CollisionPairMaxTotalContacts
 > {};
 
 template <class T>
-class SimulationFeaturesMaxContactsTest :
+class SimulationFeaturesCollisionPairMaxTotalContactsTest :
   public SimulationFeaturesTest<T>{};
-using SimulationFeaturesMaxContactsTestTypes =
-  ::testing::Types<FeaturesMaxContacts>;
-TYPED_TEST_SUITE(SimulationFeaturesMaxContactsTest,
-                 SimulationFeaturesMaxContactsTestTypes);
+using SimulationFeaturesCollisionPairMaxTotalContactsTestTypes =
+  ::testing::Types<FeaturesCollisionPairMaxTotalContacts>;
+TYPED_TEST_SUITE(SimulationFeaturesCollisionPairMaxTotalContactsTest,
+                 SimulationFeaturesCollisionPairMaxTotalContactsTestTypes);
 
 /////////////////////////////////////////////////
-TYPED_TEST(SimulationFeaturesMaxContactsTest, MaxContacts)
+TYPED_TEST(SimulationFeaturesCollisionPairMaxTotalContactsTest,
+    CollisionPairMaxTotalContacts)
 {
   for (const std::string &name : this->pluginNames)
   {
-    auto world = LoadPluginAndWorld<FeaturesMaxContacts>(
+    auto world = LoadPluginAndWorld<FeaturesCollisionPairMaxTotalContacts>(
       this->loader,
       name,
       gz::common::joinPaths(TEST_WORLD_DIR, "shapes.world"));
-    auto checkedOutput = StepWorld<FeaturesMaxContacts>(world, true, 1).first;
+    auto checkedOutput = StepWorld<FeaturesCollisionPairMaxTotalContacts>(
+        world, true, 1).first;
     EXPECT_TRUE(checkedOutput);
 
     auto contacts = world->GetContactsFromLastStep();
-    EXPECT_EQ(std::numeric_limits<std::size_t>::max(), world->GetMaxContacts());
+    EXPECT_EQ(std::numeric_limits<std::size_t>::max(),
+              world->GetCollisionPairMaxTotalContacts());
     // Large box collides with other shapes
     EXPECT_GT(contacts.size(), 30u);
 
-    world->SetMaxContacts(1u);
-    EXPECT_EQ(1u, world->GetMaxContacts());
-    checkedOutput = StepWorld<FeaturesMaxContacts>(world, true, 1).first;
+    world->SetCollisionPairMaxTotalContacts(1u);
+    EXPECT_EQ(1u, world->GetCollisionPairMaxTotalContacts());
+    checkedOutput = StepWorld<FeaturesCollisionPairMaxTotalContacts>(
+        world, true, 1).first;
     EXPECT_TRUE(checkedOutput);
 
     contacts = world->GetContactsFromLastStep();
     EXPECT_EQ(4u, contacts.size());
 
-    world->SetMaxContacts(0u);
-    EXPECT_EQ(0u, world->GetMaxContacts());
-    checkedOutput = StepWorld<FeaturesMaxContacts>(world, true, 1).first;
+    world->SetCollisionPairMaxTotalContacts(0u);
+    EXPECT_EQ(0u, world->GetCollisionPairMaxTotalContacts());
+    checkedOutput = StepWorld<FeaturesCollisionPairMaxTotalContacts>(
+        world, true, 1).first;
     EXPECT_TRUE(checkedOutput);
 
     contacts = world->GetContactsFromLastStep();