dartpy 7.0.0.dev0__cp313-cp313-manylinux_2_39_x86_64.whl

include/dart/dynamics/MimicDofProperties.hpp

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *   POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef DART_DYNAMICS_MIMICDOFPROPERTIES_HPP_
+#define DART_DYNAMICS_MIMICDOFPROPERTIES_HPP_
+
+#include <cstddef>
+
+namespace dart {
+namespace dynamics {
+
+class Joint;
+
+/// Properties of a mimicked Degree of Freedom (DoF) in a joint.
+struct MimicDofProperties
+{
+  /// Pointer to the reference joint used for mimicking behavior.
+  const Joint* mReferenceJoint;
+
+  /// Index of the reference DoF in the reference joint.
+  std::size_t mReferenceDofIndex = 0;
+
+  /// Multiplier applied to the reference joint's DoF value.
+  double mMultiplier = 1.0;
+
+  /// Offset added to the reference joint's DoF value.
+  double mOffset = 0.0;
+};
+
+} // namespace dynamics
+} // namespace dart
+
+#endif // DART_DYNAMICS_MIMICDOFPROPERTIES_HPP_

include/dart/dynamics/MultiSphereConvexHullShape.hpp

@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *   POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef DART_DYNAMICS_MULTISPHERECONVEXHULLSHAPE_HPP_
+#define DART_DYNAMICS_MULTISPHERECONVEXHULLSHAPE_HPP_
+
+#include <dart/dynamics/Shape.hpp>
+
+#include <vector>
+
+namespace dart {
+namespace dynamics {
+
+/// MultiSphereConvexHullShape represents the convex hull of a collection of
+/// spheres.
+class MultiSphereConvexHullShape : public Shape
+{
+public:
+  using Sphere = std::pair<double, Eigen::Vector3d>;
+  using Spheres = std::vector<Sphere>;
+
+  /// Constructor.
+  explicit MultiSphereConvexHullShape(const Spheres& spheres);
+
+  /// Destructor.
+  virtual ~MultiSphereConvexHullShape();
+
+  // Documentation inherited.
+  const std::string& getType() const override;
+
+  /// Returns shape type for this class
+  static const std::string& getStaticType();
+
+  /// Add a list of spheres
+  void addSpheres(const Spheres& spheres);
+
+  /// Add a sphere
+  void addSphere(const Sphere& sphere);
+
+  /// Add a sphere
+  void addSphere(double radius, const Eigen::Vector3d& position);
+
+  /// Remove all spheres
+  void removeAllSpheres();
+
+  /// Get the number of spheres
+  std::size_t getNumSpheres() const;
+
+  /// Get the set of spheres
+  const Spheres& getSpheres() const;
+
+  /// Compute the inertia of this MultiSphereConvexHullShape.
+  ///
+  /// \note The return value is an approximated inertia that is the inertia of
+  /// the axis-alinged bounding box of this MultiSphereConvexHullShape.
+  Eigen::Matrix3d computeInertia(double mass) const override;
+
+  // Documentation inherited.
+  ShapePtr clone() const override;
+
+protected:
+  // Documentation inherited.
+  void updateBoundingBox() const override;
+
+  /// Update the volume of this MultiSphereConvexHullShape.
+  ///
+  /// \note The result volume is an approximated volumen that is the volume of
+  /// the axis-alinged bounding box of this MultiSphereConvexHullShape.
+  void updateVolume() const override;
+
+private:
+  /// Spheres
+  Spheres mSpheres;
+};
+
+DART_DEPRECATED(6.2)
+typedef MultiSphereConvexHullShape MultiSphereShape;
+
+} // namespace dynamics
+} // namespace dart
+
+#endif // DART_DYNAMICS_MULTISPHERECONVEXHULLSHAPE_HPP_

