PositionBasedDynamics

https://positionbaseddynamics.readthedocs.io/en/latest/
Admin
PositionBasedDynamics is an open-source library that enables physically-based simulation of...
Tokens:645,078
Snippets:2,280
Trust Score:9.6
Update:6 months ago
Show doc for...
Tokens:
Raw
### Install Bindings from Source

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/build_from_source.md.txt

Build and install the Python package from the repository using setup.py.

```bash
git clone https://github.com/InteractiveComputerGraphics/PositionBasedDynamics.git
cd PositionBasedDynamics
python setup.py bdist_wheel
pip install build/dist/pyPBD-2.1.0-cp38-cp38-win_amd64.whl
```

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

### Install Python Bindings using setup.py

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/build_from_source.md.txt

Builds a wheel for the Python bindings and installs it using pip. Assumes the repository has been cloned and built.

```bash
git clone https://github.com/InteractiveComputerGraphics/PositionBasedDynamics.git
cd PositionBasedDynamics
python setup.py bdist_wheel
pip install build/dist/*.whl
```

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

### Install Python Bindings from Source

Source: https://positionbaseddynamics.readthedocs.io/en/latest/build_from_source.html

Builds a wheel for the Python bindings and installs it using pip. This assumes the project has already been built. It's recommended to use a virtual environment.

```bash
git clone https://github.com/InteractiveComputerGraphics/PositionBasedDynamics.git
cd PositionBasedDynamics
python setup.py bdist_wheel
pip install build/dist/*.whl

```

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

### Install Python Bindings

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/getting_started.md.txt

Clone the repository and use pip to install the PositionBasedDynamics Python bindings. It is recommended to use a virtual environment.

```shell
git clone https://github.com/InteractiveComputerGraphics/PositionBasedDynamics.git
pip install PositionBasedDynamics/
```

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

### Install Ubuntu Dependencies

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/build_from_source.md.txt

Installs essential packages for building PositionBasedDynamics on Ubuntu.

```bash
sudo apt install git cmake xorg-dev freeglut3-dev build-essential
```

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

### Build and Install pyPBD Wheel File

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/py_getting_started.md.txt

For development, build a Python wheel file from the source and install it. This allows for quicker updates.

```shell
cd PositionBasedDynamics
python setup.py bdist_wheel
pip install -I build/dist/*.whl
```

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

### Execute BarDemo

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/getting_started.md.txt

Navigate to the bin directory and execute the BarDemo to start a simulation.

```shell
cd ../bin
./BarDemo
```

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

### Install PositionBasedDynamics via pip

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/build_from_source.md.txt

Installs the PositionBasedDynamics library directly from its GitHub repository using pip. This method may not support incremental rebuilds.

```bash
pip install git+https://github.com/InteractiveComputerGraphics/PositionBasedDynamics.git
```

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

### Install System Dependencies - Ubuntu

Source: https://positionbaseddynamics.readthedocs.io/en/latest/build_from_source.html

Installs essential system packages required for building PositionBasedDynamics on Ubuntu.

```bash
sudo apt install git cmake xorg-dev freeglut3-dev build-essential

```

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

### Install Python Bindings Directly from Git

Source: https://positionbaseddynamics.readthedocs.io/en/latest/build_from_source.html

Installs the Python bindings directly from the Git repository using pip. This is a convenient alternative but may limit incremental rebuilds.

```bash
pip install git+https://github.com/InteractiveComputerGraphics/PositionBasedDynamics.git

```

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

### Install pyPBD using Pip

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/py_getting_started.md.txt

Install the pyPBD library using pip. Ensure you are in the directory above the cloned source directory and note the trailing slash.

```shell
pip install PositionBasedDynamics/
```

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

### Get RotationInitial (Mutable)

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/api/program_listing_file_Simulation_RigidBody.h.rst.txt

Retrieves a mutable reference to the initial rotation quaternion. This is useful for resetting or comparing against the starting orientation.

```cpp
FORCE_INLINE Quaternionr &getRotationInitial()
               {
                   return m_q_initial;
               }
```

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

### Get Initial Quaternion

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/api/program_listing_file_Simulation_ParticleData.h.rst.txt

Retrieves a reference to the initial quaternion at a specific index. Useful for resetting or comparing against the starting pose.

```cpp
FORCE_INLINE Quaternionr &getQuaternion0(const unsigned int i)
            {
                return m_q0[i];
            }
```

```cpp
FORCE_INLINE const Quaternionr &getQuaternion0(const unsigned int i) const
            {
                return m_q0[i];
            }
```

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

### Run Executable Demo

Source: https://positionbaseddynamics.readthedocs.io/en/latest/build_from_source.html

Navigates to the build directory and executes a demo application, loading a specified scene file.

```bash
cd ../bin
./SceneLoaderDemo ../data/Scenes/CarScene.json

```

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

### Run Executable Demo - Windows

Source: https://positionbaseddynamics.readthedocs.io/en/latest/build_from_source.html

Executes a demo application from the 'bin' folder or starts the simulation by loading a scene file via the command line.

```bash
./SceneLoaderDemo ../data/scenes/CarScene.json

```

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

### Install Numpy Dependency

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/py_getting_started.md.txt

If you encounter issues, you may need to explicitly install the numpy library, which is a common dependency.

```shell
pip install numpy
```

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

### Build PositionBasedDynamics from Source

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/build_from_source.md.txt

Clones the repository, creates a build directory, configures with CMake, and compiles the project.

```bash
git clone https://github.com/InteractiveComputerGraphics/PositionBasedDynamics.git
cd PositionBasedDynamics
mkdir build && cd build
cmake -DCMAKE_BUILD_TYPE=Release -DUSE_PYTHON_BINDINGS=<On|Off> ..
make -j 4
```

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

### Install Python Bindings Dependencies on Ubuntu

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/build_from_source.md.txt

