Struct TextCanvas

pub struct TextCanvas {
    pub output: Surface,
    pub screen: Surface,
    pub buffer: PixelBuffer,
    pub color_buffer: ColorBuffer,
    pub text_buffer: TextBuffer,
    pub is_inverted: bool,
    /* private fields */
}

Draw to the terminal like an HTML Canvas.

Examples

use textcanvas::TextCanvas;

let mut canvas = TextCanvas::new(15, 5);

assert_eq!(
    canvas.repr(),
    "Canvas(output=(15×5), screen=(30×20)))"
);

assert_eq!(
    (canvas.w(), canvas.h(), canvas.cx(), canvas.cy()),
    (29, 19, 15, 10),
);

canvas.stroke_line(0, 0, canvas.w(), canvas.h());
canvas.draw_text("hello, world", 1, 2);
assert_eq!(
    canvas.to_string(),
    "\
⠑⠢⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠑⠢⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀hello,⠢world⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠢⢄⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠢⢄
"
);

Fields

output: Surface

Properties of the output surface, whose size is given as parameter to the constructor. One unit in width and in height represents exactly one character on the terminal.

screen: Surface

Properties of the virtual output surface. This surface benefits from the increase in resolution. One unit in width and in height represents one Braille dot. There are 2 dots per character in width, and 4 per character in height. So this surface is 2× wider and 4× higher than the output surface.

buffer: PixelBuffer

The in-memory pixel buffer. This maps 1-to-1 to the virtual screen. Each pixel is this buffer is either on or off.

color_buffer: ColorBuffer

The in-memory color buffer. This maps 1-to-1 to the output buffer (and so to the physical screen). This contains color data for characters. Screen dots, being part of one output character, cannot be colored individually. Color is thus less precise than screen pixels. Note that a call to set_color() is valid for both pixels and text, but text embeds color in its own buffer, and does not use this buffer at all. Note also that this buffer is empty until the first call to set_color(). The first call to set_color() initializes the buffer and sets is_colorized() to true.

text_buffer: TextBuffer

The in-memory text buffer. This maps 1-to-1 to the output buffer (and so to the physical screen). This contains regular text characters. Text is drawn on top of the pixel buffer on a separate layer. Drawing text does not affect pixels. Pixels and text do not share the same color buffer either. Color info is embedded in the text buffer with each character directly. Note also that this buffer is empty until the first call to draw_text(). The first call to draw_text() initializes the buffer and sets is_textual() to True.

is_inverted: bool

Inverted drawing mode. In inverted mode, functions which usually turn pixels on, will turn them off, and vice-versa.

Implementations

impl TextCanvas

pub fn new(width: i32, height: i32) -> Self

Create new TextCanvas.

Panics

If width and height of canvas are < 1×1.

Also, if the pixel resolution of width or height is larger than 65_535 (realistically, should not happen). This is because we let the user interact with the canvas with i32s. i32 is a more likely user-type (maths, etc.), and allows for negative values. Even though they are never displayed, allowing negative values makes for a nicer API. We handle the complexity for the user.

Examples found in repository

examples/matrix.rs (line 202)

fn main() {
    debug_assert!(CHARS.chars().count() > STREAM_LENGTH as usize);

    if std::env::args().any(|arg| arg == "-i" || arg == "--with-intro") {
        do_intro();
    }

    let mut canvas = TextCanvas::new(NB_STREAMS, STREAM_LENGTH);
    let mut rng = Rng::new();

    let mut droplets: Vec<Droplet> = (0..(NB_STREAMS * 11 / 10))
        .map(|_| Droplet::new(&mut rng))
        .collect();

    GameLoop::loop_fixed(time::Duration::from_millis(30), &mut || {
        canvas.clear();

        for droplet in &mut droplets {
            droplet.fall();
            if droplet.has_fallen_out_of_screen() {
                droplet.recycle(&mut rng);
            }
            droplet.maybe_glitch(&mut rng);
            droplet.draw_onto(&mut canvas);
        }

        Some(canvas.to_string())
    });
}

fn do_intro() {
    let sleep = |duration| std::thread::sleep(time::Duration::from_millis(duration));

    let mut game_loop = GameLoop::new();
    game_loop.set_up();

    let mut canvas = TextCanvas::new(NB_STREAMS, STREAM_LENGTH);
    let mut rng = Rng::new_from_seed(42);

    canvas.set_color(Color::new().bright_green());

    // Wake up, Neo...
    for (x, c) in "Wake up, Neo...".chars().enumerate() {
        canvas.draw_text(&c.to_string(), x as i32 + 3, 1);
        game_loop.update(&canvas.to_string());
        sleep(if c == ',' {
            300
        } else if c == ' ' {
            100
        } else {
            50
        });
    }
    sleep(2000);

    // The Matrix has you...
    canvas.clear();
    for (x, c) in "The Matrix has you...".chars().enumerate() {
        canvas.draw_text(&c.to_string(), x as i32 + 3, 1);
        game_loop.update(&canvas.to_string());

        sleep(if x < 3 {
            400
        } else {
            u64::from(rng.urand_between(150, 300))
        });
    }
    sleep(2000);

    // Follow the white rabbit.
    canvas.clear();
    for (x, c) in "Follow the white rabbit.".chars().enumerate() {
        canvas.draw_text(&c.to_string(), x as i32 + 3, 1);
        game_loop.update(&canvas.to_string());

        sleep(if x < 4 { 100 } else { 50 });
    }
    sleep(3000);

    // Knock, knock, Neo.
    canvas.clear();
    game_loop.update(&canvas.to_string());
    sleep(70);
    canvas.draw_text("Knock, knock, Neo.", 3, 1);
    game_loop.update(&canvas.to_string());

    // Don't tear down.
    // game_loop.tear_down();

    sleep(4000);
}

examples/sines.rs (line 56)