include/dart/dynamics/MultiSphereShape.hpp

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *   POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef DART_DYNAMICS_MULTISPHERESHAPE_HPP_
+#define DART_DYNAMICS_MULTISPHERESHAPE_HPP_
+
+#pragma message(                                                               \
+    "This header has been deprecated in DART 6.2. "                            \
+    "Please include MultiSphereConvexHullShape.hpp instead.")
+
+#include <dart/dynamics/MultiSphereConvexHullShape.hpp>
+
+#endif // DART_DYNAMICS_MULTISPHERESHAPE_HPP_

include/dart/dynamics/Node.hpp

@@ -0,0 +1,273 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *   POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef DART_DYNAMICS_NODE_HPP_
+#define DART_DYNAMICS_NODE_HPP_
+
+#include <dart/dynamics/SmartPointer.hpp>
+
+#include <dart/common/Cloneable.hpp>
+#include <dart/common/EmbeddedAspect.hpp>
+#include <dart/common/Subject.hpp>
+#include <dart/common/VersionCounter.hpp>
+
+#include <memory>
+
+namespace dart {
+namespace dynamics {
+
+class BodyNode;
+class Node;
+
+//==============================================================================
+class NodeDestructor final
+{
+public:
+  /// Constructor
+  NodeDestructor(Node* _node);
+
+  /// Do not copy
+  NodeDestructor(const NodeDestructor& _other) = delete;
+
+  /// Non-virtual destructor (this class cannot be inherited)
+  ~NodeDestructor();
+
+  Node* getNode() const;
+
+private:
+  /// Node that this Destructor is responsible for
+  Node* mNode;
+};
+
+//==============================================================================
+/// The Node class is a base class for BodyNode and any object that attaches to
+/// a BodyNode. This base class handles ownership and reference counting for the
+/// classes that inherit it.
+///
+/// In most cases, when creating your own custom Node class, you will also want
+/// to inherit from AccessoryNode using CRTP.
+DART_DECLARE_CLASS_WITH_VIRTUAL_BASE_BEGIN
+class Node : public virtual common::Subject,
+             public virtual common::VersionCounter
+{
+public:
+  friend class BodyNode;
+  friend class Skeleton;
+  template <class>
+  friend class AccessoryNode;
+  template <class, class>
+  friend class TemplateNodePtr;
+  template <class, class>
+  friend class TemplateWeakNodePtr;
+
+  /// If your Node has a State class, then that State class should inherit this
+  /// Node::State class. This allows us to safely serialize, store, and clone
+  /// the states of arbitrary Node extensions. If your Node is stateless, then
+  /// you do not have to worry about extending this class, because
+  /// Node::getNodeState() will simply return a nullptr by default, which is
+  /// taken to indicate that it is stateless.
+  ///
+  /// The distinction between the State class and the Properties class is that
+  /// State will get stored in BodyNode::ExtendedState whereas Properties will
+  /// get stored in BodyNode::ExtendedProperties. Typically Properties are
+  /// values that only change rarely if ever, whereas State contains values that
+  /// might change as often as every time step.
+  class State : public common::Cloneable<State>
+  {
+  };
+
+  /// Use the MakeState class to easily create a State extension from an
+  /// existing class or struct
+  template <class Mixin>
+  using MakeState = common::MakeCloneable<State, Mixin>;
+
+  /// If your Node has a Properties class, then that Properties class should
+  /// inherit this Node::Properties class. This allows us to safely serialize,
+  /// store, and clone the properties of arbitrary Node extensions. If your
+  /// Node has no properties, then you do not have to worry about extending
+  /// this class, because Node::getNodeProperties() will simply return a nullptr
+  /// by default, which is taken to indicate that it has no properties.
+  ///
+  /// The distinction between the State class and the Properties class is that
+  /// State will get stored in BodyNode::ExtendedState whereas Properties will
+  /// get stored in BodyNode::ExtendedProperties. Typically Properties are
+  /// values that only change rarely if ever, whereas State contains values that
+  /// might change as often as every time step.
+  class Properties : public common::Cloneable<Properties>
+  {
+  };
+
+  /// Use the MakeProperties class to easily create a Properties extension
+  /// from an existing class or struct.
+  template <class Mixin>
+  using MakeProperties = common::MakeCloneable<Properties, Mixin>;
+
+  /// Virtual destructor
+  virtual ~Node() = default;
+
+  /// Set the name of this Node
+  virtual const std::string& setName(const std::string& newName) = 0;
+
+  /// Get the name of this Node
+  virtual const std::string& getName() const = 0;
+
+  /// Set the State of this Node. By default, this does nothing.
+  virtual void setNodeState(const State& otherState);
+
+  /// Get the State of this Node. By default, this returns a nullptr which
+  /// implies that the Node is stateless.
+  virtual std::unique_ptr<State> getNodeState() const;
+
+  /// Copy the State of this Node into a unique_ptr. By default, this simply
+  /// calls getNodeState() and passes the result into the outputState, but this
+  /// function can be overriden to be more performant by avoiding allocations.
+  virtual void copyNodeStateTo(std::unique_ptr<State>& outputState) const;
+
+  /// Set the Properties of this Node. By default, this does nothing.
+  virtual void setNodeProperties(const Properties& properties);
+
+  /// Get the Properties of this Node. By default, this returns a nullptr which
+  /// implies that the Node has no properties.
+  virtual std::unique_ptr<Properties> getNodeProperties() const;
+
+  /// Copy the Properties of this Node into a unique_ptr. By default, this
+  /// simply calls getNodeProperties() and passes the result into the
+  /// outputProperties, but this function can be overriden to be more
+  /// performant.
+  virtual void copyNodePropertiesTo(
+      std::unique_ptr<Properties>& outputProperties) const;
+
+  /// Get a pointer to the BodyNode that this Node is associated with
+  BodyNodePtr getBodyNodePtr();
+
+  /// Get a pointer to the BodyNode that this Node is associated with
+  ConstBodyNodePtr getBodyNodePtr() const;
+
+  /// Returns true if this Node has been staged for removal from its BodyNode.
+  /// It will be deleted once all strong references to it expire. If it is an
+  /// AccessoryNode, you can call reattach() to prevent that from happening.
+  bool isRemoved() const;
+
+  /// Return the Skeleton that this Node is attached to
+  virtual std::shared_ptr<Skeleton> getSkeleton();
+
+  /// Return the Skeleton that this Node is attached to
+  virtual std::shared_ptr<const Skeleton> getSkeleton() const;
+
+private:
+  std::shared_ptr<NodeDestructor> getOrCreateDestructor();
+
+protected:
+  /// Allow your Node implementation to be cloned into a new BodyNode
+  virtual Node* cloneNode(BodyNode* bn) const = 0;
+
+  /// Constructor
+  Node(BodyNode* _bn);
+
+  /// Inform the Skeleton that the name of this Node has changed. If the name is
+  /// already taken by another Node of the same type, then this function will
+  /// return a modified version which is unique. If the name is not already
+  /// taken, then it will just return the same name that the function was given.
+  std::string registerNameChange(const std::string& newName);
+
+  /// Attach the Node to its BodyNode
+  void attach();
+
+  /// When all external references to the Node disappear, it will be deleted
+  void stageForRemoval();
+
+  /// weak pointer to the destructor for this Node. We use a shared_ptr
+  /// "destructor" class instead of managing Nodes directly with shared_ptrs
+  /// because this scheme allows BodyNodes to circumvent the shared_ptr
+  /// management by setting the mNode member of the Destructor to a nullptr.
+  /// That way the BodyNode can never be deleted by its Destructor.
+  std::weak_ptr<NodeDestructor> mDestructor;
+
+  /// Pointer to the BodyNode that this Node is attached to
+  BodyNode* mBodyNode;
+
+  /// bool that tracks whether this Node is attached to its BodyNode
+  bool mAmAttached;
+
+  /// The index of this Node within its vector in its BodyNode's NodeMap
+  std::size_t mIndexInBodyNode;
+
+  /// The index of this Node within its vector in its Skeleton's NodeMap
+  std::size_t mIndexInSkeleton;
+
+  /// Index of this Node within its tree
+  std::size_t mIndexInTree;
+};
+DART_DECLARE_CLASS_WITH_VIRTUAL_BASE_END
+
+//==============================================================================
+/// AccessoryNode provides an interface for Nodes to get their index within the
+/// list of Nodes, as well as detach and reattach. This uses CRTP to get around
+/// the diamond of death problem.
+template <class NodeType>
+class AccessoryNode
+{
+public:
+  /// Virtual destructor
+  virtual ~AccessoryNode() = default;
+
+  /// Get the index of this Node within its BodyNode.
+  std::size_t getIndexInBodyNode() const;
+
+  /// Get the index of this Node within its Skeleton.
+  std::size_t getIndexInSkeleton() const;
+
+  /// Get the index of this Node within its tree.
+  std::size_t getIndexInTree() const;
+
+  /// Get the index of this Node's tree within its Skeleton
+  std::size_t getTreeIndex() const;
+
+  /// Stage the Node for removal. When all strong references to the Node expire,
+  /// the Node will be removed from its BodyNode and deleted.
+  void remove();
+
+  /// Undo the effectos of calling remove(). The Node will continue to exist,
+  /// even when all the strong references to it expire.
+  void reattach();
+
+protected:
+  /// Prevent a non-inheriting class from constructing one
+  AccessoryNode() = default;
+};
+
+} // namespace dynamics
+} // namespace dart
+
+#include <dart/dynamics/detail/Node.hpp>
+
+#endif // DART_DYNAMICS_NODE_HPP_

