### Launch Web GUI Server

Source: https://github.com/keenon/nimblephysics/wiki/2.-Building-and-running-code

Commands to install dependencies and start the development server for the web GUI.

```bash
# cd javascript
# npm install
# npm run dev
```

--------------------------------

### Complete Optimization Loop

Source: https://github.com/keenon/nimblephysics/blob/master/www/docs/backprop-through-physics.md

A full example demonstrating world setup, GUI initialization, simulation stepping, and the optimization loop.

```python
import torch
import nimblephysics as nimble

# Set up the world
world = nimble.simulation.World()
world.setGravity([0, -9.81, 0])
world.setTimeStep(0.01)

# Set up the box
box = nimble.dynamics.Skeleton()
boxJoint, boxBody = box.createTranslationalJoint2DAndBodyNodePair()
boxShape = boxBody.createShapeNode(nimble.dynamics.BoxShape([.1, .1, .1]))
boxVisual = boxShape.createVisualAspect()
boxVisual.setColor([0.5, 0.5, 0.5])
world.addSkeleton(box)

# Set up initial conditions for optimization
initial_position: torch.Tensor = torch.tensor([3.0, 0.0])
initial_velocity: torch.Tensor = torch.zeros((world.getNumDofs()), requires_grad=True)

# Set up the GUI
gui: nimble.NimbleGUI = nimble.NimbleGUI(world)
gui.serve(8080)
gui.nativeAPI().createSphere("goal", radius=0.1, pos=[0, 0, 0], color=[0, 255, 0])

while True:
  state: torch.Tensor = torch.cat((initial_position, initial_velocity), 0)
  states = [state]

  num_timesteps = 100
  for i in range(num_timesteps):
    state = nimble.timestep(world, state, torch.zeros((world.getNumDofs())))
    states.append(state)

  # This call will overwrite any previous set of states we were looping from
  # a previous iteration of gradient descent.
  gui.loopStates(states)

  # Our loss is just the distance to the origin at the final step
  final_position = state[:world.getNumDofs()]  # Position is the first half of the state vector
  loss = final_position.norm()
  print('loss: '+str(loss))

  loss.backward()

  # Manually update weights using gradient descent. Wrap in torch.no_grad()
  # because weights have requires_grad=True, but we don't need to track this
  # in autograd.
  with torch.no_grad():
    learning_rate = 0.01
    initial_velocity -= learning_rate * initial_velocity.grad
    initial_velocity.grad = None
```

--------------------------------

### Complete mass tuning example

Source: https://github.com/keenon/nimblephysics/blob/master/www/docs/system-identification.md

A full implementation demonstrating the setup of a simulation world, registration of mass for optimization, and the training loop using gradient descent.

```default
import torch
import numpy as np
import nimblephysics as nimble

# Set up the world
world = nimble.simulation.World()
world.setGravity([0, -9.81, 0])
world.setTimeStep(0.01)

# Set up initial conditions for optimization
initial_position: torch.Tensor = torch.tensor([3.0, 0.0])
initial_velocity: torch.Tensor = torch.tensor([-3.0011, 4.8577])
mass: torch.Tensor = torch.tensor([1.0], requires_grad=True)  # True mass is 2.0
goal: torch.Tensor = torch.Tensor([[2.4739, 2.4768]])
# We apply nonzero force so that mass can be determined from the trajectory.
action: torch.Tensor = torch.tensor([10.0, 10.0])

# Set up the box
box = nimble.dynamics.Skeleton()
boxJoint, boxBody = box.createTranslationalJoint2DAndBodyNodePair()
world.addSkeleton(box)
bound = np.zeros((1,))  # This is not used, so we just pass in zeros
world.getWrtMass().registerNode(
    boxBody,
    nimble.neural.WrtMassBodyNodeEntryType.MASS,
    bound,
    bound)


while True:
    state: torch.Tensor = torch.cat((initial_position, initial_velocity), 0)
    states = [state]

    num_timesteps = 100
    for i in range(num_timesteps):
        state = nimble.timestep(world, state, action, mass)
        states.append(state)

    # Our loss is just the distance to the origin at the final step
    final_position = state[:world.getNumDofs()]  # Position is the first half of the state vector
    loss = (goal - final_position).norm()
    print('loss: '+str(loss))

    loss.backward()

    # Manually update weights using gradient descent. Wrap in torch.no_grad()
    # because weights have requires_grad=True, but we don't need to track this
    # in autograd.
    with torch.no_grad():
        learning_rate = 0.01
        mass -= learning_rate * mass.grad
        mass.grad = None
```

--------------------------------

### Install Project Files

Source: https://github.com/keenon/nimblephysics/blob/master/dart/math/CMakeLists.txt

Configures the installation of header files. It installs the main headers and the generated math header to 'include/dart/math', and detail headers to 'include/dart/math/detail'. Files are installed as part of the 'headers' component.

```cmake
install(
  FILES ${hdrs} ${CMAKE_CURRENT_BINARY_DIR}/math.hpp
  DESTINATION include/dart/math
  COMPONENT headers
)
install(
  FILES ${detail_hdrs}
  DESTINATION include/dart/math/detail
  COMPONENT headers
)
```

--------------------------------

### Install Project Files

Source: https://github.com/keenon/nimblephysics/blob/master/dart/constraint/CMakeLists.txt

Defines installation rules for header files and their corresponding detail implementations.

```cmake
# Install
install(
  FILES ${hdrs} ${CMAKE_CURRENT_BINARY_DIR}/constraint.hpp
  DESTINATION include/dart/constraint
  COMPONENT headers
)
install(
  FILES ${detail_hdrs}
  DESTINATION include/dart/constraint/detail
  COMPONENT headers
)
```

--------------------------------

### Inspect Python Package Metadata

Source: https://github.com/keenon/nimblephysics/wiki/2.-Building-and-running-code

Example output from the pip show command to identify the installation location.

```text
Name: nimblephysics
Version: 0.6.15.1
Summary: A differentiable fully featured physics engine
Home-page: UNKNOWN
Author: Keenon Werling
Author-email: keenonwerling@gmail.com
License: MIT
Location: /home/<USERNAME>/.local/lib/python3.8/site-packages
Requires: torch, numpy
Required-by: 
```

--------------------------------

### Install Project Files

Source: https://github.com/keenon/nimblephysics/blob/master/dart/server/CMakeLists.txt

Defines the installation rules for header files to the specified destination.

