Struct SoftBodyTearEvent 

pub struct SoftBodyTearEvent {
    pub soft_body: SoftBodyHandle,
    pub torn_edges: Vec<[u32; 2]>,
    pub torn_cells: Vec<[u32; 4]>,
    pub removed_edges: Vec<[u32; 2]>,
    pub split_particles: Vec<(u32, u32)>,
    pub inserted_particles: Vec<u32>,
    pub pieces: Vec<SoftBodyPiece>,
    pub clusters: Vec<SoftClusterSplit>,
    pub moved_joints: Vec<SoftJointMove>,
}

What a tear or a cut did to a soft body (see EventHandler::handle_soft_body_tear_event, crate::dynamics::SoftBodySet::tear and crate::dynamics::SoftBodySet::cut); the indices of torn_edges/torn_cells predate the tear, the others follow it, before the split.

Fields

soft_body: SoftBodyHandle

The soft body that tore.

torn_edges: Vec<[u32; 2]>

The particle pairs of the torn edges a crack opened across. In a cut, the edges the blade meets (see crate::dynamics::SoftBody::crossing_elements).

torn_cells: Vec<[u32; 4]>

The vertices of the torn cells a crack opened through (a tear removes no cell). In a cut, the cells the blade meets.

removed_edges: Vec<[u32; 2]>

The particle pairs of the edges removed for straddling an opened crack: bending edges over a split particle, quad diagonals across an opened triangle side, edges joining two pieces.

split_particles: Vec<(u32, u32)>

The particles the tear passed through, duplicated one copy per piece: (copy, source).

inserted_particles: Vec<u32>

The particles a cut inserted where it crosses a rope, polyline or wire segment: two per crossed segment, both at the crossing, the first joined to the segment’s first particle.

pieces: Vec<SoftBodyPiece>

The soft bodies the torn body came apart into, the piece with the largest rest measure (which keeps the handle) first, the others new soft bodies remembering their origin. Empty when nothing split off; else the first entry maps the retained body’s compacted particles.

clusters: Vec<SoftClusterSplit>

The pieces of every cluster the crack split (see crate::dynamics::SoftBody::seeded_components): one piece keeps the proxy, the others get a fresh one. Empty when no cluster was split.

moved_joints: Vec<SoftJointMove>

The impulse joints moved to another proxy by a cluster split: a joint follows the piece closest to its anchor in the rest shape.

Implementations

impl SoftBodyTearEvent

pub fn bodies(&self) -> impl Iterator<Item = SoftBodyHandle> + '_

The soft bodies the torn body is in after the tear, the one keeping the handle first: the torn body alone when nothing was split off, the Self::pieces otherwise.

pub fn particle_destination( &self, particle: u32, ) -> Option<(SoftBodyHandle, u32)>

Where the particle particle of the torn body (a post-tear index, as the other fields use) is now: the soft body holding it and its index there. None for an index the torn body never had.

pub fn seeds(&self) -> Vec<[u32; 2]>

The particle pairs this tear or cut separated: every split copy with its source, and the two particles a cut inserted on each side of a crossed segment. The seeds of crate::dynamics::SoftBody::seeded_components (post-tear indices).

Trait Implementations

impl Clone for SoftBodyTearEvent

fn clone(&self) -> SoftBodyTearEvent

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SoftBodyTearEvent

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

Formats the value using the given formatter.

impl Default for SoftBodyTearEvent

fn default() -> SoftBodyTearEvent

Returns the “default value” for a type.