Struct EffectConfig 

pub struct EffectConfig {
    pub duration: usize,
    pub hold_final_frames: usize,
    pub seed: u64,
    pub gradient: Gradient,
    pub gradient_direction: GradientDirection,
    pub easing: Easing,
    pub existing_color_handling: ExistingColorHandling,
    pub no_color: bool,
    pub background: Option<Color>,
    pub canvas_width: Option<usize>,
    pub canvas_height: Option<usize>,
    pub tab_width: usize,
}

Shared configuration used by the embeddable Rust renderers.

Fields

duration: usize

hold_final_frames: usize

seed: u64

gradient: Gradient

gradient_direction: GradientDirection

easing: Easing

existing_color_handling: ExistingColorHandling

no_color: bool

background: Option<Color>

canvas_width: Option<usize>

canvas_height: Option<usize>

tab_width: usize

Implementations

impl EffectConfig

pub fn with_duration(self, duration: usize) -> Self

Examples found in repository

examples/demo.rs (line 13)

fn main() {
    let args = Args::parse();
    let kind = EffectKind::from_str(&args.effect).unwrap_or(EffectKind::Wipe);
    let mut config = EffectConfig::default()
        .with_duration(args.duration)
        .with_seed(args.seed);

    if let (Some(width), Some(height)) = (args.width, args.height) {
        config = config.with_canvas_size(width.max(1), height.max(1));
    }

    let effect = Effect::with_config(kind, args.text, config);

    let mut stdout = io::stdout();
    for frame in effect.iter() {
        write!(stdout, "\x1b[2J\x1b[H{}", frame.to_ansi_string()).unwrap();
        stdout.flush().unwrap();
        thread::sleep(Duration::from_millis((1000 / args.fps.max(1)) as u64));
    }
    writeln!(stdout).unwrap();
}

examples/showcase.rs (line 377)

fn build_panes(
    text: &str,
    layout: &Layout,
    base_duration: usize,
    theme: Theme,
) -> Vec<PaneRuntime> {
    EffectKind::all()
        .iter()
        .enumerate()
        .map(|(index, kind)| {
            let shape = pane_shape(*kind, index, layout);
            let (pane_width, pane_height) = pane_size(layout, shape);
            let inner_width = pane_width.saturating_sub(2).max(8);
            let inner_height = pane_height.saturating_sub(2).max(3);
            let snippet = snippet(text, index, inner_width, inner_height);
            let accent = theme.accent(*kind, index);
            let duration = base_duration + (index % 9) * 5;
            let config = EffectConfig::default()
                .with_duration(duration)
                .with_seed(1009 + index as u64 * 97)
                .with_canvas_size(inner_width, inner_height)
                .with_gradient(
                    effect_gradient(*kind, index, theme),
                    gradient_direction(index),
                );
            let frames = Effect::with_config(*kind, snippet, config).frames();
            PaneRuntime {
                index,
                kind: *kind,
                frames,
                offset: index * 13,
                speed_numerator: 1 + (index % 4),
                accent,
                shape,
            }
        })
        .collect()
}

examples/loader_lab.rs (line 781)