```cmake
# Install
install(
  FILES ${hdrs} ${CMAKE_CURRENT_BINARY_DIR}/server.hpp
  DESTINATION include/dart/server
  COMPONENT headers
)
```

--------------------------------

### Install Nimble Physics

Source: https://context7.com/keenon/nimblephysics/llms.txt

Use pip to install the library for immediate access to the engine.

```bash
pip3 install nimblephysics
```

--------------------------------

### Install Project Headers

Source: https://github.com/keenon/nimblephysics/blob/master/dart/simulation/CMakeLists.txt

Install the project's header files to the appropriate destination directories. This ensures that users can include the library's headers when using the installed package.

```cmake
install(
  FILES ${hdrs} ${CMAKE_CURRENT_BINARY_DIR}/simulation.hpp
  DESTINATION include/dart/simulation
  COMPONENT headers
)
install(
  FILES ${detail_hdrs}
  DESTINATION include/dart/simulation/detail
  COMPONENT headers
)
```

--------------------------------

### Install Project Files with CMake

Source: https://github.com/keenon/nimblephysics/blob/master/dart/collision/dart/CMakeLists.txt

The `install` command is used to copy header files and the generated `dart.hpp` to the destination directory. This ensures that the project's headers are available when the library is installed.

```cmake
install(
  FILES ${hdrs} ${CMAKE_CURRENT_BINARY_DIR}/dart.hpp
  DESTINATION include/dart/collision/dart
  COMPONENT headers
)
```

--------------------------------

### Define Installation Rules

Source: https://github.com/keenon/nimblephysics/blob/master/dart/common/CMakeLists.txt

Specifies the destination paths for headers and generated files during the installation process.

```cmake
install(
  FILES ${hdrs} ${CMAKE_CURRENT_BINARY_DIR}/common.hpp
  DESTINATION include/dart/common
  COMPONENT headers
)
install(
  FILES ${detail_hdrs}
  DESTINATION include/dart/common/detail
  COMPONENT headers
)
```

--------------------------------

### Install Sphinx and Read The Docs Theme

Source: https://github.com/keenon/nimblephysics/wiki/5.-Adding-pages-to-the-website

Use pip to install the required documentation tools. Ensure you are using pip3 for Python 3.

```bash
pip3 install sphinx sphinx_rtd_theme
```

--------------------------------

### Install Python Wheel

Source: https://github.com/keenon/nimblephysics/wiki/2.-Building-and-running-code

Command to install a custom-built wheel while ensuring it overrides existing installations.

```bash
--force-reinstall
```

--------------------------------

### Initialize Simulation and GUI

Source: https://github.com/keenon/nimblephysics/blob/master/python/new_examples/test.ipynb

Sets up a physics world with gravity, loads URDF skeletons, and starts a NimbleGUI server for rendering.

```python
import nimblephysics as nimble
import torch
import numpy as np
from IPython.core.display import display, HTML
world = nimble.simulation.World()
world.setGravity([0, -9.81, 0])
# Set up the 2D cartpole
arm: nimble.dynamics.Skeleton = world.loadSkeleton("../../data/urdf/KR5/KR5 sixx R650.urdf")
ground: nimble.dynamics.Skeleton = world.loadSkeleton("../../data/sdf/atlas/ground.urdf")
floorBody: nimble.dynamics.BodyNode = ground.getBodyNode(0)
floorBody.getShapeNode(0).getVisualAspect().setCastShadows(False)
ticker = nimble.realtime.Ticker(world.getTimeStep())

goal_x = 0.0
goal_y = 0.8
goal_z = -1.0
goal: torch.Tensor = torch.tensor([goal_x, goal_y, goal_z])

gui = nimble.NimbleGUI(world)
gui.serve(8081)
gui.nativeAPI().renderWorld(world, "world")
gui.nativeAPI().createSphere("goal_pos", 0.1, np.array(
    [goal_x, goal_y, goal_z]), np.array([0.0, 1.0, 0.0]), True, False)

display(HTML('<iframe src="localhost:8081">'))

gui.blockWhileServing()
```

--------------------------------

### Run IK Setup with OpenSim Command

Source: https://github.com/keenon/nimblephysics/blob/master/data/grf/Subject4/README.txt

Execute an inverse kinematics setup file using the opensim-cmd tool. This command generates a results file in the MOT format.

```bash
> opensim-cmd run-tool IK/STS1_ik_setup.xml
```

```bash
> opensim-cmd run-tool IK/walkingTO2_ik_setup.xml
```

```bash
> opensim-cmd run-tool IK/walkingTO3_ik_setup.xml
```

```bash
> opensim-cmd run-tool IK/walking1_ik_setup.xml
```

```bash
> opensim-cmd run-tool IK/DJ2_ik_setup.xml
```

```bash
> opensim-cmd run-tool IK/STSAsym1_ik_setup.xml
```

```bash
> opensim-cmd run-tool IK/walkingTO1_ik_setup.xml
```

```bash
> opensim-cmd run-tool IK/squatsAsym1_ik_setup.xml
```

```bash
> opensim-cmd run-tool IK/walking4_ik_setup.xml
```

```bash
> opensim-cmd run-tool IK/STSweakLegs1_ik_setup.xml
```

--------------------------------

### Run IK Setup on Manually Scaled Model

Source: https://github.com/keenon/nimblephysics/blob/master/data/grf/Subject4/README.txt

Execute an inverse kinematics setup file using the opensim-cmd tool on a manually scaled model. This command generates a results file in the MOT format.

```bash
> opensim-cmd run-tool IK/walkingTS2_ik_on_manually_scaled_setup.xml
```

```bash
> opensim-cmd run-tool IK/DJAsym1_ik_on_manually_scaled_setup.xml
```

```bash
> opensim-cmd run-tool IK/walkingTS3_ik_on_manually_scaled_setup.xml
```

```bash
> opensim-cmd run-tool IK/squats1_ik_on_manually_scaled_setup.xml
```

```bash
> opensim-cmd run-tool IK/DJ1_ik_on_manually_scaled_setup.xml
```

```bash
> opensim-cmd run-tool IK/DJ3_ik_on_manually_scaled_setup.xml
```

```bash
> opensim-cmd run-tool IK/walkingTS1_ik_on_manually_scaled_setup.xml
```

```bash
> opensim-cmd run-tool IK/walkingTI1_ik_on_manually_scaled_setup.xml
```

