dartpy 7.0.0.dev0__cp313-cp313-manylinux_2_39_x86_64.whl

share/doc/dart/examples/rigid_shapes/README.md

@@ -0,0 +1,19 @@
+This project is dependent on DART. Please make sure a proper version of DART is
+installed before building this project.
+
+## Build Instructions
+
+From this directory:
+
+    $ mkdir build
+    $ cd build
+    $ cmake ..
+    $ make
+
+## Execute Instructions
+
+Launch the executable from the build directory above:
+
+    $ ./{generated_executable}
+
+Follow the instructions detailed in the console.

share/doc/dart/examples/rigid_shapes/main.cpp

@@ -0,0 +1,250 @@
+/*
+ * 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 code incorporates portions of Open Dynamics Engine
+ *     (Copyright (c) 2001-2004, Russell L. Smith. All rights
+ *     reserved.) and portions of FCL (Copyright (c) 2011, Willow
+ *     Garage, Inc. All rights reserved.), which were released under
+ *     the same BSD license as below
+ *
+ *   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.
+ */
+
+#include <dart/gui/osg/osg.hpp>
+
+#include <dart/utils/utils.hpp>
+
+#include <dart/dart.hpp>
+
+#include <fcl/config.h>
+
+#include <iostream>
+
+using namespace dart::common;
+using namespace dart::dynamics;
+using namespace dart::simulation;
+using namespace dart::gui;
+using namespace dart::gui::osg;
+using namespace dart::utils;
+using namespace dart::math;
+
+class RigidShapesEventHandler : public ::osgGA::GUIEventHandler
+{
+public:
+  RigidShapesEventHandler(const WorldPtr& world) : mWorld(world) {}
+
+  bool handle(
+      const ::osgGA::GUIEventAdapter& ea, ::osgGA::GUIActionAdapter&) override
+  {
+    if (ea.getEventType() == ::osgGA::GUIEventAdapter::KEYDOWN) {
+      switch (ea.getKey()) {
+        case 'q':
+        case 'Q':
+          spawnBox(
+              getRandomTransform(),
+              Random::uniform<Eigen::Vector3d>(0.05, 0.25));
+          return true;
+        case 'w':
+        case 'W':
+          spawnEllipsoid(
+              getRandomTransform(),
+              Random::uniform<Eigen::Vector3d>(0.025, 0.125));
+          return true;
+        case 'e':
+        case 'E': {
+          const double radius = Random::uniform(0.05, 0.25);
+          const double height = Random::uniform(0.1, 0.5);
+          spawnCylinder(getRandomTransform(), radius, height);
+          return true;
+        }
+        case 'a':
+        case 'A':
+          if (mWorld->getNumSkeletons() > 1) {
+            mWorld->removeSkeleton(
+                mWorld->getSkeleton(mWorld->getNumSkeletons() - 1));
+          }
+          return true;
+        default:
+          return false;
+      }
+    }
+    return false;
+  }
+
+private:
+  Eigen::Isometry3d getRandomTransform()
+  {
+    Eigen::Isometry3d T = Eigen::Isometry3d::Identity();
+
+    const Eigen::Vector3d rotation
+        = Random::uniform<Eigen::Vector3d>(-constantsd::pi(), constantsd::pi());
+    const Eigen::Vector3d position = Eigen::Vector3d(
+        Random::uniform(-1.0, 1.0),
+        Random::uniform(0.5, 1.0),
+        Random::uniform(-1.0, 1.0));
+
+    T.translation() = position;
+    T.linear() = expMapRot(rotation);
+
+    return T;
+  }
+
+  void spawnBox(
+      const Eigen::Isometry3d& _T,
+      const Eigen::Vector3d& _size,
+      double _mass = 10)
+  {
+    SkeletonPtr newSkeleton = Skeleton::create();
+
+    ShapePtr newShape(new BoxShape(_size));
+
+    BodyNode::Properties bodyProp;
+    bodyProp.mName = "box_link";
+    bodyProp.mInertia.setMass(_mass);
+
+    FreeJoint::Properties jointProp;
+    jointProp.mName = "box_joint";
+    jointProp.mT_ParentBodyToJoint = _T;
+
+    auto pair = newSkeleton->createJointAndBodyNodePair<FreeJoint>(
+        nullptr, jointProp, bodyProp);
+    auto shapeNode = pair.second->createShapeNodeWith<
+        VisualAspect,
+        CollisionAspect,
+        DynamicsAspect>(newShape);
+    shapeNode->getVisualAspect()->setColor(
+        Random::uniform<Eigen::Vector3d>(0.0, 1.0));
+
+    mWorld->addSkeleton(newSkeleton);
+  }
+
+  void spawnEllipsoid(
+      const Eigen::Isometry3d& _T,
+      const Eigen::Vector3d& _radii,
+      double _mass = 10)
+  {
+    SkeletonPtr newSkeleton = Skeleton::create();
+
+    ShapePtr newShape(new EllipsoidShape(_radii * 2.0));
+
+    BodyNode::Properties bodyProp;
+    bodyProp.mName = "ellipsoid_link";
+    bodyProp.mInertia.setMass(_mass);
+
+    FreeJoint::Properties jointProp;
+    jointProp.mName = "ellipsoid_joint";
+    jointProp.mT_ParentBodyToJoint = _T;
+
+    auto pair = newSkeleton->createJointAndBodyNodePair<FreeJoint>(
+        nullptr, jointProp, bodyProp);
+    auto shapeNode = pair.second->createShapeNodeWith<
+        VisualAspect,
+        CollisionAspect,
+        DynamicsAspect>(newShape);
+    shapeNode->getVisualAspect()->setColor(
+        Random::uniform<Eigen::Vector3d>(0.0, 1.0));
+
+    mWorld->addSkeleton(newSkeleton);
+  }
+
+  void spawnCylinder(
+      const Eigen::Isometry3d& _T,
+      double _radius,
+      double _height,
+      double _mass = 10)
+  {
+    SkeletonPtr newSkeleton = Skeleton::create();
+
+    ShapePtr newShape(new CylinderShape(_radius, _height));
+
+    BodyNode::Properties bodyProp;
+    bodyProp.mName = "cylinder_link";
+    bodyProp.mInertia.setMass(_mass);
+
+    FreeJoint::Properties jointProp;
+    jointProp.mName = "cylinder_joint";
+    jointProp.mT_ParentBodyToJoint = _T;
+
+    auto pair = newSkeleton->createJointAndBodyNodePair<FreeJoint>(
+        nullptr, jointProp, bodyProp);
+    auto shapeNode = pair.second->createShapeNodeWith<
+        VisualAspect,
+        CollisionAspect,
+        DynamicsAspect>(newShape);
+    shapeNode->getVisualAspect()->setColor(
+        Random::uniform<Eigen::Vector3d>(0.0, 1.0));
+
+    mWorld->addSkeleton(newSkeleton);
+  }
+
+protected:
+  WorldPtr mWorld;
+};
+
+class CustomWorldNode : public RealTimeWorldNode
+{
+public:
+  CustomWorldNode(const WorldPtr& world) : RealTimeWorldNode(world) {}
+
+  void customPreStep() override {}
+};
+
+int main()
+{
+  WorldPtr myWorld = SkelParser::readWorld("dart://sample/skel/shapes.skel");
+  assert(myWorld != nullptr);
+
+  auto handler = new RigidShapesEventHandler(myWorld);
+
+  ::osg::ref_ptr<CustomWorldNode> node = new CustomWorldNode(myWorld);
+
+  auto viewer = Viewer();
+  viewer.addWorldNode(node);
+  viewer.addEventHandler(handler);
+
+  viewer.addInstructionText("space bar: simulation on/off\n");
+  viewer.addInstructionText("'q': spawn a random cube\n");
+  viewer.addInstructionText("'w': spawn a random ellipsoid\n");
+  viewer.addInstructionText("'e': spawn a random cylinder\n");
+  viewer.addInstructionText("'a': delete a spawned object at last\n");
+  std::cout << viewer.getInstructions() << std::endl;
+
+  viewer.setUpViewInWindow(0, 0, 640, 480);
+
+  viewer.getCameraManipulator()->setHomePosition(
+      ::osg::Vec3(2.0f, 2.0f, 2.0f),
+      ::osg::Vec3(0.0f, 0.0f, 0.0f),
+      ::osg::Vec3(0.0f, 0.0f, 1.0f));
+
+  viewer.setCameraManipulator(viewer.getCameraManipulator());
+
+  viewer.run();
+
+  return 0;
+}

