dartpy 7.0.0.dev0__cp312-cp312-manylinux_2_39_x86_64.whl

include/dart/collision/CollisionOption.hpp

@@ -0,0 +1,71 @@
+/*
+ * 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_COLLISIONOPTION_HPP_
+#define DART_COLLISION_COLLISIONOPTION_HPP_
+
+#include <memory>
+
+#include <cstddef>
+
+namespace dart {
+namespace collision {
+
+class CollisionFilter;
+
+struct CollisionOption
+{
+  /// Flag whether the collision detector computes contact information (contact
+  /// point, normal, and penetration depth). If it is set to false, only the
+  /// result of that which pairs are colliding will be stored in the
+  /// CollisionResult without the contact information.
+  bool enableContact;
+
+  /// Maximum number of contacts to detect. Once the contacts are found up to
+  /// this number, the collision checking will terminate at that moment. Set
+  /// this to 1 for binary check.
+  std::size_t maxNumContacts;
+
+  /// CollisionFilter
+  std::shared_ptr<CollisionFilter> collisionFilter;
+
+  /// Constructor
+  CollisionOption(
+      bool enableContact = true,
+      std::size_t maxNumContacts = 1000u,
+      const std::shared_ptr<CollisionFilter>& collisionFilter = nullptr);
+};
+
+} // namespace collision
+} // namespace dart
+
+#endif // DART_COLLISION_COLLISIONOPTION_HPP_

include/dart/collision/CollisionResult.hpp

@@ -0,0 +1,109 @@
+/*
+ * 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_COLLISIONRESULT_HPP_
+#define DART_COLLISION_COLLISIONRESULT_HPP_
+
+#include <dart/collision/Contact.hpp>
+
+#include <unordered_set>
+#include <vector>
+
+namespace dart {
+
+namespace dynamics {
+
+class BodyNode;
+class ShapeFrame;
+
+} // namespace dynamics
+
+namespace collision {
+
+class CollisionResult
+{
+public:
+  /// Add one contact
+  void addContact(const Contact& contact);
+
+  /// Return number of contacts
+  std::size_t getNumContacts() const;
+
+  /// Return the index-th contact
+  Contact& getContact(std::size_t index);
+
+  /// Return (const) the index-th contact
+  const Contact& getContact(std::size_t index) const;
+
+  /// Return contacts
+  const std::vector<Contact>& getContacts() const;
+
+  /// Return the set of BodyNodes that are in collision
+  const std::unordered_set<const dynamics::BodyNode*>& getCollidingBodyNodes()
+      const;
+
+  /// Return the set of ShapeFrames that are in collision
+  const std::unordered_set<const dynamics::ShapeFrame*>&
+  getCollidingShapeFrames() const;
+
+  /// Returns true if the given BodyNode is in collision
+  bool inCollision(const dynamics::BodyNode* bn) const;
+
+  /// Returns true if the given ShapeFrame is in collision
+  bool inCollision(const dynamics::ShapeFrame* frame) const;
+
+  /// Return binary collision result
+  bool isCollision() const;
+
+  /// Implicitly converts this CollisionResult to the value of isCollision()
+  operator bool() const;
+
+  /// Clear all the contacts
+  void clear();
+
+protected:
+  void addObject(CollisionObject* object);
+
+  /// List of contact information for each contact
+  std::vector<Contact> mContacts;
+
+  /// Set of BodyNodes that are colliding
+  std::unordered_set<const dynamics::BodyNode*> mCollidingBodyNodes;
+
+  /// Set of ShapeFrames that are colliding
+  std::unordered_set<const dynamics::ShapeFrame*> mCollidingShapeFrames;
+};
+
+} // namespace collision
+} // namespace dart
+
+#endif // DART_COLLISION_COLLISIONRESULT_HPP_

include/dart/collision/Contact.hpp

@@ -0,0 +1,103 @@
+/*
+ * 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_CONTACT_HPP_
+#define DART_COLLISION_CONTACT_HPP_
+
+#include <dart/collision/SmartPointer.hpp>
+
+#include <dart/dynamics/SmartPointer.hpp>
+
+#include <Eigen/Dense>
+
+namespace dart {
+namespace collision {
+
+/// Contact information
+struct Contact
+{
+  /// Default constructor
+  Contact();
+
+  /// Contact point w.r.t. the world frame
+  Eigen::Vector3d point;
+
+  /// Contact normal vector from bodyNode2 to bodyNode1 w.r.t. the world frame
+  Eigen::Vector3d normal;
+
+  /// Contact force acting on bodyNode1 w.r.t. the world frame
+  ///
+  /// The contact force acting on bodyNode2 is -force, which is the opposite
+  /// direction of the force.
+  Eigen::Vector3d force;
+
+  /// First colliding collision object
+  CollisionObject* collisionObject1;
+
+  /// Second colliding collision object
+  CollisionObject* collisionObject2;
+
+  /// Penetration depth
+  double penetrationDepth;
+
+  // TODO(JS): triID1 will be deprecated when we don't use fcl_mesh
+  /// \brief
+  int triID1;
+
+  // TODO(JS): triID2 will be deprecated when we don't use fcl_mesh
+  /// \brief
+  int triID2;
+
+  // TODO(JS): userData is an experimental variable.
+  /// \brief User data.
+  void* userData;
+
+  /// Returns the epsilon to be used for determination of zero-length normal.
+  constexpr static double getNormalEpsilon();
+
+  /// Returns the squired epsilon to be used for determination of zero-length
+  /// normal.
+  constexpr static double getNormalEpsilonSquared();
+
+  /// Returns true if the length of a normal is less than the epsilon.
+  static bool isZeroNormal(const Eigen::Vector3d& normal);
+
+  /// Returns !isZeroNormal().
+  static bool isNonZeroNormal(const Eigen::Vector3d& normal);
+};
+
+} // namespace collision
+} // namespace dart
+
+#include <dart/collision/detail/Contact-impl.hpp>
+
+#endif // DART_COLLISION_CONTACT_HPP_

include/dart/collision/DistanceFilter.hpp

@@ -0,0 +1,66 @@
+/*
+ * 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_DISTANCEFILTER_HPP_
+#define DART_COLLISION_DISTANCEFILTER_HPP_
+
+namespace dart {
+
+namespace dynamics {
+class BodyNode;
+} // namespace dynamics
+
+namespace collision {
+
+class CollisionObject;
+
+struct DistanceFilter
+{
+  virtual bool needDistance(
+      const CollisionObject* object1, const CollisionObject* object2) const = 0;
+};
+
+struct BodyNodeDistanceFilter : DistanceFilter
+{
+  bool needDistance(
+      const CollisionObject* object1,
+      const CollisionObject* object2) const override;
+
+  bool areAdjacentBodies(
+      const dynamics::BodyNode* bodyNode1,
+      const dynamics::BodyNode* bodyNode2) const;
+};
+
+} // namespace collision
+} // namespace dart
+
+#endif // DART_COLLISION_DISTANCEFILTER_HPP_

include/dart/collision/DistanceOption.hpp

@@ -0,0 +1,80 @@
+/*
+ * 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_DISTANCE_OPTION_HPP_
+#define DART_COLLISION_DISTANCE_OPTION_HPP_
+
+#include <memory>
+
+#include <cstddef>
+
+namespace dart {
+namespace collision {
+
+struct DistanceFilter;
+
+struct DistanceOption
+{
+  /// Whether to calculate the nearest points.
+  ///
+  /// The default is false.
+  /// \sa DistanceResult::nearestPoint1, DistanceResult::nearestPoint2
+  bool enableNearestPoints;
+
+  /// Stopping criteria for distance calculation in broadphase.
+  ///
+  /// This option is used for early termination of distance calculate that stops
+  /// as soon as a distance is found that is equal to or less than the lower
+  /// bound. If you want to check all the shape pairs without the early
+  /// termination then set this value to -inf.
+  ///
+  /// The default value is 0.0.
+  double distanceLowerBound;
+
+  /// Distance filter for excluding ShapeFrame pairs from distance calculation
+  /// in broadphase.
+  ///
+  /// If nullptr, every pairs of ShapeFrames in the CollisionGroup(s) are
+  /// checked. The default is nullptr. \sa DistanceFilter
+  std::shared_ptr<DistanceFilter> distanceFilter;
+
+  /// Constructor
+  DistanceOption(
+      bool enableNearestPoints = false,
+      double distanceLowerBound = 0.0,
+      const std::shared_ptr<DistanceFilter>& distanceFilter = nullptr);
+};
+
+} // namespace collision
+} // namespace dart
+
+#endif // DART_COLLISION_DISTANCE_OPTION_HPP_

include/dart/collision/DistanceResult.hpp

@@ -0,0 +1,123 @@
+/*
+ * 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_DISTANCE_RESULT_HPP_
+#define DART_COLLISION_DISTANCE_RESULT_HPP_
+
+#include <Eigen/Dense>
+
+namespace dart {
+
+namespace dynamics {
+class ShapeFrame;
+} // namespace dynamics
+
+namespace collision {
+
+struct DistanceResult
+{
+  /// Minimum \b singed distance between the checked Shape pairs.
+  ///
+  /// If no shape pair was checked (the collision group was empty or all pairs
+  /// were excluded by the filter) then this value will be remained the default
+  /// value 0.0. You can check if a valid distance was found using
+  /// DistanceResult::found() that returns true when it's found.
+  ///
+  /// The result minimum distance is clamped by
+  /// DistanceOption::distanceLowerBound
+  /// (min. distance >= distance lower bound). You can still get the unclamped
+  /// distance from DistanceResult::unclampedMinDistance.
+  ///
+  /// If the minimum distance is negative value, that means the distance is
+  /// the negative penetration depth measured from the shapes that are in
+  /// collision.
+  double minDistance;
+
+  /// Unclamped minimum distance that is the first distance equal to or less
+  /// than DistanceOption::distanceLowerBound.
+  ///
+  /// \warning This value is implementation defined, which means the value could
+  /// be different depending on various factors (e.g., the collision detector
+  /// and even the version of the collision detector), and we don't intend this
+  /// value to be (reasonably) indentical over thoes factors. This valude is for
+  /// debugging purpose or advanced use.
+  double unclampedMinDistance;
+
+  /// First ShapeFrame of the minDistance
+  ///
+  /// If no shape pair was checked then shapeFrame1 will be nullptr.
+  const dynamics::ShapeFrame* shapeFrame1;
+
+  /// Second ShapeFrame of the minDistance
+  ///
+  /// If no shape pair was checked then shapeFrame2 will be nullptr.
+  const dynamics::ShapeFrame* shapeFrame2;
+
+  /// The nearest point on DistanceResult::shapeFrame1 expressed in the world
+  /// coordinates.
+  ///
+  /// The point is calculated only when DistanceOption::enableNearestPoints is
+  /// true.
+  ///
+  /// The distance between the two nearest points is equal to
+  /// unclampedMinDistance rather than minDistance.
+  Eigen::Vector3d nearestPoint1;
+
+  /// The nearest point on DistanceResult::shapeFrame2 expressed the world
+  /// coordinates.
+  ///
+  /// The point is calculated only when DistanceOption::enableNearestPoints is
+  /// true.
+  ///
+  /// The distance between the two nearest points is equal to
+  /// unclampedMinDistance rather than minDistance.
+  Eigen::Vector3d nearestPoint2;
+
+  /// Constructor
+  DistanceResult();
+
+  /// Clear the result
+  void clear();
+
+  /// Get true if the result is valid (at least one shape pair was checked
+  /// and the result values are good to use).
+  bool found() const;
+
+  /// Get true if the minimum distance was not clamped
+  /// (minDistance == unclampedMinDistance).
+  bool isMinDistanceClamped() const;
+};
+
+} // namespace collision
+} // namespace dart
+
+#endif // DART_COLLISION_DISTANCE_RESULT_HPP_

include/dart/collision/Option.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_COLLISION_OPTION_HPP_
+#define DART_COLLISION_OPTION_HPP_
+
+#pragma message(                                                               \
+    "This header has been deprecated in DART 6.1. "                            \
+    "Please include CollisionOption.hpp instead.")
+
+#include <dart/collision/CollisionOption.hpp>
+
+#endif // DART_COLLISION_OPTION_HPP_

include/dart/collision/RaycastOption.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_RAYCASTOPTION_HPP_
+#define DART_COLLISION_RAYCASTOPTION_HPP_
+
+#include <memory>
+
+#include <cstddef>
+
+namespace dart {
+namespace collision {
+
+struct RaycastOption
+{
+  /// Constructor
+  RaycastOption(bool enableAllHits = false, bool sortByClosest = false);
+
+  bool mEnableAllHits;
+
+  bool mSortByClosest;
+
+  // TODO(JS): Add filter
+};
+
+} // namespace collision
+} // namespace dart
+
+#endif // DART_COLLISION_RAYCASTOPTION_HPP_