```bash
> opensim-cmd run-tool IK/DJAsym2_ik_on_manually_scaled_setup.xml
```

```bash
> opensim-cmd run-tool IK/walkingTI2_ik_on_manually_scaled_setup.xml
```

```bash
> opensim-cmd run-tool IK/walkingTI3_ik_on_manually_scaled_setup.xml
```

```bash
> opensim-cmd run-tool IK/DJAsym3_ik_on_manually_scaled_setup.xml
```

```bash
> opensim-cmd run-tool IK/walking2_ik_on_manually_scaled_setup.xml
```

```bash
> opensim-cmd run-tool IK/static1_ik_on_manually_scaled_setup.xml
```

```bash
> opensim-cmd run-tool IK/STS1_ik_on_manually_scaled_setup.xml
```

```bash
> opensim-cmd run-tool IK/walkingTO2_ik_on_manually_scaled_setup.xml
```

```bash
> opensim-cmd run-tool IK/walkingTO3_ik_on_manually_scaled_setup.xml
```

```bash
> opensim-cmd run-tool IK/walking1_ik_on_manually_scaled_setup.xml
```

```bash
> opensim-cmd run-tool IK/DJ2_ik_on_manually_scaled_setup.xml
```

```bash
> opensim-cmd run-tool IK/STSAsym1_ik_on_manually_scaled_setup.xml
```

```bash
> opensim-cmd run-tool IK/walkingTO1_ik_on_manually_scaled_setup.xml
```

--------------------------------

### Install Utility Headers

Source: https://github.com/keenon/nimblephysics/blob/master/dart/utils/CMakeLists.txt

Installs the collected header files and the generated `utils.hpp` to the `include/dart/utils` directory as part of the 'headers' component.

```cmake
install(
  FILES ${hdrs} ${CMAKE_CURRENT_BINARY_DIR}/utils.hpp
  DESTINATION include/dart/utils
  COMPONENT headers
)
```

--------------------------------

### Install Headers

Source: https://github.com/keenon/nimblephysics/blob/master/dart/exo/CMakeLists.txt

Installs the header files to the 'include/dart/exo' directory within the package. This command is used for packaging and distribution.

```cmake
install(
  FILES ${hdrs} ${CMAKE_CURRENT_BINARY_DIR}/exo.hpp
  DESTINATION include/dart/exo
  COMPONENT headers
)
```

--------------------------------

### Verify Docker Installation

Source: https://github.com/keenon/nimblephysics/wiki/1.-Setting-up-your-dev-environment

Use this command to check if Docker is correctly installed and operational on your system.

```console
docker run hello-world
```

--------------------------------

### Run Inverse Kinematics Tools

Source: https://github.com/keenon/nimblephysics/blob/master/data/grf/Subject4/README.txt

Executes IK tools using specific XML setup files.

```bash
opensim-cmd run-tool IK/squatsAsym1_ik_on_manually_scaled_setup.xml
```

```bash
opensim-cmd run-tool IK/walking4_ik_on_manually_scaled_setup.xml
```

```bash
opensim-cmd run-tool IK/STSweakLegs1_ik_on_manually_scaled_setup.xml
```

--------------------------------

### Initialize and serve the Nimble GUI

Source: https://github.com/keenon/nimblephysics/blob/master/www/docs/gui-tutorial.md

Standard boilerplate for creating a GUI instance, starting the server, and preventing the script from exiting.

```python
import nimblephysics as nimble

# Create a GUI
gui = nimble.NimbleGUI()

# Serve the GUI on port 8080
gui.serve(8080)

############################
# Do something useful here!
############################

# Do not immediately exit
gui.blockWhileServing()
```

--------------------------------

### Manage and Install NimblePhysics Utilities

Source: https://github.com/keenon/nimblephysics/blob/master/dart/utils/sdf/CMakeLists.txt

Collects source files, generates a namespace header, and defines installation rules for the project.

```cmake
# Search all header and source files
file(GLOB hdrs "*.hpp")
file(GLOB srcs "*.cpp")

dart_add_utils_headers(${hdrs})
dart_add_utils_headers(${srcs})

# Generate header for this namespace
dart_get_filename_components(header_names "utils_sdf headers" ${hdrs})
dart_generate_include_header_file(
  "${CMAKE_CURRENT_BINARY_DIR}/sdf.hpp"
  "dart/utils/sdf/"
  ${header_names}
)

# Install
install(
  FILES ${hdrs} ${CMAKE_CURRENT_BINARY_DIR}/sdf.hpp
  DESTINATION include/dart/utils/sdf
  COMPONENT headers
)
```

--------------------------------

### Complete Nimble Physics Example

Source: https://github.com/keenon/nimblephysics/blob/master/www/docs/quick-start.md

A complete Python script demonstrating loading a robot, simulating its physics, and visualizing the trajectory. This combines all the previous steps into a single runnable example.

```default
import nimblephysics as nimble
import torch

# Load the world

world = nimble.loadWorld("./half_cheetah.skel")

# Set up initial state

initialState = torch.zeros((world.getStateSize()))
action = torch.zeros((world.getActionSize()))

# Run a simulation for 300 timesteps

state = initialState
states = []
for _ in range(300):
  state = nimble.timestep(world, state, action)
  states.append(state)

# Display our trajectory in a GUI

gui = nimble.NimbleGUI(world)
gui.serve(8080) # host the GUI on localhost:8080
gui.loopStates(states) # tells the GUI to animate our list of states
gui.blockWhileServing() # block here so we don't exit the program
```

--------------------------------

### Install Headers

Source: https://github.com/keenon/nimblephysics/blob/master/dart/proto/CMakeLists.txt

Installs the generated proto headers and the consolidated include header to the project's include directory. This makes the generated code available for external use.

```cmake
# Install
install(
  FILES ${hdrs} ${CMAKE_CURRENT_BINARY_DIR}/proto.hpp
  DESTINATION include/dart/proto
  COMPONENT headers
)
```

--------------------------------

### Install Nimblephysics

Source: https://github.com/keenon/nimblephysics/blob/master/www/docs/install.md

Use this command to install Nimblephysics on Linux or Mac OS X with Python 3.7+ and pip.

```bash
pip install nimblephysics
```

--------------------------------

### Install Project Headers

Source: https://github.com/keenon/nimblephysics/blob/master/dart/neural/CMakeLists.txt

Installs the project's header files and the generated neural header to the include directory, categorized under the 'headers' component.

