A component that can be attached to a PhysicObject of the type DynamicMesh that add soft body physics behaviors to the deformable Mesh.

Soft body physics (or dynamics) can be used for cloth simulation, replicate a whole range of "jelly" and other deformable objects as well as aeros (such as leaves falling etc...).

Static Variables

Name	Description
`physicobject`	Reference to the parent PhysicObject that maintains the SoftBody component.
Declaration PhysicObject *physicobject
`position_iterations`	Specify the current amount of position iterations.
Declaration unsigned char position_iterations Range 1 to 8
`cluster_iterations`	Available only when soft cluster collision is enabled. This value control how many iterations should be used on clusters.
Declaration unsigned char cluster_iterations Range 1 to 8
`velocity_iterations`	Amounts of iterations the velocity solver is currently executing.
Declaration unsigned char velocity_iterations Range 1 to 8
`drift_iterations`	A value greater than 0 represent that the solver is also processing drift.
Declaration unsigned char drift_iterations Range 0 to 8
`drift_interpolation`	Available only if drift solving is enabled. This value allows you to control the smoothness of the drift.
Declaration float drift_interpolation Range 0.0 to 1.0
`clusters_generation`	The active cluster size.
Declaration unsigned int clusters_generation Range 0 to 64 Warning The higher the more precise simulation you will get at the cost of more CPU usage.
`clusters_refine_pass`	The number of pass to refine clusters.
Declaration unsigned int clusters_refine_pass Range 0 to 16
`damping_coefficient`	The active amount of damping controlling how much the environment will affect the SoftBody.
Declaration float damping_coefficient Range 0.0 to 1.0 Remarks A value of 0.0 represents that the air has very little impact, while a value of 1.0 represents full impact.
`drag_coefficient`	The current drag force coefficient to apply on the SoftBody.
Declaration float drag_coefficient
`lift_coefficient`	The current lift force coefficients that affect the active SoftBody.
Declaration float lift_coefficient
`pressure_coefficient`	Represents the influence of the pressure applied on the SoftBody.
Declaration float pressure_coefficient
`volume_conservation`	Factor that determine how much upon impact the percentage of the original volume should be kept.
Declaration float volume_conservation Range 0.0 to 1.0 Remarks The lower the value the more elasticity will be applied; the higher the value the more sturdy the SoftBody will be.
`volume_pose_matching`	Control the percentage of the volume that can be deformed compare to its original pose.
Declaration float volume_pose_matching Range 0.0 to 1.0
`rigid_collision_type`	Determine which RigidSoftCollision algorithm should be used when the SoftBody collides with a RigidBody.
Declaration RigidSoftCollision rigid_collision_type
`rigid_contact_hardness`	Controls the amount of rigid contact hardness.
Declaration float rigid_contact_hardness Range 0.0 to 1.0
`kinetic_contact_hardness`	Controls the influence of kinetic contact hardness.
Declaration float kinetic_contact_hardness Range 0.0 to 1.0
`clusters_rigid_contact_hardness`	Controls the amount of soft vs rigid clusters contact hardness.
Declaration float clusters_rigid_contact_hardness Range 0.0 to 1.0
`clusters_kinetic_contact_hardness`	Controls the kinetic hardness on soft vs rigid clusters.
Declaration float clusters_kinetic_contact_hardness Range 0.0 to 1.0
`clusters_rigid_impulse_split`	Controls the rigid impulse split factor for soft vs rigid clusters collision.
Declaration float clusters_rigid_impulse_split Range 0.0 to 1.0
`clusters_kinetic_impulse_split`	Determine the impulse split factor to use for soft vs rigid clusters collision.
Declaration float clusters_kinetic_impulse_split Range 0.0 to 1.0
`soft_contact_hardness`	Soft contact hardness factor to use on soft vs soft collision.
Declaration float soft_contact_hardness Range 0.0 to 1.0
`clusters_soft_contact_hardness`	Controls the amount of soft contact hardness soft vs soft clusters collision.
Declaration float clusters_soft_contact_hardness Range 0.0 to 1.0
`clusters_soft_impulse_split`	Determine the impulse split factor for soft vs soft clusters collision.
Declaration float clusters_soft_impulse_split Range 0.0 to 1.0
`clusters_matching`	Percentage the clusters should match the original geometry topology.
Declaration float clusters_matching Range 0.0 to 1.0
`clusters_linear_damping`	Amount of linear damping the clusters should be using.
Declaration float clusters_linear_damping Range 0.0 to 1.0
`clusters_angular_damping`	Amount of angular damping the clusters should be using.
Declaration float clusters_angular_damping Range 0.0 to 1.0
`clusters_node_damping`	Amount of damping cluster nodes should be using.
Declaration float kinetic_contact_hardness Range 0.0 to 1.0
`clusters_self_collision_impulse_factor`	Available only when clusters self-collision is enabled; this value controls the amount of impact with nearby clusters.
Declaration float clusters_self_collision_impulse_factor Range 0.0 to 1.0
`clusters_self_max_collision_impulse`	Determine the maximum amount of impulse that can be applied by nearby clusters.
Declaration float clusters_self_max_collision_impulse
`softconstraint_count`	Current amount of SoftConstraint attached to the active SoftBody.
Declaration unsigned short softconstraint_count

