dartpy 7.0.0.dev0__cp312-cp312-manylinux_2_39_x86_64.whl

include/dart/dynamics/ScrewJoint.hpp

@@ -0,0 +1,126 @@
+/*
+ * 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_SCREWJOINT_HPP_
+#define DART_DYNAMICS_SCREWJOINT_HPP_
+
+#include <dart/dynamics/detail/ScrewJointAspect.hpp>
+
+namespace dart {
+namespace dynamics {
+
+/// class ScrewJoint
+class ScrewJoint : public detail::ScrewJointBase
+{
+public:
+  friend class Skeleton;
+  using UniqueProperties = detail::ScrewJointUniqueProperties;
+  using Properties = detail::ScrewJointProperties;
+  using Base = detail::ScrewJointBase;
+
+  DART_BAKE_SPECIALIZED_ASPECT_IRREGULAR(Aspect, ScrewJointAspect)
+
+  ScrewJoint(const ScrewJoint&) = delete;
+
+  /// Destructor
+  virtual ~ScrewJoint();
+
+  /// Set the Properties of this ScrewJoint
+  void setProperties(const Properties& _properties);
+
+  /// Set the Properties of this ScrewJoint
+  void setProperties(const UniqueProperties& _properties);
+
+  /// Set the AspectProperties of this ScrewJoint
+  void setAspectProperties(const AspectProperties& properties);
+
+  /// Get the Properties of this ScrewJoint
+  Properties getScrewJointProperties() const;
+
+  /// Copy the Properties of another ScrewJoint
+  void copy(const ScrewJoint& _otherJoint);
+
+  /// Copy the Properties of another ScrewJoint
+  void copy(const ScrewJoint* _otherJoint);
+
+  /// Copy the Properties of another ScrewJoint
+  ScrewJoint& operator=(const ScrewJoint& _otherJoint);
+
+  // Documentation inherited
+  const std::string& getType() const override;
+
+  /// Get joint type for this class
+  static const std::string& getStaticType();
+
+  // Documentation inherited
+  bool isCyclic(std::size_t _index) const override;
+
+  ///
+  void setAxis(const Eigen::Vector3d& _axis);
+
+  ///
+  const Eigen::Vector3d& getAxis() const;
+
+  ///
+  void setPitch(double _pitch);
+
+  ///
+  double getPitch() const;
+
+  // Documentation inherited
+  GenericJoint<math::R1Space>::JacobianMatrix getRelativeJacobianStatic(
+      const GenericJoint<math::R1Space>::Vector& positions) const override;
+
+protected:
+  /// Constructor called by Skeleton class
+  ScrewJoint(const Properties& properties);
+
+  // Documentation inherited
+  Joint* clone() const override;
+
+  // Documentation inherited
+  void updateDegreeOfFreedomNames() override;
+
+  // Documentation inherited
+  void updateRelativeTransform() const override;
+
+  // Documentation inherited
+  void updateRelativeJacobian(bool _mandatory = true) const override;
+
+  // Documentation inherited
+  void updateRelativeJacobianTimeDeriv() const override;
+};
+
+} // namespace dynamics
+} // namespace dart
+
+#endif // DART_DYNAMICS_SCREWJOINT_HPP_

include/dart/dynamics/Shape.hpp

@@ -0,0 +1,231 @@
+/*
+ * 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_SHAPE_HPP_
+#define DART_DYNAMICS_SHAPE_HPP_
+
+#include <dart/dynamics/SmartPointer.hpp>
+
+#include <dart/math/Geometry.hpp>
+
+#include <dart/common/Castable.hpp>
+#include <dart/common/ClassWithVirtualBase.hpp>
+#include <dart/common/Deprecated.hpp>
+#include <dart/common/Signal.hpp>
+#include <dart/common/Subject.hpp>
+#include <dart/common/VersionCounter.hpp>
+
+#include <Eigen/Dense>
+
+#include <memory>
+
+namespace dart {
+namespace dynamics {
+
+DART_DECLARE_CLASS_WITH_VIRTUAL_BASE_BEGIN
+class Shape : public virtual common::Subject,
+              public virtual common::VersionCounter,
+              public common::Castable<Shape>
+{
+public:
+  using VersionChangedSignal
+      = common::Signal<void(Shape* shape, std::size_t version)>;
+
+  /// \deprecated Deprecated in 6.1. Please use getType() instead.
+  enum ShapeType
+  {
+    SPHERE,
+    BOX,
+    ELLIPSOID,
+    CYLINDER,
+    CAPSULE,
+    CONE,
+    PYRAMID,
+    RECTANGULAR_PYRAMID,
+    PLANE,
+    MULTISPHERE,
+    MESH,
+    SOFT_MESH,
+    LINE_SEGMENT,
+    HEIGHTMAP,
+    UNSUPPORTED
+  };
+
+  /// DataVariance can be used by renderers to determine whether it should
+  /// expect data for this shape to change during each update.
+  enum DataVariance
+  {
+    STATIC = 0, /// No data will ever change
+    DYNAMIC_TRANSFORM
+    = 1 << 1, /// The relative transform of the Shape might change
+    DYNAMIC_PRIMITIVE = 1 << 2, /// The primitive properties (such as x/y/z
+                                /// scaling) of the shape might change
+    DYNAMIC_COLOR
+    = 1 << 3, /// The coloring or textures of the shape might change
+    DYNAMIC_VERTICES
+    = 1 << 4, /// Vertex positions of a mesh might change (this does not include
+              /// adding or removing vertices) (this enum is not relevant for
+              /// primitive shapes)
+    DYNAMIC_ELEMENTS
+    = 1 << 5, /// The number of elements and/or arrangement of elements might
+              /// change (this includes adding and removing vertices)  (this
+              /// enum is not relevant for primitive shapes)
+    DYNAMIC = 0xFF /// All data is subject to changing
+  };
+
+  /// \brief Constructor
+  /// \deprecated Deprecated in 6.1. Please use getType() instead.
+  explicit Shape(ShapeType _type);
+
+  /// \brief Constructor
+  Shape();
+
+  /// \brief Destructor
+  virtual ~Shape();
+
+  /// Returns a string representing the shape type
+  /// \sa is()
+  virtual const std::string& getType() const = 0;
+
+  /// \brief Get the bounding box of the shape in its local coordinate frame.
+  ///        The dimension will be automatically determined by the sub-classes
+  ///        such as BoxShape, EllipsoidShape, CylinderShape, and MeshShape.
+  const math::BoundingBox& getBoundingBox() const;
+
+  /// Computes the inertia.
+  virtual Eigen::Matrix3d computeInertia(double mass) const = 0;
+
+  Eigen::Matrix3d computeInertiaFromDensity(double density) const;
+
+  Eigen::Matrix3d computeInertiaFromMass(double mass) const;
+
+  /// Returns volume of this shape.
+  ///
+  /// The volume will be automatically calculated by the sub-classes such as
+  /// BoxShape, EllipsoidShape, CylinderShape, and MeshShape.
+  double getVolume() const;
+
+  /// \brief
+  std::size_t getID() const;
+
+  /// \deprecated Deprecated in 6.1. Please use getType() instead.
+  DART_DEPRECATED(6.1)
+  ShapeType getShapeType() const;
+
+  /// Set the data variance of this shape. Use the DataVariance to indicate what
+  /// kind of shape information might change during run time so that renderers
+  /// can optimize reliably.
+  void setDataVariance(unsigned int _variance);
+
+  /// Add a type of variance to this shape. All other variance types will remain
+  /// the same.
+  void addDataVariance(unsigned int _variance);
+
+  /// Remove a type of variance from this shape. All other variance types will
+  /// remain the same.
+  void removeDataVariance(unsigned int _variance);
+
+  /// Get the data variance of this shape
+  unsigned int getDataVariance() const;
+
+  /// True iff this Shape has the specified type of DataVariance
+  bool checkDataVariance(DataVariance type) const;
+
+  /// Instruct this shape to update its data
+  virtual void refreshData();
+
+  /// Notify that the alpha of this shape has updated
+  DART_DEPRECATED(6.2)
+  virtual void notifyAlphaUpdate(double alpha);
+
+  /// Notify that the alpha of this shape has updated
+  virtual void notifyAlphaUpdated(double alpha);
+
+  /// Notify that the color (rgba) of this shape has updated
+  DART_DEPRECATED(6.2)
+  virtual void notifyColorUpdate(const Eigen::Vector4d& color);
+
+  /// Notify that the color (rgba) of this shape has updated
+  virtual void notifyColorUpdated(const Eigen::Vector4d& color);
+
+  /// Increment the version of this Shape and notify its subscribers
+  std::size_t incrementVersion() override final;
+
+  /// Deep copy shape
+  virtual ShapePtr clone() const = 0;
+
+protected:
+  /// Updates volume
+  virtual void updateVolume() const = 0;
+
+  /// Updates bounding box
+  virtual void updateBoundingBox() const = 0;
+
+  /// \brief The bounding box (in the local coordinate frame) of the shape.
+  mutable math::BoundingBox mBoundingBox;
+
+  /// Whether bounding box needs update
+  mutable bool mIsBoundingBoxDirty;
+
+  /// Volume enclosed by the geometry.
+  mutable double mVolume;
+
+  /// Whether volume needs update
+  mutable bool mIsVolumeDirty;
+
+  /// \brief Unique id.
+  const std::size_t mID;
+
+  /// The DataVariance of this Shape
+  unsigned int mVariance;
+
+  /// \brief
+  static std::atomic_int mCounter;
+
+  /// \deprecated Deprecated in 6.1. Please use getType() instead.
+  /// Type of primitive shpae.
+  ShapeType mType;
+
+private:
+  /// Triggered by incrementVersion()
+  VersionChangedSignal mVersionChangedSignal;
+
+public:
+  /// Use this to subscribe to version change signals
+  common::SlotRegister<VersionChangedSignal> onVersionChanged;
+};
+DART_DECLARE_CLASS_WITH_VIRTUAL_BASE_END
+
+} // namespace dynamics
+} // namespace dart
+
+#endif // DART_DYNAMICS_SHAPE_HPP_

include/dart/dynamics/ShapeFrame.hpp

@@ -0,0 +1,291 @@
+/*
+ * 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_SHAPEFRAME_HPP_
+#define DART_DYNAMICS_SHAPEFRAME_HPP_
+
+#include <dart/dynamics/EllipsoidShape.hpp>
+#include <dart/dynamics/FixedFrame.hpp>
+#include <dart/dynamics/TemplatedJacobianNode.hpp>
+#include <dart/dynamics/detail/ShapeFrameAspect.hpp>
+
+#include <dart/common/AspectWithVersion.hpp>
+#include <dart/common/Signal.hpp>
+#include <dart/common/SpecializedForAspect.hpp>
+
+#include <Eigen/Dense>
+
+namespace dart {
+namespace dynamics {
+
+//==============================================================================
+class VisualAspect final : public common::AspectWithVersionedProperties<
+                               VisualAspect,
+                               detail::VisualAspectProperties,
+                               ShapeFrame>
+{
+public:
+  using Base = common::AspectWithVersionedProperties<
+      VisualAspect,
+      detail::VisualAspectProperties,
+      ShapeFrame>;
+
+  /// Constructor
+  VisualAspect(const PropertiesData& properties = PropertiesData());
+
+  VisualAspect(const VisualAspect&) = delete;
+
+  /// Set RGBA color
+  void setRGBA(const Eigen::Vector4d& color);
+
+  DART_COMMON_GET_ASPECT_PROPERTY(Eigen::Vector4d, RGBA)
+  // const Eigen::Vector4d& getRGBA() const;
+
+  DART_COMMON_SET_GET_ASPECT_PROPERTY(bool, Hidden)
+  // void setHidden(const bool& value);
+  // const bool& getHidden() const;
+
+  DART_COMMON_SET_GET_ASPECT_PROPERTY(bool, Shadowed)
+  // void setShadowed(const bool& value);
+  // const bool& getShadowed() const;
+
+  /// Identical to setRGB(const Eigen::Vector3d&)
+  void setColor(const Eigen::Vector3d& color);
+
+  /// Identical to setRGBA(const Eigen::Vector4d&)
+  void setColor(const Eigen::Vector4d& color);
+
+  /// Set RGB color components (leave alpha alone)
+  void setRGB(const Eigen::Vector3d& rgb);
+
+  /// Set the transparency of the Shape
+  void setAlpha(const double alpha);
+
+  /// Get color
+  Eigen::Vector3d getColor() const;
+
+  /// Get RGB color components
+  Eigen::Vector3d getRGB() const;
+
+  /// Get the transparency of the Shape
+  double getAlpha() const;
+
+  /// Hide the ShapeNode
+  void hide();
+
+  /// Show the ShapeNode
+  void show();
+
+  /// True iff the ShapeNode is set to be hidden. Use hide(bool) to change this
+  /// setting
+  bool isHidden() const;
+};
+
+//==============================================================================
+class CollisionAspect final : public common::AspectWithVersionedProperties<
+                                  CollisionAspect,
+                                  detail::CollisionAspectProperties,
+                                  ShapeFrame>
+{
+public:
+  CollisionAspect(const CollisionAspect&) = delete;
+  CollisionAspect(const PropertiesData& properties = PropertiesData());
+
+  DART_COMMON_SET_GET_ASPECT_PROPERTY(bool, Collidable)
+  // void setCollidable(const bool& value);
+  // const bool& getCollidable() const;
+
+  /// Return true if this body can collide with others bodies
+  bool isCollidable() const;
+};
+
+//==============================================================================
+class DynamicsAspect final : public common::AspectWithVersionedProperties<
+                                 DynamicsAspect,
+                                 detail::DynamicsAspectProperties,
+                                 ShapeFrame>
+{
+public:
+  using Base = common::AspectWithVersionedProperties<
+      DynamicsAspect,
+      detail::DynamicsAspectProperties,
+      ShapeFrame>;
+
+  DynamicsAspect(const DynamicsAspect&) = delete;
+
+  DynamicsAspect(const PropertiesData& properties = PropertiesData());
+
+  /// Set both primary and secondary friction coefficients to the same value.
+  void setFrictionCoeff(const double& value);
+  /// Get average of primary and secondary friction coefficients.
+  double getFrictionCoeff() const;
+
+  // DART_COMMON_SET_GET_ASPECT_PROPERTY(double, PrimaryFrictionCoeff)
+  void setPrimaryFrictionCoeff(const double& value);
+  const double& getPrimaryFrictionCoeff() const;
+
+  DART_COMMON_SET_GET_ASPECT_PROPERTY(double, SecondaryFrictionCoeff)
+  // void setSecondaryFrictionCoeff(const double& value);
+  // const double& getSecondaryFrictionCoeff() const;
+  DART_COMMON_SET_GET_ASPECT_PROPERTY(double, RestitutionCoeff)
+  // void setRestitutionCoeff(const double& value);
+  // const double& getRestitutionCoeff() const;
+
+  /// Slip compliance parameters act as constraint force mixing (cfm)
+  /// for the friction constraints.
+  /// They start with a default value of -1.0 and will be ignored
+  /// in favor of the global default value unless explicitly
+  /// set to a positive value.
+  DART_COMMON_SET_GET_ASPECT_PROPERTY(double, PrimarySlipCompliance)
+  // void sePrimarytSlipCompliance(const double& value);
+  // const double& getPrimarySlipCompliance() const;
+  DART_COMMON_SET_GET_ASPECT_PROPERTY(double, SecondarySlipCompliance)
+  // void setSecondarySlipCompliance(const double& value);
+  // const double& getSecondarySlipCompliance() const;
+
+  /// Set the frame for interpreting the first friction direction vector.
+  /// The frame pointer defaults to nullptr, which is interpreted as this
+  /// ShapeFrame.
+  void setFirstFrictionDirectionFrame(const Frame* value);
+
+  /// Get the frame for the first friction direction vector.
+  const Frame* getFirstFrictionDirectionFrame() const;
+
+  DART_COMMON_SET_GET_ASPECT_PROPERTY(Eigen::Vector3d, FirstFrictionDirection)
+  // void setFirstFrictionDirection(const Eigen::Vector3d& value);
+  // const Eigen::Vector3d& getFirstFrictionDirection() const;
+};
+
+//==============================================================================
+DART_DECLARE_CLASS_WITH_VIRTUAL_BASE_BEGIN
+class ShapeFrame : public virtual common::VersionCounter,
+                   public detail::ShapeFrameCompositeBase,
+                   public virtual Frame
+{
+public:
+  friend class BodyNode;
+
+  using ShapeUpdatedSignal = common::Signal<void(
+      const ShapeFrame* thisShapeFrame,
+      const ShapePtr& oldShape,
+      const ShapePtr& newShape)>;
+
+  using RelativeTransformUpdatedSignal = common::Signal<void(
+      const ShapeFrame* thisShapeFrame,
+      const Eigen::Isometry3d& oldTransform,
+      const Eigen::Isometry3d& newTransform)>;
+
+  using UniqueProperties = AspectProperties;
+  using Properties = UniqueProperties;
+
+  /// Destructor
+  virtual ~ShapeFrame() override;
+
+  /// Set the UniqueProperties of this ShapeFrame
+  void setProperties(const UniqueProperties& properties);
+
+  /// Set the AspectProperties of this ShapeFrame
+  void setAspectProperties(const AspectProperties& properties);
+
+  const AspectProperties& getAspectProperties() const;
+
+  /// Set shape
+  void setShape(const ShapePtr& shape);
+
+  /// Return shape
+  ShapePtr getShape();
+
+  /// Return (const) shape
+  ConstShapePtr getShape() const;
+
+  DART_BAKE_SPECIALIZED_ASPECT(VisualAspect)
+
+  DART_BAKE_SPECIALIZED_ASPECT(CollisionAspect)
+
+  DART_BAKE_SPECIALIZED_ASPECT(DynamicsAspect)
+
+  // Documentation inherited
+  ShapeFrame* asShapeFrame() override;
+
+  // Documentation inherited
+  const ShapeFrame* asShapeFrame() const override;
+
+  /// Returns true if this Frame is a ShapeNode
+  bool isShapeNode() const;
+
+  /// Convert 'this' into a ShapeNode pointer if ShapeFrame is a ShapeNode,
+  /// otherwise return nullptr
+  virtual ShapeNode* asShapeNode();
+
+  /// Convert 'const this' into a ShapeNode pointer if ShapeFrame is a
+  /// ShapeNode, otherwise return nullptr.
+  ///
+  /// This should be preferred over performing a dynamic_cast when you want to
+  /// cast a ShapeFrame into a ShapeNode, because this method costs less.
+  virtual const ShapeNode* asShapeNode() const;
+
+protected:
+  /// Constructor
+  ShapeFrame(Frame* parent, const Properties& properties);
+
+  /// Constructor
+  ShapeFrame(Frame* parent, const ShapePtr& shape = nullptr);
+
+  /// Delegating constructor
+  ShapeFrame(const std::tuple<Frame*, Properties>& args);
+
+  /// Contains whether or not this is a ShapeNode
+  bool mAmShapeNode;
+
+  /// Shape updated signal
+  ShapeUpdatedSignal mShapeUpdatedSignal;
+
+  /// Relative transformation updated signal
+  RelativeTransformUpdatedSignal mRelativeTransformUpdatedSignal;
+
+  /// Connect to changes in the Shape version
+  common::Connection mConnectionForShapeVersionChange;
+
+public:
+  /// Slot register for shape updated signal
+  common::SlotRegister<ShapeUpdatedSignal> onShapeUpdated;
+
+  /// Slot register for relative transformation updated signal
+  common::SlotRegister<RelativeTransformUpdatedSignal>
+      onRelativeTransformUpdated;
+};
+DART_DECLARE_CLASS_WITH_VIRTUAL_BASE_END
+
+} // namespace dynamics
+} // namespace dart
+
+#endif // DART_DYNAMICS_SHAPEFRAME_HPP_