```cmake
install(
  FILES ${hdrs} ${CMAKE_CURRENT_BINARY_DIR}/neural.hpp
  DESTINATION include/dart/neural
  COMPONENT headers
)
```

--------------------------------

### Configure and Install External Library with CMake

Source: https://github.com/keenon/nimblephysics/blob/master/dart/external/lodepng/CMakeLists.txt

Defines a library target using globbed source files and sets up installation rules for headers.

```cmake
# Search all header and source files
file(GLOB hdrs "*.h")
file(GLOB srcs "*.cpp")

# Set local target name
set(target_name ${PROJECT_NAME}-external-lodepng)
set(component_name external-lodepng)

dart_add_library(${target_name} ${hdrs} ${srcs})
target_include_directories(${target_name}
  PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
)

# Component
add_component(${PROJECT_NAME} ${component_name})
add_component_targets(${PROJECT_NAME} ${component_name} ${target_name})

# Install
install(
  FILES ${hdrs}
  DESTINATION include/dart/external/lodepng
  COMPONENT headers
)
```

--------------------------------

### Install Headers

Source: https://github.com/keenon/nimblephysics/blob/master/dart/performance/CMakeLists.txt

Installs the project's header files, including the generated performance header, to the 'include/dart/performance' directory.

```cmake
# Install
install(
  FILES ${hdrs} ${CMAKE_CURRENT_BINARY_DIR}/performance.hpp
  DESTINATION include/dart/performance
  COMPONENT headers
)
```

--------------------------------

### Configure NimblePhysics Build and Install

Source: https://github.com/keenon/nimblephysics/blob/master/dart/lcpsolver/CMakeLists.txt

Uses DART macros to register source files, generate a consolidated header, and define installation paths.

```cmake
# Search all header and source files
file(GLOB hdrs "*.hpp")
file(GLOB srcs "*.cpp")
dart_add_core_headers(${hdrs})
dart_add_core_sources(${srcs})

# Generate header for this namespace
dart_get_filename_components(header_names "lcpsolver headers" ${hdrs})
dart_generate_include_header_file(
  "${CMAKE_CURRENT_BINARY_DIR}/lcpsolver.hpp"
  "dart/lcpsolver/"
  ${header_names}
)

# Install
install(
  FILES ${hdrs} ${CMAKE_CURRENT_BINARY_DIR}/lcpsolver.hpp
  DESTINATION include/dart/lcpsolver
  COMPONENT headers
)

dart_format_add(${hdrs} ${srcs})
```

--------------------------------

### Install Dart Header File

Source: https://github.com/keenon/nimblephysics/blob/master/dart/CMakeLists.txt

Installs the 'dart.hpp' header file to the 'include/dart/' directory as part of the 'headers' component.

```cmake
install(FILES dart.hpp DESTINATION include/dart/ COMPONENT headers)
```

--------------------------------

### Find Protobuf and gRPC

Source: https://github.com/keenon/nimblephysics/blob/master/dart/proto/CMakeLists.txt

Locates Protobuf and gRPC installations and includes necessary directories. Ensure Protobuf and gRPC are installed and findable by CMake.

```cmake
# include(FindProtobuf)

# Enable protobuf
find_package(Protobuf REQUIRED)
include_directories(${Protobuf_INCLUDE_DIRS})
include_directories(${CMAKE_CURRENT_BINARY_DIR})
```

```cmake
# Find gRPC installation
# Looks for gRPCConfig.cmake file installed by gRPC's cmake installation.
find_package(gRPC CONFIG REQUIRED)
message(STATUS "Using gRPC ${gRPC_VERSION}")
```

--------------------------------

### Install Project Files

Source: https://github.com/keenon/nimblephysics/blob/master/dart/trajectory/CMakeLists.txt

Installs the project's header files and the generated trajectory header to the 'include/dart/trajectory' directory. This is configured to be part of the 'headers' component.

```cmake
install(
  FILES ${hdrs} ${CMAKE_CURRENT_BINARY_DIR}/trajectory.hpp
  DESTINATION include/dart/trajectory
  COMPONENT headers
)
```

--------------------------------

### Install Headers

Source: https://github.com/keenon/nimblephysics/blob/master/dart/realtime/CMakeLists.txt

Installs header files to the specified destination directory with a component name. This ensures headers are available for external use.

```cmake
install(
  FILES ${hdrs} ${CMAKE_CURRENT_BINARY_DIR}/realtime.hpp
  DESTINATION include/dart/realtime
  COMPONENT headers
)
```

--------------------------------

### Import Nimblephysics and PyTorch

Source: https://github.com/keenon/nimblephysics/blob/master/www/docs/backprop-through-physics.md

Import the necessary libraries for physics simulation and tensor operations. Ensure PyTorch is installed and familiar.

```default
import torch
import nimblephysics as nimble
```

--------------------------------

### GoogleTest Setup in CMake

Source: https://github.com/keenon/nimblephysics/blob/master/unittests/CMakeLists.txt

Configures GoogleTest libraries and links them to the main project. Ensures correct include directories are set.

```cmake
include_directories(BEFORE SYSTEM ${CMAKE_SOURCE_DIR}/unittests/gtest/include)
include_directories(BEFORE SYSTEM ${CMAKE_SOURCE_DIR}/unittests/gtest)
add_library(gtest STATIC gtest/src/gtest-all.cc)
add_library(gtest_main STATIC gtest/src/gtest_main.cc)
target_link_libraries(gtest_main gtest)
if(NOT WIN32)
  target_link_libraries(gtest pthread)
endif()
set_target_properties(
  gtest PROPERTIES
  ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
)
```

--------------------------------

### C++ Header File Structure and Conventions

Source: https://github.com/keenon/nimblephysics/blob/master/CONTRIBUTING.md

This example demonstrates the recommended structure for C++ header files, including header guards, include order, namespace usage, smart pointer declarations, class definitions with Doxygen comments, and explicit handling of copy/move constructors and destructors. It also shows how to override interface functions and document methods with parameters and output arguments.