include/dart/dynamics/NodeManagerJoiner.hpp

@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *   POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef DART_DYNAMICS_NODEMANAGERJOINER_HPP_
+#define DART_DYNAMICS_NODEMANAGERJOINER_HPP_
+
+#include <dart/common/Empty.hpp>
+
+#include <string>
+
+namespace dart {
+namespace dynamics {
+
+//==============================================================================
+/// Declaration of the variadic template
+template <class... OtherBases>
+class NodeManagerJoinerForBodyNode
+{
+};
+
+//==============================================================================
+/// Special case of only having 1 class: we do nothing but inherit it.
+template <class Base1>
+class NodeManagerJoinerForBodyNode<Base1> : public Base1
+{
+};
+
+//==============================================================================
+/// NodeManagerJoiner allows classes that inherit from various
+/// SpecializedNodeManager types to be inherited by a single derived class. This
+/// class solved the diamond-of-death problem for multiple
+/// SpecializedNodeManager inheritance.
+template <class Base1, class Base2>
+class NodeManagerJoinerForBodyNode<Base1, Base2> : public Base1, public Base2
+{
+public:
+  /// Default constructor
+  NodeManagerJoinerForBodyNode() = default;
+
+  /// This constructor allows one argument to be passed to the Base1 constructor
+  /// and arbitrarily many arguments to be passed to the Base2 constructor.
+  template <typename Base1Arg, typename... Base2Args>
+  NodeManagerJoinerForBodyNode(Base1Arg&& arg1, Base2Args&&... args2);
+
+  /// This constructor passes one argument to the Base1 constructor and no
+  /// arguments to the Base2 constructor.
+  template <typename Base1Arg>
+  NodeManagerJoinerForBodyNode(Base1Arg&& arg1, common::NoArgTag);
+
+  /// This constructor passes no arguments to the Base1 constructor and
+  /// arbitrarily many arguments to the Base2 constructor.
+  template <typename... Base2Args>
+  NodeManagerJoinerForBodyNode(common::NoArgTag, Base2Args&&... args2);
+
+  template <class NodeType>
+  std::size_t getNumNodes() const;
+
+  template <class NodeType>
+  NodeType* getNode(std::size_t index);
+
+  template <class NodeType>
+  const NodeType* getNode(std::size_t index) const;
+
+  template <class NodeType>
+  static constexpr bool isSpecializedForNode();
+};
+
+//==============================================================================
+/// This is the variadic version of the NodeManagerJoinerForBodyNode class which
+/// allows you to include arbitrarily many base classes in the joining.
+template <class Base1, class Base2, class... OtherBases>
+class NodeManagerJoinerForBodyNode<Base1, Base2, OtherBases...>
+  : public NodeManagerJoinerForBodyNode<
+        Base1,
+        NodeManagerJoinerForBodyNode<Base2, OtherBases...>>
+{
+public:
+  NodeManagerJoinerForBodyNode() = default;
+
+  template <typename... Args>
+  NodeManagerJoinerForBodyNode(Args&&... args);
+};
+
+//==============================================================================
+/// Declaration of variadic template
+template <class... OtherBases>
+class NodeManagerJoinerForSkeleton
+{
+};
+
+//==============================================================================
+/// Special case of only having 1 class: we do nothing but inherit it
+template <class Base1>
+class NodeManagerJoinerForSkeleton<Base1> : public Base1
+{
+};
+
+//==============================================================================
+template <class Base1, class Base2>
+class NodeManagerJoinerForSkeleton<Base1, Base2>
+  : public NodeManagerJoinerForBodyNode<Base1, Base2>
+{
+public:
+  using Base = NodeManagerJoinerForBodyNode<Base1, Base2>;
+  using Base::getNode;
+  using Base::getNumNodes;
+  using Base::isSpecializedForNode;
+
+  /// Default constructor
+  NodeManagerJoinerForSkeleton() = default;
+
+  /// Forwards construction to NodeManagerJoinerForBodyNode
+  template <typename... Args>
+  NodeManagerJoinerForSkeleton(Args&&... args);
+
+  /// Get the number of Nodes of the specified type that are in the treeIndexth
+  /// tree of this Skeleton
+  template <class NodeType>
+  std::size_t getNumNodes(std::size_t treeIndex) const;
+
+  /// Get the nodeIndexth Node of the specified type within the tree of
+  /// treeIndex.
+  template <class NodeType>
+  NodeType* getNode(std::size_t treeIndex, std::size_t nodeIndex);
+
+  /// Get the nodeIndexth Node of the specified type within the tree of
+  /// treeIndex.
+  template <class NodeType>
+  const NodeType* getNode(std::size_t treeIndex, std::size_t nodeIndex) const;
+
+  /// Get the Node of the specified type with the given name.
+  template <class NodeType>
+  NodeType* getNode(const std::string& name);
+
+  /// Get the Node of the specified type with the given name.
+  template <class NodeType>
+  const NodeType* getNode(const std::string& name) const;
+};
+
+//==============================================================================
+/// This is the variadic version of the NodeManagerJoinerForSkeleton class which
+/// allows you to include arbitrarily many base classes in the joining.
+template <class Base1, class Base2, class... OtherBases>
+class NodeManagerJoinerForSkeleton<Base1, Base2, OtherBases...>
+  : public NodeManagerJoinerForSkeleton<
+        Base1,
+        NodeManagerJoinerForSkeleton<Base2, OtherBases...>>
+{
+public:
+  NodeManagerJoinerForSkeleton() = default;
+
+  template <typename... Args>
+  NodeManagerJoinerForSkeleton(Args&&... args);
+};
+
+} // namespace dynamics
+} // namespace dart
+
+#include <dart/dynamics/detail/NodeManagerJoiner.hpp>
+
+#endif // DART_DYNAMICS_NODEMANAGERJOINER_HPP_