Installs Python development tools and pipx for managing Python bindings.

```bash
sudo apt install python3-dev python3-pip python3-venv
python3 -m pip install pipx
python3 -m pipx ensurepath
```

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

### Run Executable Demo on Windows

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/build_from_source.md.txt

Executes a demo application from the 'bin' folder on Windows, loading a specified scene file.

```bash
./SceneLoaderDemo ../data/scenes/CarScene.json
```

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

### Build PositionBasedDynamics from Source

Source: https://positionbaseddynamics.readthedocs.io/en/latest/build_from_source.html

Clones the repository, creates a build directory, configures the build with CMake (enabling Python bindings if desired), and compiles the project using Make.

```bash
git clone https://github.com/InteractiveComputerGraphics/PositionBasedDynamics.git
cd PositionBasedDynamics
mkdir build && cd build
cmake -DCMAKE_BUILD_TYPE=Release -DUSE_PYTHON_BINDINGS=<On|Off> ..
make -j 4

```

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

### Initialize Cloth Simulation Parameters

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/api/program_listing_file_Simulation_SimulationModel.cpp.rst.txt

Sets up enumeration parameters for cloth simulation methods. Use this to select the desired simulation algorithm.

```cpp
CLOTH_SIMULATION_METHOD = createEnumParameter("clothSimulationMethod", "Simulation method", std::bind(&SimulationModel::getClothSimulationMethod, this), std::bind(static_cast<void (SimulationModel::*)(const int)>(&SimulationModel::setClothSimulationMethod), this, std::placeholders::_1));
setGroup(CLOTH_SIMULATION_METHOD, "Cloth|General");
setDescription(CLOTH_SIMULATION_METHOD, "Cloth simulation method");
EnumParameter* enumParam = static_cast<EnumParameter*>(getParameter(CLOTH_SIMULATION_METHOD));
enumParam->addEnumValue("None", ENUM_CLOTHSIM_NONE);
enumParam->addEnumValue("Distance constraints", ENUM_CLOTHSIM_DISTANCE_CONSTRAINTS);
enumParam->addEnumValue("FEM based PBD", ENUM_CLOTHSIM_FEM_PBD);
enumParam->addEnumValue("Strain based dynamics", ENUM_CLOTHSIM_SBD);
enumParam->addEnumValue("XPBD distance constraints", ENUM_CLOTHSIM_DISTANCE_CONSTRAINTS_XPBD);
```

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

### Initialize Volume Constraint (XPBD)

Source: https://positionbaseddynamics.readthedocs.io/en/latest/api/program_listing_file_Simulation_Constraints.cpp.html

Sets up the initial state and rest volume for an XPBD volume constraint.

```cpp
bool VolumeConstraint_XPBD::initConstraint(SimulationModel& model, const unsigned int particle1, const unsigned int particle2,
    const unsigned int particle3, const unsigned int particle4, const Real stiffness)
{
    m_stiffness = stiffness;
    m_lambda = 0.0;
    m_bodies[0] = particle1;
    m_bodies[1] = particle2;
    m_bodies[2] = particle3;
    m_bodies[3] = particle4;
    ParticleData& pd = model.getParticles();

    const Vector3r& p0 = pd.getPosition0(particle1);
    const Vector3r& p1 = pd.getPosition0(particle2);
    const Vector3r& p2 = pd.getPosition0(particle3);
    const Vector3r& p3 = pd.getPosition0(particle4);

    m_restVolume = fabs(static_cast<Real>(1.0 / 6.0) * (p3 - p0).dot((p2 - p0).cross(p1 - p0)));

    return true;
}
```

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

### Initialize Solver Tree

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/api/program_listing_file_PositionBasedDynamics_PositionBasedElasticRods.cpp.rst.txt

Configures the initial interval settings for the stiff rod solver.

```cpp
   void PBD::DirectPositionBasedSolverForStiffRods::initTree(std::vector<RodConstraint*> &rodConstraints, std::vector<RodSegment*> & rodSegments, Interval* &intervals, int &numberOfIntervals, std::list <Node*> * &forward, std::list <Node*> * &backward, Node* &root)
   {
       numberOfIntervals = 1;
       intervals = new Interval[1];
       intervals[0].start = 0;
       intervals[0].end = (int)rodConstraints.size() - 1;
```

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

### Initialize Cloth Bending Method Parameters

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/api/program_listing_file_Simulation_SimulationModel.cpp.rst.txt

Sets up enumeration parameters for cloth bending methods. Choose the appropriate method based on simulation needs.

```cpp
CLOTH_BENDING_METHOD = createEnumParameter("clothBendingMethod", "Bending method", std::bind(&SimulationModel::getClothBendingMethod, this), std::bind(static_cast<void (SimulationModel::*)(const int)>(&SimulationModel::setClothBendingMethod), this, std::placeholders::_1));
setGroup(CLOTH_BENDING_METHOD, "Cloth|General");
setDescription(CLOTH_BENDING_METHOD, "Cloth bending method");
enumParam = static_cast<EnumParameter*>(getParameter(CLOTH_BENDING_METHOD));
enumParam->addEnumValue("None", ENUM_CLOTH_BENDING_NONE);
enumParam->addEnumValue("Dihedral angle", ENUM_CLOTH_BENDING_DIHEDRAL_ANGLE);
enumParam->addEnumValue("Isometric bending", ENUM_CLOTH_BENDING_ISOMETRIC);
enumParam->addEnumValue("Isometric bending (XPBD)", ENUM_CLOTH_BENDING_ISOMETRIX_XPBD);
```

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

### Initialize Before Projection for Stiff Rods Solver

Source: https://positionbaseddynamics.readthedocs.io/en/latest/api/program_listing_file_PositionBasedDynamics_PositionBasedElasticRods.h.html

