Struct DeformableBody 

pub struct DeformableBody {
    pub positions: Vec<Vec3Fix>,
    pub velocities: Vec<Vec3Fix>,
    pub inv_masses: Vec<Fix128>,
    pub tetrahedra: Vec<[usize; 4]>,
    pub surface_triangles: Vec<[usize; 3]>,
    pub config: DeformableConfig,
    /* private fields */
}

Deformable body simulation

Fields

positions: Vec<Vec3Fix>

Particle positions

velocities: Vec<Vec3Fix>

Velocities

inv_masses: Vec<Fix128>

Inverse mass per particle

tetrahedra: Vec<[usize; 4]>

Tetrahedra (4 vertex indices each)

surface_triangles: Vec<[usize; 3]>

Surface triangles (for rendering/collision)

config: DeformableConfig

Configuration

Implementations

impl DeformableBody

pub fn new( positions: Vec<Vec3Fix>, tetrahedra: &[[usize; 4]], surface_triangles: Vec<[usize; 3]>, mass_per_particle: Fix128, ) -> Self

Create from particle positions and tetrahedra

pub fn new_cube(center: Vec3Fix, half_extent: Fix128, mass: Fix128) -> Self

Create a simple cube deformable (for testing)

pub fn particle_count(&self) -> usize

Number of particles

pub fn step(&mut self, dt: Fix128)

Step simulation

pub fn step_with_sdf(&mut self, dt: Fix128, sdf_colliders: &[SdfCollider])

Step with SDF collision

pub fn center_of_mass(&self) -> Vec3Fix

Centroid of the particle positions. Every constructor gives all particles the same mass, for which this is the centre of mass; it is not mass weighted if inv_masses are edited to differ. Zero for a body without particles.

pub fn resolve_rigid_body_collisions( &mut self, rigid_bodies: &mut [RigidBody], body_radii: &[Fix128], dt: Fix128, )

Resolve collisions between deformable body particles and rigid bodies

Treats each rigid body as a sphere with given radius for simplicity. Applies two-way coupling: deformable particles are pushed out, and rigid bodies receive reaction impulses.

The correction and the (perfectly inelastic) normal impulse are shared by inverse mass, w_p / (w_p + w_b) to the particle and w_b / (w_p + w_b) to the body; a body with zero inverse mass (static, kinematic) takes none, so a particle pressed into it ends exactly on its surface with zero approach speed. A particle exactly at the centre of a body has no push direction and is left untouched; pinned particles (zero inverse mass) are skipped. dt only gates the call (zero is a no-op).

Trait Implementations

impl Debug for DeformableBody

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.