share/doc/dart/examples/simple_frames/CMakeLists.txt

@@ -0,0 +1,19 @@
+cmake_minimum_required(VERSION 3.22.1)
+
+get_filename_component(example_name ${CMAKE_CURRENT_LIST_DIR} NAME)
+
+project(${example_name})
+
+set(required_components utils-urdf gui-osg)
+set(required_libraries dart dart-utils-urdf dart-gui-osg)
+
+if(DART_IN_SOURCE_BUILD)
+  dart_build_example_in_source(${example_name} LINK_LIBRARIES ${required_libraries})
+  return()
+endif()
+
+find_package(DART 6.15.0 REQUIRED COMPONENTS ${required_components} CONFIG)
+
+file(GLOB srcs "*.cpp" "*.hpp")
+add_executable(${example_name} ${srcs})
+target_link_libraries(${example_name} PUBLIC ${required_libraries})

share/doc/dart/examples/simple_frames/README.md

@@ -0,0 +1,27 @@
+This project is dependent on DART. Please make sure a proper version of DART is
+installed before building this project.
+
+## Build Instructions
+
+From this directory:
+
+    $ mkdir build
+    $ cd build
+    $ cmake ..
+    $ make
+
+## Execute Instructions
+
+Launch the executable from the build directory above:
+
+    $ ./{generated_executable}
+
+This example demonstrates how to create and visualize simple frames using the OSG
+renderer in DART. It shows various geometric shapes (boxes, ellipsoids, arrows)
+attached to different coordinate frames with different transformations applied.
+
+Key features demonstrated:
+- Creating SimpleFrame objects with different transformations
+- Attaching shapes to frames
+- Frame hierarchy and relative transformations
+- OSG-based visualization

