Struct SoftRecoverySettings 

pub struct SoftRecoverySettings {

    pub authored_velocity_margin: bool,
    pub edge_speculation: bool,
    pub inverted_cell_detection: bool,
    pub self_crossing_detection: bool,
    pub detection_motion_gating: bool,
    pub cross_body_detection: bool,
    pub self_stand_down: bool,
    pub cross_body_expel_gate: bool,
    pub edge_stand_down: bool,
    pub crossing_repulsion: bool,
    pub crossing_repulsion_guide: bool,
    pub crossing_repulsion_self_guide: bool,
    pub recovery_pace: f32,
    pub overlap_constraints: bool,
    pub overlap_rigid: bool,
    pub overlap_skip_self_tangled: bool,
    pub overlap_edge_stand_down: bool,
    pub overlap_constraint_pace: f32,
    pub overlap_patch_constraints: SoftPatchConstraints,
    pub overlap_skin_volume: bool,
    pub overlap_kept_depth: f32,
    pub overlap_self_regions: bool,
    pub overlap_normal_push: bool,
    pub overlap_multi_volume: bool,
    pub overlap_split: u32,
    pub overlap_patience: u32,
    pub overlap_progress_margin: f32,
}

Runtime configuration of the soft-body tangle detection and recovery stack. It lives on crate::dynamics::SoftBodiesSettings::recovery (itself on IntegrationParameters::soft_bodies), so it can be changed between steps.

Fields

authored_velocity_margin: bool

Raise the speculative contact margin from velocities authored between steps (insertion, set_particle_velocity), so the coming step’s reach covers them and a fast fresh body does not tunnel. (default: true)

edge_speculation: bool

Give the edge-vs-edge pass a speculative reach (motion margin plus the closing-speed rule) and, in 3D, edge constraints for closed-vs-closed pairs, so bodies crossing corner-first collide; on, those constraints leave pressed 3D piles crossed. (default: false)

inverted_cell_detection: bool

Detect inverted cells (material locally inside out) each step; feeds the self stand-down. (default: true)

self_crossing_detection: bool

Detect surface self-crossings each step (the BVTT sweep); feeds the self stand-down. (default: true)

detection_motion_gating: bool

Skip the self-crossing sweep while the surface’s accumulated travel could not have bridged half a skin (crossings only form through motion). Off: sweep every step. (default: true)

cross_body_detection: bool

Detect boundary crossings between pairs of soft surfaces; feeds the cross-body expel-only gate, the edge-pass stand-down and the intersection-volume constraints. (default: true)

self_stand_down: bool

Self contacts of tangled features (inverted cells, self-crossings) stand down so the elasticity resolves the tangle instead of freezing it at skin distance. (default: true)

cross_body_expel_gate: bool

A vertex constraint touching a boundary crossing between two surfaces may only expel, never hold (a keep-apart constraint there is wrong-sided by construction). (default: true)

edge_stand_down: bool

Edge constraints touching a cross-body boundary crossing stand down (thin open bodies meet through their edge constraints, so the vertex gate alone cannot free them). (default: true)

crossing_repulsion: bool

Constraints on crossing-flagged features repel instead of standing down: the vertex is pushed to the side of the element where its one-ring centroid lies, through to skin distance; a neighborhood straddling the element still stands down. (default: false)

crossing_repulsion_guide: bool

Guide the crossing repulsion by the pair’s volume normal (the separating direction of the two intruding patches’ intersection-volume gradients, per grid cell) instead of the pierced element’s plane normal. Closed pairs only; needs no volume constraint. (default: false)

crossing_repulsion_self_guide: bool

Guide the self-crossing repulsion by the fold’s volume normal: the vertices inside their own body’s self-intersection region are pulled toward the surface they face along the region’s mean normal. Closed meshes only; needs no volume constraint. (default: false)

recovery_pace: f32

Material recovery pace, in length units per second (scaled by IntegrationParameters::length_unit): the corrective rate allowed to deep recovery, demoted intruders and untangling pulls. (default: 0.5)

overlap_constraints: bool

Intersection-volume contact (Allard et al. 2010) for closed surfaces: one coupled constraint per overlapping pair (soft-soft or soft-rigid) over both sides’ intruding patches, corrected by the intersection volume; master switch of the knobs below. (default: true)

overlap_rigid: bool

Overlap constraints against rigid colliders too (the surface vertices inside the shape; a dynamic rigid body takes the reaction, a fixed or kinematic one is a wall). (default: true)

overlap_skip_self_tangled: bool

A self-crossed mesh takes no pair constraint: part of its winding is mirrored, so its volume gradient points the wrong way there (two crossed eights exploded without this). (default: true)

overlap_edge_stand_down: bool

The 3D closed-closed edge constraints stand down on a pair an overlap constraint owns (inside the overlap they are wrong-sided and freeze it). (default: true)

overlap_constraint_pace: f32

Bound on the velocity change the coupled constraint may hand any side per step, in multiples of Self::recovery_pace; Real::MAX makes it hard. (default: 1.0)

overlap_patch_constraints: SoftPatchConstraints

What the per-point constraints (manifold constraints against rigid colliders, vertex constraints against soft surfaces) of the features inside a volume constraint’s patch do, feature by feature (see SoftPatchConstraints). (default: AlongNormal)

overlap_skin_volume: bool

Measure the intersection volume on the contact skins (surfaces dilated by their skin), not the geometric surfaces: a resting pair then has a hard volume constraint with speculative slack before the skins meet. (default: false)

overlap_kept_depth: f32

The skin overlap kept at rest, as a fraction of the pair’s skins (the paper’s maintained interpenetration layer): the correction removes only the volume beyond it, holding the patch’s average depth there; 0.0 rests the surfaces at their skins. (default: 0.0)

overlap_self_regions: bool

Volume constraints on a body’s self-overlaps between distinct surface regions: the vertices behind another part of their own surface form one patch per connected region, each coupled with the surface it faces like a pair of bodies. Closed meshes only. (default: false)

overlap_normal_push: bool

Push along each constraint’s normal instead of the volume gradients: every entry keeps its gradient’s magnitude but takes the constraint’s mean direction, so the whole patch separates along one axis. (default: true)

overlap_multi_volume: bool

Multi-volume grid (the paper’s section 5): each pair’s patch is split into a regular grid of cells along its tangent axes, each with its own constraint and multiplier, so the pressure and friction state vary across the patch. (default: false)

overlap_split: u32

Cells per tangent axis of the multi-volume grid. (default: 3)

overlap_patience: u32

Steps without progress of a pair’s volume estimate before its positional correction stands down (a wedged pair jiggled forever otherwise); it re-arms when the estimate drops again. (default: 240)

overlap_progress_margin: f32

Relative drop of the estimate that counts as progress for the patience. (default: 0.02)

Trait Implementations

impl Clone for SoftRecoverySettings

fn clone(&self) -> SoftRecoverySettings

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for SoftRecoverySettings

impl Debug for SoftRecoverySettings

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

Formats the value using the given formatter.

impl Default for SoftRecoverySettings

fn default() -> SoftRecoverySettings

Returns the “default value” for a type.

impl PartialEq for SoftRecoverySettings

fn eq(&self, other: &SoftRecoverySettings) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for SoftRecoverySettings