fn with_fixed_time_step() {
    let mut canvas = TextCanvas::new(80, 16);

    let mut big_sine = TextCanvas::new(80, 10);
    let mut medium_sine = TextCanvas::new(80, 6);
    let mut small_sine = TextCanvas::new(80, 4);

    let f = |x: f64| x.sin();

    let mut i = 0;
    #[rustfmt::skip]
    GameLoop::loop_fixed(time::Duration::from_millis(30), &mut || {
        if i == 108 {
            // Break out of the loop.
            return None;
        }

        let big_offset = f64::from(i) / 350.0 * 37.0;
        let medium_offset = f64::from(i) / 250.0 * 37.0;
        let small_offset = f64::from(i) / 150.0 * 37.0;

        canvas.clear();

        big_sine.clear();
        medium_sine.clear();
        small_sine.clear();

        Plot::function(&mut big_sine, -10.0 + big_offset, 10.0 + big_offset, &f);
        Plot::function(&mut medium_sine, -10.0 + medium_offset, 10.0 + medium_offset, &f);
        Plot::function(&mut small_sine, -10.0 + small_offset, 10.0 + small_offset, &f);

        canvas.merge_canvas(&big_sine, 0, 12);
        canvas.merge_canvas(&medium_sine, 0, 20);
        canvas.merge_canvas(&small_sine, 0, 25);

        canvas.draw_text(&format!("  i: {i}"), 0, 0);
        canvas.draw_text("Fixed", 37, 0);

        i += 1;

        Some(canvas.to_string())
    });
}

/// Will loop as fast as possible.
fn with_variable_time_step() {
    let mut canvas = TextCanvas::new(80, 16);

    let mut big_sine = TextCanvas::new(80, 10);
    let mut medium_sine = TextCanvas::new(80, 6);
    let mut small_sine = TextCanvas::new(80, 4);

    let f = |x: f64| x.sin();

    let mut accumulator = 0.0;
    #[rustfmt::skip]
    GameLoop::loop_variable(&mut |delta_time| {
        if accumulator >= 333.33 {
            // Break out of the loop.
            return None;
        }

        let big_offset = accumulator / 350.0 * 12.0;
        let medium_offset = accumulator / 250.0 * 12.0;
        let small_offset = accumulator / 150.0 * 12.0;

        canvas.clear();

        big_sine.clear();
        medium_sine.clear();
        small_sine.clear();

        Plot::function(&mut big_sine, -10.0 + big_offset, 10.0 + big_offset, &f);
        Plot::function(&mut medium_sine, -10.0 + medium_offset, 10.0 + medium_offset, &f);
        Plot::function(&mut small_sine, -10.0 + small_offset, 10.0 + small_offset, &f);

        canvas.merge_canvas(&big_sine, 0, 12);
        canvas.merge_canvas(&medium_sine, 0, 20);
        canvas.merge_canvas(&small_sine, 0, 25);

        canvas.draw_text(&format!(" Δt: {delta_time:.9}"), 0, 0);
        canvas.draw_text(&format!("acc: {accumulator:>11.7}"), 0, 1);
        canvas.draw_text("Variable", 36, 0);

        accumulator += 100.0 * delta_time;

        Some(canvas.to_string())
    });
}

examples/cube.rs (line 53)

fn main() {
    let mut canvas = TextCanvas::new(CANVAS_WIDTH as i32, CANVAS_HEIGHT as i32);

    let camera = Camera::new();
    let mut cube = Cube::new();

    GameLoop::loop_variable(&mut |delta_time| {
        canvas.clear();

        let rotate = 1.0 * delta_time;
        cube.rotate(rotate, rotate, rotate);

        let mut model = camera.project_cube(&cube);
        for face in &mut model {
            let mut first: Option<Vec2D> = None;
            let mut previous: Option<Vec2D> = None;
            for vertex in face {
                let [x, y, z] = *vertex;

                let [x, y] = world_to_screen([x, y, z]);
                *vertex = [x, y, 0.0]; // `z` gets ditched.

                if let Some(previous) = previous {
                    canvas.stroke_line(
                        previous[0].trunc() as i32,
                        previous[1].trunc() as i32,
                        x.trunc() as i32,
                        y.trunc() as i32,
                    );
                }

                if first.is_none() {
                    first = Some([x, y]);
                }

                previous = Some([x, y]);
            }

            // Close.
            if let (Some(first), Some(previous)) = (first, previous) {
                canvas.stroke_line(
                    previous[0].trunc() as i32,
                    previous[1].trunc() as i32,
                    first[0].trunc() as i32,
                    first[1].trunc() as i32,
                );
            }
        }

        // Don't eat up the whole CPU.
        std::thread::sleep(std::time::Duration::from_millis(7));

        Some(canvas.to_string())
    });
}

pub fn new_auto() -> Result<Self, TextCanvasError>

Create new TextCanvas by reading size from environment.

Errors

If either or both WIDTH and HEIGHT variables cannot be read from the environment.

pub fn get_default_size() -> (i32, i32)

Default canvas size.

This value is used by TextCanvas::default(), but it may be useful to query it separately.

pub fn get_auto_size() -> Result<(i32, i32), TextCanvasError>

Read canvas size from WIDTH and HEIGHT env variables.

This value is used by TextCanvas::new_auto(), but it may be useful to query it separately.

Errors

If either or both WIDTH and HEIGHT variables cannot be read from the environment.

pub fn repr(&self) -> String

High-level string representation of the canvas.

Examples

use textcanvas::TextCanvas;

let mut canvas = TextCanvas::new(15, 5);

assert_eq!(
    canvas.repr(),
    "Canvas(output=(15×5), screen=(30×20)))"
);

pub fn w(&self) -> i32

Shortcut for width of pixel screen (index of last column).

pub fn uw(&self) -> usize

Shortcut for width of pixel screen (index of last column).

pub fn fw(&self) -> f64

Shortcut for width of pixel screen (index of last column).

pub fn h(&self) -> i32

Shortcut for height of pixel screen (index of last row).

pub fn uh(&self) -> usize

Shortcut for height of pixel screen (index of last row).

pub fn fh(&self) -> f64

Shortcut for height of pixel screen (index of last row).

pub fn cx(&self) -> i32

Shortcut for center-X of pixel screen.

pub fn ucx(&self) -> usize

Shortcut for center-X of pixel screen.

pub fn fcx(&self) -> f64

Shortcut for center-X of pixel screen.