```c++
#ifndef DART_EXAMPLE_EXAMPLECLASS_HPP_
#define DART_EXAMPLE_EXAMPLECLASS_HPP_

#include <stl_headers>
#include <library/headers.hpp>
#include "dart/common/pointers.hpp"
#include "dart/component_name/ExampleInterface.hpp"
#include "dart/component_name/ExampleOtherInterface.hpp"

namespace dart {
namespace example {

DART_COMMON_MAKE_SHARED_WEAK(ExampleClass)

/// A required Doxygen comment description for this class. This can be extended
/// to include various useful details about the class, and can use the standard
/// Doxygen tag set to refer to other classes or documentation. It should use
/// the '///' style of block comment.
class ExampleClass : public ExampleInterface, public ExampleOtherInterface
{
public:
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW   

  /// Required brief description of constructor. This will often be as simple as:
  /// "Creates an instance of ExampleClass."
  ///
  /// \param[in] foo This is an example parameter description.
  /// \param[in] bar This is a longer example parameter description that needs
  /// to wrap across multiple lines.
  ExampleClass(std::unique_ptr<util::RNG> foo,
               const Eigen::Isometry3d& bar = Eigen::Isometry3d::Identity());

  ExampleClass(const ExampleClass& other);
  ExampleClass(ExampleClass&& other);

  ExampleClass& operator=(const ExampleClass& other);
  ExampleClass& operator=(ExampleClass&& other);

  ExampleClass(const ExampleClass&) = delete;
  ExampleClass(ExampleClass&& other) = delete;
  ExampleClass& operator=(const ExampleClass& other) = delete;
  ExampleClass& operator=(ExampleClass&& other) = delete;

  virtual ~ExampleClass() = default;

  int exampleInterfaceFunction() const override;

  /// Required brief description of method.
  /// \note If a method has output parameters, they should be the last
  /// arguments.
  ///
  /// \param[in] a A description of a
  /// \param[in] b A description of b
  /// \param[out] out A description of out
  int exampleMethod(int a, int b, int* out) const;

private:
  std::unique_ptr<util::RNG> mExampleMember; 
};

} // namespace example
} // namespace dart

#include "dart/component_name/detail/ExampleClass-impl.hpp"

#endif // DART_EXAMPLE_EXAMPLECLASS_HPP_

```

--------------------------------

### Locate Python Binary Path

Source: https://github.com/keenon/nimblephysics/wiki/2.-Building-and-running-code

Path template for the installed NimblePhysics binary.

```bash
<LIB_DIR>/lib/python3.8/site-packages/nimblephysics_libs/_nimblephysics.so
```

--------------------------------

### Import Nimble and PyTorch

Source: https://github.com/keenon/nimblephysics/blob/master/www/docs/quick-start.md

Import the necessary libraries for Nimble Physics and PyTorch. Ensure these libraries are installed in your environment.

```default
import nimblephysics as nimble
import torch
```

--------------------------------

### Configure NimblePhysics Build Files

Source: https://github.com/keenon/nimblephysics/blob/master/dart/utils/amc/CMakeLists.txt

Collects source and header files, generates an include header, and defines installation rules for the project.

```cmake
# Search all header and source files
file(GLOB hdrs "*.hpp")
file(GLOB srcs "*.cpp")
dart_add_core_headers(${hdrs})
dart_add_core_sources(${srcs})

# dart_add_utils_headers(${hdrs})
# dart_add_utils_headers(${srcs})

# Generate header for this namespace
dart_get_filename_components(header_names "utils_amc headers" ${hdrs})
dart_generate_include_header_file(
  "${CMAKE_CURRENT_BINARY_DIR}/amc.hpp"
  "dart/utils/amc/"
  ${header_names}
)

set(target_name ${PROJECT_NAME}-utils-amc)

# dart_add_library(${target_name} ${hdrs} ${srcs})

# Install
install(
  FILES ${hdrs} ${CMAKE_CURRENT_BINARY_DIR}/amc.hpp
  DESTINATION include/dart/utils/amc
  COMPONENT headers
)
```

--------------------------------

### Configure NimblePhysics Build Files

Source: https://github.com/keenon/nimblephysics/blob/master/dart/biomechanics/CMakeLists.txt

Collects source and header files, generates a namespace-specific header, and defines installation rules.

```cmake
# Search all header and source files
file(GLOB hdrs "*.hpp")
file(GLOB srcs "*.cpp")
dart_add_core_headers(${hdrs})
dart_add_core_sources(${srcs})

# Generate header for this namespace
dart_get_filename_components(header_names "biomechanics headers" ${hdrs})
dart_generate_include_header_file(
  "${CMAKE_CURRENT_BINARY_DIR}/biomechanics.hpp"
  "dart/biomechanics/"
  ${header_names}
)

# Install
install(
  FILES ${hdrs} ${CMAKE_CURRENT_BINARY_DIR}/biomechanics.hpp
  DESTINATION include/dart/biomechanics
  COMPONENT headers
)
```

--------------------------------

### Upgrade Pip and Install Nimblephysics

Source: https://github.com/keenon/nimblephysics/blob/master/www/docs/install.md

If you encounter 'ERROR: No matching distribution found for nimblephysics' due to an older pip version, upgrade pip first, then install Nimblephysics.

```bash
pip install -U pip
pip install nimblephysics
```

--------------------------------

### Configure NimblePhysics Dynamics Files

Source: https://github.com/keenon/nimblephysics/blob/master/dart/dynamics/CMakeLists.txt

Collects source and header files, generates a namespace header, and defines installation rules for the dynamics module.

```cmake
file(GLOB hdrs "*.hpp")
file(GLOB srcs "*.cpp")
file(GLOB detail_hdrs "detail/*.hpp")
file(GLOB detail_srcs "detail/*.cpp")
dart_add_core_headers(${hdrs} ${detail_hdrs})
dart_add_core_sources(${srcs} ${detail_srcs})

# Generate header for this namespace
dart_get_filename_components(header_names "dynamics headers" ${hdrs})
# TODO: remove below line once the files are completely removed.
list(REMOVE_ITEM header_names "MultiSphereShape.hpp")
dart_generate_include_header_file(
  "${CMAKE_CURRENT_BINARY_DIR}/dynamics.hpp"
  "dart/dynamics/"
  ${header_names}
)

# Install
install(
  FILES ${hdrs} ${CMAKE_CURRENT_BINARY_DIR}/dynamics.hpp
  DESTINATION include/dart/dynamics
  COMPONENT headers
)
install(
  FILES ${detail_hdrs}
  DESTINATION include/dart/dynamics/detail
  COMPONENT headers
)
```

--------------------------------

### Handle Address Already In Use Error

Source: https://github.com/keenon/nimblephysics/blob/master/python/new_examples/test.ipynb