share/doc/dart/examples/simple_frames/main.cpp

@@ -0,0 +1,124 @@
+/*
+ * 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.
+ */
+
+#include <dart/gui/osg/osg.hpp>
+
+#include <dart/dart.hpp>
+
+using namespace dart::dynamics;
+using namespace dart::gui;
+using namespace dart::gui::osg;
+
+int main()
+{
+  dart::simulation::WorldPtr myWorld(new dart::simulation::World);
+
+  Eigen::Isometry3d tf1(Eigen::Isometry3d::Identity());
+  tf1.translate(Eigen::Vector3d(0.1, -0.1, 0));
+
+  Eigen::Isometry3d tf2(Eigen::Isometry3d::Identity());
+  tf2.translate(Eigen::Vector3d(0, 0.1, 0));
+  tf2.rotate(
+      Eigen::AngleAxisd(dart::math::toRadian(45.0), Eigen::Vector3d(1, 0, 0)));
+
+  Eigen::Isometry3d tf3(Eigen::Isometry3d::Identity());
+  tf3.translate(Eigen::Vector3d(0, 0, 0.1));
+  tf3.rotate(
+      Eigen::AngleAxisd(dart::math::toRadian(60.0), Eigen::Vector3d(0, 1, 0)));
+
+  SimpleFramePtr F1(new SimpleFrame(Frame::World(), "F1", tf1));
+  F1->setShape(
+      std::shared_ptr<Shape>(new BoxShape(Eigen::Vector3d(0.05, 0.05, 0.02))));
+  SimpleFrame F2(F1.get(), "F2", tf2);
+  F2.setShape(
+      std::shared_ptr<Shape>(new BoxShape(Eigen::Vector3d(0.05, 0.05, 0.02))));
+  SimpleFrame F3(&F2, "F3", tf3);
+  F3.setShape(
+      std::shared_ptr<Shape>(new BoxShape(Eigen::Vector3d(0.05, 0.05, 0.02))));
+
+  // Note: Adding a Frame to the world will also cause all Entities that descend
+  // from that Frame to be rendered.
+  myWorld->addSimpleFrame(F1);
+
+  SimpleFramePtr A(new SimpleFrame(Frame::World(), "A"));
+  A->setShape(std::shared_ptr<Shape>(
+      new EllipsoidShape(Eigen::Vector3d(0.02, 0.02, 0.02))));
+  SimpleFrame A1(A.get(), "A1", F1->getTransform(A.get()));
+  A1.setShape(std::shared_ptr<Shape>(
+      new EllipsoidShape(Eigen::Vector3d(0.01, 0.01, 0.01))));
+  SimpleFrame A2(A.get(), "A2", F2.getTransform(A.get()));
+  A2.setShape(std::shared_ptr<Shape>(
+      new EllipsoidShape(Eigen::Vector3d(0.01, 0.01, 0.01))));
+  SimpleFrame A3(A.get(), "A3", F3.getTransform(A.get()));
+  A3.setShape(std::shared_ptr<Shape>(
+      new EllipsoidShape(Eigen::Vector3d(0.01, 0.01, 0.01))));
+
+  myWorld->addSimpleFrame(A);
+
+  SimpleFramePtr arrow(new SimpleFrame(Frame::World(), "arrow"));
+  arrow->setShape(std::shared_ptr<Shape>(new ArrowShape(
+      Eigen::Vector3d(0.1, -0.1, 0.0),
+      Eigen::Vector3d(0.1, 0.0, 0.0),
+      ArrowShape::Properties(0.002, 1.8),
+      Eigen::Vector4d(1.0, 0.5, 0.5, 1.0))));
+  myWorld->addSimpleFrame(arrow);
+
+  // CAREFUL: For a Frame that gets added to the world to be
+  // rendered correctly, it must be a child of the World Frame
+  // TODO(MXG): Fix this issue ^
+
+  // Create a WorldNode and wrap it around the world
+  ::osg::ref_ptr<dart::gui::osg::RealTimeWorldNode> node
+      = new dart::gui::osg::RealTimeWorldNode(myWorld);
+
+  // Create a Viewer and set it up with the WorldNode
+  auto viewer = Viewer();
+  viewer.addWorldNode(node);
+
+  // Set up the window to be 640x480
+  viewer.setUpViewInWindow(0, 0, 640, 480);
+
+  // Adjust the viewpoint of the Viewer
+  viewer.getCameraManipulator()->setHomePosition(
+      ::osg::Vec3(2.0f, 1.0f, 2.0f),
+      ::osg::Vec3(0.0f, 0.0f, 0.0f),
+      ::osg::Vec3(0.0f, 0.0f, 1.0f));
+
+  // We need to re-dirty the CameraManipulator by passing it into the viewer
+  // again, so that the viewer knows to update its HomePosition setting
+  viewer.setCameraManipulator(viewer.getCameraManipulator());
+
+  // Begin running the application loop
+  viewer.run();
+
+  return 0;
+}