pub fn cy(&self) -> i32

Shortcut for center-Y of pixel screen.

pub fn ucy(&self) -> usize

Shortcut for center-Y of pixel screen.

pub fn fcy(&self) -> f64

Shortcut for center-Y of pixel screen.

pub fn clear(&mut self)

Turn all pixels off and remove color and text.

Note: This method does not drop the color and text buffers, it only clears them. No memory is freed, and all references remain valid (buffers are cleared in-place, not replaced).

Note: clear() is not affected by inverted mode, it works on a lower level.

Examples found in repository

examples/matrix.rs (line 210)

fn main() {
    debug_assert!(CHARS.chars().count() > STREAM_LENGTH as usize);

    if std::env::args().any(|arg| arg == "-i" || arg == "--with-intro") {
        do_intro();
    }

    let mut canvas = TextCanvas::new(NB_STREAMS, STREAM_LENGTH);
    let mut rng = Rng::new();

    let mut droplets: Vec<Droplet> = (0..(NB_STREAMS * 11 / 10))
        .map(|_| Droplet::new(&mut rng))
        .collect();

    GameLoop::loop_fixed(time::Duration::from_millis(30), &mut || {
        canvas.clear();

        for droplet in &mut droplets {
            droplet.fall();
            if droplet.has_fallen_out_of_screen() {
                droplet.recycle(&mut rng);
            }
            droplet.maybe_glitch(&mut rng);
            droplet.draw_onto(&mut canvas);
        }

        Some(canvas.to_string())
    });
}

fn do_intro() {
    let sleep = |duration| std::thread::sleep(time::Duration::from_millis(duration));

    let mut game_loop = GameLoop::new();
    game_loop.set_up();

    let mut canvas = TextCanvas::new(NB_STREAMS, STREAM_LENGTH);
    let mut rng = Rng::new_from_seed(42);

    canvas.set_color(Color::new().bright_green());

    // Wake up, Neo...
    for (x, c) in "Wake up, Neo...".chars().enumerate() {
        canvas.draw_text(&c.to_string(), x as i32 + 3, 1);
        game_loop.update(&canvas.to_string());
        sleep(if c == ',' {
            300
        } else if c == ' ' {
            100
        } else {
            50
        });
    }
    sleep(2000);

    // The Matrix has you...
    canvas.clear();
    for (x, c) in "The Matrix has you...".chars().enumerate() {
        canvas.draw_text(&c.to_string(), x as i32 + 3, 1);
        game_loop.update(&canvas.to_string());

        sleep(if x < 3 {
            400
        } else {
            u64::from(rng.urand_between(150, 300))
        });
    }
    sleep(2000);

    // Follow the white rabbit.
    canvas.clear();
    for (x, c) in "Follow the white rabbit.".chars().enumerate() {
        canvas.draw_text(&c.to_string(), x as i32 + 3, 1);
        game_loop.update(&canvas.to_string());

        sleep(if x < 4 { 100 } else { 50 });
    }
    sleep(3000);

    // Knock, knock, Neo.
    canvas.clear();
    game_loop.update(&canvas.to_string());
    sleep(70);
    canvas.draw_text("Knock, knock, Neo.", 3, 1);
    game_loop.update(&canvas.to_string());

    // Don't tear down.
    // game_loop.tear_down();

    sleep(4000);
}

examples/sines.rs (line 76)

fn with_fixed_time_step() {
    let mut canvas = TextCanvas::new(80, 16);

    let mut big_sine = TextCanvas::new(80, 10);
    let mut medium_sine = TextCanvas::new(80, 6);
    let mut small_sine = TextCanvas::new(80, 4);

    let f = |x: f64| x.sin();

    let mut i = 0;
    #[rustfmt::skip]
    GameLoop::loop_fixed(time::Duration::from_millis(30), &mut || {
        if i == 108 {
            // Break out of the loop.
            return None;
        }

        let big_offset = f64::from(i) / 350.0 * 37.0;
        let medium_offset = f64::from(i) / 250.0 * 37.0;
        let small_offset = f64::from(i) / 150.0 * 37.0;

        canvas.clear();

        big_sine.clear();
        medium_sine.clear();
        small_sine.clear();

        Plot::function(&mut big_sine, -10.0 + big_offset, 10.0 + big_offset, &f);
        Plot::function(&mut medium_sine, -10.0 + medium_offset, 10.0 + medium_offset, &f);
        Plot::function(&mut small_sine, -10.0 + small_offset, 10.0 + small_offset, &f);

        canvas.merge_canvas(&big_sine, 0, 12);
        canvas.merge_canvas(&medium_sine, 0, 20);
        canvas.merge_canvas(&small_sine, 0, 25);

        canvas.draw_text(&format!("  i: {i}"), 0, 0);
        canvas.draw_text("Fixed", 37, 0);

        i += 1;

        Some(canvas.to_string())
    });
}

/// Will loop as fast as possible.
fn with_variable_time_step() {
    let mut canvas = TextCanvas::new(80, 16);

    let mut big_sine = TextCanvas::new(80, 10);
    let mut medium_sine = TextCanvas::new(80, 6);
    let mut small_sine = TextCanvas::new(80, 4);

    let f = |x: f64| x.sin();

    let mut accumulator = 0.0;
    #[rustfmt::skip]
    GameLoop::loop_variable(&mut |delta_time| {
        if accumulator >= 333.33 {
            // Break out of the loop.
            return None;
        }

        let big_offset = accumulator / 350.0 * 12.0;
        let medium_offset = accumulator / 250.0 * 12.0;
        let small_offset = accumulator / 150.0 * 12.0;

        canvas.clear();

        big_sine.clear();
        medium_sine.clear();
        small_sine.clear();

        Plot::function(&mut big_sine, -10.0 + big_offset, 10.0 + big_offset, &f);
        Plot::function(&mut medium_sine, -10.0 + medium_offset, 10.0 + medium_offset, &f);
        Plot::function(&mut small_sine, -10.0 + small_offset, 10.0 + small_offset, &f);

        canvas.merge_canvas(&big_sine, 0, 12);
        canvas.merge_canvas(&medium_sine, 0, 20);
        canvas.merge_canvas(&small_sine, 0, 25);

        canvas.draw_text(&format!(" Δt: {delta_time:.9}"), 0, 0);
        canvas.draw_text(&format!("acc: {accumulator:>11.7}"), 0, 1);
        canvas.draw_text("Variable", 36, 0);

        accumulator += 100.0 * delta_time;

        Some(canvas.to_string())
    });
}