Performs initialization steps before the projection phase in the direct position-based solver for stiff rods. It calculates compliance-related values based on the inverse time step size and updates lambda sums.

```cpp
static bool initBeforeProjection_DirectPositionBasedSolverForStiffRodsConstraint(
            const std::vector<RodConstraint*> &rodConstraints,
            const Real inverseTimeStepSize,
            std::vector<Vector6r> & lambdaSums
            );
```

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

### ParticleRigidBodyContactConstraint Constructor

Source: https://positionbaseddynamics.readthedocs.io/en/latest/api/class_p_b_d_1_1_particle_rigid_body_contact_constraint.html

Default constructor for ParticleRigidBodyContactConstraint. No specific setup is required.

```cpp
inline ParticleRigidBodyContactConstraint(){
     
     }
```

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

### Get Constraint Groups

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/api/program_listing_file_Simulation_SimulationModel.cpp.rst.txt

Returns a reference to the vector of ConstraintGroup objects.

```cpp
SimulationModel::ConstraintGroupVector & SimulationModel::getConstraintGroups()
{
       return m_constraintGroups;
}
```

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

### Initialize Direct Position Based Solver for Stiff Rods Constraint

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/api/program_listing_file_PositionBasedDynamics_PositionBasedElasticRods.h.rst.txt

Initializes the solver before projection. Requires rod constraints and inverse time step size.

```cpp
static bool initBeforeProjection_DirectPositionBasedSolverForStiffRodsConstraint(
               const std::vector<RodConstraint*> &rodConstraints,
               const Real inverseTimeStepSize,
               std::vector<Vector6r> & lambdaSums
               );
```

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

### Get Inverse Mass

Source: https://positionbaseddynamics.readthedocs.io/en/latest/api/program_listing_file_Simulation_RigidBody.h.html

Provides inline access to the pre-calculated inverse mass.

```cpp
FORCE_INLINE const Real &getInvMass() const
            {
                return m_invMass;
            }
```

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

### Rod Simulation Configuration

Source: https://positionbaseddynamics.readthedocs.io/en/latest/api/class_p_b_d_1_1_simulation_model.html

Functions for setting and getting rod simulation parameters.

```APIDOC
## Rod Simulation API

### Description
Provides methods to configure and retrieve settings related to rod simulations.

### Methods

#### Set Rod Stretching Stiffness
```cpp
void setRodStretchingStiffness(Real val)
```
Sets the stretching stiffness for rod simulation.

#### Get Rod Stretching Stiffness
```cpp
Real getRodStretchingStiffness()
```
Retrieves the stretching stiffness of the rod simulation.

#### Set Rod Shearing Stiffness X
```cpp
void setRodShearingStiffnessX(Real val)
```
Sets the shearing stiffness in the X direction for rod simulation.

#### Get Rod Shearing Stiffness X
```cpp
Real getRodShearingStiffnessX()
```
Retrieves the shearing stiffness in the X direction of the rod simulation.

#### Set Rod Shearing Stiffness Y
```cpp
void setRodShearingStiffnessY(Real val)
```
Sets the shearing stiffness in the Y direction for rod simulation.

#### Get Rod Shearing Stiffness Y
```cpp
Real getRodShearingStiffnessY()
```
Retrieves the shearing stiffness in the Y direction of the rod simulation.

#### Set Rod Bending Stiffness X
```cpp
void setRodBendingStiffnessX(Real val)
```
Sets the bending stiffness in the X direction for rod simulation.

#### Get Rod Bending Stiffness X
```cpp
Real getRodBendingStiffnessX()
```
Retrieves the bending stiffness in the X direction of the rod simulation.

#### Set Rod Bending Stiffness Y
```cpp
void setRodBendingStiffnessY(Real val)
```
Sets the bending stiffness in the Y direction for rod simulation.

#### Get Rod Bending Stiffness Y
```cpp
Real getRodBendingStiffnessY()
```
Retrieves the bending stiffness in the Y direction of the rod simulation.

#### Set Rod Twisting Stiffness
```cpp
void setRodTwistingStiffness(Real val)
```
Sets the twisting stiffness for rod simulation.

#### Get Rod Twisting Stiffness
```cpp
Real getRodTwistingStiffness()
```
Retrieves the twisting stiffness of the rod simulation.
```

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

### Initialize Stiff Rods Constraint

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/api/program_listing_file_Simulation_Constraints.cpp.rst.txt

Sets up the constraint by creating RodSegment instances, mapping body indices, and defining rod constraints based on input parameters. It also initializes the sparse direct solver.