Example of an OSError occurring when the GUI server port is already occupied.

```text
Error (truncated):
--> 466         self.socket.bind(self.server_address)
    467         self.server_address = self.socket.getsockname()
    468 

OSError: [Errno 98] Address already in use
```

--------------------------------

### Set up GUI and Goal Marker

Source: https://github.com/keenon/nimblephysics/blob/master/www/docs/backprop-through-physics.md

Initialize a Nimble GUI to visualize the simulation and add a green sphere to mark the target goal position.

```default
# Set up the GUI
gui: nimble.NimbleGUI = nimble.NimbleGUI(world)
gui.serve(8080)
gui.nativeAPI().createSphere("goal", radius=0.1, pos=[0, 0, 0], color=[0, 255, 0])
```

--------------------------------

### Configure DART Configuration Header

Source: https://github.com/keenon/nimblephysics/blob/master/dart/CMakeLists.txt

Configures a 'config.hpp' file from a template ('config.hpp.in') and installs it. This file typically contains build-specific configuration macros and definitions for the DART library.

```cmake
set(DART_CONFIG_HPP_IN ${CMAKE_SOURCE_DIR}/dart/config.hpp.in)
set(DART_CONFIG_HPP_OUT ${CMAKE_BINARY_DIR}/dart/config.hpp)

if(DART_VERBOSE)
  message(STATUS ${DART_CONFIG_HPP_OUT})
endif()

configure_file(${DART_CONFIG_HPP_IN} ${DART_CONFIG_HPP_OUT} @ONLY)
install(FILES ${DART_CONFIG_HPP_OUT} DESTINATION include/dart)
```

--------------------------------

### Build HTML Documentation

Source: https://github.com/keenon/nimblephysics/wiki/5.-Adding-pages-to-the-website

Navigate to the docs directory and run the make command to generate the HTML documentation. The output will be in the _build folder.

```bash
make html
```

--------------------------------

### Initialize Optimization Environment

Source: https://github.com/keenon/nimblephysics/blob/master/www/docs/optimization.md

Initializes the skeleton model and GUI server for performing gradient-based optimization.

```python
import nimblephysics as nimble
import numpy as np
import time

rajagopal_opensim: nimble.biomechanics.OpenSimFile = nimble.RajagopalHumanBodyModel()
skeleton: nimble.dynamics.Skeleton = rajagopal_opensim.skeleton
right_wrist: nimble.dynamics.Joint = skeleton.getJoint("radius_hand_r")

# Set an arbitrary target location
target: np.ndarray = np.array([0.5, 0.5, 0.5])

# Create a GUI and serve on port 8080
gui = nimble.NimbleGUI()
gui.serve(8080)
```

--------------------------------

### Visualize Skeleton with GUI

Source: https://github.com/keenon/nimblephysics/blob/master/www/docs/understanding-skeletons.md

Launches a local web server to render the skeleton in a 3D GUI.

```python
import nimblephysics as nimble

# Load the model
rajagopal_opensim: nimble.biomechanics.OpenSimFile = nimble.RajagopalHumanBodyModel()
skeleton: nimble.dynamics.Skeleton = rajagopal_opensim.skeleton

# Create a GUI
gui = nimble.NimbleGUI()

# Serve the GUI on port 8080
gui.serve(8080)

# Render the skeleton to the GUI
gui.nativeAPI().renderSkeleton(skeleton)

# Block until the GUI is closed
gui.blockWhileServing()
```

--------------------------------

### Set up Simulation World and Box

Source: https://github.com/keenon/nimblephysics/blob/master/www/docs/backprop-through-physics.md

Initialize a Nimble physics world with gravity and timestep settings. Create a box skeleton with a translational joint and body node, defining its shape and visual properties.

```default
# Set up the world
world = nimble.simulation.World()
world.setGravity([0, -9.81, 0])
world.setTimeStep(0.01)

# Set up the box
box = nimble.dynamics.Skeleton()
boxJoint, boxBody = box.createTranslationalJoint2DAndBodyNodePair()
boxShape = boxBody.createShapeNode(nimble.dynamics.BoxShape([.1, .1, .1]))
boxVisual = boxShape.createVisualAspect()
boxVisual.setColor([0.5, 0.5, 0.5])
world.addSkeleton(box)
```

--------------------------------

### Load and Render Trial Frames

Source: https://github.com/keenon/nimblephysics/blob/master/www/docs/working-with-addbiomechanics-data.md

This snippet demonstrates how to load all frames from a selected trial, calculate the time step between frames, and then loop through each frame to set the skeleton's state and render it to the GUI. It includes logic for looping back to the first frame after reaching the end.

```python
trial_frames: List[nimble.biomechanics.Frame] = your_subject.readFrames(
    trial=trial,
    processingPass=0,
    startFrame=0,
    numFramesToRead=your_subject.getTrialLength(trial))

seconds_per_frame = your_subject.getTrialTimestep(trial)

frame = 0
while True:
    frame_to_render = trial_frames[frame]

    skeleton.setPositions(frame_to_render.processingPasses[0].pos)

    gui.nativeAPI().renderSkeleton(skeleton)

    time.sleep(seconds_per_frame)

    frame += 1
    if frame >= len(trial_frames):
       frame = 0
```

--------------------------------

### Set Up Initial State and Action Tensors

Source: https://github.com/keenon/nimblephysics/blob/master/www/docs/quick-start.md

Initialize PyTorch tensors for the physics engine's state and the action command. These tensors can be used for backpropagation.

```python
# Set up initial state

initialState = torch.zeros((world.getStateSize()))
action = torch.zeros((world.getActionSize()))
```

--------------------------------

### Configure Source Files and Headers

Source: https://github.com/keenon/nimblephysics/blob/master/dart/common/CMakeLists.txt

Collects header and source files from the current directory and subdirectories, then registers them with the build system.

```cmake
file(GLOB hdrs "*.hpp")
file(GLOB srcs "*.cpp")
file(GLOB detail_hdrs "detail/*.hpp")
file(GLOB detail_srcs "detail/*.cpp")
dart_add_core_headers(${hdrs} ${detail_hdrs})
dart_add_core_sources(${srcs} ${detail_srcs})
```

--------------------------------

### Create Physics World and Run Simulation

Source: https://context7.com/keenon/nimblephysics/llms.txt

Initialize a world, configure skeletons, and perform differentiable simulation steps using PyTorch tensors.