examples/cube.rs (line 59)

fn main() {
    let mut canvas = TextCanvas::new(CANVAS_WIDTH as i32, CANVAS_HEIGHT as i32);

    let camera = Camera::new();
    let mut cube = Cube::new();

    GameLoop::loop_variable(&mut |delta_time| {
        canvas.clear();

        let rotate = 1.0 * delta_time;
        cube.rotate(rotate, rotate, rotate);

        let mut model = camera.project_cube(&cube);
        for face in &mut model {
            let mut first: Option<Vec2D> = None;
            let mut previous: Option<Vec2D> = None;
            for vertex in face {
                let [x, y, z] = *vertex;

                let [x, y] = world_to_screen([x, y, z]);
                *vertex = [x, y, 0.0]; // `z` gets ditched.

                if let Some(previous) = previous {
                    canvas.stroke_line(
                        previous[0].trunc() as i32,
                        previous[1].trunc() as i32,
                        x.trunc() as i32,
                        y.trunc() as i32,
                    );
                }

                if first.is_none() {
                    first = Some([x, y]);
                }

                previous = Some([x, y]);
            }

            // Close.
            if let (Some(first), Some(previous)) = (first, previous) {
                canvas.stroke_line(
                    previous[0].trunc() as i32,
                    previous[1].trunc() as i32,
                    first[0].trunc() as i32,
                    first[1].trunc() as i32,
                );
            }
        }

        // Don't eat up the whole CPU.
        std::thread::sleep(std::time::Duration::from_millis(7));

        Some(canvas.to_string())
    });
}

pub fn fill(&mut self)

Turn all pixels on.

This does not affect the color and text buffers.

Note: fill() is not affected by inverted mode, it works on a lower level.

pub fn invert(&mut self)

Invert drawing mode.

In inverted mode, functions that usually turn pixels on, will turn them off, and vice versa. This can be used to cut out shapes for instance.

pub fn is_colorized(&self) -> bool

Whether the canvas can contain colors.

Note: This does not mean that any colors are displayed. This only means the color buffer is active.

Examples

use textcanvas::{Color, TextCanvas};

let mut canvas = TextCanvas::new(15, 5);

assert!(!canvas.is_colorized());

canvas.set_color(&Color::new().fix());  // Buffer is initialized.
assert!(canvas.is_colorized());

pub fn is_textual(&self) -> bool

Whether the canvas can contain text.

Note: This does not mean that any text is displayed. This only means the text buffer is active.

Examples

use textcanvas::TextCanvas;

let mut canvas = TextCanvas::new(15, 5);

assert!(!canvas.is_textual());

canvas.draw_text("", 0, 0);  // Buffer is initialized.
assert!(canvas.is_textual());

pub fn set_color(&mut self, color: &Color)

Set context color.

Examples

use textcanvas::{Color, TextCanvas};

let mut canvas = TextCanvas::new(3, 1);
let green = Color::new().bright_green().fix();

canvas.set_color(&green);
assert!(canvas.is_colorized());

canvas.draw_text("foo", 0, 0);
assert_eq!(
    canvas.to_string(),
    "\x1b[0;92mf\x1b[0m\x1b[0;92mo\x1b[0m\x1b[0;92mo\x1b[0m\n"
);

Examples found in repository

examples/matrix.rs (line 132)

    pub fn draw_onto(&mut self, canvas: &mut TextCanvas) {
        let chars = self.to_string();
        debug_assert!(chars.chars().count() == STREAM_LENGTH as usize);

        let i_tip = self.iy() + self.length - 1;

        // Start at `y=0`, NOT `droplet.y`. The droplet is already
        // rendered, including spacing, etc.
        for (i, char_) in chars.chars().enumerate() {
            let i = i as i32;
            canvas.set_color(&self.determine_char_color(i, i_tip));
            // `merge_text()` ignores spaces.
            canvas.merge_text(&char_.to_string(), self.x, i);
        }
    }

    fn determine_char_color(&self, i: i32, i_tip: i32) -> Color {
        if i == i_tip {
            return Shade::Tip.into();
        }
        if i == i_tip - 1 {
            return Shade::PreTip.into();
        }

        // Use `self.x` and `self.length` to deterministically randomize
        // bucket size and bright spots distribution.
        let s = f64::from(self.x).sin().abs(); // [0; 1]
        let d = f64::from(self.length).sin() - 0.3; // [-1.3; 0.7] (slightly skewed towards dim).

        if f64::from(i_tip - i).sin() * s <= d {
            // `sin(x) * S >= D`
            // Deterministic way (`i_tip - i`) to modulate shade.
            // `S` influences the size of the (base) buckets.
            // `D` (`[-1; 1]`) affects the distribution. Higher means
            //     bias towards bright, lower means bias towards dim,
            //     `0.0` being neutral.
            Shade::BrightGreen.into()
        } else {
            Shade::DimGreen.into()
        }
    }
}

impl fmt::Display for Droplet {
    /// Render droplet as part of a stream, with leading and trailing whitespace.
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        // Not yet visible (above screen).
        if self.iy() + self.length <= 0 {
            return write!(f, "{}", " ".repeat(STREAM_LENGTH as usize));
        }
        // No longer visible (below screen).
        if self.iy() >= STREAM_LENGTH {
            return write!(f, "{}", " ".repeat(STREAM_LENGTH as usize));
        }
        let window_start = self.iy().clamp(0, STREAM_LENGTH - 1) as usize;
        let window_end = (self.iy() + self.length - 1).clamp(0, STREAM_LENGTH - 1) as usize;