fn build_panes(effect_width: usize, effect_height: usize, focus_ticks: usize) -> Vec<Pane> {
    let ops = [
        ("DOWNLOAD", "tendon-atlas", "MB"),
        ("UPLOAD", "field-manifest", "MB"),
        ("SYNC", "sensor-mesh", "pkt"),
        ("VERIFY", "leverage-map", "chk"),
        ("STREAM", "gait-vectors", "vec"),
        ("FORGE", "actuator-curve", "N"),
        ("DECRYPT", "intent-bus", "blk"),
        ("MIRROR", "joint-state", "msg"),
        ("PACK", "motion-plan", "ops"),
        ("RELAY", "balance-loop", "hz"),
        ("CALIBRATE", "cable-stack", "mm"),
        ("ARCHIVE", "field-log", "MB"),
    ];
    let effects = [
        EffectKind::Matrix,
        EffectKind::Burn,
        EffectKind::Decrypt,
        EffectKind::Thunderstorm,
        EffectKind::LaserEtch,
        EffectKind::Blackhole,
        EffectKind::Rings,
        EffectKind::Swarm,
        EffectKind::Fireworks,
        EffectKind::Slice,
        EffectKind::Waves,
        EffectKind::Wipe,
    ];
    let palette = [
        Color::rgb(74, 255, 170),
        Color::rgb(255, 118, 54),
        Color::rgb(92, 204, 255),
        Color::rgb(255, 216, 92),
        Color::rgb(172, 130, 255),
        Color::rgb(255, 112, 218),
        Color::rgb(112, 236, 255),
        Color::rgb(255, 178, 72),
    ];
    let speeds = [1, 2, 3, 4, 5, 7, 9, 11];

    LoaderKind::all()
        .iter()
        .enumerate()
        .map(|(index, kind)| {
            let (op, noun, unit) = ops[index % ops.len()];
            let effect_kind = effects[(index * 5 + 3) % effects.len()];
            let accent = palette[index % palette.len()];
            let label = format!("{} {}", op.to_ascii_lowercase(), noun);
            let effect_text = format!("{} {}\n{}", op, kind.name(), noun).to_ascii_uppercase();
            let effect = Effect::with_config(
                effect_kind,
                effect_text,
                EffectConfig::default()
                    .with_duration(focus_ticks)
                    .with_seed(991 + index as u64 * 37)
                    .with_canvas_size(effect_width, effect_height.max(1))
                    .with_gradient(
                        Gradient::new(
                            vec![accent, accent.brighten(0.32), Color::rgb(230, 244, 250)],
                            20,
                        ),
                        GradientDirection::Diagonal,
                    ),
            );
            Pane {
                index,
                kind: *kind,
                op,
                noun,
                label,
                unit,
                total: 128 + ((index as u64 * 97) % 2048),
                speed: speeds[index % speeds.len()],
                offset: index * 17,
                accent,
                effect_kind,
                effect_frames: effect.frames(),
            }
        })
        .collect()
}

examples/story.rs (line 567)

fn build_scenes(source: &str, layout: &Layout, scene_ticks: usize) -> Vec<Scene> {
    let paragraphs = paragraphs(source);
    let effect_w = layout.stage.w.saturating_sub(8).max(40);
    let effect_h = layout.stage.h.saturating_sub(16).max(5).min(12);
    let specs = [
        (
            "BOOT SEQUENCE",
            "matrix rain resolves the mission",
            EffectKind::Matrix,
            Color::rgb(74, 255, 170),
            0usize,
        ),
        (
            "FORGE",
            "burning the actuator constraints",
            EffectKind::Burn,
            Color::rgb(255, 118, 54),
            3,
        ),
        (
            "STORM SENSORS",
            "signal and response in the weather",
            EffectKind::Thunderstorm,
            Color::rgb(96, 204, 255),
            2,
        ),
        (
            "LASER ETCH",
            "leverage maps cut into the frame",
            EffectKind::LaserEtch,
            Color::rgb(255, 220, 92),
            7,
        ),
        (
            "GRAVITY WELL",
            "weight and balance collapse into order",
            EffectKind::Blackhole,
            Color::rgb(164, 126, 255),
            5,
        ),
        (
            "ORBITAL BALANCE",
            "rings of motion settle around intent",
            EffectKind::Rings,
            Color::rgb(110, 255, 224),
            6,
        ),
        (
            "SWARM CALIBRATION",
            "many small forces become one gait",
            EffectKind::Swarm,
            Color::rgb(255, 112, 218),
            4,
        ),
        (
            "FIELD DEMO",
            "fireworks over the completed machine",
            EffectKind::Fireworks,
            Color::rgb(255, 180, 72),
            1,
        ),
    ];
    specs
        .iter()
        .enumerate()
        .map(
            |(index, (title, subtitle, kind, accent, paragraph_index))| {
                let paragraph = paragraphs
                    .get(*paragraph_index)
                    .or_else(|| paragraphs.get(index % paragraphs.len().max(1)))
                    .cloned()
                    .unwrap_or_else(|| source.to_string());
                let extra = match kind {
                    EffectKind::Matrix => "Data falls until it becomes purpose.",
                    EffectKind::Burn => "The forge removes everything that does not serve motion.",
                    EffectKind::Thunderstorm => "Noise becomes weather; weather becomes signal.",
                    EffectKind::LaserEtch => "Leverage is written as geometry and timing.",
                    EffectKind::Blackhole => {
                        "Weight collapses into balance before it expands into gait."
                    }
                    EffectKind::Rings => "Joints orbit a center of intention.",
                    EffectKind::Swarm => "Many corrections gather into one quiet step.",
                    _ => "The machine disappears into the grace of the whole.",
                };
                let text = wrap_text(&format!("{}\n\n{}", paragraph, extra), effect_w);
                let gradient = Gradient::new(
                    vec![*accent, accent.brighten(0.36), Color::rgb(235, 244, 250)],
                    32,
                );
                let config = EffectConfig::default()
                    .with_duration(scene_ticks.max(8))
                    .with_seed(700 + index as u64 * 97)
                    .with_canvas_size(effect_w, effect_h)
                    .with_gradient(gradient, GradientDirection::Diagonal);
                let frames = Effect::with_config(*kind, text.clone(), config).frames();
                Scene {
                    title,
                    subtitle,
                    effect: *kind,
                    accent: *accent,
                    frames,
                    quote: paragraph,
                }
            },
        )
        .collect()
}