```python
import nimblephysics as nimble
import torch

# Create and configure the world
world = nimble.simulation.World()
world.setGravity([0, -9.81, 0])
world.setTimeStep(0.01)

# Create a box with a translational joint (2D movement)
box = nimble.dynamics.Skeleton()
boxJoint, boxBody = box.createTranslationalJoint2DAndBodyNodePair()
boxShape = boxBody.createShapeNode(nimble.dynamics.BoxShape([0.1, 0.1, 0.1]))
boxVisual = boxShape.createVisualAspect()
boxVisual.setColor([0.5, 0.5, 0.5])
world.addSkeleton(box)

# Set up initial state as PyTorch tensors (position + velocity)
initial_position = torch.tensor([3.0, 0.0])
initial_velocity = torch.zeros((world.getNumDofs()), requires_grad=True)
state = torch.cat((initial_position, initial_velocity), 0)

# Run simulation for 100 timesteps - fully differentiable!
states = [state]
for i in range(100):
    state = nimble.timestep(world, state, torch.zeros((world.getNumDofs())))
    states.append(state)

# Access final position for loss computation
final_position = state[:world.getNumDofs()]
loss = final_position.norm()
print(f"Final distance from origin: {loss.item()}")
```

--------------------------------

### Get BodyNode by Name

Source: https://github.com/keenon/nimblephysics/blob/master/www/docs/understanding-skeletons.md

Retrieves a specific BodyNode from a skeleton using its name. Ensure the skeleton is loaded.

```python
right_hand_body: nimble.dynamics.BodyNode = skeleton.getBodyNode("hand_r")
```

--------------------------------

### Load Skeleton and Initialize GUI

Source: https://github.com/keenon/nimblephysics/blob/master/www/docs/understanding-worlds.md

Loads a URDF skeleton into a Nimble simulation world and initializes a GUI for visualization. Ensure the URDF file and associated assets are correctly located.

```python
import nimblephysics as nimble
import os


world: nimble.simulation.World = nimble.simulation.World()
arm: nimble.dynamics.Skeleton = world.loadSkeleton(os.path.join(
    os.path.dirname(__file__), "./KR5.urdf"))

# Your code here

gui = nimble.NimbleGUI(world)
gui.serve(8080)
gui.blockWhileServing()
```

--------------------------------

### Configure CMake for External Library

Source: https://github.com/keenon/nimblephysics/blob/master/dart/external/odelcpsolver/CMakeLists.txt

Defines the library target, sets C++14 standards, and registers the component for installation.

```cmake
# Search all header and source files
file(GLOB hdrs "*.h")
file(GLOB srcs "*.cpp")

# Set local target name
set(target_name ${PROJECT_NAME}-external-odelcpsolver)
set(component_name external-odelcpsolver)

dart_add_library(${target_name} ${hdrs} ${srcs})
target_include_directories(${target_name}
  PUBLIC
    $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}>
    $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}>
)
if(CMAKE_VERSION VERSION_LESS 3.8.2)
  target_compile_options(${target_name} PUBLIC -std=c++14)
else()
  target_compile_features(${target_name} PUBLIC cxx_std_14)
endif()

# Component
add_component(${PROJECT_NAME} ${component_name})
add_component_targets(${PROJECT_NAME} ${component_name} ${target_name})

# Install
install(
  FILES ${hdrs}
  DESTINATION include/dart/external/odelcpsolver
  COMPONENT headers
)
```

--------------------------------

### GUI Visualization and Animation

Source: https://context7.com/keenon/nimblephysics/llms.txt

Sets up and serves a web-based GUI for visualizing skeletons and simulation results. Allows for real-time animation and adding custom visualization elements.

```python
import nimblephysics as nimble
import numpy as np
import torch

world = nimble.loadWorld("./half_cheetah.skel")

initial_state = torch.zeros((world.getStateSize()))
action = torch.zeros((world.getActionSize()))

state = initial_state
states = []
for _ in range(300):
    state = nimble.timestep(world, state, action)
    states.append(state)

gui = nimble.NimbleGUI(world)
gui.serve(8080)

gui.loopStates(states)

gui.nativeAPI().createSphere("goal", radius=0.1, pos=[1, 0, 0], color=[0, 255, 0, 255])
gui.nativeAPI().createLine("path", points=[[0,0,0], [1,0,0], [1,1,0]], color=[1,0,0,1])
gui.nativeAPI().createBox("obstacle", size=[0.5, 0.5, 0.5], pos=[2, 0, 0], color=[0.5, 0.5, 0.5, 1])

gui.nativeAPI().renderBasis(scale=0.5, pos=[0, 0, 0])

gui.blockWhileServing()
```

--------------------------------

### Physics Simulation Entrypoint

Source: https://github.com/keenon/nimblephysics/wiki/3.-How-the-code-is-organized

The primary method for advancing a physics simulation by one timestep.

```APIDOC
## World::step()

### Description
Computes a single timestep of a physical simulation on a `World` object. This method orchestrates the entire simulation update, including dynamics computation, integration, and constraint solving.

### Method
`dart::simulation::World::step()`

### Endpoint
N/A (This is a C++ method call)

### Parameters
None directly exposed in the method signature for this high-level description.

### Request Example
```cpp
dart::simulation::World world;
// ... configure world with skeletons, joints, bodies ...
world.step();
```

### Response
None (modifies the `World` object in place).
```

--------------------------------

### Verify pytest installation in CMake

Source: https://github.com/keenon/nimblephysics/blob/master/python/tests/CMakeLists.txt

Checks for the presence and version of pytest using the Python executable before proceeding with test configuration.

```cmake
execute_process(
  COMMAND ${PYTHON_EXECUTABLE} -c "import pytest; print(pytest.__version__)"
  RESULT_VARIABLE pytest_not_found
  OUTPUT_VARIABLE pytest_version
  ERROR_QUIET
)
if(pytest_not_found)
  message(STATUS "Running the tests requires pytest. Please install it manually"
    " (try: ${PYTHON_EXECUTABLE} -m pip install pytest)"
  )
  set(DARTPY_PYTEST_FOUND FALSE)
elseif(pytest_version VERSION_LESS 3.0)
  message(STATUS "Running the tests requires pytest >= 3.0. Found: ${pytest_version}"
    "Please update it (try: ${PYTHON_EXECUTABLE} -m pip install -U pytest)"
  )
  set(DARTPY_PYTEST_FOUND FALSE)
else()
  set(DARTPY_PYTEST_FOUND TRUE)
endif()
```