```cpp
bool PBD::DirectPositionBasedSolverForStiffRodsConstraint::initConstraint(
    SimulationModel &model, 
    const std::vector<std::pair<unsigned int, unsigned int>> & constraintSegmentIndices, 
    const std::vector<Vector3r> &constraintPositions,
    const std::vector<Real> &averageRadii,
    const std::vector<Real> &averageSegmentLengths,
    const std::vector<Real> &youngsModuli,
    const std::vector<Real> &torsionModuli
    )
{
    // create unique segment indices from joints

    std::set<unsigned int> uniqueSegmentIndices;
    for (auto &idxPair :  constraintSegmentIndices)
    {
        uniqueSegmentIndices.insert(idxPair.first);
        uniqueSegmentIndices.insert(idxPair.second);
    }

    m_bodies.resize(uniqueSegmentIndices.size());

    // initialize m_bodies for constraint colouring algorithm of multi threading implementation

    size_t segmentIdx(0);

    for (auto idx : uniqueSegmentIndices)
    {
        m_bodies[segmentIdx] = idx;
        ++segmentIdx;
    }

    // create RodSegment instances and map simulation model body indices to RodSegment indices

    std::map<unsigned int, unsigned int> idxMap;
    unsigned int idx(0);

    m_Segments.reserve(uniqueSegmentIndices.size());
    m_rodSegments.reserve(uniqueSegmentIndices.size());
    for (auto bodyIdx : uniqueSegmentIndices)
    {
        idx = (unsigned int)m_Segments.size();
        idxMap[bodyIdx] = idx;
        m_Segments.push_back(RodSegmentImpl(model, bodyIdx));
        m_rodSegments.push_back(&m_Segments.back());
    }

    // create rod constraints

    m_Constraints.resize(constraintPositions.size());
    m_rodConstraints.resize(constraintPositions.size());

    for (size_t idx(0); idx < constraintPositions.size(); ++idx)
    {
        const std::pair<unsigned int, unsigned int> &bodyIndices( constraintSegmentIndices[idx]);
        unsigned int firstSegmentIndex(idxMap.find(bodyIndices.first)->second);
        unsigned int secondSegmentIndex(idxMap.find(bodyIndices.second)->second);

        m_Constraints[idx].m_segments.push_back(firstSegmentIndex);
        m_Constraints[idx].m_segments.push_back(secondSegmentIndex);
        m_Constraints[idx].m_averageSegmentLength = averageSegmentLengths[idx];
        m_rodConstraints[idx] = &m_Constraints[idx];
    }

    // initialize data of the sparse direct solver
    deleteNodes();
    DirectPositionBasedSolverForStiffRods::init_DirectPositionBasedSolverForStiffRodsConstraint(
        m_rodConstraints, m_rodSegments, intervals, numberOfIntervals, forward, backward, root,
        constraintPositions, averageRadii, youngsModuli, torsionModuli,
        m_rightHandSide, m_lambdaSums, m_bendingAndTorsionJacobians, m_corr_x, m_corr_q);

    return true;
}
```

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

### Solid Simulation Configuration

Source: https://positionbaseddynamics.readthedocs.io/en/latest/api/class_p_b_d_1_1_simulation_model.html

Functions for setting and getting solid simulation parameters.

```APIDOC
## Solid Simulation API

### Description
Provides methods to configure and retrieve settings related to solid simulations.

### Methods

#### Add Solid Constraints
```cpp
void addSolidConstraints(const TetModel *tm, const unsigned int solidMethod, const Real stiffness, const Real poissonRatio, const Real volumeStiffness, const bool normalizeStretch, const bool normalizeShear)
```
Adds constraints to a tetrahedral model for solid simulation.

#### Set Solid Simulation Method
```cpp
void setSolidSimulationMethod(const int val)
```
Sets the simulation method for solids.

#### Get Solid Simulation Method
```cpp
int getSolidSimulationMethod()
```
Retrieves the current simulation method for solids.

#### Set Solid Stiffness
```cpp
void setSolidStiffness(Real val)
```
Sets the stiffness for solid simulation.

#### Get Solid Stiffness
```cpp
Real getSolidStiffness()
```
Retrieves the stiffness of the solid simulation.

#### Set Solid Poisson Ratio
```cpp
void setSolidPoissonRatio(Real val)
```
Sets the Poisson's ratio for solid simulation.

#### Get Solid Poisson Ratio
```cpp
Real getSolidPoissonRatio()
```
Retrieves the Poisson's ratio of the solid simulation.

#### Set Solid Volume Stiffness
```cpp
void setSolidVolumeStiffness(Real val)
```
Sets the volume stiffness for solid simulation.

#### Get Solid Volume Stiffness
```cpp
Real getSolidVolumeStiffness()
```
Retrieves the volume stiffness of the solid simulation.

#### Set Solid Normalize Stretch
```cpp
void setSolidNormalizeStretch(bool val)
```
Enables or disables stretch normalization for solids.

#### Get Solid Normalize Stretch
```cpp
bool getSolidNormalizeStretch()
```
Checks if stretch normalization is enabled for solids.

#### Set Solid Normalize Shear
```cpp
void setSolidNormalizeShear(bool val)
```
Enables or disables shear normalization for solids.

#### Get Solid Normalize Shear
```cpp
bool getSolidNormalizeShear()
```
Checks if shear normalization is enabled for solids.

### Constants

- `SOLID_SIMULATION_METHOD`
- `ENUM_SOLIDSIM_NONE`
- `ENUM_SOLIDSIM_DISTANCE_CONSTRAINTS`
- `ENUM_SOLIDSIM_FEM_PBD`
- `ENUM_SOLIDSIM_FEM_XPBD`
- `ENUM_SOLIDSIM_SBD`
- `ENUM_SOLIDSIM_SHAPE_MATCHING`
- `ENUM_SOLIDSIM_DISTANCE_CONSTRAINTS_XPBD`
- `SOLID_STIFFNESS`
- `SOLID_POISSON_RATIO`
- `SOLID_VOLUME_STIFFNESS`
- `SOLID_NORMALIZE_STRETCH`
- `SOLID_NORMALIZE_SHEAR`
```

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

### Initialize Before Projection for Direct Position Based Solver

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/api/program_listing_file_PositionBasedDynamics_PositionBasedElasticRods.cpp.rst.txt

Prepares constraints for the projection phase by initializing stretch, bending, and torsion constraints with relevant parameters like stiffness, time step, and compliance.

```cpp
bool PBD::DirectPositionBasedSolverForStiffRods::initBeforeProjection_DirectPositionBasedSolverForStiffRodsConstraint(
       const std::vector<RodConstraint*> &rodConstraints,
       const Real inverseTimeStepSize,
       std::vector<Vector6r> & lambdaSums
       )
   {
       for (size_t cIdx(0); cIdx < rodConstraints.size(); ++cIdx)
       {
           RodConstraint * constraint(rodConstraints[cIdx]);

           initBeforeProjection_StretchBendingTwistingConstraint(
               constraint->getStiffnessCoefficientK(),
               inverseTimeStepSize,
               constraint->getAverageSegmentLength(),
               constraint->getStretchCompliance(),
               constraint->getBendingAndTorsionCompliance(),
               lambdaSums[cIdx]);
       }
       return true;
   }
```

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