pub fn with_seed(self, seed: u64) -> Self

Examples found in repository

examples/demo.rs (line 14)

fn main() {
    let args = Args::parse();
    let kind = EffectKind::from_str(&args.effect).unwrap_or(EffectKind::Wipe);
    let mut config = EffectConfig::default()
        .with_duration(args.duration)
        .with_seed(args.seed);

    if let (Some(width), Some(height)) = (args.width, args.height) {
        config = config.with_canvas_size(width.max(1), height.max(1));
    }

    let effect = Effect::with_config(kind, args.text, config);

    let mut stdout = io::stdout();
    for frame in effect.iter() {
        write!(stdout, "\x1b[2J\x1b[H{}", frame.to_ansi_string()).unwrap();
        stdout.flush().unwrap();
        thread::sleep(Duration::from_millis((1000 / args.fps.max(1)) as u64));
    }
    writeln!(stdout).unwrap();
}

examples/showcase.rs (line 378)

fn build_panes(
    text: &str,
    layout: &Layout,
    base_duration: usize,
    theme: Theme,
) -> Vec<PaneRuntime> {
    EffectKind::all()
        .iter()
        .enumerate()
        .map(|(index, kind)| {
            let shape = pane_shape(*kind, index, layout);
            let (pane_width, pane_height) = pane_size(layout, shape);
            let inner_width = pane_width.saturating_sub(2).max(8);
            let inner_height = pane_height.saturating_sub(2).max(3);
            let snippet = snippet(text, index, inner_width, inner_height);
            let accent = theme.accent(*kind, index);
            let duration = base_duration + (index % 9) * 5;
            let config = EffectConfig::default()
                .with_duration(duration)
                .with_seed(1009 + index as u64 * 97)
                .with_canvas_size(inner_width, inner_height)
                .with_gradient(
                    effect_gradient(*kind, index, theme),
                    gradient_direction(index),
                );
            let frames = Effect::with_config(*kind, snippet, config).frames();
            PaneRuntime {
                index,
                kind: *kind,
                frames,
                offset: index * 13,
                speed_numerator: 1 + (index % 4),
                accent,
                shape,
            }
        })
        .collect()
}

examples/loader_lab.rs (line 782)