--------------------------------

### Configure Source Files and Headers

Source: https://github.com/keenon/nimblephysics/blob/master/dart/server/CMakeLists.txt

Collects header and source files using GLOB and registers them with the core build system.

```cmake
# Search all header and source files
file(GLOB hdrs "*.hpp")
file(GLOB srcs "*.cpp")
dart_add_core_headers(${hdrs})
dart_add_core_sources(${srcs})
dart_add_core_sources("${CMAKE_SOURCE_DIR}/dart/server/external/jsoncpp.cpp")
dart_add_core_sources("${CMAKE_SOURCE_DIR}/dart/server/external/base64/base64.cpp")
```

--------------------------------

### Configure NimblePhysics Project with CMake

Source: https://github.com/keenon/nimblephysics/blob/master/data/urdf/drchubo/CMakeLists.txt

Sets up the minimum CMake version and project name. Finds and includes the Catkin package for ROS build system integration.

```cmake
cmake_minimum_required(VERSION 2.8.3)
project(drchubo)
find_package(catkin REQUIRED)
catkin_package()
```

--------------------------------

### Get Skeleton State from Frame

Source: https://github.com/keenon/nimblephysics/blob/master/www/docs/working-with-addbiomechanics-data.md

Retrieve a copy of the skeleton in the correct state for a given frame by calling `readSkel` on the `SubjectOnDisk` object.

```python
skel = your_subject.readSkel(...)
```

--------------------------------

### Set Accelerometer Readings Jacobian

Source: https://github.com/keenon/nimblephysics/blob/master/www/docs/accs-and-gyros.md

Configures the measurement matrix for accelerometer readings with respect to acceleration. This is typically used in Kalman filter setups.

```python
measurement_matrix[one_sensor_type_dim:2*one_sensor_type_dim, 2*num_dofs:3*num_dofs] = skeleton.getAccelerometerReadingsJacobianWrt(sensors, wrt=nimble.neural.WRT_ACCELERATION)
```

--------------------------------

### C++ Source File Structure

Source: https://github.com/keenon/nimblephysics/blob/master/CONTRIBUTING.md

Demonstrates standard header inclusion, namespace nesting, and function separation using 80-column lines.

```cpp
// Includes should be at the top of the file.
// The first include in a class source file should be the matching `.hpp` header file.
#include "dart/example/ExampleClass.hpp"

#include <stl_headers>
#include <library/headers.hpp>
#include "dart/example/OtherHeaders.hpp"

// Namespace nesting is preferred to "using namespace" directives.
// Namespaces scopes should be one line each with "cuddled" braces.
namespace dart {
namespace example {

// Each function is separated by an 80 column line of "=" characters.
//==============================================================================
int ExampleClass::exampleInterfaceFunction() const
{
  if (mExampleMember)
    return 3;

  return -1;
}

//==============================================================================
int ExampleClass::exampleMethod(int a, int b, int* out) const
{
  int result = a + b;
  if (out)
    *out = result;
  return result;
}

} // namespace example
} // namespace dart
```

--------------------------------

### Docker Permission Error Message

Source: https://github.com/keenon/nimblephysics/wiki/1.-Setting-up-your-dev-environment

Example of the error message displayed when the current user lacks sufficient permissions to execute Docker commands.

```text
Current user does not have permission to run `docker`. Try adding the user to the `docker` group.
```

--------------------------------

### Get Joint World Position in Nimblephysics

Source: https://github.com/keenon/nimblephysics/blob/master/www/docs/understanding-skeletons.md

Retrieve the world position of a specific joint by its index. Ensure the model and skeleton are loaded before use.

```python
import nimblephysics as nimble
# Load the model
rajagopal_opensim: nimble.biomechanics.OpenSimFile = nimble.RajagopalHumanBodyModel()
skeleton: nimble.dynamics.Skeleton = rajagopal_opensim.skeleton

# Print the root joint's position
joint_index = 0
print(skeleton.getJointWorldPosition(joint_index))
```

--------------------------------

### Discover Header and Source Files

Source: https://github.com/keenon/nimblephysics/blob/master/dart/exo/CMakeLists.txt

Uses GLOB to find all .hpp and .cpp files in the current directory. Ensure these files are correctly placed for discovery.

```cmake
file(GLOB hdrs "*.hpp")
file(GLOB srcs "*.cpp")
```

--------------------------------

### Link Libraries in CMake

Source: https://github.com/keenon/nimblephysics/wiki/2.-Building-and-running-code

When a test requires additional libraries, use target_link_libraries to link them. For example, linking 'dart-utils' is necessary for loading robot files.

```cmake
target_link_libraries
```

--------------------------------

### Login to NPM

Source: https://github.com/keenon/nimblephysics/blob/master/javascript/README.md

Log in to your NPM account before publishing. Run this command if you are not already logged in.

```bash
npm login
```

--------------------------------

### Get Concatenated Joint World Positions in Nimblephysics

Source: https://github.com/keenon/nimblephysics/blob/master/www/docs/understanding-skeletons.md

Retrieve a concatenated vector of all joint world positions. This API is designed for use in gradient calculations.

```python
# Get and print a concatenated vector of joint centers
joints = [skeleton.getJoint(i) for i in range(skeleton.getNumJoints())]
joint_positions = skeleton.getJointWorldPositions(joints)
```

--------------------------------

### Get All Joint World Positions Map in Nimblephysics

Source: https://github.com/keenon/nimblephysics/blob/master/www/docs/understanding-skeletons.md

Obtain a dictionary mapping joint names to their world positions. This is useful for quick lookups and debugging.

```python
# Print a dictionary of key-value pairs, where the key is the joint name and the value is the joint world position
print(skeleton.getJointWorldPositionsMap())
```

--------------------------------

### Add CompleteHumanModel Unit Test (CMake)

Source: https://github.com/keenon/nimblephysics/blob/master/unittests/unit/CMakeLists.txt

Configures the 'test_CompleteHumanModel' unit test, linking it to 'dart-utils' and 'dart-utils-urdf'. This setup is for tests involving a complete human model.

```cmake
dart_add_test("unit" test_CompleteHumanModel)
  target_link_libraries(test_CompleteHumanModel dart-utils)
  target_link_libraries(test_CompleteHumanModel dart-utils-urdf)
```