        write!(
            f,
            "{}{}{}",
            " ".repeat(window_start),
            // Equivalent to `&self.chars[window_start..=window_end]`, but with `chars()`.
            &self
                .chars
                .chars()
                .skip(window_start)
                .take(window_end - window_start + 1)
                .collect::<String>(),
            " ".repeat(STREAM_LENGTH as usize - window_end - 1)
        )
    }
}

fn main() {
    debug_assert!(CHARS.chars().count() > STREAM_LENGTH as usize);

    if std::env::args().any(|arg| arg == "-i" || arg == "--with-intro") {
        do_intro();
    }

    let mut canvas = TextCanvas::new(NB_STREAMS, STREAM_LENGTH);
    let mut rng = Rng::new();

    let mut droplets: Vec<Droplet> = (0..(NB_STREAMS * 11 / 10))
        .map(|_| Droplet::new(&mut rng))
        .collect();

    GameLoop::loop_fixed(time::Duration::from_millis(30), &mut || {
        canvas.clear();

        for droplet in &mut droplets {
            droplet.fall();
            if droplet.has_fallen_out_of_screen() {
                droplet.recycle(&mut rng);
            }
            droplet.maybe_glitch(&mut rng);
            droplet.draw_onto(&mut canvas);
        }

        Some(canvas.to_string())
    });
}

fn do_intro() {
    let sleep = |duration| std::thread::sleep(time::Duration::from_millis(duration));

    let mut game_loop = GameLoop::new();
    game_loop.set_up();

    let mut canvas = TextCanvas::new(NB_STREAMS, STREAM_LENGTH);
    let mut rng = Rng::new_from_seed(42);

    canvas.set_color(Color::new().bright_green());

    // Wake up, Neo...
    for (x, c) in "Wake up, Neo...".chars().enumerate() {
        canvas.draw_text(&c.to_string(), x as i32 + 3, 1);
        game_loop.update(&canvas.to_string());
        sleep(if c == ',' {
            300
        } else if c == ' ' {
            100
        } else {
            50
        });
    }
    sleep(2000);

    // The Matrix has you...
    canvas.clear();
    for (x, c) in "The Matrix has you...".chars().enumerate() {
        canvas.draw_text(&c.to_string(), x as i32 + 3, 1);
        game_loop.update(&canvas.to_string());

        sleep(if x < 3 {
            400
        } else {
            u64::from(rng.urand_between(150, 300))
        });
    }
    sleep(2000);

    // Follow the white rabbit.
    canvas.clear();
    for (x, c) in "Follow the white rabbit.".chars().enumerate() {
        canvas.draw_text(&c.to_string(), x as i32 + 3, 1);
        game_loop.update(&canvas.to_string());

        sleep(if x < 4 { 100 } else { 50 });
    }
    sleep(3000);

    // Knock, knock, Neo.
    canvas.clear();
    game_loop.update(&canvas.to_string());
    sleep(70);
    canvas.draw_text("Knock, knock, Neo.", 3, 1);
    game_loop.update(&canvas.to_string());

    // Don't tear down.
    // game_loop.tear_down();

    sleep(4000);
}

pub fn get_pixel(&self, x: i32, y: i32) -> Option<bool>

Get the state of a screen pixel.

Some(true) if the pixel is turned on, Some(false) if it is turned off, and None if the coordinates are outside the bounds of the buffer.

Arguments

• x - Screen X (high resolution).
• y - Screen Y (high resolution).

pub fn set_pixel(&mut self, x: i32, y: i32, state: bool)

Set the state of a screen pixel.

Note: Coordinates outside the screen bounds are ignored.

Note: Turning a pixel off also removes color. This side effect does not affect text, as text has a separate color buffer.

Arguments

• x - Screen X (high resolution).
• y - Screen Y (high resolution).
• state - true means on, false means off.

pub fn draw_text(&mut self, text: &str, x: i32, y: i32)

Draw text onto the canvas.

Note: Spaces are transparent (you see pixels through). But drawing spaces over text erases the text beneath. If you want to keep the text, use the merge_text() method.

Note: Coordinates outside the screen bounds are ignored.

Note: Text is rendered on top of pixels, as a separate layer.

Note: set_color() works for text as well, but text does not share its color buffer with pixels.

Examples found in repository

examples/sines.rs (line 90)

fn with_fixed_time_step() {
    let mut canvas = TextCanvas::new(80, 16);

    let mut big_sine = TextCanvas::new(80, 10);
    let mut medium_sine = TextCanvas::new(80, 6);
    let mut small_sine = TextCanvas::new(80, 4);

    let f = |x: f64| x.sin();

    let mut i = 0;
    #[rustfmt::skip]
    GameLoop::loop_fixed(time::Duration::from_millis(30), &mut || {
        if i == 108 {
            // Break out of the loop.
            return None;
        }

        let big_offset = f64::from(i) / 350.0 * 37.0;
        let medium_offset = f64::from(i) / 250.0 * 37.0;
        let small_offset = f64::from(i) / 150.0 * 37.0;

        canvas.clear();

        big_sine.clear();
        medium_sine.clear();
        small_sine.clear();

        Plot::function(&mut big_sine, -10.0 + big_offset, 10.0 + big_offset, &f);
        Plot::function(&mut medium_sine, -10.0 + medium_offset, 10.0 + medium_offset, &f);
        Plot::function(&mut small_sine, -10.0 + small_offset, 10.0 + small_offset, &f);

        canvas.merge_canvas(&big_sine, 0, 12);
        canvas.merge_canvas(&medium_sine, 0, 20);
        canvas.merge_canvas(&small_sine, 0, 25);

        canvas.draw_text(&format!("  i: {i}"), 0, 0);
        canvas.draw_text("Fixed", 37, 0);

        i += 1;

        Some(canvas.to_string())
    });
}