fn build_panes(effect_width: usize, effect_height: usize, focus_ticks: usize) -> Vec<Pane> {
    let ops = [
        ("DOWNLOAD", "tendon-atlas", "MB"),
        ("UPLOAD", "field-manifest", "MB"),
        ("SYNC", "sensor-mesh", "pkt"),
        ("VERIFY", "leverage-map", "chk"),
        ("STREAM", "gait-vectors", "vec"),
        ("FORGE", "actuator-curve", "N"),
        ("DECRYPT", "intent-bus", "blk"),
        ("MIRROR", "joint-state", "msg"),
        ("PACK", "motion-plan", "ops"),
        ("RELAY", "balance-loop", "hz"),
        ("CALIBRATE", "cable-stack", "mm"),
        ("ARCHIVE", "field-log", "MB"),
    ];
    let effects = [
        EffectKind::Matrix,
        EffectKind::Burn,
        EffectKind::Decrypt,
        EffectKind::Thunderstorm,
        EffectKind::LaserEtch,
        EffectKind::Blackhole,
        EffectKind::Rings,
        EffectKind::Swarm,
        EffectKind::Fireworks,
        EffectKind::Slice,
        EffectKind::Waves,
        EffectKind::Wipe,
    ];
    let palette = [
        Color::rgb(74, 255, 170),
        Color::rgb(255, 118, 54),
        Color::rgb(92, 204, 255),
        Color::rgb(255, 216, 92),
        Color::rgb(172, 130, 255),
        Color::rgb(255, 112, 218),
        Color::rgb(112, 236, 255),
        Color::rgb(255, 178, 72),
    ];
    let speeds = [1, 2, 3, 4, 5, 7, 9, 11];

    LoaderKind::all()
        .iter()
        .enumerate()
        .map(|(index, kind)| {
            let (op, noun, unit) = ops[index % ops.len()];
            let effect_kind = effects[(index * 5 + 3) % effects.len()];
            let accent = palette[index % palette.len()];
            let label = format!("{} {}", op.to_ascii_lowercase(), noun);
            let effect_text = format!("{} {}\n{}", op, kind.name(), noun).to_ascii_uppercase();
            let effect = Effect::with_config(
                effect_kind,
                effect_text,
                EffectConfig::default()
                    .with_duration(focus_ticks)
                    .with_seed(991 + index as u64 * 37)
                    .with_canvas_size(effect_width, effect_height.max(1))
                    .with_gradient(
                        Gradient::new(
                            vec![accent, accent.brighten(0.32), Color::rgb(230, 244, 250)],
                            20,
                        ),
                        GradientDirection::Diagonal,
                    ),
            );
            Pane {
                index,
                kind: *kind,
                op,
                noun,
                label,
                unit,
                total: 128 + ((index as u64 * 97) % 2048),
                speed: speeds[index % speeds.len()],
                offset: index * 17,
                accent,
                effect_kind,
                effect_frames: effect.frames(),
            }
        })
        .collect()
}

examples/story.rs (line 568)

fn build_scenes(source: &str, layout: &Layout, scene_ticks: usize) -> Vec<Scene> {
    let paragraphs = paragraphs(source);
    let effect_w = layout.stage.w.saturating_sub(8).max(40);
    let effect_h = layout.stage.h.saturating_sub(16).max(5).min(12);
    let specs = [
        (
            "BOOT SEQUENCE",
            "matrix rain resolves the mission",
            EffectKind::Matrix,
            Color::rgb(74, 255, 170),
            0usize,
        ),
        (
            "FORGE",
            "burning the actuator constraints",
            EffectKind::Burn,
            Color::rgb(255, 118, 54),
            3,
        ),
        (
            "STORM SENSORS",
            "signal and response in the weather",
            EffectKind::Thunderstorm,
            Color::rgb(96, 204, 255),
            2,
        ),
        (
            "LASER ETCH",
            "leverage maps cut into the frame",
            EffectKind::LaserEtch,
            Color::rgb(255, 220, 92),
            7,
        ),
        (
            "GRAVITY WELL",
            "weight and balance collapse into order",
            EffectKind::Blackhole,
            Color::rgb(164, 126, 255),
            5,
        ),
        (
            "ORBITAL BALANCE",
            "rings of motion settle around intent",
            EffectKind::Rings,
            Color::rgb(110, 255, 224),
            6,
        ),
        (
            "SWARM CALIBRATION",
            "many small forces become one gait",
            EffectKind::Swarm,
            Color::rgb(255, 112, 218),
            4,
        ),
        (
            "FIELD DEMO",
            "fireworks over the completed machine",
            EffectKind::Fireworks,
            Color::rgb(255, 180, 72),
            1,
        ),
    ];
    specs
        .iter()
        .enumerate()
        .map(
            |(index, (title, subtitle, kind, accent, paragraph_index))| {
                let paragraph = paragraphs
                    .get(*paragraph_index)
                    .or_else(|| paragraphs.get(index % paragraphs.len().max(1)))
                    .cloned()
                    .unwrap_or_else(|| source.to_string());
                let extra = match kind {
                    EffectKind::Matrix => "Data falls until it becomes purpose.",
                    EffectKind::Burn => "The forge removes everything that does not serve motion.",
                    EffectKind::Thunderstorm => "Noise becomes weather; weather becomes signal.",
                    EffectKind::LaserEtch => "Leverage is written as geometry and timing.",
                    EffectKind::Blackhole => {
                        "Weight collapses into balance before it expands into gait."
                    }
                    EffectKind::Rings => "Joints orbit a center of intention.",
                    EffectKind::Swarm => "Many corrections gather into one quiet step.",
                    _ => "The machine disappears into the grace of the whole.",
                };
                let text = wrap_text(&format!("{}\n\n{}", paragraph, extra), effect_w);
                let gradient = Gradient::new(
                    vec![*accent, accent.brighten(0.36), Color::rgb(235, 244, 250)],
                    32,
                );
                let config = EffectConfig::default()
                    .with_duration(scene_ticks.max(8))
                    .with_seed(700 + index as u64 * 97)
                    .with_canvas_size(effect_w, effect_h)
                    .with_gradient(gradient, GradientDirection::Diagonal);
                let frames = Effect::with_config(*kind, text.clone(), config).frames();
                Scene {
                    title,
                    subtitle,
                    effect: *kind,
                    accent: *accent,
                    frames,
                    quote: paragraph,
                }
            },
        )
        .collect()
}