### Cloth Simulation Configuration

Source: https://positionbaseddynamics.readthedocs.io/en/latest/api/class_p_b_d_1_1_simulation_model.html

Functions for setting and getting cloth simulation parameters.

```APIDOC
## Cloth Simulation API

### Description
Provides methods to configure and retrieve settings related to cloth simulations.

### Methods

#### Set Cloth Simulation Method
```cpp
void setClothSimulationMethod(const int val)
```
Sets the simulation method for cloth.

#### Get Cloth Simulation Method
```cpp
int getClothSimulationMethod()
```
Retrieves the current simulation method for cloth.

#### Set Cloth Bending Method
```cpp
void setClothBendingMethod(const int val)
```
Sets the bending method for cloth.

#### Get Cloth Bending Method
```cpp
int getClothBendingMethod()
```
Retrieves the current bending method for cloth.

#### Set Cloth Stiffness
```cpp
void setClothStiffness(Real val)
```
Sets the general stiffness for cloth.

#### Get Cloth Stiffness
```cpp
Real getClothStiffness()
```
Retrieves the general stiffness of the cloth.

#### Set Cloth Stiffness XX
```cpp
void setClothStiffnessXX(Real val)
```
Sets the stiffness in the XX direction for cloth.

#### Get Cloth Stiffness XX
```cpp
Real getClothStiffnessXX()
```
Retrieves the stiffness in the XX direction of the cloth.

#### Set Cloth Stiffness YY
```cpp
void setClothStiffnessYY(Real val)
```
Sets the stiffness in the YY direction for cloth.

#### Get Cloth Stiffness YY
```cpp
Real getClothStiffnessYY()
```
Retrieves the stiffness in the YY direction of the cloth.

#### Set Cloth Stiffness XY
```cpp
void setClothStiffnessXY(Real val)
```
Sets the stiffness in the XY direction for cloth.

#### Get Cloth Stiffness XY
```cpp
Real getClothStiffnessXY()
```
Retrieves the stiffness in the XY direction of the cloth.

#### Set Cloth Poisson Ratio XY
```cpp
void setClothPoissonRatioXY(Real val)
```
Sets the Poisson's ratio (XY) for cloth.

#### Get Cloth Poisson Ratio XY
```cpp
Real getClothPoissonRatioXY()
```
Retrieves the Poisson's ratio (XY) of the cloth.

#### Set Cloth Poisson Ratio YX
```cpp
void setClothPoissonRatioYX(Real val)
```
Sets the Poisson's ratio (YX) for cloth.

#### Get Cloth Poisson Ratio YX
```cpp
Real getClothPoissonRatioYX()
```
Retrieves the Poisson's ratio (YX) of the cloth.

#### Set Cloth Bending Stiffness
```cpp
void setClothBendingStiffness(Real val)
```
Sets the bending stiffness for cloth.

#### Get Cloth Bending Stiffness
```cpp
Real getClothBendingStiffness()
```
Retrieves the bending stiffness of the cloth.

#### Set Cloth Normalize Stretch
```cpp
void setClothNormalizeStretch(bool val)
```
Enables or disables stretch normalization for cloth.

#### Get Cloth Normalize Stretch
```cpp
bool getClothNormalizeStretch()
```
Checks if stretch normalization is enabled for cloth.

#### Set Cloth Normalize Shear
```cpp
void setClothNormalizeShear(bool val)
```
Enables or disables shear normalization for cloth.

#### Get Cloth Normalize Shear
```cpp
bool getClothNormalizeShear()
```
Checks if shear normalization is enabled for cloth.

### Constants

- `CLOTH_SIMULATION_METHOD`
- `ENUM_CLOTHSIM_NONE`
- `ENUM_CLOTHSIM_DISTANCE_CONSTRAINTS`
- `ENUM_CLOTHSIM_FEM_PBD`
- `ENUM_CLOTHSIM_SBD`
- `ENUM_CLOTHSIM_DISTANCE_CONSTRAINTS_XPBD`
- `CLOTH_STIFFNESS`
- `CLOTH_STIFFNESS_XX`
- `CLOTH_STIFFNESS_YY`
- `CLOTH_STIFFNESS_XY`
- `CLOTH_POISSON_RATIO_XY`
- `CLOTH_POISSON_RATIO_YX`
- `CLOTH_BENDING_METHOD`
- `ENUM_CLOTH_BENDING_NONE`
- `ENUM_CLOTH_BENDING_DIHEDRAL_ANGLE`
- `ENUM_CLOTH_BENDING_ISOMETRIC`
- `ENUM_CLOTH_BENDING_ISOMETRIX_XPBD`
- `CLOTH_BENDING_STIFFNESS`
- `CLOTH_NORMALIZE_STRETCH`
- `CLOTH_NORMALIZE_SHEAR`
```

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

### Initialize Tree Structure for PBD Solver

Source: https://positionbaseddynamics.readthedocs.io/en/latest/api/program_listing_file_PositionBasedDynamics_PositionBasedElasticRods.cpp.html

Sets up the initial tree structure for the PBD solver, defining intervals and initializing lists and root nodes.

```cpp
void PBD::DirectPositionBasedSolverForStiffRods::initTree(std::vector<RodConstraint*> &rodConstraints, std::vector<RodSegment*> & rodSegments, Interval* &intervals, int &numberOfIntervals, std::list <Node*> * &forward, std::list <Node*> * &backward, Node* &root)
{
    numberOfIntervals = 1;
    intervals = new Interval[1];
    intervals[0].start = 0;
    intervals[0].end = (int)rodConstraints.size() - 1;
    initLists(numberOfIntervals, forward, backward, root);

    std::vector <RodConstraint*> markedConstraints;
    for (int i = 0; i < numberOfIntervals; i++)
    {
        initNodes(i, rodSegments, root, intervals, rodConstraints, forward, backward, markedConstraints);
        markedConstraints.clear();
    }
}
```

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