/// Will loop as fast as possible.
fn with_variable_time_step() {
    let mut canvas = TextCanvas::new(80, 16);

    let mut big_sine = TextCanvas::new(80, 10);
    let mut medium_sine = TextCanvas::new(80, 6);
    let mut small_sine = TextCanvas::new(80, 4);

    let f = |x: f64| x.sin();

    let mut accumulator = 0.0;
    #[rustfmt::skip]
    GameLoop::loop_variable(&mut |delta_time| {
        if accumulator >= 333.33 {
            // Break out of the loop.
            return None;
        }

        let big_offset = accumulator / 350.0 * 12.0;
        let medium_offset = accumulator / 250.0 * 12.0;
        let small_offset = accumulator / 150.0 * 12.0;

        canvas.clear();

        big_sine.clear();
        medium_sine.clear();
        small_sine.clear();

        Plot::function(&mut big_sine, -10.0 + big_offset, 10.0 + big_offset, &f);
        Plot::function(&mut medium_sine, -10.0 + medium_offset, 10.0 + medium_offset, &f);
        Plot::function(&mut small_sine, -10.0 + small_offset, 10.0 + small_offset, &f);

        canvas.merge_canvas(&big_sine, 0, 12);
        canvas.merge_canvas(&medium_sine, 0, 20);
        canvas.merge_canvas(&small_sine, 0, 25);

        canvas.draw_text(&format!(" Δt: {delta_time:.9}"), 0, 0);
        canvas.draw_text(&format!("acc: {accumulator:>11.7}"), 0, 1);
        canvas.draw_text("Variable", 36, 0);

        accumulator += 100.0 * delta_time;

        Some(canvas.to_string())
    });
}

examples/matrix.rs (line 238)

fn do_intro() {
    let sleep = |duration| std::thread::sleep(time::Duration::from_millis(duration));

    let mut game_loop = GameLoop::new();
    game_loop.set_up();

    let mut canvas = TextCanvas::new(NB_STREAMS, STREAM_LENGTH);
    let mut rng = Rng::new_from_seed(42);

    canvas.set_color(Color::new().bright_green());

    // Wake up, Neo...
    for (x, c) in "Wake up, Neo...".chars().enumerate() {
        canvas.draw_text(&c.to_string(), x as i32 + 3, 1);
        game_loop.update(&canvas.to_string());
        sleep(if c == ',' {
            300
        } else if c == ' ' {
            100
        } else {
            50
        });
    }
    sleep(2000);

    // The Matrix has you...
    canvas.clear();
    for (x, c) in "The Matrix has you...".chars().enumerate() {
        canvas.draw_text(&c.to_string(), x as i32 + 3, 1);
        game_loop.update(&canvas.to_string());

        sleep(if x < 3 {
            400
        } else {
            u64::from(rng.urand_between(150, 300))
        });
    }
    sleep(2000);

    // Follow the white rabbit.
    canvas.clear();
    for (x, c) in "Follow the white rabbit.".chars().enumerate() {
        canvas.draw_text(&c.to_string(), x as i32 + 3, 1);
        game_loop.update(&canvas.to_string());

        sleep(if x < 4 { 100 } else { 50 });
    }
    sleep(3000);

    // Knock, knock, Neo.
    canvas.clear();
    game_loop.update(&canvas.to_string());
    sleep(70);
    canvas.draw_text("Knock, knock, Neo.", 3, 1);
    game_loop.update(&canvas.to_string());

    // Don't tear down.
    // game_loop.tear_down();

    sleep(4000);
}

pub fn draw_text_vertical(&mut self, text: &str, x: i32, y: i32)

pub fn merge_text(&mut self, text: &str, x: i32, y: i32)

Merge text onto the canvas.

This is the same as draw_text(), but spaces do not erase text underneath.

Examples found in repository

examples/matrix.rs (line 134)

    pub fn draw_onto(&mut self, canvas: &mut TextCanvas) {
        let chars = self.to_string();
        debug_assert!(chars.chars().count() == STREAM_LENGTH as usize);

        let i_tip = self.iy() + self.length - 1;

        // Start at `y=0`, NOT `droplet.y`. The droplet is already
        // rendered, including spacing, etc.
        for (i, char_) in chars.chars().enumerate() {
            let i = i as i32;
            canvas.set_color(&self.determine_char_color(i, i_tip));
            // `merge_text()` ignores spaces.
            canvas.merge_text(&char_.to_string(), self.x, i);
        }
    }

pub fn merge_text_vertical(&mut self, text: &str, x: i32, y: i32)

pub fn iter_buffer(&self) -> IterPixelBuffer<i32>

Iterate over all cells of the pixel buffer.

Yields all X/Y coordinates, left-right, top-bottom.

Values are i32, this is meant to be used with the public API.

pub fn uiter_buffer(&self) -> IterPixelBuffer<usize>

Iterate over all cells of the pixel buffer.

Yields all X/Y coordinates, left-right, top-bottom.

Values are usize, this is meant to index directly into the buffer.

impl TextCanvas

Implementation of drawing primitives.

pub fn stroke_line(&mut self, x1: i32, y1: i32, x2: i32, y2: i32)

Stroke line.

Examples

use textcanvas::TextCanvas;

let mut canvas = TextCanvas::new(15, 5);

canvas.stroke_line(5, 5, 25, 15);

assert_eq!(
    canvas.to_string(),
    "\
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠐⠤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠉⠒⠤⣀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠒⠤⣀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
"
);

Examples found in repository

examples/cube.rs (lines 75-80)

fn main() {
    let mut canvas = TextCanvas::new(CANVAS_WIDTH as i32, CANVAS_HEIGHT as i32);

    let camera = Camera::new();
    let mut cube = Cube::new();

    GameLoop::loop_variable(&mut |delta_time| {
        canvas.clear();

        let rotate = 1.0 * delta_time;
        cube.rotate(rotate, rotate, rotate);

        let mut model = camera.project_cube(&cube);
        for face in &mut model {
            let mut first: Option<Vec2D> = None;
            let mut previous: Option<Vec2D> = None;
            for vertex in face {
                let [x, y, z] = *vertex;

                let [x, y] = world_to_screen([x, y, z]);
                *vertex = [x, y, 0.0]; // `z` gets ditched.

                if let Some(previous) = previous {
                    canvas.stroke_line(
                        previous[0].trunc() as i32,
                        previous[1].trunc() as i32,
                        x.trunc() as i32,
                        y.trunc() as i32,
                    );
                }

                if first.is_none() {
                    first = Some([x, y]);
                }

                previous = Some([x, y]);
            }

            // Close.
            if let (Some(first), Some(previous)) = (first, previous) {
                canvas.stroke_line(
                    previous[0].trunc() as i32,
                    previous[1].trunc() as i32,
                    first[0].trunc() as i32,
                    first[1].trunc() as i32,
                );
            }
        }

        // Don't eat up the whole CPU.
        std::thread::sleep(std::time::Duration::from_millis(7));

        Some(canvas.to_string())
    });
}