pub fn with_gradient( self, gradient: Gradient, direction: GradientDirection, ) -> Self

Examples found in repository

examples/showcase.rs (lines 380-383)

fn build_panes(
    text: &str,
    layout: &Layout,
    base_duration: usize,
    theme: Theme,
) -> Vec<PaneRuntime> {
    EffectKind::all()
        .iter()
        .enumerate()
        .map(|(index, kind)| {
            let shape = pane_shape(*kind, index, layout);
            let (pane_width, pane_height) = pane_size(layout, shape);
            let inner_width = pane_width.saturating_sub(2).max(8);
            let inner_height = pane_height.saturating_sub(2).max(3);
            let snippet = snippet(text, index, inner_width, inner_height);
            let accent = theme.accent(*kind, index);
            let duration = base_duration + (index % 9) * 5;
            let config = EffectConfig::default()
                .with_duration(duration)
                .with_seed(1009 + index as u64 * 97)
                .with_canvas_size(inner_width, inner_height)
                .with_gradient(
                    effect_gradient(*kind, index, theme),
                    gradient_direction(index),
                );
            let frames = Effect::with_config(*kind, snippet, config).frames();
            PaneRuntime {
                index,
                kind: *kind,
                frames,
                offset: index * 13,
                speed_numerator: 1 + (index % 4),
                accent,
                shape,
            }
        })
        .collect()
}

examples/loader_lab.rs (lines 784-790)

fn build_panes(effect_width: usize, effect_height: usize, focus_ticks: usize) -> Vec<Pane> {
    let ops = [
        ("DOWNLOAD", "tendon-atlas", "MB"),
        ("UPLOAD", "field-manifest", "MB"),
        ("SYNC", "sensor-mesh", "pkt"),
        ("VERIFY", "leverage-map", "chk"),
        ("STREAM", "gait-vectors", "vec"),
        ("FORGE", "actuator-curve", "N"),
        ("DECRYPT", "intent-bus", "blk"),
        ("MIRROR", "joint-state", "msg"),
        ("PACK", "motion-plan", "ops"),
        ("RELAY", "balance-loop", "hz"),
        ("CALIBRATE", "cable-stack", "mm"),
        ("ARCHIVE", "field-log", "MB"),
    ];
    let effects = [
        EffectKind::Matrix,
        EffectKind::Burn,
        EffectKind::Decrypt,
        EffectKind::Thunderstorm,
        EffectKind::LaserEtch,
        EffectKind::Blackhole,
        EffectKind::Rings,
        EffectKind::Swarm,
        EffectKind::Fireworks,
        EffectKind::Slice,
        EffectKind::Waves,
        EffectKind::Wipe,
    ];
    let palette = [
        Color::rgb(74, 255, 170),
        Color::rgb(255, 118, 54),
        Color::rgb(92, 204, 255),
        Color::rgb(255, 216, 92),
        Color::rgb(172, 130, 255),
        Color::rgb(255, 112, 218),
        Color::rgb(112, 236, 255),
        Color::rgb(255, 178, 72),
    ];
    let speeds = [1, 2, 3, 4, 5, 7, 9, 11];

    LoaderKind::all()
        .iter()
        .enumerate()
        .map(|(index, kind)| {
            let (op, noun, unit) = ops[index % ops.len()];
            let effect_kind = effects[(index * 5 + 3) % effects.len()];
            let accent = palette[index % palette.len()];
            let label = format!("{} {}", op.to_ascii_lowercase(), noun);
            let effect_text = format!("{} {}\n{}", op, kind.name(), noun).to_ascii_uppercase();
            let effect = Effect::with_config(
                effect_kind,
                effect_text,
                EffectConfig::default()
                    .with_duration(focus_ticks)
                    .with_seed(991 + index as u64 * 37)
                    .with_canvas_size(effect_width, effect_height.max(1))
                    .with_gradient(
                        Gradient::new(
                            vec![accent, accent.brighten(0.32), Color::rgb(230, 244, 250)],
                            20,
                        ),
                        GradientDirection::Diagonal,
                    ),
            );
            Pane {
                index,
                kind: *kind,
                op,
                noun,
                label,
                unit,
                total: 128 + ((index as u64 * 97) % 2048),
                speed: speeds[index % speeds.len()],
                offset: index * 17,
                accent,
                effect_kind,
                effect_frames: effect.frames(),
            }
        })
        .collect()
}

