--[BE Week] Articulated Object Loading refactors and cleanup (#2291)

* --initial commit
Add 'applyScaleToMass' method to determine whether geometric scaling should be applied to mass calc for objects as well as articulated objects
* --remove unused urdf-related add function
* --update docs
* --add tests
* --remove unused addArticulatedObjectFromURDF method

Author: jturner65

docs/pages/attributesJSON.rst

@@ -189,6 +189,9 @@ All rigid and articulated objects instanced in the scene during initialization s
         - "non_uniform_scale"
             - 3-vector
             - A non-uniform scale vector to apply in addition to the uniform scale.
+          "apply_scale_to_mass"
+            - boolean
+            - Whether or not to apply the product of the geometric scaling to the mass.
         - "translation_origin"
             - string
             - One of ('COM', 'asset_local'). Defines whether the translation provided for this object instance is applied in render asset local space or center of mass (COM) aligned space. All rigid object translations within Habitat-sim are in COM space, but external translations (e.g. exported from Blender) may not be.
@@ -223,6 +226,9 @@ All rigid and articulated objects instanced in the scene during initialization s
         - "mass_scale"
             - float
             - Mass does not scale linearly with object scale, so you can customize this.
+          "apply_scale_to_mass"
+            - boolean
+            - Whether or not to apply the product of the geometric scaling to the mass. This is in addition to any scaling specified via "mass_scale" .
         - "translation_origin"
             - string
             - One of ('COM', 'asset_local'). Defines whether the translation provided for this object instance is applied in render asset local space or center of mass (COM) aligned space.

src/esp/metadata/attributes/SceneInstanceAttributes.cpp

@@ -33,6 +33,7 @@ SceneObjectInstanceAttributes::SceneObjectInstanceAttributes(
   setUniformScale(1.0);
   setNonUniformScale({1.0, 1.0, 1.0});
   setMassScale(1.0);
+  setApplyScaleToMass(true);
 }
 
 std::string SceneObjectInstanceAttributes::getObjectInfoHeaderInternal() const {
@@ -117,6 +118,9 @@ void SceneObjectInstanceAttributes::writeValuesToJson(
   if (getNonUniformScale() != Mn::Vector3(1.0, 1.0, 1.0)) {
     writeValueToJson("non_uniform_scale", jsonObj, allocator);
   }
+  if (!getApplyScaleToMass()) {
+    writeValueToJson("apply_scale_to_mass", jsonObj, allocator);
+  }
   if (getMassScale() != 1.0) {
     writeValueToJson("mass_scale", jsonObj, allocator);
   }

src/esp/metadata/attributes/SceneInstanceAttributes.h

@@ -189,6 +189,22 @@ class SceneObjectInstanceAttributes : public AbstractAttributes {
     set("non_uniform_scale", non_uniform_scale);
   }
 
+  /**
+   * @brief Object and Articulated Object Instance only. Get whether or
+   * not to apply geometric scaling to mass (i.e. to maintain object mean
+   * density)
+   */
+  bool getApplyScaleToMass() const { return get<bool>("apply_scale_to_mass"); }
+
+  /**
+   * @brief Object and Articulated Object Instance only. Set whether or
+   * not to apply geometric scaling to mass (i.e. to maintain object mean
+   * density)
+   */
+  void setApplyScaleToMass(bool apply_scale_to_mass) {
+    set("apply_scale_to_mass", apply_scale_to_mass);
+  }
+
   /**
    * @brief Get or set the mass scaling of the instanced object.
    */

src/esp/metadata/managers/SceneInstanceAttributesManager.cpp

@@ -461,6 +461,12 @@ void SceneInstanceAttributesManager::setAbstractObjectAttributesFromJson(
         instanceAttrs->setNonUniformScale(non_uniform_scale);
       });
 
+  // whether geometric scaling should be applied to mass to maintain density.
+  io::jsonIntoSetter<bool>(
+      jCell, "apply_scale_to_mass", [instanceAttrs](bool apply_scale_to_mass) {
+        instanceAttrs->setApplyScaleToMass(apply_scale_to_mass);
+      });
+
   // whether particular instance is visible or not - only modify if actually
   // present in instance json
   io::jsonIntoSetter<bool>(

src/esp/physics/PhysicsManager.cpp

@@ -157,6 +157,14 @@ int PhysicsManager::addObjectInstance(
   // non-uniform scaling
   objAttributes->setScale(objAttributes->getScale() *
                           objInstAttributes->getNonUniformScale());
+
+  // If boolean specifies to do so, apply geometric scaling to mass (product of
+  // scale values)
+  if (objInstAttributes->getApplyScaleToMass()) {
+    objAttributes->setMass(
+        objAttributes->getMass() *
+        static_cast<double>(objAttributes->getScale().product()));
+  }
   // set scaled mass
   objAttributes->setMass(objAttributes->getMass() *
                          objInstAttributes->getMassScale());
@@ -367,16 +375,9 @@ int PhysicsManager::addArticulatedObjectInstance(
   int visSet = aObjInstAttributes->getIsInstanceVisible();
   if (visSet != ID_UNDEFINED) {
     // specfied in scene instance
-    // objAttributes->setIsVisible(visSet == 1);
+    // artObjAttributes->setIsVisible(visSet == 1);
     // TODO: manage articulated object visibility.
   }
-  // set uniform scale
-  artObjAttributes->setUniformScale(artObjAttributes->getUniformScale() *
-                                    aObjInstAttributes->getUniformScale());
-  // set scaled mass
-  artObjAttributes->setMassScale(artObjAttributes->getMassScale() *
-                                 aObjInstAttributes->getMassScale());
-
   // set shader type to use for articulated object instance, which may override
   // shadertype specified in articulated object attributes.
   const auto artObjShaderType = aObjInstAttributes->getShaderType();
@@ -385,6 +386,22 @@ int PhysicsManager::addArticulatedObjectInstance(
     artObjAttributes->setShaderType(getShaderTypeName(artObjShaderType));
   }
 
+  // set uniform scale
+  artObjAttributes->setUniformScale(artObjAttributes->getUniformScale() *
+                                    aObjInstAttributes->getUniformScale());
+
+  // If boolean specifies to do so, apply geometric scaling to mass (product of
+  // scale values)
+  if (aObjInstAttributes->getApplyScaleToMass()) {
+    artObjAttributes->setMassScale(
+        artObjAttributes->getMassScale() *
+        static_cast<double>(artObjAttributes->getUniformScale()));
+  }
+
+  // set scaled mass
+  artObjAttributes->setMassScale(artObjAttributes->getMassScale() *
+                                 aObjInstAttributes->getMassScale());
+
   const auto baseType = aObjInstAttributes->getBaseType();
   if (baseType !=
       metadata::attributes::ArticulatedObjectBaseType::Unspecified) {
@@ -467,59 +484,47 @@ int PhysicsManager::addArticulatedObjectFromURDF(
     // acquire context if available
     simulator_->getRenderGLContext();
     auto& drawables = simulator_->getDrawableGroup();
-    return addArticulatedObjectFromURDF(
-        filepath, &drawables, fixedBase, globalScale, massScale, forceReload,
-        maintainLinkOrder, intertiaFromURDF, lightSetup);
+
+    // Retrieve or create the appropriate ArticulatedObjectAttributes to create
+    // this AO.
+
+    bool attribsFound =
+        resourceManager_.getAOAttributesManager()->getObjectLibHasHandle(
+            filepath);
+
+    esp::metadata::attributes::ArticulatedObjectAttributes::ptr
+        artObjAttributes =
+            attribsFound
+                ? resourceManager_.getAOAttributesManager()
+                      ->getObjectCopyByHandle(filepath)
+                : resourceManager_.getAOAttributesManager()->createObject(
+                      filepath, true);
+
+    // Set pertinent values
+    artObjAttributes->setUniformScale(globalScale);
+    artObjAttributes->setMassScale(static_cast<double>(massScale));
+
+    artObjAttributes->setBaseType(metadata::attributes::getAOBaseTypeName(
+        fixedBase ? metadata::attributes::ArticulatedObjectBaseType::Fixed
+                  : metadata::attributes::ArticulatedObjectBaseType::Free));
+
+    artObjAttributes->setInertiaSource(
+        metadata::attributes::getAOInertiaSourceName(
+            intertiaFromURDF
+                ? metadata::attributes::ArticulatedObjectInertiaSource::URDF
+                : metadata::attributes::ArticulatedObjectInertiaSource::
+                      Computed));
+
+    artObjAttributes->setLinkOrder(metadata::attributes::getAOLinkOrderName(
+        maintainLinkOrder
+            ? metadata::attributes::ArticulatedObjectLinkOrder::URDFOrder
+            : metadata::attributes::ArticulatedObjectLinkOrder::TreeTraversal));
+
+    return addArticulatedObject(artObjAttributes, &drawables, forceReload,
+                                lightSetup);
   }
   return ID_UNDEFINED;
-}  // PhysicsManager::addArticulatedObjectFromURDF
-
-int PhysicsManager::addArticulatedObjectFromURDF(
-    const std::string& filepath,
-    DrawableGroup* drawables,
-    bool fixedBase,
-    float globalScale,
-    float massScale,
-    bool forceReload,
-    bool maintainLinkOrder,
-    bool intertiaFromURDF,
-    const std::string& lightSetup) {
-  // Retrieve or create the appropriate ArticulatedObjectAttributes to create
-  // this AO.
-
-  bool attribsFound =
-      resourceManager_.getAOAttributesManager()->getObjectLibHasHandle(
-          filepath);
-
-  esp::metadata::attributes::ArticulatedObjectAttributes::ptr artObjAttributes =
-      attribsFound
-          ? resourceManager_.getAOAttributesManager()->getObjectCopyByHandle(
-                filepath)
-          : resourceManager_.getAOAttributesManager()->createObject(filepath,
-                                                                    true);
-
-  // Set pertinent values
-  artObjAttributes->setUniformScale(globalScale);
-  artObjAttributes->setMassScale(static_cast<double>(massScale));
-
-  artObjAttributes->setBaseType(metadata::attributes::getAOBaseTypeName(
-      fixedBase ? metadata::attributes::ArticulatedObjectBaseType::Fixed
-                : metadata::attributes::ArticulatedObjectBaseType::Free));
-
-  artObjAttributes->setInertiaSource(
-      metadata::attributes::getAOInertiaSourceName(
-          intertiaFromURDF
-              ? metadata::attributes::ArticulatedObjectInertiaSource::URDF
-              : metadata::attributes::ArticulatedObjectInertiaSource::
-                    Computed));
-
-  artObjAttributes->setLinkOrder(metadata::attributes::getAOLinkOrderName(
-      maintainLinkOrder
-          ? metadata::attributes::ArticulatedObjectLinkOrder::URDFOrder
-          : metadata::attributes::ArticulatedObjectLinkOrder::TreeTraversal));
-
-  return addArticulatedObject(artObjAttributes, drawables, forceReload,
-                              lightSetup);
+  //}  // PhysicsManager::addArticulatedObjectFromURDF
 
 }  // PhysicsManager::addArticulatedObjectFromURDF
 

src/esp/physics/PhysicsManager.h

@@ -576,45 +576,6 @@ class PhysicsManager : public std::enable_shared_from_this<PhysicsManager> {
       bool intertiaFromURDF = false,
       const std::string& lightSetup = DEFAULT_LIGHTING_KEY);
 
-  /**
-   * @brief Load, parse, and import a URDF file instantiating an @ref
-   * ArticulatedObject in the world.
-   *
-   * Not implemented in base PhysicsManager.
-   * @param filepath The fully-qualified filename for the URDF file describing
-   * the model the articulated object is to be built from.
-   * @param drawables Reference to the scene graph drawables group to enable
-   * rendering of the newly initialized @ref ArticulatedObject.
-   * @param fixedBase Whether the base of the @ref ArticulatedObject should be
-   * fixed.
-   * @param globalScale A scale multiplier to be applied uniformly in 3
-   * dimensions to the entire @ref ArticulatedObject.
-   * @param massScale A scale multiplier to be applied to the mass of the all
-   * the components of the @ref ArticulatedObject.
-   * @param forceReload If true, reload the source URDF from file, replacing the
-   * cached model.
-   * @param maintainLinkOrder If true, maintain the order of link definitions
-   * from the URDF file as the link indices.
-   * @param intertiaFromURDF If true, load the link inertia matrices from the
-   * URDF file instead of computing automatically from collision shapes.
-   * @param lightSetup The string name of the desired lighting setup to use.
-   *
-   * @return The instanced @ref ArticulatedObject 's ID, mapping to the articulated
-   * object in @ref PhysicsManager::existingObjects_ if successful, or
-   * @ref esp::ID_UNDEFINED. These values come from the same pool used
-   * by rigid objects.
-   */
-  int addArticulatedObjectFromURDF(
-      const std::string& filepath,
-      DrawableGroup* drawables,
-      bool fixedBase = false,
-      float globalScale = 1.0,
-      float massScale = 1.0,
-      bool forceReload = false,
-      bool maintainLinkOrder = false,
-      bool intertiaFromURDF = false,
-      const std::string& lightSetup = DEFAULT_LIGHTING_KEY);
-
   //! Remove an @ref ArticulatedObject from the world by unique id.
   virtual void removeArticulatedObject(int objectId);