pub fn stroke_rect(&mut self, x: i32, y: i32, width: i32, height: i32)

Stroke rectangle.

Examples

use textcanvas::TextCanvas;

let mut canvas = TextCanvas::new(15, 5);

canvas.stroke_rect(5, 5, 20, 10);

assert_eq!(
    canvas.to_string(),
    "\
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⢰⠒⠒⠒⠒⠒⠒⠒⠒⠒⡆⠀⠀
⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀
⠀⠀⠸⠤⠤⠤⠤⠤⠤⠤⠤⠤⠇⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
"
);

pub fn frame(&mut self)

Draw a border around the canvas.

Examples

use textcanvas::TextCanvas;

let mut canvas = TextCanvas::new(15, 5);

canvas.frame();

assert_eq!(
    canvas.to_string(),
    "\
⡏⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⢹
⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸
⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸
⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸
⣇⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣀⣸
"
);

pub fn fill_rect(&mut self, x: i32, y: i32, width: i32, height: i32)

Fill rectangle.

Examples

use textcanvas::TextCanvas;

let mut canvas = TextCanvas::new(15, 5);

canvas.fill_rect(5, 5, 20, 10);

assert_eq!(
    canvas.to_string(),
    "\
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⢰⣶⣶⣶⣶⣶⣶⣶⣶⣶⡆⠀⠀
⠀⠀⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⠀⠀
⠀⠀⠸⠿⠿⠿⠿⠿⠿⠿⠿⠿⠇⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
"
);

pub fn stroke_triangle( &mut self, x1: i32, y1: i32, x2: i32, y2: i32, x3: i32, y3: i32, )

Stroke triangle.

Examples

use textcanvas::TextCanvas;

let mut canvas = TextCanvas::new(15, 5);

canvas.stroke_triangle(5, 5, 20, 10, 4, 17);

assert_eq!(
    canvas.to_string(),
    "\
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⢰⠢⠤⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⢸⠀⠀⠀⠈⠉⢒⡢⠄⠀⠀⠀⠀
⠀⠀⡇⠀⣀⠤⠔⠊⠁⠀⠀⠀⠀⠀⠀
⠀⠀⠓⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
"
);

pub fn fill_triangle( &mut self, x1: i32, y1: i32, x2: i32, y2: i32, x3: i32, y3: i32, )

Fill triangle.

Examples

use textcanvas::TextCanvas;

let mut canvas = TextCanvas::new(15, 5);

canvas.fill_triangle(5, 5, 20, 10, 4, 17);

assert_eq!(
    canvas.to_string(),
    "\
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⢰⣦⣤⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⢸⣿⣿⣿⣿⣿⣶⡦⠄⠀⠀⠀⠀
⠀⠀⣿⣿⣿⠿⠟⠋⠁⠀⠀⠀⠀⠀⠀
⠀⠀⠛⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
"
);

pub fn stroke_circle(&mut self, x: i32, y: i32, radius: i32)

Stroke circle.

Examples

use textcanvas::TextCanvas;

let mut canvas = TextCanvas::new(15, 5);

canvas.stroke_circle(canvas.cx(), canvas.cy(), 7);

assert_eq!(
    canvas.to_string(),
    "\
⠀⠀⠀⠀⠀⠀⣀⣀⣀⡀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⡠⠊⠀⠀⠀⠈⠢⡀⠀⠀⠀
⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀
⠀⠀⠀⠀⠣⡀⠀⠀⠀⠀⡠⠃⠀⠀⠀
⠀⠀⠀⠀⠀⠈⠒⠒⠒⠊⠀⠀⠀⠀⠀
"
);

pub fn fill_circle(&mut self, x: i32, y: i32, radius: i32)

Fill circle.

Examples

use textcanvas::TextCanvas;

let mut canvas = TextCanvas::new(15, 5);

canvas.fill_circle(canvas.cx(), canvas.cy(), 7);

assert_eq!(
    canvas.to_string(),
    "\
⠀⠀⠀⠀⠀⠀⣀⣀⣀⡀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⣠⣾⣿⣿⣿⣿⣦⡀⠀⠀⠀
⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⡇⠀⠀⠀
⠀⠀⠀⠀⠻⣿⣿⣿⣿⣿⡿⠃⠀⠀⠀
⠀⠀⠀⠀⠀⠈⠛⠛⠛⠋⠀⠀⠀⠀⠀
"
);

pub fn stroke_ngon( &mut self, x: i32, y: i32, radius: i32, sides: i32, angle: f64, )

Stroke n-gon.

Examples

use textcanvas::TextCanvas;
use std::f64::consts::PI;

let mut canvas = TextCanvas::new(15, 5);

canvas.stroke_ngon(canvas.cx(), canvas.cy(), 7, 5, PI / 2.0);

assert_eq!(
    canvas.to_string(),
    "\
⠀⠀⠀⠀⠀⠀⠀⢀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⢀⡠⠊⠁⠉⠢⣀⠀⠀⠀⠀
⠀⠀⠀⠀⢣⠀⠀⠀⠀⠀⢠⠃⠀⠀⠀
⠀⠀⠀⠀⠀⢇⠀⠀⠀⢀⠎⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠈⠉⠉⠉⠉⠀⠀⠀⠀⠀
"
);

Panics

Panics if sides < 3.

pub fn fill_ngon(&mut self, x: i32, y: i32, radius: i32, sides: i32, angle: f64)

Fill n-gon.

Examples

use textcanvas::TextCanvas;

let mut canvas = TextCanvas::new(15, 5);

canvas.fill_ngon(canvas.cx(), canvas.cy(), 7, 4, 0.0);