share/doc/dart/examples/simulation_event_handler/CMakeLists.txt

@@ -0,0 +1,19 @@
+cmake_minimum_required(VERSION 3.22.1)
+
+get_filename_component(example_name ${CMAKE_CURRENT_LIST_DIR} NAME)
+
+project(${example_name})
+
+set(required_components gui-osg)
+set(required_libraries dart dart-gui-osg)
+
+if(DART_IN_SOURCE_BUILD)
+  dart_build_example_in_source(${example_name} LINK_LIBRARIES ${required_libraries})
+  return()
+endif()
+
+find_package(DART 6.15.0 REQUIRED COMPONENTS ${required_components} CONFIG)
+
+file(GLOB srcs "*.cpp" "*.hpp")
+add_executable(${example_name} ${srcs})
+target_link_libraries(${example_name} PUBLIC ${required_libraries})

share/doc/dart/examples/simulation_event_handler/README.md

@@ -0,0 +1,189 @@
+# Simulation Event Handler
+
+This example demonstrates a comprehensive event handler class that replaces the functionality typically found in `MyWindow.cpp` files in physics simulation applications. The `SimulationEventHandler` provides a complete solution for interactive rigid body physics simulation control.
+
+## Features
+
+### 1. Force Application on Rigid Bodies
+- Apply forces to selected rigid bodies in world coordinates
+- Real-time force magnitude adjustment
+- Support for both translational forces and rotational torques
+- Forces applied at the center of mass of selected bodies
+
+### 2. Keyboard Interaction for Simulation Control
+- **Simulation Control**: Play/pause, step-by-step execution, reset
+- **Body Selection**: Navigate through all rigid bodies in the scene
+- **Force Application**: Arrow keys for linear forces, QWEAZC keys for torques
+- **Parameter Adjustment**: Real-time modification of force magnitudes and time steps
+- **Visualization Control**: Toggle force arrow visualization
+
+### 3. Arrow Visualization
+- Red arrows showing applied forces in real-time
+- Arrows scale with force magnitude and direction
+- Arrows automatically clear after each application
+- Toggle on/off visualization for performance
+
+### 4. Time Stepping Logic
+- Configurable simulation time step
+- Real-time time step adjustment during simulation
+- Step-by-step simulation for debugging
+- Automatic integration with DART's physics engine
+
+## Controls
+
+### Simulation Control
+- **Space**: Toggle simulation play/pause
+- **S**: Step simulation one frame forward
+- **R**: Reset simulation to initial state
+
+### Body Selection
+- **Tab**: Select next rigid body
+- **Backspace**: Select previous rigid body
+
+### Force Application (on selected body)
+- **Arrow Keys**: Apply forces in X/Y directions
+- **U**: Apply upward force (+Z direction)
+- **D**: Apply downward force (-Z direction)
+
+### Torque Application (on selected body)
+- **Q/A**: Apply torque around X axis (+/-)
+- **W/Z**: Apply torque around Y axis (+/-)
+- **E/C**: Apply torque around Z axis (+/-)
+
+### Parameter Adjustment
+- **+/=**: Increase force/torque magnitude
+- **-/_**: Decrease force/torque magnitude
+- **>/.**: Increase simulation time step
+- **</, **: Decrease simulation time step
+
+### Visualization
+- **V**: Toggle force arrow visualization
+
+### Information
+- **I**: Print current simulation state
+- **H/?**: Show detailed help
+
+## Usage
+
+### Basic Usage
+
+```cpp
+#include "SimulationEventHandler.hpp"
+
+// Create physics world
+WorldPtr world = World::create();
+world->setGravity(Eigen::Vector3d(0.0, 0.0, -9.81));
+
+// Add rigid bodies to the world
+// ... (create and add skeletons)
+
+// Create viewer
+dart::gui::osg::Viewer viewer;
+
+// Create event handler
+SimulationEventHandler* handler = new SimulationEventHandler(world, &viewer);
+
+// Set up viewer
+viewer.addEventHandler(handler);
+viewer.run();
+```
+
+### Advanced Usage
+
+```cpp
+// Customize event handler behavior
+handler->setTimeStep(0.0005);           // Set smaller time step
+handler->setForceMagnitude(200.0);      // Set higher force magnitude
+handler->setShowForceArrows(false);     // Disable arrow visualization
+
+// Update in custom render loop
+void customRenderLoop() {
+  handler->update();  // Call each frame for arrow updates
+  // ... other rendering code
+}
+```
+
+## Implementation Details
+
+### Architecture
+- **Header File**: `SimulationEventHandler.hpp` - Class declaration and interface
+- **Implementation**: `SimulationEventHandler.cpp` - Full functionality implementation
+- **Demo**: `main.cpp` - Example usage with sample rigid bodies
+
+### Key Components
+1. **Event Handling**: Inherits from `osgGA::GUIEventHandler` for OSG integration
+2. **Force System**: Manages force/torque application with visual feedback
+3. **Body Management**: Automatic detection and selection of rigid bodies
+4. **Visualization**: OpenSceneGraph-based arrow rendering system
+5. **State Management**: Tracks simulation state and user preferences
+
+### Performance Considerations
+- Arrow visualization updates only every 5 frames to reduce overhead
+- Automatic cleanup of visualization objects
+- Efficient rigid body detection and caching
+- Memory-safe OSG object management
+
+## Building
+
+This example is integrated with the DART build system:
+
+```bash
+# From DART root directory
+mkdir build && cd build
+cmake ..
+make simulation_event_handler
+
+# Run the example
+./bin/simulation_event_handler
+```
+
+## Extending the Event Handler
+
+The `SimulationEventHandler` class is designed to be easily extensible:
+
+### Adding New Controls
+```cpp
+// In handle() method, add new key cases:
+case 'n':  // Custom action
+  performCustomAction();
+  return true;
+```
+
+### Custom Force Application
+```cpp
+// Override or extend force application methods:
+void applyCustomForce(const Eigen::Vector3d& direction) {
+  if (mSelectedBody) {
+    Eigen::Vector3d customForce = computeCustomForce(direction);
+    mSelectedBody->addExtForce(customForce);
+  }
+}
+```
+
+### Additional Visualizations
+```cpp
+// Add new visualization types:
+void addCustomVisualization() {
+  // Create custom OSG nodes
+  // Add to scene graph
+}
+```
+
+## Comparison to MyWindow.cpp
+
+This event handler replaces typical `MyWindow.cpp` functionality by providing:
+
+1. **Structured Event Handling**: Clean separation of concerns vs. monolithic window class
+2. **Modern DART API**: Uses current DART patterns and best practices
+3. **Extensible Design**: Easy to modify and extend for specific applications
+4. **Better Documentation**: Comprehensive documentation and examples
+5. **Integrated Visualization**: Built-in force visualization system
+6. **Flexible Integration**: Works with any DART/OSG application
+
+## Notes
+
+- The event handler automatically detects rigid bodies (those with FreeJoint, BallJoint, etc.)
+- Force arrows are temporary and clear after each update cycle
+- Time step changes affect the entire world simulation
+- The handler maintains compatibility with DART's constraint system
+- All coordinate systems use world coordinates for consistency