Expose ArticulatedObject creation_attributes

src/esp/bindings/PhysicsObjectBindings.cpp

@@ -357,6 +357,11 @@ void declareArticulatedObjectWrapper(py::module& m,
              AbstractManagedPhysicsObject<ArticulatedObject>,
              std::shared_ptr<ManagedArticulatedObject>>(m,
                                                         classStrPrefix.c_str())
+      .def_property_readonly(
+          "creation_attributes",
+          &ManagedArticulatedObject::getInitializationAttributes,
+          ("Get a copy of the attributes used to create this " + objType + ".")
+              .c_str())
       .def_property_readonly(
           "global_scale", &ManagedArticulatedObject::getGlobalScale,
           R"(The uniform global scaling applied to this object during import.)")

src/esp/metadata/URDFParser.h

@@ -418,6 +418,17 @@ class Model {
     return initializationAttributes_->getUserConfiguration();
   }
 
+  /**
+   * @brief Get a copy of the template used to initialize this object.
+   *
+   * @return A copy of the @ref esp::metadata::attributes::ArticulatedObjectAttributes
+   * template used to create this object.
+   */
+  std::shared_ptr<metadata::attributes::ArticulatedObjectAttributes>
+  getInitializationAttributes() const {
+    return initializationAttributes_;
+  };
+
  protected:
   /**
    * @brief Json-based attributes defining characteristics of this model not

src/esp/physics/ArticulatedObject.h

@@ -852,6 +852,18 @@ class ArticulatedObject : public esp::physics::PhysicsObjectBase {
         metadata::attributes::SceneAOInstanceAttributes>();
   }
 
+  /**
+   * @brief Get a copy of the template used to initialize this object.
+   *
+   * @return A copy of the @ref esp::metadata::attributes::ArticulatedObjectAttributes
+   * template used to create this object.
+   */
+  std::shared_ptr<metadata::attributes::ArticulatedObjectAttributes>
+  getInitializationAttributes() const {
+    return PhysicsObjectBase::getInitializationAttributes<
+        metadata::attributes::ArticulatedObjectAttributes>();
+  };
+
  protected:
   /**
    * @brief Used to synchronize simulator's notion of the object state

src/esp/physics/PhysicsObjectBase.h

@@ -86,6 +86,20 @@ class PhysicsObjectBase : public Magnum::SceneGraph::AbstractFeature3D {
     return static_cast<const scene::SceneNode&>(
         Magnum::SceneGraph::AbstractFeature3D::object());
   }
+
+  /** @brief Get a copy of the template used to initialize this object
+   * or scene.
+   * @return A copy of the initialization template used to create this object
+   * instance or nullptr if no template exists.
+   */
+  template <class T>
+  std::shared_ptr<T> getInitializationAttributes() const {
+    if (!initializationAttributes_) {
+      return nullptr;
+    }
+    return T::create(*(static_cast<T*>(initializationAttributes_.get())));
+  }
+
   /**
    * @brief Get the @ref MotionType of the object. See @ref
    * setMotionType.
@@ -547,6 +561,12 @@ class PhysicsObjectBase : public Magnum::SceneGraph::AbstractFeature3D {
    */
   core::config::Configuration::ptr userAttributes_ = nullptr;
 
+  /**
+   * @brief Saved attributes when the object was initialized.
+   */
+  metadata::attributes::AbstractAttributes::ptr initializationAttributes_ =
+      nullptr;
+
  private:
   /**
    * @brief This object's instancing attributes, if any were used during its

src/esp/physics/RigidBase.h

@@ -302,19 +302,6 @@ class RigidBase : public esp::physics::PhysicsObjectBase {
         metadata::attributes::SceneObjectInstanceAttributes>();
   }
 
-  /** @brief Get a copy of the template used to initialize this object
-   * or scene.
-   * @return A copy of the initialization template used to create this object
-   * instance or nullptr if no template exists.
-   */
-  template <class T>
-  std::shared_ptr<T> getInitializationAttributes() const {
-    if (!initializationAttributes_) {
-      return nullptr;
-    }
-    return T::create(*(static_cast<T*>(initializationAttributes_.get())));
-  }
-
   /** @brief Get the scalar linear damping coefficient of the object. Only used
    * for dervied dynamic implementations of @ref RigidObject.
    * @return The scalar linear damping coefficient of the object.
@@ -378,7 +365,9 @@ class RigidBase : public esp::physics::PhysicsObjectBase {
    * @return The scaling for the object relative to its initially loaded meshes.
    */
   virtual Magnum::Vector3 getScale() const {
-    return initializationAttributes_->getScale();
+    return PhysicsObjectBase::getInitializationAttributes<
+               metadata::attributes::AbstractObjectAttributes>()
+        ->getScale();
   }
 
   /**
@@ -451,12 +440,6 @@ class RigidBase : public esp::physics::PhysicsObjectBase {
    */
   bool isCollidable_ = false;
 
-  /**
-   * @brief Saved attributes when the object was initialized.
-   */
-  metadata::attributes::AbstractObjectAttributes::ptr
-      initializationAttributes_ = nullptr;
-
  public:
   ESP_SMART_POINTERS(RigidBase)
 };  // class RigidBase