examples/story.rs (line 570)

fn build_scenes(source: &str, layout: &Layout, scene_ticks: usize) -> Vec<Scene> {
    let paragraphs = paragraphs(source);
    let effect_w = layout.stage.w.saturating_sub(8).max(40);
    let effect_h = layout.stage.h.saturating_sub(16).max(5).min(12);
    let specs = [
        (
            "BOOT SEQUENCE",
            "matrix rain resolves the mission",
            EffectKind::Matrix,
            Color::rgb(74, 255, 170),
            0usize,
        ),
        (
            "FORGE",
            "burning the actuator constraints",
            EffectKind::Burn,
            Color::rgb(255, 118, 54),
            3,
        ),
        (
            "STORM SENSORS",
            "signal and response in the weather",
            EffectKind::Thunderstorm,
            Color::rgb(96, 204, 255),
            2,
        ),
        (
            "LASER ETCH",
            "leverage maps cut into the frame",
            EffectKind::LaserEtch,
            Color::rgb(255, 220, 92),
            7,
        ),
        (
            "GRAVITY WELL",
            "weight and balance collapse into order",
            EffectKind::Blackhole,
            Color::rgb(164, 126, 255),
            5,
        ),
        (
            "ORBITAL BALANCE",
            "rings of motion settle around intent",
            EffectKind::Rings,
            Color::rgb(110, 255, 224),
            6,
        ),
        (
            "SWARM CALIBRATION",
            "many small forces become one gait",
            EffectKind::Swarm,
            Color::rgb(255, 112, 218),
            4,
        ),
        (
            "FIELD DEMO",
            "fireworks over the completed machine",
            EffectKind::Fireworks,
            Color::rgb(255, 180, 72),
            1,
        ),
    ];
    specs
        .iter()
        .enumerate()
        .map(
            |(index, (title, subtitle, kind, accent, paragraph_index))| {
                let paragraph = paragraphs
                    .get(*paragraph_index)
                    .or_else(|| paragraphs.get(index % paragraphs.len().max(1)))
                    .cloned()
                    .unwrap_or_else(|| source.to_string());
                let extra = match kind {
                    EffectKind::Matrix => "Data falls until it becomes purpose.",
                    EffectKind::Burn => "The forge removes everything that does not serve motion.",
                    EffectKind::Thunderstorm => "Noise becomes weather; weather becomes signal.",
                    EffectKind::LaserEtch => "Leverage is written as geometry and timing.",
                    EffectKind::Blackhole => {
                        "Weight collapses into balance before it expands into gait."
                    }
                    EffectKind::Rings => "Joints orbit a center of intention.",
                    EffectKind::Swarm => "Many corrections gather into one quiet step.",
                    _ => "The machine disappears into the grace of the whole.",
                };
                let text = wrap_text(&format!("{}\n\n{}", paragraph, extra), effect_w);
                let gradient = Gradient::new(
                    vec![*accent, accent.brighten(0.36), Color::rgb(235, 244, 250)],
                    32,
                );
                let config = EffectConfig::default()
                    .with_duration(scene_ticks.max(8))
                    .with_seed(700 + index as u64 * 97)
                    .with_canvas_size(effect_w, effect_h)
                    .with_gradient(gradient, GradientDirection::Diagonal);
                let frames = Effect::with_config(*kind, text.clone(), config).frames();
                Scene {
                    title,
                    subtitle,
                    effect: *kind,
                    accent: *accent,
                    frames,
                    quote: paragraph,
                }
            },
        )
        .collect()
}

pub fn with_canvas_size(self, width: usize, height: usize) -> Self

Examples found in repository

examples/demo.rs (line 17)

