dartpy 7.0.0.dev0__cp312-cp312-manylinux_2_39_x86_64.whl

include/dart/gui/osg/InteractiveFrame.hpp

@@ -0,0 +1,170 @@
+/*
+ * 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_GUI_OSG_INTERACTIVEFRAME_HPP_
+#define DART_GUI_OSG_INTERACTIVEFRAME_HPP_
+
+#include <dart/dynamics/SimpleFrame.hpp>
+
+namespace dart {
+
+namespace dynamics {
+class MeshShape;
+} // namespace dynamics
+
+namespace gui {
+namespace osg {
+
+class InteractiveFrame;
+
+class InteractiveTool : public dart::dynamics::SimpleFrame
+{
+public:
+  enum Type
+  {
+
+    LINEAR = 0, /// Tool for linearly constrained translations
+    ANGULAR,    /// Tool for rotations
+    PLANAR,     /// Tool for planar translations
+
+    NUM_TYPES
+  };
+
+  InteractiveTool(
+      InteractiveFrame* frame, double defaultAlpha, const std::string& name);
+
+  /// Set this tool to be enabled or disabled
+  void setEnabled(bool enabled);
+
+  /// Returns true if this tool is enabled
+  bool getEnabled() const;
+
+  /// Set the alpha of this tool
+  void setAlpha(double alpha);
+
+  /// Reset the alpha of this tool back to its default value
+  void resetAlpha();
+
+  /// Set the default alpha for this tool. This alpha value will be
+  /// applied immediately if reset is true.
+  void setDefaultAlpha(double alpha, bool reset = true);
+
+  /// Get the default alpha setting for this tool
+  double getDefaultAlpha() const;
+
+  /// Get the InteractiveFrame that this tool belongs to
+  InteractiveFrame* getInteractiveFrame();
+
+  /// Get the InteractiveFrame that this tool belongs to
+  const InteractiveFrame* getInteractiveFrame() const;
+
+  dart::dynamics::SimpleFrame* addShapeFrame(
+      const dart::dynamics::ShapePtr& shape);
+
+  const std::vector<dart::dynamics::SimpleFrame*> getShapeFrames();
+
+  const std::vector<const dart::dynamics::SimpleFrame*> getShapeFrames() const;
+
+  void removeAllShapeFrames();
+
+protected:
+  std::vector<std::unique_ptr<dart::dynamics::SimpleFrame>> mSimpleFrames;
+
+  double mDefaultAlpha;
+
+  bool mEnabled;
+
+  InteractiveFrame* mInteractiveFrame;
+};
+
+class InteractiveFrame : public dart::dynamics::SimpleFrame
+{
+public:
+  DART_DEFINE_ALIGNED_SHARED_OBJECT_CREATOR(InteractiveFrame)
+
+  /// Constructor
+  InteractiveFrame(
+      dart::dynamics::Frame* referenceFrame,
+      const std::string& name = "interactive_frame",
+      const Eigen::Isometry3d& relativeTransform
+      = Eigen::Isometry3d::Identity(),
+      double size_scale = 0.2,
+      double thickness_scale = 2.0);
+
+  /// Destructor
+  virtual ~InteractiveFrame();
+
+  /// Recreate the visuals for this InteractiveFrame according to the specified
+  /// scales.
+  virtual void resizeStandardVisuals(
+      double size_scale = 0.2, double thickness_scale = 2.0);
+
+  /// Get the specified tool
+  InteractiveTool* getTool(InteractiveTool::Type tool, std::size_t coordinate);
+
+  /// Get the specified tool
+  const InteractiveTool* getTool(
+      InteractiveTool::Type tool, std::size_t coordinate) const;
+
+  dart::dynamics::SimpleFrame* addShapeFrame(
+      const dart::dynamics::ShapePtr& shape);
+
+  const std::vector<dart::dynamics::SimpleFrame*> getShapeFrames();
+
+  const std::vector<const dart::dynamics::SimpleFrame*> getShapeFrames() const;
+
+  void removeAllShapeFrames();
+
+protected:
+  /// Creates the standard visualization shapes for InteractiveFrames. Overload
+  /// this to create an InteractiveFrame with custom visualization shapes.
+  void createStandardVisualizationShapes(double size, double thickness);
+
+  /// Deletes all the visualization shapes held by the InteractiveFrame.
+  void deleteAllVisualizationShapes();
+
+  /// Delete all the tool entities belonging to this InteractiveFrame
+  void deleteAllTools();
+
+  /// Array of tools belonging to this InteractiveFrame
+  InteractiveTool* mTools[InteractiveTool::NUM_TYPES][3];
+
+  std::vector<std::unique_ptr<dart::dynamics::SimpleFrame>> mSimpleFrames;
+};
+
+typedef std::shared_ptr<InteractiveFrame> InteractiveFramePtr;
+
+} // namespace osg
+} // namespace gui
+} // namespace dart
+
+#endif // DART_GUI_OSG_INTERACTIVEFRAME_HPP_

include/dart/gui/osg/MouseEventHandler.hpp

@@ -0,0 +1,76 @@
+/*
+ * 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_GUI_OSG_MOUSEEVENTHANDLER_HPP_
+#define DART_GUI_OSG_MOUSEEVENTHANDLER_HPP_
+
+#include <dart/gui/osg/DefaultEventHandler.hpp>
+
+#include <dart/common/ClassWithVirtualBase.hpp>
+#include <dart/common/Observer.hpp>
+#include <dart/common/Subject.hpp>
+
+namespace dart {
+namespace gui {
+namespace osg {
+
+class DefaultEventHandler;
+
+DART_DECLARE_CLASS_WITH_VIRTUAL_BASE_BEGIN
+class MouseEventHandler : public virtual dart::common::Subject,
+                          public virtual dart::common::Observer
+{
+public:
+  friend class DefaultEventHandler;
+
+  inline MouseEventHandler() : mEventHandler(nullptr) {}
+
+  /// Overload this function to set behavior that will get triggered during a
+  /// mouse event
+  virtual void update() = 0;
+
+protected:
+  void handleDestructionNotification(const Subject* _subject) override
+  {
+    if (mEventHandler == _subject)
+      delete this;
+  }
+
+  DefaultEventHandler* mEventHandler;
+};
+DART_DECLARE_CLASS_WITH_VIRTUAL_BASE_END
+
+} // namespace osg
+} // namespace gui
+} // namespace dart
+
+#endif // DART_GUI_OSG_MOUSEEVENTHANDLER_HPP_

include/dart/gui/osg/RealTimeWorldNode.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_GUI_OSG_REALTIMEWORLDNODE_HPP_
+#define DART_GUI_OSG_REALTIMEWORLDNODE_HPP_
+
+#include <dart/gui/osg/WorldNode.hpp>
+
+#include <osg/Timer>
+
+namespace dart {
+namespace gui {
+namespace osg {
+
+class RealTimeWorldNode : public WorldNode
+{
+public:
+  /// Construct a world node that will attempt to run a simulation with close
+  /// to real-time playback. If a simulation is too computationally expensive,
+  /// the simulation might not be able to keep up with real time.
+  ///
+  /// \param[in] world
+  ///   The world to simulate
+  ///
+  /// \param[in] targetFrequency
+  ///   The expected refresh rate. The actual refresh rate may depend on your
+  ///   monitor and your computer's display settings.
+  ///
+  /// \param[in] targetRealTimeFactor
+  ///   This factor at which the simulation should run. A value of 1.0 (default)
+  ///   means it will try to run at real time. A value 2.0 means the simulation
+  ///   will try to run at double real time speed (fast-forward). A value of 0.5
+  ///   means the simulation will try to run at half of real-time speed (slowed
+  ///   down).
+  ///
+  /// \param[in] shadower
+  ///   The shading technique to use when rendering this world.
+  RealTimeWorldNode(
+      const std::shared_ptr<dart::simulation::World>& world = nullptr,
+      const ::osg::ref_ptr<osgShadow::ShadowTechnique>& shadower = nullptr,
+      double targetFrequency = 60.0,
+      double targetRealTimeFactor = 1.0);
+
+  /// Set the target refresh rate frequency
+  void setTargetFrequency(double targetFrequency);
+
+  /// Get the target refresh rate frequency
+  double getTargetFrequency() const;
+
+  /// Set the target real time factor
+  void setTargetRealTimeFactor(double targetRTF);
+
+  /// Get the target real time factor
+  double getTargetRealTimeFactor() const;
+
+  /// Get the real time factor that was achieved in the last refresh cycle. This
+  /// may be smaller than target real time factor, because the simulation may
+  /// not have had time to reach it.
+  double getLastRealTimeFactor() const;
+
+  /// Get the lowest real time factor that has been hit during the simulation.
+  double getLowestRealTimeFactor() const;
+
+  /// Get the highest real time factor that has been hit during the simulation.
+  double getHighestRealTimeFactor() const;
+
+  // Documentation inherited
+  void refresh() override;
+
+protected:
+  /// Reset each time the simulation is paused
+  bool mFirstRefresh;
+
+  /// Keeps track of the time between refreshes
+  ::osg::Timer mRefreshTimer;
+
+  /// The target for how much time should elapse between refreshes
+  double mTargetRealTimeLapse;
+
+  /// The target for how much simulation time should elapse between refreshes
+  double mTargetSimTimeLapse;
+
+  /// The RTF that was achieved in the last refresh cycle
+  double mLastRealTimeFactor;
+
+  /// The lowest RTF that has been achieved
+  double mLowestRealTimeFactor;
+
+  /// The highest RTF that has been achieved
+  double mHighestRealTimeFactor;
+};
+
+} // namespace osg
+} // namespace gui
+} // namespace dart
+
+#endif // DART_GUI_OSG_REALTIMEWORLDNODE_HPP_

include/dart/gui/osg/ShapeFrameNode.hpp

@@ -0,0 +1,117 @@
+/*
+ * 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_GUI_OSG_SHAPEFRAMENODE_HPP_
+#define DART_GUI_OSG_SHAPEFRAMENODE_HPP_
+
+#include <dart/config.hpp>
+
+#include <dart/dynamics/SmartPointer.hpp>
+
+#include <osg/MatrixTransform>
+
+#include <map>
+#include <memory>
+
+namespace dart {
+namespace dynamics {
+class ShapeFrame;
+class Entity;
+class Shape;
+} // namespace dynamics
+
+namespace gui {
+namespace osg {
+
+namespace render {
+class ShapeNode;
+} // namespace render
+
+class WorldNode;
+
+class ShapeFrameNode : public ::osg::MatrixTransform
+{
+public:
+  /// Create a ShapeFrameNode. If recursive is set to true, it will also create
+  /// nodes for all child Entities and child Frames
+  ShapeFrameNode(dart::dynamics::ShapeFrame* frame, WorldNode* worldNode);
+
+  /// Pointer to the ShapeFrame associated with this ShapeFrameNode
+  dart::dynamics::ShapeFrame* getShapeFrame(bool checkUtilization = false);
+
+  /// Pointer to the ShapeFrame associated with this ShapeFrameNode
+  const dart::dynamics::ShapeFrame* getShapeFrame(
+      bool checkUtilization = false) const;
+
+  WorldNode* getWorldNode();
+
+  const WorldNode* getWorldNode() const;
+
+  /// Update all rendering data for this ShapeFrame
+  ///
+  /// If shortCircuitIfUtilized is true, this will skip the refresh process if
+  /// mUtilized is set to true. clearUtilization() needs to be called before
+  /// this function if short circuiting is going to be used.
+  void refresh(bool shortCircuitIfUtilized = false);
+
+  /// True iff this ShapeFrameNode has been utilized on the latest update
+  bool wasUtilized() const;
+
+  /// Set mUtilized to false
+  void clearUtilization();
+
+protected:
+  virtual ~ShapeFrameNode();
+
+  void refreshShapeNode(const std::shared_ptr<dart::dynamics::Shape>& shape);
+
+  void createShapeNode(const std::shared_ptr<dart::dynamics::Shape>& shape);
+
+  /// Pointer to the ShapeFrame that this ShapeFrameNode is associated with
+  dart::dynamics::ShapeFrame* mShapeFrame;
+
+  /// Pointer to the WorldNode that this ShapeFrameNode belongs to
+  WorldNode* mWorldNode;
+
+  render::ShapeNode* mRenderShapeNode;
+
+  /// True iff this ShapeFrameNode has been utilized on the latest update.
+  /// If it has not, that is an indication that it is no longer being
+  /// used and should be deleted.
+  bool mUtilized;
+};
+
+} // namespace osg
+} // namespace gui
+} // namespace dart
+
+#endif // DART_GUI_OSG_SHAPEFRAMENODE_HPP_

include/dart/gui/osg/SupportPolygonVisual.hpp

@@ -0,0 +1,202 @@
+/*
+ * 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_GUI_OSG_SUPPORTPOLYGONVISUAL_HPP_
+#define DART_GUI_OSG_SUPPORTPOLYGONVISUAL_HPP_
+
+#include <dart/gui/osg/ShapeFrameNode.hpp>
+#include <dart/gui/osg/Viewer.hpp>
+
+#include <dart/dynamics/SmartPointer.hpp>
+
+#include <osg/Geode>
+
+namespace dart {
+namespace gui {
+namespace osg {
+
+/// Attach this to a Viewer in order to visualize the support polygon of a
+/// Skeleton
+class SupportPolygonVisual : public ViewerAttachment
+{
+public:
+  /// Visualize the support polygon of an entire Skeleton
+  SupportPolygonVisual(
+      const dart::dynamics::SkeletonPtr& skeleton = nullptr,
+      double elevation = 0.02);
+
+  /// Visualize the support polygon of a specific tree in a Skeleton
+  SupportPolygonVisual(
+      const dart::dynamics::SkeletonPtr& skeleton,
+      std::size_t treeIndex,
+      double elevation = 0.02);
+
+  /// Change the Skeleton that is being visualized
+  void setSkeleton(const dart::dynamics::SkeletonPtr& skeleton);
+
+  /// Get the Skeleton associated with this visual
+  dart::dynamics::SkeletonPtr getSkeleton() const;
+
+  /// Visualize the entire Skeleton
+  void visualizeWholeSkeleton();
+
+  /// Visualize a specific tree in the Skeleton
+  void visualizeTree(std::size_t treeIndex);
+
+  /// Change the elevation height at which the polygon is displayed
+  void setDisplayElevation(double elevation);
+
+  /// Get the elevation of display for the support polygon
+  double getDisplayElevation() const;
+
+  /// Display the support polygon
+  void displayPolygon(bool display);
+
+  /// Returns true if the support polygon is being displayed
+  bool isPolygonDisplayed() const;
+
+  /// Set the color of the support polygon
+  void setPolygonColor(const Eigen::Vector4d& color);
+
+  /// Get the color of the support polygon
+  Eigen::Vector4d getPolygonColor() const;
+
+  /// Display the centroid
+  void displayCentroid(bool display);
+
+  /// Returns true if the centroid is being displayed
+  bool isCentroidDisplayed() const;
+
+  /// Set the radius of the centroid visualization
+  void setCentroidRadius(double radius);
+
+  /// Get the radius of the centroid visualization
+  double getCentroidRadius() const;
+
+  /// Display the center of mass
+  void displayCenterOfMass(bool display);
+
+  /// Returns true if the center of mass is being displayed
+  bool isCenterOfMassDisplayed() const;
+
+  /// Set the radius of the center of mass visualization
+  void setCenterOfMassRadius(double radius);
+
+  /// Get the radius of the center of mass visualization
+  double getCenterOfMassRadius() const;
+
+  /// Set the color that will be used for the center of mass if its projection
+  /// is on the support polygon
+  void setValidCOMColor(const Eigen::Vector4d& color);
+
+  /// Get the color that will be used for the center of mass if its projection
+  /// is on the support polygon
+  const Eigen::Vector4d& getValidCOMColor() const;
+
+  /// Set the color that will be used for the center of mass if its projection
+  /// is NOT on the support polygon
+  void setInvalidCOMColor(const Eigen::Vector4d& color);
+
+  /// Get the color that will be used for the center of mass if its projection
+  /// is NOT on the support polygon
+  const Eigen::Vector4d& getInvalidCOMColor() const;
+
+  /// Update the support polygon visual
+  void refresh() override final;
+
+protected:
+  /// Initialize the memory used by this visual
+  void initialize();
+
+  /// Skeleton for this visual
+  dart::dynamics::WeakSkeletonPtr mSkeleton;
+
+  /// Tree index for this visual
+  std::size_t mTreeIndex;
+
+  /// Elevation that this visual should use
+  double mElevation;
+
+  /// Whether to display the polygon
+  bool mDisplayPolygon;
+
+  /// Whether to display the centroid
+  bool mDisplayCentroid;
+
+  /// SimpleFrame for the centroid
+  dart::dynamics::SimpleFramePtr mCentroid;
+
+  /// Radius to be used by the centroid
+  double mCentroidRadius;
+
+  /// Whether to display the center of mass
+  bool mDisplayCOM;
+
+  /// SimpleFrame for the center of mass
+  dart::dynamics::SimpleFramePtr mCom;
+
+  /// Radius to be used by the center of mass
+  double mComRadius;
+
+  /// Color to be used when COM is valid
+  Eigen::Vector4d mValidColor;
+
+  /// Color to be used when COM is invalid
+  Eigen::Vector4d mInvalidColor;
+
+  /// Color for the polygon
+  ::osg::ref_ptr<::osg::Vec4Array> mPolygonColor;
+
+  /// Geode to hold the polygon
+  ::osg::ref_ptr<::osg::Geode> mPolygonGeode;
+
+  /// Geometry to describe the polygon
+  ::osg::ref_ptr<::osg::Geometry> mPolygonGeom;
+
+  /// Vertices of the polygon
+  ::osg::ref_ptr<::osg::Vec3Array> mVertices;
+
+  /// Faces of the polygon
+  ::osg::ref_ptr<::osg::DrawElementsUShort> mFaces;
+
+  /// Node to render the centroid
+  ::osg::ref_ptr<ShapeFrameNode> mCentroidNode;
+
+  /// Node to render the COM
+  ::osg::ref_ptr<ShapeFrameNode> mComNode;
+};
+
+} // namespace osg
+} // namespace gui
+} // namespace dart
+
+#endif // DART_GUI_OSG_SUPPORTPOLYGONVISUAL_HPP_