src/esp/physics/RigidObject.h

@@ -127,7 +127,7 @@ class RigidObject : public RigidBase {
    */
   std::shared_ptr<metadata::attributes::ObjectAttributes>
   getInitializationAttributes() const {
-    return RigidBase::getInitializationAttributes<
+    return PhysicsObjectBase::getInitializationAttributes<
         metadata::attributes::ObjectAttributes>();
   };
 

src/esp/physics/RigidStage.h

@@ -47,9 +47,10 @@ class RigidStage : public RigidBase {
    */
   std::shared_ptr<metadata::attributes::StageAttributes>
   getInitializationAttributes() const {
-    return RigidBase::getInitializationAttributes<
+    return PhysicsObjectBase::getInitializationAttributes<
         metadata::attributes::StageAttributes>();
   };
+
   /**
    * @brief Finalize the creation of this @ref RigidStage
    * @return whether successful finalization.

src/esp/physics/bullet/BulletArticulatedObject.cpp

@@ -193,6 +193,7 @@ void BulletArticulatedObject::initializeFromURDF(
     }
     // set user config attributes from model.
     setUserAttributes(urdfModel->getUserConfiguration());
+    initializationAttributes_ = urdfModel->getInitializationAttributes();
 
     // in case the base transform is not zero by default
     syncPose();

src/esp/physics/bullet/BulletRigidObject.cpp

@@ -94,11 +94,12 @@ bool BulletRigidObject::constructCollisionShape() {
   //! Iterate through all mesh components for one object
   //! The components are combined into a convex compound shape
   bObjectShape_ = std::make_unique<btCompoundShape>();
+  auto initAttr = PhysicsObjectBase::getInitializationAttributes<
+      metadata::attributes::ObjectAttributes>();
   // collision mesh/asset handle
-  const std::string collisionAssetHandle =
-      initializationAttributes_->getCollisionAssetHandle();
+  const std::string collisionAssetHandle = initAttr->getCollisionAssetHandle();
 
-  if (!initializationAttributes_->getUseMeshCollision()) {
+  if (!initAttr->getUseMeshCollision()) {
     // if using prim collider get appropriate bullet collision primitive
     // attributes and build bullet collision shape
     auto primAttributes =

src/esp/physics/bullet/BulletRigidStage.cpp

@@ -67,9 +67,10 @@ void BulletRigidStage::setCollidable(bool collidable) {
 
 void BulletRigidStage::constructAndAddCollisionObjects() {
   if (bStaticCollisionObjects_.empty()) {
+    auto initAttr = PhysicsObjectBase::getInitializationAttributes<
+        metadata::attributes::StageAttributes>();
     // construct the objects first time
-    const auto collisionAssetHandle =
-        initializationAttributes_->getCollisionAssetHandle();
+    const auto collisionAssetHandle = initAttr->getCollisionAssetHandle();
 
     const std::vector<assets::CollisionMeshData>& meshGroup =
         resMgr_.getCollisionMesh(collisionAssetHandle);
@@ -80,9 +81,8 @@ void BulletRigidStage::constructAndAddCollisionObjects() {
     constructBulletSceneFromMeshes(Magnum::Matrix4{}, meshGroup, metaData.root);
 
     for (auto& object : bStaticCollisionObjects_) {
-      object->setFriction(initializationAttributes_->getFrictionCoefficient());
-      object->setRestitution(
-          initializationAttributes_->getRestitutionCoefficient());
+      object->setFriction(initAttr->getFrictionCoefficient());
+      object->setRestitution(initAttr->getRestitutionCoefficient());
       collisionObjToObjIds_->emplace(object.get(), objectId_);
     }
   }
@@ -141,7 +141,9 @@ void BulletRigidStage::constructBulletSceneFromMeshes(
     std::unique_ptr<btBvhTriangleMeshShape> meshShape =
         std::make_unique<btBvhTriangleMeshShape>(indexedVertexArray.get(),
                                                  true);
-    meshShape->setMargin(initializationAttributes_->getMargin());
+    auto initAttr = PhysicsObjectBase::getInitializationAttributes<
+        metadata::attributes::StageAttributes>();
+    meshShape->setMargin(initAttr->getMargin());
     meshShape->setLocalScaling(
         btVector3{transformFromLocalToWorld
                       .scaling()});  // scale is a property of the shape

src/esp/physics/objectWrappers/ManagedArticulatedObject.h

@@ -24,6 +24,14 @@ class ManagedArticulatedObject
       : AbstractManagedPhysicsObject<esp::physics::ArticulatedObject>(
             classKey) {}
 
+  std::shared_ptr<metadata::attributes::ArticulatedObjectAttributes>
+  getInitializationAttributes() const {
+    if (auto sp = this->getObjectReference()) {
+      return sp->getInitializationAttributes();
+    }
+    return nullptr;
+  }  // getInitializationAttributes()
+
   float getGlobalScale() const {
     if (auto sp = getObjectReference()) {
       return sp->getGlobalScale();