fn main() {
    let args = Args::parse();
    let kind = EffectKind::from_str(&args.effect).unwrap_or(EffectKind::Wipe);
    let mut config = EffectConfig::default()
        .with_duration(args.duration)
        .with_seed(args.seed);

    if let (Some(width), Some(height)) = (args.width, args.height) {
        config = config.with_canvas_size(width.max(1), height.max(1));
    }

    let effect = Effect::with_config(kind, args.text, config);

    let mut stdout = io::stdout();
    for frame in effect.iter() {
        write!(stdout, "\x1b[2J\x1b[H{}", frame.to_ansi_string()).unwrap();
        stdout.flush().unwrap();
        thread::sleep(Duration::from_millis((1000 / args.fps.max(1)) as u64));
    }
    writeln!(stdout).unwrap();
}

examples/showcase.rs (line 379)

fn build_panes(
    text: &str,
    layout: &Layout,
    base_duration: usize,
    theme: Theme,
) -> Vec<PaneRuntime> {
    EffectKind::all()
        .iter()
        .enumerate()
        .map(|(index, kind)| {
            let shape = pane_shape(*kind, index, layout);
            let (pane_width, pane_height) = pane_size(layout, shape);
            let inner_width = pane_width.saturating_sub(2).max(8);
            let inner_height = pane_height.saturating_sub(2).max(3);
            let snippet = snippet(text, index, inner_width, inner_height);
            let accent = theme.accent(*kind, index);
            let duration = base_duration + (index % 9) * 5;
            let config = EffectConfig::default()
                .with_duration(duration)
                .with_seed(1009 + index as u64 * 97)
                .with_canvas_size(inner_width, inner_height)
                .with_gradient(
                    effect_gradient(*kind, index, theme),
                    gradient_direction(index),
                );
            let frames = Effect::with_config(*kind, snippet, config).frames();
            PaneRuntime {
                index,
                kind: *kind,
                frames,
                offset: index * 13,
                speed_numerator: 1 + (index % 4),
                accent,
                shape,
            }
        })
        .collect()
}

examples/loader_lab.rs (line 783)

fn build_panes(effect_width: usize, effect_height: usize, focus_ticks: usize) -> Vec<Pane> {
    let ops = [
        ("DOWNLOAD", "tendon-atlas", "MB"),
        ("UPLOAD", "field-manifest", "MB"),
        ("SYNC", "sensor-mesh", "pkt"),
        ("VERIFY", "leverage-map", "chk"),
        ("STREAM", "gait-vectors", "vec"),
        ("FORGE", "actuator-curve", "N"),
        ("DECRYPT", "intent-bus", "blk"),
        ("MIRROR", "joint-state", "msg"),
        ("PACK", "motion-plan", "ops"),
        ("RELAY", "balance-loop", "hz"),
        ("CALIBRATE", "cable-stack", "mm"),
        ("ARCHIVE", "field-log", "MB"),
    ];
    let effects = [
        EffectKind::Matrix,
        EffectKind::Burn,
        EffectKind::Decrypt,
        EffectKind::Thunderstorm,
        EffectKind::LaserEtch,
        EffectKind::Blackhole,
        EffectKind::Rings,
        EffectKind::Swarm,
        EffectKind::Fireworks,
        EffectKind::Slice,
        EffectKind::Waves,
        EffectKind::Wipe,
    ];
    let palette = [
        Color::rgb(74, 255, 170),
        Color::rgb(255, 118, 54),
        Color::rgb(92, 204, 255),
        Color::rgb(255, 216, 92),
        Color::rgb(172, 130, 255),
        Color::rgb(255, 112, 218),
        Color::rgb(112, 236, 255),
        Color::rgb(255, 178, 72),
    ];
    let speeds = [1, 2, 3, 4, 5, 7, 9, 11];

    LoaderKind::all()
        .iter()
        .enumerate()
        .map(|(index, kind)| {
            let (op, noun, unit) = ops[index % ops.len()];
            let effect_kind = effects[(index * 5 + 3) % effects.len()];
            let accent = palette[index % palette.len()];
            let label = format!("{} {}", op.to_ascii_lowercase(), noun);
            let effect_text = format!("{} {}\n{}", op, kind.name(), noun).to_ascii_uppercase();
            let effect = Effect::with_config(
                effect_kind,
                effect_text,
                EffectConfig::default()
                    .with_duration(focus_ticks)
                    .with_seed(991 + index as u64 * 37)
                    .with_canvas_size(effect_width, effect_height.max(1))
                    .with_gradient(
                        Gradient::new(
                            vec![accent, accent.brighten(0.32), Color::rgb(230, 244, 250)],
                            20,
                        ),
                        GradientDirection::Diagonal,
                    ),
            );
            Pane {
                index,
                kind: *kind,
                op,
                noun,
                label,
                unit,
                total: 128 + ((index as u64 * 97) % 2048),
                speed: speeds[index % speeds.len()],
                offset: index * 17,
                accent,
                effect_kind,
                effect_frames: effect.frames(),
            }
        })
        .collect()
}

