Struct CohesionManager 

pub struct CohesionManager {
    pub glyphs: Vec<GlyphCohesion>,
    pub cohesion: f32,
    pub dissolution: Option<f32>,
    pub burst_velocities: Vec<Vec3>,
    /* private fields */
}

Manages cohesion for all glyphs in an entity.

Fields

glyphs: Vec<GlyphCohesion>

cohesion: f32

Entity-level cohesion [0, 1]. 0 = chaotic, 1 = perfectly bound.

dissolution: Option<f32>

Dissolution state: None = intact, Some(t) = dissolving (t = time since start).

burst_velocities: Vec<Vec3>

Velocity vectors set during dissolution burst.

Implementations

impl CohesionManager

pub fn new(positions: &[Vec3], cohesion: f32) -> Self

Create with N glyphs at given positions.

pub fn tick(&mut self, dt: f32) -> Vec<Vec3>

Tick all glyph springs by dt. Returns Vec of positions.

pub fn set_floor(&mut self, y: Option<f32>)

Put a floor under the matter.

y is where the ground is, in the same space the formation is in, and y grows downward — so nothing may end up with a larger y than this. None removes it.

This is what stops a figure being a cloud that happens to hover at the right height. Matter driven into the ground stops at it, debris from a death piles up on it instead of falling through it, and a body that crouches has something to crouch onto.

The bounce is deliberately small and the friction large: this is a stone floor and a body, not a ball.

pub fn floor(&self) -> Option<f32>

Where the floor is, if there is one.

pub fn damage_cohesion(&mut self, amount: f32)

Apply damage to cohesion (reduce it by amount).

pub fn restore_cohesion(&mut self, amount: f32)

Restore cohesion (healing effect).

pub fn end_dissolution(&mut self, cohesion: f32)

Stop dissolving and let the springs take hold again.

Dissolution is a one-way branch in tick: once it starts, glyphs coast on their burst velocities and the springs are never consulted again. That is right for a death, and wrong for everything else matter can do — scattering and re-forming into a different shape, a teleport, a transformation. Ending it puts the glyphs back under the springs from wherever they happen to have drifted to, so they fly home rather than snapping.

pub fn dissolving(&self) -> bool

Whether the matter is currently coming apart.

pub fn heat_all(&mut self, temperature: f32, time: f32)

Apply thermal energy to all glyphs (makes them jitter).

pub fn set_bind(&mut self, stiffness_scale: f32, damping_scale: f32)

Set how hard the springs pull, on top of what cohesion asks for.

1.0, 1.0 is the plain cohesion curve, which is underdamped on purpose: a body that has just been hit should wobble. Raising both makes matter arrive faster and stop when it gets there, which is what a title card or any deliberate transformation wants.

pub fn set_bind_each(&mut self, springs: &[(f32, f32)])

Give each glyph its own spring, by slot.

This is what makes a material a material. Cohesion says how strongly the entity holds together; these multipliers say how strongly each piece of matter in it resists being moved, and they are the difference between a steel blade and a wool cloak hanging off the same shoulders. Steel is four hundred thousand times stiffer than flesh in reality; nothing here needs that range, but the ordering has to be real or a sword bends like an arm.

Damping is the other half and is just as material: steel rings because it barely damps, cloth does not because it damps almost completely.

Shorter than the glyph list is fine: the rest keep what they have.

pub fn set_masses(&mut self, masses: &[f32])

Give each glyph its own inertia, by slot.

Shorter than the glyph list is fine: the rest keep the mass they have.

pub fn total_mass(&self) -> f32

Total mass of the matter in this entity.

pub fn cool_all(&mut self, rate: f32, dt: f32)

Cool all glyphs down.

pub fn apply_shockwave(&mut self, center: Vec3, strength: f32)

Apply an outward impulse from center (e.g. shockwave impact).

pub fn apply_force(&mut self, force: Vec3)

Apply a directional force to all glyphs.

pub fn update_targets(&mut self, new_positions: &[Vec3])

Update formation targets (e.g. entity moved, or formation changed).

pub fn teleport_all(&mut self, positions: &[Vec3])

Teleport all glyphs instantly to formation positions (no animation).

pub fn is_dissolving(&self) -> bool

Whether the entity is currently dissolving.

pub fn is_dissolved(&self) -> bool

Whether dissolution is complete (> 2 seconds have elapsed).

pub fn centroid(&self) -> Vec3

Average position of all glyphs.

pub fn max_drift(&self) -> f32

Max drift across all glyphs (measures how chaotic the formation is).

pub fn avg_temperature(&self) -> f32

Average temperature.

Trait Implementations

impl Clone for CohesionManager

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.