### Get Constraints

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/api/program_listing_file_Simulation_SimulationModel.cpp.rst.txt

Returns a reference to the vector of Constraint objects active in the simulation.

```cpp
SimulationModel::ConstraintVector & SimulationModel::getConstraints()
{
       return m_constraints;
}
```

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

### Get Mass Matrix

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/api/program_listing_file_PositionBasedDynamics_PositionBasedElasticRods.cpp.rst.txt

Retrieves the mass matrix for a given rod segment.

```cpp
   void PBD::DirectPositionBasedSolverForStiffRods::getMassMatrix(RodSegment *segment, Matrix6r &M)
   {
       if (!segment->isDynamic())
       {
           M = Matrix6r::Identity();
           return;
       }
   
       const Vector3r &inertiaLocal = segment->InertiaTensor();
       Matrix3r rotationMatrix(segment->Rotation().toRotationMatrix());
       Matrix3r inertia(rotationMatrix *
           Eigen::DiagonalMatrix<Real, 3>(inertiaLocal) *
           rotationMatrix.transpose());
   
       Real mass = segment->Mass();
   
       // Upper half
       for (int i = 0; i < 3; i++)
       for (int j = 0; j < 6; j++)
       if (i == j)
           M(i, j) = mass;
       else
           M(i, j) = 0.0;
   
       // lower left
       for (int i = 3; i < 6; i++)
       for (int j = 0; j < 3; j++)
           M(i, j) = 0.0;
   
       // lower right
       for (int i = 3; i < 6; i++)
       for (int j = 3; j < 6; j++)
           M(i, j) = inertia(i - 3, j - 3);
   }
```

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

### Execute SceneLoaderDemo

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/getting_started.md.txt

Navigate to the bin directory and execute the SceneLoaderDemo with a scene file to simulate it.

```shell
cd ../bin
./SceneLoaderDemo ../data/Scenes/CarScene.json
```

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

### Initialize Direct Position Based Solver for Stiff Rods Constraint

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/api/program_listing_file_PositionBasedDynamics_PositionBasedElasticRods.cpp.rst.txt

Initializes the solver by setting up constraints, computing tree data structures, and resizing/filling necessary data structures like RHS, lambdaSums, Jacobians, and correction vectors.

```cpp
bool PBD::DirectPositionBasedSolverForStiffRods::init_DirectPositionBasedSolverForStiffRodsConstraint(
       std::vector<RodConstraint*> &rodConstraints, 
       std::vector<RodSegment*> & rodSegments, 
       Interval* &intervals, 
       int &numberOfIntervals, 
       std::list <Node*> * &forward, 
       std::list <Node*> * &backward, 
       Node* &root, 
       const std::vector<Vector3r> &constraintPositions,
       const std::vector<Real> &averageRadii,
       const std::vector<Real> &youngsModuli,
       const std::vector<Real> &torsionModuli, 
       std::vector<Vector6r> & RHS, 
       std::vector<Vector6r> & lambdaSums, 
       std::vector<std::vector<Matrix3r>> & bendingAndTorsionJacobians, 
       std::vector<Vector3r> & corr_x, 
       std::vector<Quaternionr> & corr_q
       )
   {
       // init constraints
       for (size_t cIdx(0); cIdx < rodConstraints.size(); ++cIdx)
       {
           RodConstraint * constraint(rodConstraints[cIdx]);
           RodSegment * segment0(rodSegments[constraint->segmentIndex(0)]);
           RodSegment * segment1(rodSegments[constraint->segmentIndex(1)]);

           init_StretchBendingTwistingConstraint(
               segment0->Position(), segment0->Rotation(), segment1->Position(), segment1->Rotation(),
               constraintPositions[cIdx], averageRadii[cIdx], constraint->getAverageSegmentLength(),
               youngsModuli[cIdx], torsionModuli[cIdx], constraint->getConstraintInfo(),
               constraint->getStiffnessCoefficientK(), constraint->getRestDarbouxVector());
       }
       
       // compute tree data structure for direct solver
       initTree(rodConstraints, rodSegments, intervals, numberOfIntervals, forward, backward, root);

       RHS.resize(rodConstraints.size());
       std::fill(RHS.begin(), RHS.end(), Vector6r::Zero());

       lambdaSums.resize(rodConstraints.size());
       std::fill(lambdaSums.begin(), lambdaSums.end(), Vector6r::Zero());

       bendingAndTorsionJacobians.resize(rodConstraints.size());
       std::vector<Matrix3r> sampleJacobians(2);
       sampleJacobians[0].setZero();
       sampleJacobians[1].setZero();
       std::fill(bendingAndTorsionJacobians.begin(), bendingAndTorsionJacobians.end(), sampleJacobians);

       corr_x.resize(rodSegments.size());
       std::fill(corr_x.begin(), corr_x.end(), Vector3r::Zero());

       corr_q.resize(rodSegments.size());
       std::fill(corr_q.begin(), corr_q.end(), Quaternionr::Identity());

       return true;
   }
```

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

### POST /initBeforeProjection_DirectPositionBasedSolverForStiffRodsConstraint

Source: https://positionbaseddynamics.readthedocs.io/en/latest/api/program_listing_file_PositionBasedDynamics_PositionBasedElasticRods.h.html

Initializes the solver before the projection step, calculating compliance based on the time step.