Variables

Name	Description
`default_state`	The default ActivationState the SoftBody after it is created.
Declaration ActivationState default_state
`revision`	Active revision number of the active SoftBody.
Declaration unsigned int revision Note Changing the revision number manually will force the internal system to rebuild the SoftBody.
`friction`	Friction factor to apply on the SoftBody.
Declaration float friction Range 0.0 to 1.0
`margin`	Value used to reduce penetration issues during simulation.
Declaration float margin Range 0.0 to 1.0
`contact_processing_threshold`	Specify the amount of time in second (where 1.0 = 1 sec.) before the SoftBody contact point is considered resting; allowing it to be deactivated.
Declaration float contact_processing_threshold Range 0.0 to 1.0
`sleeping_threshold`	The amount of time the active velocity should be considered stable to allow the SoftBody to be deactivated.
Declaration float sleeping_threshold Range 0.0 to 1.0
`mass`	Specify the amount of time in second (where 1.0 = 1 sec.) before the SoftBody contact point is considered resting; allowing it to be deactivated.
Declaration float mass Range 0.0 to inf.
`weighted_mass`	Force the mass to be evenly spreaded among the nodes that form the SoftBody.
Declaration bool weighted_mass
`aero_model`	Specify aero dynamic model (AeroModel) to use for the active SoftBody.
Declaration AeroModel aero_model
`anisotropic_friction`	Controls the internal friction damping by altering the value of each axis.
Declaration vec3 anisotropic_friction Range 0.0 to 1.0
`wind_velocity`	Specify a custom wind velocity that will only affect the active SoftBody.
Declaration vec3 wind_velocity Note If the vector value is set to zero, the SoftBody will use the wind velocity specified in the World properties.
`gravity`	Setup a custom gravity vector that will only affect the active SoftBody.
Declaration vec3 gravity Note If the vector value is set to zero, the SoftBody will use the gravity vector specified in the World properties.
`bending_constraints`	Determine the type of BendingConstraints to use for the active SoftBody.
Declaration BendingConstraints bending_constraints
`anchor_hardness`	Factor that specifies the impact of anchors attached to the SoftBody.
Declaration float anchor_hardness Range 0.0 to 1.0
`randomize_constraints`	Force to randomize the bending constraints applied on the SoftBody.
Declaration bool randomize_constraints
`force`	Control the amount of force applied on the SoftBody.
Declaration vec3 force
`velocity`	Control the amount of velocity applied on the SoftBody.
Declaration vec3 velocity

Functions

