Struct dexterior_visuals::Animation

pub struct Animation<'mesh, State, StepFn, DrawFn>
where
    State: AnimationState,
    StepFn: FnMut(&mut State),
    DrawFn: FnMut(&State, &mut Painter<'_, '_>),
{
    pub mesh: &'mesh SimplicialMesh<2>,
    pub dt: f64,
    pub params: AnimationParams,
    pub state: State,
    pub step: StepFn,
    pub draw: DrawFn,
}

An animated visualization of simulation data.

To display the animation in a window, use RenderWindow::run_animation.

The State type must implement AnimationState to facilitate interpolated rendering. If you don’t care about this, you can simply leave the impl block empty:

impl AnimationState for MyState {}

Note that MyState must still implement Clone. To enable interpolation, implement the interpolate member function and call lerp for each cochain in your state (and decide how/whether to interpolate anything else in your state that isn’t a cochain):

use dexterior as dex;
#[derive(Clone)]
struct MyState {
    p: dex::Cochain<0, dex::Primal>,
    v: dex::Cochain<1, dex::Primal>,
};
impl AnimationState for MyState {
    fn interpolate(old: &Self, new: &Self, t: f64) -> Self {
        Self {
            p: old.p.lerp(&new.p, t),
            v: old.v.lerp(&new.v, t),
        }
    }
}

Note: this could be done with a macro, but it’s a low-priority development, so for now you have to write this boilerplate by hand.

Fields

mesh: &'mesh SimplicialMesh<2>

The mesh that the simulation is derived from.

For now, only 2D meshes are supported. This will change in the future.

dt: f64

Time in seconds per simulation timestep.

params: AnimationParams

Control parameters.

state: State

Initial state of the simulation.

step: StepFn

A function that runs the simulation forward for a timestep.

draw: DrawFn

A function that draws the simulation state.