```APIDOC
## POST /initBeforeProjection_DirectPositionBasedSolverForStiffRodsConstraint

### Description
Prepares the solver for the projection step by calculating compliance using the inverse time step size.

### Method
POST

### Parameters
#### Request Body
- **rodConstraints** (vector<RodConstraint*>) - Required - Combined zero-stretch, bending and torsion constraints.
- **inverseTimeStepSize** (Real) - Required - Inverse of the current time step size.
- **lambdaSums** (vector<Vector6r>) - Required - Sum of lambda updates for each constraint.
```

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

### Timing Utility Methods

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/api/program_listing_file_Utils_Timing.h.rst.txt

Core methods for starting and stopping performance timers.

```APIDOC
## Timing::startTiming

### Description
Starts a new timer and pushes it onto the internal timing stack.

### Parameters
#### Request Body
- **name** (string) - Optional - The name of the timer to be logged.

## Timing::stopTiming

### Description
Stops the most recently started timer, calculates the elapsed time in milliseconds, and optionally logs the result.

### Parameters
#### Request Body
- **print** (bool) - Required - If true, logs the elapsed time to the console.
- **id** (int) - Optional - Reference to an ID for tracking average times.

### Response
#### Success Response (200)
- **time** (double) - The elapsed time in milliseconds.
```

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

### Get Line Models

Source: https://positionbaseddynamics.readthedocs.io/en/latest/api/program_listing_file_Simulation_SimulationModel.cpp.html

Returns a reference to the vector of line models used in the simulation.

```cpp
SimulationModel::LineModelVector & SimulationModel::getLineModels()
{
    return m_lineModels;
}
```

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

### Get Tet Models

Source: https://positionbaseddynamics.readthedocs.io/en/latest/api/program_listing_file_Simulation_SimulationModel.cpp.html

Returns a reference to the vector of tetrahedron models used in the simulation.

```cpp
SimulationModel::TetModelVector & SimulationModel::getTetModels()
{
    return m_tetModels;
}
```

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

### Initialize Direct Position Based Solver

Source: https://positionbaseddynamics.readthedocs.io/en/latest/api/program_listing_file_PositionBasedDynamics_PositionBasedElasticRods.cpp.html

Initializes the tree data structure and required buffers for the stiff rod solver.

```cpp
bool PBD::DirectPositionBasedSolverForStiffRods::init_DirectPositionBasedSolverForStiffRodsConstraint(
    std::vector<RodConstraint*> &rodConstraints,
    std::vector<RodSegment*> & rodSegments,
    Interval* &intervals,
    int &numberOfIntervals,
    std::list <Node*> * &forward,
    std::list <Node*> * &backward,
    Node* &root,
    const std::vector<Vector3r> &constraintPositions,
    const std::vector<Real> &averageRadii,
    const std::vector<Real> &youngsModuli,
    const std::vector<Real> &torsionModuli,
    std::vector<Vector6r> & RHS,
    std::vector<Vector6r> & lambdaSums,
    std::vector<std::vector<Matrix3r>> & bendingAndTorsionJacobians,
    std::vector<Vector3r> & corr_x,
    std::vector<Quaternionr> & corr_q
    )
{
    // init constraints
    for (size_t cIdx(0); cIdx < rodConstraints.size(); ++cIdx)
    {
        RodConstraint * constraint(rodConstraints[cIdx]);
        RodSegment * segment0(rodSegments[constraint->segmentIndex(0)]);
        RodSegment * segment1(rodSegments[constraint->segmentIndex(1)]);

        init_StretchBendingTwistingConstraint(
            segment0->Position(), segment0->Rotation(), segment1->Position(), segment1->Rotation(),
            constraintPositions[cIdx], averageRadii[cIdx], constraint->getAverageSegmentLength(),
            youngsModuli[cIdx], torsionModuli[cIdx], constraint->getConstraintInfo(),
            constraint->getStiffnessCoefficientK(), constraint->getRestDarbouxVector());
    }

    // compute tree data structure for direct solver
    initTree(rodConstraints, rodSegments, intervals, numberOfIntervals, forward, backward, root);

    RHS.resize(rodConstraints.size());
    std::fill(RHS.begin(), RHS.end(), Vector6r::Zero());

    lambdaSums.resize(rodConstraints.size());
    std::fill(lambdaSums.begin(), lambdaSums.end(), Vector6r::Zero());

    bendingAndTorsionJacobians.resize(rodConstraints.size());
    std::vector<Matrix3r> sampleJacobians(2);
    sampleJacobians[0].setZero();
    sampleJacobians[1].setZero();
    std::fill(bendingAndTorsionJacobians.begin(), bendingAndTorsionJacobians.end(), sampleJacobians);

    corr_x.resize(rodSegments.size());
    std::fill(corr_x.begin(), corr_x.end(), Vector3r::Zero());

    corr_q.resize(rodSegments.size());
    std::fill(corr_q.begin(), corr_q.end(), Quaternionr::Identity());

    return true;
}
```

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

### init_DirectPositionBasedSolverForStiffRodsConstraint

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/api/program_listing_file_PositionBasedDynamics_PositionBasedElasticRods.h.rst.txt

Initializes the direct solver by computing constraint connectors, diagonal stiffness matrices, and Darboux vectors, while setting up node lists.