Name	Description
`Activate`	Try to activate the active SoftBody.
Declaration void Activate( bool force_activation ) Parameters `force_activation`: Toggle wheter or not to force activation of the SoftBody.
`Deactivate`	Trigger the deactivation of the active SoftBody.
Declaration void Deactivate( void )
`WantsDeactivation`	Hint that the SoftBody require to be deactivated.
Declaration void WantsDeactivation( void )
`DisableDeactivation`	Prevent the SoftBody to be deactivated.
Declaration void DisableDeactivation( void )
`DisableSimulation`	Skip the physic simulation of the active SoftBody.
Declaration void DisableSimulation( void ) Note The SoftBody will still remain in the physics World but will be part of the simulation; to reactivate use the `Activate` function and force its re-activation.
`GetActivationState`	Return the current ActivationState of the active SoftBody.
Declaration ActivationState GetActivationState( void )
`SetMass`	Manually set the mass of a specific node.
Declaration bool SetMass( unsigned int node, float mass ) Parameters `node`: The node index to update. `mass`: The new mass to apply on the node. Return Value `true` if the node index specified is in range and the mass is >= than zero; else return `false`.
`SetIterations`	Helper to modify the active iterations and settings to use for the active SoftBody.
Declaration void SetIterations( unsigned char position_iterations, unsigned char cluster_iterations, bool solve_velocities, unsigned char velocity_iterations, unsigned char drift_iterations, float drift_interpolation ) Parameters `position_iterations`: Specify the current amount of iterations to evaluate the node positions. `cluster_iterations`: Controls the amount of cluster iterations. `solve_velocities`: Determine wheter or not node velocities should be solved. `velocity_iterations`: The amount of iterations to use to solve node velocities. `drift_iterations`: Amount of drift iterations. `drift_interpolation`: Controls the drift interpolation factor to smooth out drifting.
`SetClusterSettings`	Update the settings of a specific cluster.
Declaration bool SetClusterSettings( int cluster float matching, float linear_damping, float angular_damping, float node_damping, float self_collision_impulse, float self_max_collision_impulse ) Parameters `cluster`: Index of the cluster to update. `matching`: Prcentage the clusters should match the original geometry topology. `linear_damping`: The new amount of linear damping the clusters should be using. `angular_damping`: The new amount of angular damping the clusters should be using. `node_damping`: Specify the new node damping factor. `self_collision_impulse`: Factor to use for clusters self collision. `self_max_collision_impulse`: Maximum amount of impulse that can be applied upon self collision. Return Value `false` if the SoftBody does not have any clusters or if the cluster index specified is out of bounds; else return `true`. Note Specifying a `cluster` index below `0` will force all existing clusters to use the settings received by the function.
`BuildClusters`	Function allowing you to build the clusters of the SoftBody.
Declaration void BuildClusters( unsigned int clusters_generation, unsigned int clusters_refine_pass ) Parameters `clusters_generation`: Specify the amount of clusters. `clusters_refine_pass`: Determine the amount of refinement pass.
`SetCoefficients`	Helper allowing you to setup/update the different type of coefficient used by the SoftBody.
Declaration void SetCoefficients( float damping_coefficient, float drag_coefficient, float lift_coefficient, float pressure_coefficient ) Parameters `damping_coefficient`: Specify how much the environment affect the SoftBody. `drag_coefficient`: Determine the amount of drag force that can be applied on the SoftBody. `lift_coefficient`: Factor that controls the impact of lift force on the SoftBody. `pressure_coefficient`: The amount of pressure that can be applied on the SoftBody.
`SetPose`	Function to control the orginal pose of the SoftBody to allow it to come back to its original form.
Declaration void SetPose( bool volume, bool frame ) Parameters `volume`: Snapshot the volume allowing the SoftBody to come back to its original volume. `frame`: Snapshot the vertex positions allowing the SoftBody to come back to its original form.
`SetVolumeSettings`	Controls that amounf of volume deformation that can be applied on the active SoftBody.
Declaration void SetVolumeSettings( float conservation, float pose_matching ) Parameters `conservation`: Upon impact how much percentage of the original volume should be kept. `pose_matching`: How much percent the volume can be deformed compare to its original pose (see `SetPose`).
`SetRigidCollisionSettings`	Function to setup SoftBody vs RigidBody collision settings.
Declaration void SetRigidCollisionSettings( float rigid_contact_hardness, float kinetic_contact_hardness ) Parameters `rigid_contact_hardness`: Controls the hardness of the contacts with a RigidBody. `kinetic_contact_hardness`: Determine the amount of kinetic contact hardness with the RigidBody.
`SetRigidClustersCollisionSettings`	Setup clusters collision parameters.
Declaration void SetRigidClustersCollisionSettings( float rigid_contact_hardness, float kinetic_contact_hardness, float rigid_impulse_split, float kinetic_impulse_split ) Parameters `rigid_contact_hardness`: Controls the hardness of the contacts with a RigidBody. `kinetic_contact_hardness`: Determine the amount of kinetic contact hardness with the RigidBody. `rigid_impulse_split`: Amount of impulse split. `kinetic_impulse_split`: Amount of kinectic impulse split.
`SetRigidCollisionType`	Setup the type of collision to use against RigidBody (RigidSoftCollision).
Declaration void SetRigidCollisionType( const RigidSoftCollision type ) Parameters `type`: The RigidSoftCollision type to use for RigidBody vs SoftBody.
`SetSoftCollisionSettings`	Specify the SoftBody vs SoftBody collision settings.
Declaration void SetSoftCollisionSettings( float contact_hardness ) Parameters `contact_hardness`: Controls the amount of contact hardness vs other SoftBody.
`SetSoftClustersCollisionSettings`	SoftBody vs SoftBody clusters collision settings.
Declaration void SetSoftClustersCollisionSettings( float contact_hardness, float impulse_split, bool self_collision ) Parameters `contact_hardness`: Controls the amount of contact hardness. `impulse_split`: Controls the amount of impulse split. `self_collision`: Determine if self collision of clusters is allowed.
`SetSoftCollisionType`	Specify the type of collision the SoftBody clusters will be processing.
Declaration void SetSoftCollisionType( bool vertex_vs_face, bool clusters ) Parameters `vertex_vs_face`: Compute vertex vs face collision. `clusters`: Compute direct clusters collision.
`SetPhysicMaterial`	Assign a PhysicMaterial to an existing SoftBody primitive.
Declaration void SetPhysicMaterial( unsigned short primitive_index, PhysicMaterial physicmaterial ) Parameters* `primitive_index`: Index of the primitive to apply to PhysicMaterial to. `physicmaterial`: Reference to an existing PhysicMaterial. To remove an existing reference set `nil`.
`ClearForces`	Reset all forces applied on the nodes of SoftBody back to `0`.
Declaration void ClearForces( void )
`AddForce`	Append a certain amount of force to one or more SoftBody node(s).
Declaration bool AddForce( int node, const vec3 force ) Parameters `node`: Specify the index of the node to add force to. `force`: Specify the force vector to append. Return Value `true` if the node index specified was valid; else return `false`. Note Specifying a negative node index will append the force vector to all nodes of the SoftBody.
`SetForce`	Manually set the amount of force of one or all node(s) that construct the SoftBody.
Declaration bool SetForce( int node, const vec3 force ) Parameters `node`: Specify the index of the node to setup the force to. `force`: Specify the amount of force to set for each axis. Return Value `true` if the node index specified was valid; else return `false`. Note To set the same force vector all nodes specify a negative node index.
`GetForce`	Return the active force applied on a specific node.
Declaration vec3 GetForce( int node ) Parameters `index`: Index of the node to return the force. Return Value Upon failure (if the index specified is invalid) return a zeroed/`nil` vector; else return the current force applied to the node.
`ClearVelocities`	Zero out the velocity of all nodes contained in the SoftBody.
Declaration void ClearVelocities( void )
`AddVelocity`	Append velocity to one or all nodes of the SoftBody.
Declaration bool AddVelocity( int node, vec3 velocity ) Parameters `node`: Node index to append velocity to. `velocity`: The amount of velocity to append. Note To append the velocity all nodes set a negative node index.
`SetVelocity`	Set the velocity of one or all nodes contained in the active SoftBody.
Declaration bool SetVelocity( int node, const vec3 velocity ) Parameters `node`: Node index to set velocity to. `velocity`: The amount of velocity to setup. Note To apply the same velocity all nodes set a negative node index.
`GetVelocity`	Helper that return that active velocity use by a specific node index.
Declaration vec3 GetVelocity( int node ) Parameters `node`: The node index to return the velocity for. Return Value The current velocity used by the node specified by index. Return a zeroed/`nil` velocity vector if the node index specified is invalid.
`GetClosestNode`	Helper that returns the AudioPreset reference associated to a specific index.
Declaration int GetClosestNode( const vec3 position, bool local ) Parameters `position`: An arbitrary position. `local`: Specify that the position is either in local space (`true`) or in world space (`false`). Return Value Index of the closests node; `-1` if the function is unable to pin point any node.
`GetNodeInfo`	Return the current NodeInfo structure associated with a particular node.
Declaration NodeInfo GetNodeInfo( unsigned int node ) Parameters `node`: The name of the AudioPreset to retrieve. Return Value Upon failure return a zeroed NodeInfo structure; else return a fully filled structure that contains the node information.
`GetNumConstraintLinks`	Return the amount of constraints currently connected to the active SoftBody.
Declaration int GetNumConstraintLinks( void ) Return Value The amount of constraints (either rigid or soft) connected to the SoftBody.
`AddConstraint`	Generic function to create a new SoftConstraint.
Declaration SoftConstraint AddConstraint( const char name, SoftConstraintType type ) Parameters `name`: A unique name to identify the new SoftConstraint. `type`: Specify the type of SoftConstraintType to create. Return Value Reference to the newly created generic SoftConstraint of the type specified.
`AddPinConstraint`	Helper function to create and attach a new PinConstraint to the active SoftBody.
Declaration PinConstraint AddPinConstraint( const char name ) Parameters `name`: A unique name to identify the new PinConstraint. Return Value Reference to the new PinConstraint freshly created.
`AddAnchorConstraint`	Helper function to create and attach a new AnchorConstraint to the active SoftBody.
Declaration AnchorConstraint AddAnchorConstraint( const char name ) Parameters `name`: A unique name to identify the new AnchorConstraint. Return Value Reference to the newly created AnchorConstraint.
`AddLinearJointConstraint`	Helper that creates a new LinearJointConstraint and attach it to the active SoftBody.
Declaration LinearJointConstraint AddLinearJointConstraint( const char name ) Parameters `name`: A unique name to identify the new LinearJointConstraint. Return Value Reference to the newly created LinearJointConstraint.
`AddAngularJointConstraint`	Helper that creates a new AngularJointConstraint and attach it to the active SoftBody.
Declaration AngularJointConstraint AddAngularJointConstraint( const char name ) Parameters `name`: A unique name to identify the new AngularJointConstraint. Return Value Reference to the newly created AngularJointConstraint.
`GetConstraint`	Retrieve an existing SoftConstraint maintained by the active SoftBody.
Declaration SoftConstraint GetConstraint( const char name ) Parameters `name`: Name of the SoftConstraint to retrieve. Return Value `nil` if no SoftConstraint can be associated to the name received in parameter; else return a valid SoftConstraint reference.
`GetConstraintAt`	Retrieve a constraint using its index as key.
Declaration SoftConstraint GetConstraintAt( unsigned short index ) Parameters* `index`: Index of the SoftConstraint to retrieve. Return Value `nil` if the index provided to the function is invalid; else return the SoftConstraint reference associated to the index received in parameter.
`GetConstraintIndex`	Retrieve the internal index of a specific SoftConstraint maintained by the active SoftBody.
Declaration int GetConstraintIndex( const SoftConstraint softconstraint ) Parameters* `softconstraint`: Reference to a valid SoftConstraint. Return Value `-1` if the SoftConstraint is invalid; else return the internal index of the reference.
`RemoveConstraint`	Remove a SoftConstraint associated to the current SoftBody.
Declaration bool RemoveConstraint( SoftConstraint softconstraint ) Parameters* `softconstraint`: Reference to the SoftConstraint to remove. Return Value `true` if the SoftConstraint have been removed successfully; else return `false` if the reference is invalid.
`RemoveConstraintAt`	Remove a SoftConstraint using its index as key.
Declaration bool RemoveConstraintAt( int index ) Parameters `index`: Index of the SoftConstraint to remove. Return Value `false` if the index is invalid; `true` if the operation was successfull.
`Restore`	Restore the current SoftBody back to its original form before deformation.
Declaration bool Restore( void ) Return Value `true` on success; `false` if the SoftBody have not been deformed, or does have any nodes created yet.
`UpdateBounds`	Manually force to update the Bounds of the underlying Object connected to the PhysicObject associated to the current SoftBody.
Declaration void UpdateBounds( void )
`Update`	Trigger a manual update of the SoftBody re-evaluating its deformation.
Declaration void Update( void )
`SetBendingConstraintPhysicMaterial`	Set the PhysicMaterial to use for BendingConstraints.
Declaration void SetBendingConstraintPhysicMaterial( PhysicMaterial physicmaterial ) Parameters* `physicmaterial`: Reference to an existing PhysicMaterial. To remove an existing reference set to `nil`.