examples/story.rs (line 569)

fn build_scenes(source: &str, layout: &Layout, scene_ticks: usize) -> Vec<Scene> {
    let paragraphs = paragraphs(source);
    let effect_w = layout.stage.w.saturating_sub(8).max(40);
    let effect_h = layout.stage.h.saturating_sub(16).max(5).min(12);
    let specs = [
        (
            "BOOT SEQUENCE",
            "matrix rain resolves the mission",
            EffectKind::Matrix,
            Color::rgb(74, 255, 170),
            0usize,
        ),
        (
            "FORGE",
            "burning the actuator constraints",
            EffectKind::Burn,
            Color::rgb(255, 118, 54),
            3,
        ),
        (
            "STORM SENSORS",
            "signal and response in the weather",
            EffectKind::Thunderstorm,
            Color::rgb(96, 204, 255),
            2,
        ),
        (
            "LASER ETCH",
            "leverage maps cut into the frame",
            EffectKind::LaserEtch,
            Color::rgb(255, 220, 92),
            7,
        ),
        (
            "GRAVITY WELL",
            "weight and balance collapse into order",
            EffectKind::Blackhole,
            Color::rgb(164, 126, 255),
            5,
        ),
        (
            "ORBITAL BALANCE",
            "rings of motion settle around intent",
            EffectKind::Rings,
            Color::rgb(110, 255, 224),
            6,
        ),
        (
            "SWARM CALIBRATION",
            "many small forces become one gait",
            EffectKind::Swarm,
            Color::rgb(255, 112, 218),
            4,
        ),
        (
            "FIELD DEMO",
            "fireworks over the completed machine",
            EffectKind::Fireworks,
            Color::rgb(255, 180, 72),
            1,
        ),
    ];
    specs
        .iter()
        .enumerate()
        .map(
            |(index, (title, subtitle, kind, accent, paragraph_index))| {
                let paragraph = paragraphs
                    .get(*paragraph_index)
                    .or_else(|| paragraphs.get(index % paragraphs.len().max(1)))
                    .cloned()
                    .unwrap_or_else(|| source.to_string());
                let extra = match kind {
                    EffectKind::Matrix => "Data falls until it becomes purpose.",
                    EffectKind::Burn => "The forge removes everything that does not serve motion.",
                    EffectKind::Thunderstorm => "Noise becomes weather; weather becomes signal.",
                    EffectKind::LaserEtch => "Leverage is written as geometry and timing.",
                    EffectKind::Blackhole => {
                        "Weight collapses into balance before it expands into gait."
                    }
                    EffectKind::Rings => "Joints orbit a center of intention.",
                    EffectKind::Swarm => "Many corrections gather into one quiet step.",
                    _ => "The machine disappears into the grace of the whole.",
                };
                let text = wrap_text(&format!("{}\n\n{}", paragraph, extra), effect_w);
                let gradient = Gradient::new(
                    vec![*accent, accent.brighten(0.36), Color::rgb(235, 244, 250)],
                    32,
                );
                let config = EffectConfig::default()
                    .with_duration(scene_ticks.max(8))
                    .with_seed(700 + index as u64 * 97)
                    .with_canvas_size(effect_w, effect_h)
                    .with_gradient(gradient, GradientDirection::Diagonal);
                let frames = Effect::with_config(*kind, text.clone(), config).frames();
                Scene {
                    title,
                    subtitle,
                    effect: *kind,
                    accent: *accent,
                    frames,
                    quote: paragraph,
                }
            },
        )
        .collect()
}

Trait Implementations

impl Clone for EffectConfig

fn clone(&self) -> EffectConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EffectConfig

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

Formats the value using the given formatter.

impl Default for EffectConfig

fn default() -> Self

Returns the “default value” for a type.