```APIDOC
## POST /init_DirectPositionBasedSolverForStiffRodsConstraint

### Description
Computes constraint connectors in segment space, computes the diagonal stiffness matrices and the Darboux vectors of the initial state. Initializes the forward and backward lists of nodes for the direct solver.

### Method
POST

### Parameters
#### Request Body
- **rodConstraints** (std::vector<RodConstraint*>&) - Required - Combined zero-stretch, bending and torsion constraints.
- **rodSegments** (std::vector<RodSegment*>&) - Required - Segments of the rod.
- **intervals** (Interval*&) - Required - Intervals for the solver.
- **numberOfIntervals** (int&) - Required - Total number of intervals.
- **forward** (std::list<Node*>*&) - Required - List of nodes in acyclic tree (parent nodes occur later).
- **backward** (std::list<Node*>*&) - Required - Reverse of the forward list.
- **root** (Node*&) - Required - Root node of the tree.
- **constraintPositions** (const std::vector<Vector3r>&) - Required - Positions of constraints in world coordinates.
- **averageRadii** (const std::vector<Real>&) - Required - Average radii at constraint positions (m).
- **youngsModuli** (const std::vector<Real>&) - Required - Young's modulus for each constraint (Pa).
- **torsionModuli** (const std::vector<Real>&) - Required - Torsion modulus for each constraint (Pa).
- **RHS** (std::vector<Vector6r>&) - Required - Right hand side of the system of equations.
- **lambdaSums** (std::vector<Vector6r>&) - Required - Sum of lambda updates for each constraint.
- **bendingAndTorsionJacobians** (std::vector<std::vector<Matrix3r>>&) - Required - Temporary storage for Jacobians.
- **corr_x** (std::vector<Vector3r>&) - Required - Position corrections for segments.
- **corr_q** (std::vector<Quaternionr>&) - Required - Rotation corrections for segments.

### Response
#### Success Response (200)
- **result** (bool) - Returns true if initialization is successful.
```

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

### Get Triangle Models

Source: https://positionbaseddynamics.readthedocs.io/en/latest/api/program_listing_file_Simulation_SimulationModel.cpp.html

Returns a reference to the vector of triangle models used in the simulation.

```cpp
SimulationModel::TriangleModelVector & SimulationModel::getTriangleModels()
{
    return m_triangleModels;
}
```

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

### Get Last Position

Source: https://positionbaseddynamics.readthedocs.io/en/latest/api/program_listing_file_Simulation_RigidBody.h.html

Provides inline access to the previously recorded position of the object.

```cpp
FORCE_INLINE Vector3r &getLastPosition()
            {
                return m_lastX;
            }
```

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

### Configure Solid Simulation Parameters

Source: https://positionbaseddynamics.readthedocs.io/en/latest/api/program_listing_file_Simulation_SimulationModel.cpp.html

Methods to update stiffness, Poisson ratios, volume stiffness, and normalization settings for solid constraints.

```cpp
void PBD::SimulationModel::setSolidStiffness(Real val)
{
    m_solid_stiffness = val;
    setConstraintValue<FEMTetConstraint, Real, &FEMTetConstraint::m_stiffness>(val);
    setConstraintValue<XPBD_FEMTetConstraint, Real, &XPBD_FEMTetConstraint::m_stiffness>(val);
    setConstraintValue<StrainTetConstraint, Real, &StrainTetConstraint::m_stretchStiffness>(val);
    setConstraintValue<StrainTetConstraint, Real, &StrainTetConstraint::m_shearStiffness>(val);
    setConstraintValue<DistanceConstraint, Real, &DistanceConstraint::m_stiffness>(val);
    setConstraintValue<DistanceConstraint_XPBD, Real, &DistanceConstraint_XPBD::m_stiffness>(val);
    setConstraintValue<ShapeMatchingConstraint, Real, &ShapeMatchingConstraint::m_stiffness>(val);
}
```

```cpp
void PBD::SimulationModel::setSolidPoissonRatio(Real val)
{
    m_solid_poissonRatio = val;
    setConstraintValue<FEMTetConstraint, Real, &FEMTetConstraint::m_poissonRatio>(val);
    setConstraintValue<XPBD_FEMTetConstraint, Real, &XPBD_FEMTetConstraint::m_poissonRatio>(val);
}
```

```cpp
void PBD::SimulationModel::setSolidVolumeStiffness(Real val)
{
    m_solid_volumeStiffness = val;
    setConstraintValue<VolumeConstraint, Real, &VolumeConstraint::m_stiffness>(val);
    setConstraintValue<VolumeConstraint_XPBD, Real, &VolumeConstraint_XPBD::m_stiffness>(val);
}
```

```cpp
void PBD::SimulationModel::setSolidNormalizeStretch(bool val)
{
    m_solid_normalizeStretch = val;
    setConstraintValue<StrainTetConstraint, bool, &StrainTetConstraint::m_normalizeStretch>(val);
}
```

```cpp
void PBD::SimulationModel::setSolidNormalizeShear(bool val)
{
    m_solid_normalizeShear = val;
    setConstraintValue<StrainTetConstraint, bool, &StrainTetConstraint::m_normalizeShear>(val);
}
```

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

### Torque Management

Source: https://positionbaseddynamics.readthedocs.io/en/latest/api/class_p_b_d_1_1_rigid_body.html

Provides methods to get and set the torque applied to a rigid body.

```APIDOC
## GET /rigidBody/torque

### Description
Retrieves the current torque applied to the rigid body.

### Method
GET

### Endpoint
/rigidBody/torque

### Response
#### Success Response (200)
- **torque** (Vector3r) - The current torque.

#### Response Example
```json
{
  "torque": {
    "x": 0.0,
    "y": 0.0,
    "z": 0.0
  }
}
```

## SET /rigidBody/torque

### Description
Sets the torque applied to the rigid body.

### Method
POST

### Endpoint
/rigidBody/torque

### Parameters
#### Request Body
- **value** (Vector3r) - Required - The desired torque.

### Request Example
```json
{
  "value": {
    "x": 5.0,
    "y": 0.0,
    "z": 0.0
  }
}
```
```

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

### Get Line Models

Source: https://positionbaseddynamics.readthedocs.io/en/latest/_sources/api/program_listing_file_Simulation_SimulationModel.cpp.rst.txt

Returns a reference to the vector of LineModel objects used in the simulation.

```cpp
SimulationModel::LineModelVector & SimulationModel::getLineModels()
{
       return m_lineModels;
}
```
Tokens:
Raw