dartpy 7.0.0.dev0__cp312-cp312-manylinux_2_39_x86_64.whl

include/dart/collision/ode/detail/OdeSphere.hpp

@@ -0,0 +1,58 @@
+/*
+ * 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_COLLISION_ODE_DETAIL_ODESPHERE_HPP_
+#define DART_COLLISION_ODE_DETAIL_ODESPHERE_HPP_
+
+#include <dart/collision/ode/detail/OdeGeom.hpp>
+
+#include <ode/ode.h>
+
+namespace dart {
+namespace collision {
+namespace detail {
+
+class OdeSphere : public OdeGeom
+{
+public:
+  /// Constructor
+  OdeSphere(const OdeCollisionObject* parent, double radius);
+
+  /// Destructor
+  virtual ~OdeSphere();
+};
+
+} // namespace detail
+} // namespace collision
+} // namespace dart
+
+#endif // DART_COLLISION_ODE_DETAIL_ODESPHERE_HPP_

include/dart/collision/ode/ode.hpp

@@ -0,0 +1,14 @@
+// Automatically generated file by cmake
+
+// DEPRECATED: This header is deprecated and will be removed in the next major release.
+// Please use <dart/collision/ode/all.hpp> instead of <dart/collision/ode/ode.hpp>
+
+#ifndef DART_SUPPRESS_DEPRECATED_HEADER_WARNING
+#if defined(_MSC_VER)
+#  pragma message("Warning: dart/collision/ode/ode.hpp is deprecated. Use dart/collision/ode/all.hpp instead.")
+#elif defined(__GNUC__) || defined(__clang__)
+#  warning "dart/collision/ode/ode.hpp is deprecated. Use dart/collision/ode/all.hpp instead."
+#endif
+#endif // DART_SUPPRESS_DEPRECATED_HEADER_WARNING
+
+#include "dart/collision/ode/all.hpp"

include/dart/common/Aspect.hpp

@@ -0,0 +1,215 @@
+/*
+ * 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_COMMON_ASPECT_HPP_
+#define DART_COMMON_ASPECT_HPP_
+
+#include <dart/common/ClassWithVirtualBase.hpp>
+#include <dart/common/Cloneable.hpp>
+#include <dart/common/detail/NoOp.hpp>
+
+#include <string>
+
+namespace dart {
+namespace common {
+
+class Composite;
+
+class Aspect
+{
+public:
+  friend class Composite;
+
+  /// If your Aspect has a State, then that State class should inherit this
+  /// Aspect::State class. This allows us to safely serialize, store, and clone
+  /// the states of arbitrary Aspect extensions. If your Aspect is stateless,
+  /// then you do not have to worry about extending this class, because
+  /// Aspect::getState() 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 Composite::State whereas Properties will get
+  /// stored in Composite::Properties. 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 Cloneable<State>
+  {
+  };
+
+  /// Use the MakeState class to easily create a State extension from an
+  /// existing class or struct.
+  template <class Mixin>
+  using MakeState = MakeCloneable<State, Mixin>;
+
+  /// If your Aspect has Properties, then that Properties class should inherit
+  /// this Aspect::Properties class. This allows us to safely serialize, store,
+  /// and clone the properties of arbitrary Aspect extensions. If your Aspect
+  /// has no properties, then you do not have to worry about extending this
+  /// class, because Aspect::getProperties() 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 Composite::State whereas Properties will get
+  /// stored in Composite::Properties. 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 Cloneable<Properties>
+  {
+  };
+
+  /// Use the MakeProperties class to easily create a Properties extension
+  /// from an existing class or struct.
+  template <class Mixin>
+  using MakeProperties = MakeCloneable<Properties, Mixin>;
+
+  /// Virtual destructor
+  virtual ~Aspect() = default;
+
+  /// Clone this Aspect into a new composite
+  virtual std::unique_ptr<Aspect> cloneAspect() const = 0;
+
+  /// Set the State of this Aspect. By default, this does nothing.
+  virtual void setAspectState(const State& otherState);
+
+  /// Get the State of this Aspect. By default, this returns a nullptr which
+  /// implies that the Aspect is stateless.
+  virtual const State* getAspectState() const;
+
+  /// Set the Properties of this Aspect. By default, this does nothing.
+  virtual void setAspectProperties(const Properties& someProperties);
+
+  /// Get the Properties of this Aspect. By default, this returns a nullptr
+  /// which implies that the Aspect has no properties.
+  virtual const Properties* getAspectProperties() const;
+
+protected:
+  /// This function will be triggered (1) after the Aspect has been created
+  /// [transfer will be false] and (2) after the Aspect has been transferred
+  /// to a new Composite [transfer will be true]. You should override this
+  /// function if your Aspect requires special handling in either of those
+  /// cases. By default, this function does nothing.
+  virtual void setComposite(Composite* newComposite);
+
+  /// This function will be triggered if your Aspect is about to be removed from
+  /// its Composite. While this function is being called, the Aspect is still a
+  /// valid part of the Composite; it will be removed immediately after this
+  /// function call. By default, this function does nothing.
+  virtual void loseComposite(Composite* oldComposite);
+};
+
+//==============================================================================
+template <class CompositeType>
+class CompositeTrackingAspect : public Aspect
+{
+public:
+  /// Default constructor
+  CompositeTrackingAspect();
+
+  /// Get the Composite of this Aspect
+  CompositeType* getComposite();
+
+  /// Get the Composite of this Aspect
+  const CompositeType* getComposite() const;
+
+  /// Returns true if this Aspect has a Composite that matches CompositeType
+  bool hasComposite() const;
+
+protected:
+  /// Grab the new Composite
+  void setComposite(Composite* newComposite) override;
+
+  /// Clear the old Composite
+  void loseComposite(Composite* oldComposite) override;
+
+  /// Pointer to the current Composite of this Aspect
+  CompositeType* mComposite;
+};
+
+} // namespace common
+} // namespace dart
+
+//==============================================================================
+#define DART_COMMON_ASPECT_PROPERTY_CONSTRUCTOR(                               \
+    ClassName, UpdatePropertiesMacro)                                          \
+  ClassName(const ClassName&) = delete;                                        \
+  inline ClassName(const PropertiesData& properties = PropertiesData())        \
+    : AspectWithVersionedProperties<                                           \
+        Base,                                                                  \
+        Derived,                                                               \
+        PropertiesData,                                                        \
+        CompositeType,                                                         \
+        UpdatePropertiesMacro>(properties)                                     \
+  {                                                                            \
+  }
+
+//==============================================================================
+#define DART_COMMON_ASPECT_STATE_PROPERTY_CONSTRUCTORS(ClassName)              \
+  ClassName(const ClassName&) = delete;                                        \
+  inline ClassName(                                                            \
+      const StateData& state = StateData(),                                    \
+      const PropertiesData& properties = PropertiesData())                     \
+    : AspectImpl(state, properties)                                            \
+  {                                                                            \
+  }                                                                            \
+  inline ClassName(                                                            \
+      const PropertiesData& properties, const StateData state = StateData())   \
+    : AspectImpl(properties, state)                                            \
+  {                                                                            \
+  }
+
+//==============================================================================
+#define DART_COMMON_SET_ASPECT_PROPERTY_CUSTOM(Type, Name, Update)             \
+  inline void set##Name(const Type& value)                                     \
+  {                                                                            \
+    mProperties.m##Name = value;                                               \
+    Update();                                                                  \
+  }
+
+//==============================================================================
+#define DART_COMMON_SET_ASPECT_PROPERTY(Type, Name)                            \
+  DART_COMMON_SET_ASPECT_PROPERTY_CUSTOM(Type, Name, notifyPropertiesUpdated)
+
+//==============================================================================
+#define DART_COMMON_GET_ASPECT_PROPERTY(Type, Name)                            \
+  inline const Type& get##Name() const                                         \
+  {                                                                            \
+    return mProperties.m##Name;                                                \
+  }
+
+//==============================================================================
+#define DART_COMMON_SET_GET_ASPECT_PROPERTY(Type, Name)                        \
+  DART_COMMON_SET_ASPECT_PROPERTY(Type, Name)                                  \
+  DART_COMMON_GET_ASPECT_PROPERTY(Type, Name)
+
+#include <dart/common/detail/Aspect.hpp>
+
+#endif // DART_COMMON_ASPECT_HPP_

include/dart/common/AspectWithVersion.hpp

@@ -0,0 +1,180 @@
+/*
+ * 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_COMMON_ASPECTWITHVERSION_HPP_
+#define DART_COMMON_ASPECTWITHVERSION_HPP_
+
+#include <dart/common/detail/AspectWithVersion.hpp>
+
+namespace dart {
+namespace common {
+
+//==============================================================================
+template <
+    class DerivedT,
+    typename StateDataT,
+    class CompositeT = Composite,
+    void (*updateState)(DerivedT*) = &detail::NoOp<DerivedT*>>
+using AspectWithState = detail::AspectWithState<
+    CompositeTrackingAspect<CompositeT>,
+    DerivedT,
+    StateDataT,
+    CompositeT,
+    updateState>;
+
+//==============================================================================
+template <
+    class DerivedT,
+    typename PropertiesDataT,
+    class CompositeT = Composite,
+    void (*updateProperties)(DerivedT*) = &detail::NoOp<DerivedT*>>
+using AspectWithVersionedProperties = detail::AspectWithVersionedProperties<
+    CompositeTrackingAspect<CompositeT>,
+    DerivedT,
+    PropertiesDataT,
+    CompositeT,
+    updateProperties>;
+
+//==============================================================================
+template <
+    class DerivedT,
+    typename StateDataT,
+    typename PropertiesDataT,
+    class CompositeT = Composite,
+    void (*updateState)(DerivedT*) = &detail::NoOp<DerivedT*>,
+    void (*updateProperties)(DerivedT*) = updateState>
+class AspectWithStateAndVersionedProperties
+  : public detail::AspectWithVersionedProperties<
+        AspectWithState<DerivedT, StateDataT, CompositeT, updateState>,
+        DerivedT,
+        PropertiesDataT,
+        CompositeT,
+        updateProperties>
+{
+public:
+  using Derived = DerivedT;
+  using StateData = StateDataT;
+  using PropertiesData = PropertiesDataT;
+  using CompositeType = CompositeT;
+  using State = common::Aspect::MakeState<StateData>;
+  using Properties = common::Aspect::MakeProperties<PropertiesData>;
+  constexpr static void (*UpdateState)(Derived*) = updateState;
+  constexpr static void (*UpdateProperties)(Derived*) = updateProperties;
+
+  using AspectStateImpl
+      = common::AspectWithState<Derived, StateData, CompositeType, updateState>;
+
+  using AspectPropertiesImpl = detail::AspectWithVersionedProperties<
+      AspectStateImpl,
+      Derived,
+      PropertiesData,
+      CompositeType,
+      updateProperties>;
+
+  using AspectImpl = AspectWithStateAndVersionedProperties<
+      DerivedT,
+      StateDataT,
+      PropertiesDataT,
+      CompositeT,
+      updateState,
+      updateProperties>;
+
+  AspectWithStateAndVersionedProperties(
+      const AspectWithStateAndVersionedProperties&)
+      = delete;
+
+  /// Construct using a StateData and a PropertiesData instance
+  AspectWithStateAndVersionedProperties(
+      const StateData& state = StateData(),
+      const PropertiesData& properties = PropertiesData())
+    : AspectPropertiesImpl(properties, state)
+  {
+    // Do nothing
+  }
+
+  /// Construct using a PropertiesData and a StateData instance
+  AspectWithStateAndVersionedProperties(
+      const PropertiesData& properties, const StateData& state = StateData())
+    : AspectPropertiesImpl(properties, state)
+  {
+    // Do nothing
+  }
+
+  // Documentation inherited
+  std::unique_ptr<Aspect> cloneAspect() const override
+  {
+    return std::make_unique<Derived>(this->getState(), this->getProperties());
+  }
+};
+
+//==============================================================================
+//
+// These namespace-level definitions are required to enable ODR-use of static
+// constexpr member variables.
+//
+// See this StackOverflow answer: http://stackoverflow.com/a/14396189/111426
+//
+template <
+    class DerivedT,
+    typename StateDataT,
+    typename PropertiesDataT,
+    class CompositeT,
+    void (*updateState)(DerivedT*),
+    void (*updateProperties)(DerivedT*)>
+constexpr void (*AspectWithStateAndVersionedProperties<
+                DerivedT,
+                StateDataT,
+                PropertiesDataT,
+                CompositeT,
+                updateState,
+                updateProperties>::UpdateState)(DerivedT*);
+
+//==============================================================================
+template <
+    class DerivedT,
+    typename StateDataT,
+    typename PropertiesDataT,
+    class CompositeT,
+    void (*updateState)(DerivedT*),
+    void (*updateProperties)(DerivedT*)>
+constexpr void (*AspectWithStateAndVersionedProperties<
+                DerivedT,
+                StateDataT,
+                PropertiesDataT,
+                CompositeT,
+                updateState,
+                updateProperties>::UpdateProperties)(DerivedT*);
+
+} // namespace common
+} // namespace dart
+
+#endif // DART_COMMON_ASPECTWITHVERSION_HPP_

include/dart/common/CAllocator.hpp

@@ -0,0 +1,65 @@
+/*
+ * 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_COMMON_CALLOCATOR_HPP_
+#define DART_COMMON_CALLOCATOR_HPP_
+
+#include <dart/common/MemoryAllocator.hpp>
+
+namespace dart::common {
+
+/// A stateless memory allocator (in release mode) that uses std::malloc and
+/// std::free for memory allocation and deallocation.
+class CAllocator : public MemoryAllocator
+{
+public:
+  /// Constructor
+  CAllocator() noexcept;
+
+  /// Destructor
+  ~CAllocator() override;
+
+  DART_STRING_TYPE(CAllocator);
+
+  // Documentation inherited
+  [[nodiscard]] void* allocate(size_t bytes) noexcept override;
+
+  // Documentation inherited
+  void deallocate(void* pointer, size_t bytes) override;
+
+  // Documentation inherited
+  void print(std::ostream& os = std::cout, int indent = 0) const override;
+};
+
+} // namespace dart::common
+
+#endif // DART_COMMON_CALLOCATOR_HPP_

include/dart/common/Castable.hpp

@@ -0,0 +1,102 @@
+/*
+ * 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_COMMON_CASTABLE_HPP_
+#define DART_COMMON_CASTABLE_HPP_
+
+#include <string>
+
+#define DART_STRING_TYPE(type_name)                                            \
+  /** Returns type string. */                                                  \
+  [[nodiscard]] static const std::string& getStaticType()                      \
+  {                                                                            \
+    static const std::string type = #type_name;                                \
+    return type;                                                               \
+  }                                                                            \
+                                                                               \
+  [[nodiscard]] const std::string& getType() const override                    \
+  {                                                                            \
+    return getStaticType();                                                    \
+  }                                                                            \
+  void _ANONYMOUS_FUNCTION_1()
+
+namespace dart::common {
+
+/// A CRTP base class that provides an interface for easily casting to the
+/// derived types.
+template <typename Base>
+class Castable
+{
+public:
+  /// Returns true if the types of this \c Base and the template parameter (a
+  /// base class) are identical. This function is a syntactic sugar, which
+  /// is identical to: (getType() == ShapeType::getStaticType()).
+  ///
+  /// Example code:
+  /// \code
+  /// if (shape->is<Sphere>())
+  ///   std::cout << "The shape type is sphere!\n";
+  /// \endcode
+  template <typename Derived>
+  [[nodiscard]] bool is() const;
+
+  /// Casts to pointer of Derived if Base is its base class. Returns nullptr
+  /// otherwise.
+  template <typename Derived>
+  [[nodiscard]] const Derived* as() const;
+
+  /// Casts to pointer of Derived if Base is its base class. Returns nullptr
+  /// otherwise.
+  template <typename Derived>
+  [[nodiscard]] Derived* as();
+
+  /// Casts to reference of Derived if Base is its base class. UB otherwise.
+  template <typename Derived>
+  [[nodiscard]] const Derived& asRef() const;
+
+  /// Casts to reference of Derived if Base is its base class. UB otherwise.
+  template <typename Derived>
+  [[nodiscard]] Derived& asRef();
+
+private:
+  /// Casts to Base const-reference
+  [[nodiscard]] const Base& base() const;
+
+  /// Casts to Base reference
+  [[nodiscard]] Base& base();
+};
+
+} // namespace dart::common
+
+#include <dart/common/detail/Castable-impl.hpp>
+
+#endif // DART_COMMON_CASTABLE_HPP_

include/dart/common/ClassWithVirtualBase.hpp

@@ -0,0 +1,47 @@
+/*
+ * 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_COMMON_CLASSWITHVIRTUALBASE_HPP_
+#define DART_COMMON_CLASSWITHVIRTUALBASE_HPP_
+
+// This macro is used to mark all the class that inherit
+// virtually from another to avoid problems on MSVC
+// See https://github.com/dartsim/dart/issues/1522
+#if defined(_MSC_VER)
+  #define DART_DECLARE_CLASS_WITH_VIRTUAL_BASE_BEGIN __pragma(vtordisp(push, 2))
+  #define DART_DECLARE_CLASS_WITH_VIRTUAL_BASE_END __pragma(vtordisp(pop))
+#else
+  #define DART_DECLARE_CLASS_WITH_VIRTUAL_BASE_BEGIN
+  #define DART_DECLARE_CLASS_WITH_VIRTUAL_BASE_END
+#endif
+
+#endif // DART_COMMON_CLASSWITHVIRTUALBASE_HPP_