assert_eq!(
    canvas.to_string(),
    "\
⠀⠀⠀⠀⠀⠀⠀⢀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⢀⣴⣿⣷⣄⠀⠀⠀⠀⠀
⠀⠀⠀⠀⢴⣿⣿⣿⣿⣿⣷⠄⠀⠀⠀
⠀⠀⠀⠀⠀⠙⢿⣿⣿⠟⠁⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠙⠁⠀⠀⠀⠀⠀⠀
"
);

Panics

Panics if sides < 3.

pub fn draw_canvas(&mut self, canvas: &Self, dx: i32, dy: i32)

Draw another canvas onto the current canvas.

The other canvas completely overrides the current canvas where it is drawn (but it does not affect the portions where it is not drawn).

Note: Inverted mode has no effect here, this is a low level copy-paste.

Examples

use textcanvas::TextCanvas;

let mut canvas = TextCanvas::new(15, 5);
canvas.stroke_line(0, 0, canvas.w(), canvas.h());
canvas.stroke_line(0, canvas.h(), canvas.w(), 0);

let mut overlay = TextCanvas::new(7, 3);
overlay.frame();

canvas.draw_canvas(&overlay, 8, 4);

assert_eq!(
    canvas.to_string(),
    "\
⠑⠢⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠔⠊
⠀⠀⠀⠑⡏⠉⠉⠉⠉⠉⢹⠊⠀⠀⠀
⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀
⠀⠀⠀⡠⣇⣀⣀⣀⣀⣀⣸⢄⠀⠀⠀
⡠⠔⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠢⢄
"
);

pub fn merge_canvas(&mut self, canvas: &Self, dx: i32, dy: i32)

Merge another canvas with the current canvas.

The other canvas is merged with the current canvas. That is, pixels that are turned on get draw, but those that are off are ignored.

Note: Inverted mode has no effect here, this is a low level copy-paste.

Examples

use textcanvas::TextCanvas;

let mut canvas = TextCanvas::new(15, 5);
canvas.stroke_line(0, 0, canvas.w(), canvas.h());
canvas.stroke_line(0, canvas.h(), canvas.w(), 0);

let mut overlay = TextCanvas::new(7, 3);
overlay.frame();

canvas.merge_canvas(&overlay, 8, 4);

assert_eq!(
    canvas.to_string(),
    "\
⠑⠢⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠔⠊
⠀⠀⠀⠑⡯⣉⠉⠉⠉⣉⢽⠊⠀⠀⠀
⠀⠀⠀⠀⡇⠀⡱⠶⢎⠀⢸⠀⠀⠀⠀
⠀⠀⠀⡠⣗⣉⣀⣀⣀⣉⣺⢄⠀⠀⠀
⡠⠔⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠢⢄
"
);

Examples found in repository

examples/sines.rs (line 86)

fn with_fixed_time_step() {
    let mut canvas = TextCanvas::new(80, 16);

    let mut big_sine = TextCanvas::new(80, 10);
    let mut medium_sine = TextCanvas::new(80, 6);
    let mut small_sine = TextCanvas::new(80, 4);

    let f = |x: f64| x.sin();

    let mut i = 0;
    #[rustfmt::skip]
    GameLoop::loop_fixed(time::Duration::from_millis(30), &mut || {
        if i == 108 {
            // Break out of the loop.
            return None;
        }

        let big_offset = f64::from(i) / 350.0 * 37.0;
        let medium_offset = f64::from(i) / 250.0 * 37.0;
        let small_offset = f64::from(i) / 150.0 * 37.0;

        canvas.clear();

        big_sine.clear();
        medium_sine.clear();
        small_sine.clear();

        Plot::function(&mut big_sine, -10.0 + big_offset, 10.0 + big_offset, &f);
        Plot::function(&mut medium_sine, -10.0 + medium_offset, 10.0 + medium_offset, &f);
        Plot::function(&mut small_sine, -10.0 + small_offset, 10.0 + small_offset, &f);

        canvas.merge_canvas(&big_sine, 0, 12);
        canvas.merge_canvas(&medium_sine, 0, 20);
        canvas.merge_canvas(&small_sine, 0, 25);

        canvas.draw_text(&format!("  i: {i}"), 0, 0);
        canvas.draw_text("Fixed", 37, 0);

        i += 1;

        Some(canvas.to_string())
    });
}

/// Will loop as fast as possible.
fn with_variable_time_step() {
    let mut canvas = TextCanvas::new(80, 16);

    let mut big_sine = TextCanvas::new(80, 10);
    let mut medium_sine = TextCanvas::new(80, 6);
    let mut small_sine = TextCanvas::new(80, 4);

    let f = |x: f64| x.sin();

    let mut accumulator = 0.0;
    #[rustfmt::skip]
    GameLoop::loop_variable(&mut |delta_time| {
        if accumulator >= 333.33 {
            // Break out of the loop.
            return None;
        }

        let big_offset = accumulator / 350.0 * 12.0;
        let medium_offset = accumulator / 250.0 * 12.0;
        let small_offset = accumulator / 150.0 * 12.0;

        canvas.clear();

        big_sine.clear();
        medium_sine.clear();
        small_sine.clear();

        Plot::function(&mut big_sine, -10.0 + big_offset, 10.0 + big_offset, &f);
        Plot::function(&mut medium_sine, -10.0 + medium_offset, 10.0 + medium_offset, &f);
        Plot::function(&mut small_sine, -10.0 + small_offset, 10.0 + small_offset, &f);

        canvas.merge_canvas(&big_sine, 0, 12);
        canvas.merge_canvas(&medium_sine, 0, 20);
        canvas.merge_canvas(&small_sine, 0, 25);

        canvas.draw_text(&format!(" Δt: {delta_time:.9}"), 0, 0);
        canvas.draw_text(&format!("acc: {accumulator:>11.7}"), 0, 1);
        canvas.draw_text("Variable", 36, 0);

        accumulator += 100.0 * delta_time;

        Some(canvas.to_string())
    });
}

Trait Implementations

impl Debug for TextCanvas

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

Formats the value using the given formatter.

impl Default for TextCanvas

fn default() -> Self

Returns the “default value” for a type.

impl Display for TextCanvas

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

Formats the value using the given formatter.