#include <esp/physics/objectManagers/PhysicsObjectBaseManager.h>
template<class T>
esp::physics::PhysicsObjectBaseManager class

Class template defining responsibilities and functionality for managineg object wrappers specializing esp::physics::AbstractManagedPhysicsObject template.

Template parameters
T the type of managed physics object wrapper a particular specialization of this class works with. Must inherit from esp::physics::AbstractManagedPhysicsObject

Base classes

template<class T, ManagedObjectAccess Access>
class esp::core::managedContainers::ManagedContainer<T, core::managedContainers::ManagedObjectAccess::Copy>
Class template defining responsibilities and functionality for managing esp::core::managedContainers::AbstractManagedObject constructs.

Derived classes

template<class T>
class RigidBaseManager
Class template defining responsibilities and functionality shared for managing all esp::physics::AbstractManagedRigidBase wrappers.
template<class T>
class RigidBaseManager
Class template defining responsibilities and functionality shared for managing all esp::physics::AbstractManagedRigidBase wrappers.

Public types

using ObjWrapperPtr = std::shared_ptr<T>

Constructors, destructors, conversion operators

PhysicsObjectBaseManager(const std::string& objType) explicit
~PhysicsObjectBaseManager() defaulted override

Public functions

void setPhysicsManager(std::weak_ptr<physics::PhysicsManager> physMgr)
set the weak reference to the physics manager that owns this wrapper manager
auto createObject(const std::string& objectTypeName, bool registerObject = false) -> ObjWrapperPtr override
Creates an empty esp::physics::AbstractManagedPhysicsObject of the type managed by this manager.

Protected types

using Map_Of_ManagedObjTypeCtors = std::map<std::string, ObjWrapperPtr(PhysicsObjectBaseManager<T>::*)()>
Define a map type referencing function pointers to createRigidObjectWrapper() keyed by string names of classes being instanced, as defined in PrimitiveNames3DMap.

Protected functions

void resetFinalize() override
Any physics-object-wrapper-specific resetting that needs to happen on reset.
template<typename U>
auto createPhysicsObjectWrapper() -> ObjWrapperPtr
Build a shared pointer to a ManagedRigidObject wrapper around an appropriately cast esp::physics::RigidObject, either the base kinematic version, or one built to support a dynamic library.
auto initNewObjectInternal(const std::string& objectTypeName, bool builtFromConfig) -> ObjWrapperPtr override
Used Internally. Create and configure newly-created managed object with any default values, before any specific values are set.
auto preRegisterObjectFinalize(ObjWrapperPtr object, const std::string& objectHandle, bool forceRegistration) -> core::managedContainers::ManagedObjectPreregistration override
Not required for this manager.
void postRegisterObjectHandling(int objectID, const std::string& objectHandle) override
Not required for this manager.
auto getPhysicsManager() const -> std::shared_ptr<esp::physics::PhysicsManager>
return a reference to physicsManager_, or null ptr if it does not exist anymore. This is necessary since a reference of this manager may linger in python after simulator/physicsManager get clobbered/rebuilt.

Protected variables

std::weak_ptr<esp::physics::PhysicsManager> weakPhysManager_
Weak reference to owning physics manager.
Map_Of_ManagedObjTypeCtors managedObjTypeConstructorMap_
Map of function pointers to instantiate a esp::physics::AbstractManagedPhysicsObject wrapper object, keyed by the wrapper's class name. A ManagedRigidObject wrapper of the appropriate type is instanced by accessing the constructor map with the appropriate classname.

Function documentation

template<class T>
ObjWrapperPtr esp::physics::PhysicsObjectBaseManager<T>::createObject(const std::string& objectTypeName, bool registerObject = false) override

Creates an empty esp::physics::AbstractManagedPhysicsObject of the type managed by this manager.

Parameters
objectTypeName Class name of the wrapper to create. This will be used as a key in managedObjTypeConstructorMap_.
registerObject whether to add this managed object to the library or not. If the user is going to edit this managed object, this should be false. Defaults to true. If specified as true, then this function returns a copy of the registered managed object.
Returns a reference to the desired managed object.

template<class T>
ObjWrapperPtr esp::physics::PhysicsObjectBaseManager<T>::initNewObjectInternal(const std::string& objectTypeName, bool builtFromConfig) override protected

Used Internally. Create and configure newly-created managed object with any default values, before any specific values are set.

Parameters
objectTypeName Used to determine what kind of Rigid Object wrapper to make (either kinematic or dynamic-library-specific)
builtFromConfig Unused for wrapper objects. All wrappers are constructed from scratch.
Returns Newly created but unregistered ManagedObject pointer, with only default values set.

template<class T>
core::managedContainers::ManagedObjectPreregistration esp::physics::PhysicsObjectBaseManager<T>::preRegisterObjectFinalize(ObjWrapperPtr object, const std::string& objectHandle, bool forceRegistration) override protected

Not required for this manager.

Parameters
object the managed object to be registered
objectHandle the name to register the managed object with. Expected to be valid.
forceRegistration Will register object even if conditional registration checks fail.
Returns Whether the preregistration has succeeded and what handle to use to register the object if it has.

This method will perform any essential updating to the managed object before registration is performed. If this updating fails, registration will also fail.

template<class T>
void esp::physics::PhysicsObjectBaseManager<T>::postRegisterObjectHandling(int objectID, const std::string& objectHandle) override protected

Not required for this manager.

Parameters
objectID the ID of the successfully registered managed object
objectHandle The name of the managed object

This method will perform any final manager-related handling after successfully registering an object.

See esp::attributes::managers::ObjectAttributesManager for an example.