BendingConstraints

Available types of bending constraints.

kDoNotUse: Do not use bending constraints for the active SoftBody; this will cause the SoftBody nodes to be fully bendable and will show no resistance.
kOptimized: Optimized version to calculate bending constraints (slightly slower than kRegular but gives better results).
kRegular: Generic way to calculate bending constraints (faster than kOptimized to process and give acceptable results).

AeroModel

Available types of aerodynamic models you can use to simulate different types of deformable aeros such as leaves, cloth etc...

kVertexOneSided: Vertex normals are taken as it is.
kVertexPoint: Vertex normals are oriented toward velocity.
kVertexTwoSided: Vertex normals are flipped to match velocity.
kVertexTwoSidedLiftDrag: Vertex normals are flipped to match velocity and lift and drag forces are applied.
kFaceOnSided: Face normals are taken as it is.
kFaceTwoSided: Face normals are flipped to match the velocity.
kFaceTwoSidedLiftDrag: Face normals are flipped to match velocity and lift and drag forces are applied.

Note: Using a face approach is faster than using vertices; however all vertex models gives more realistic result but is more complex to calculate (up to 3x).

RigidSoftCollision

Constant types of RigidBody vs SoftBody collision algorithm available. Profile your application to find which model is more suitable.

kRigidSoftDisabled: Completly disable rigid vs soft collision detection.
kRigidSoftSDF: Use signed distance fields to evaluate the collision between rigid and soft body (approximated).
kRigidSoftClusters: Rely on clusters to evaluate collision detection; more precise than using SDF at the cost of more memory (clusters creation is required).

NodeInfo

Structure used to retrieve information about a specific node of a SoftBody.

Static Variables

Name	Description
`location`	Current location of the node in world space.
Declaration vec3 location
`normal`	Current face normal of the node.
Declaration vec3 normal
`linear_velocity`	The active linear velocity of the node.
Declaration vec3 linear_velocity
`force`	Amount of force applied on the node.
Declaration vec3 force
`mass`	Current mass of the node.
Declaration float mass