Struct Donut

pub struct Donut<const WIDTH: u8 = 80, const HEIGHT: u8 = 22, const J_STEP_VALUE: u8 = 7, const J_STEP_DENOM: u8 = 100, const I_STEP_VALUE: u8 = 2, const I_STEP_DENOM: u8 = 100, const CHAR_BRIGHTNESS_0: char = ' ', const CHAR_BRIGHTNESS_1: char = '.', const CHAR_BRIGHTNESS_2: char = ',', const CHAR_BRIGHTNESS_3: char = '-', const CHAR_BRIGHTNESS_4: char = '~', const CHAR_BRIGHTNESS_5: char = ':', const CHAR_BRIGHTNESS_6: char = ';', const CHAR_BRIGHTNESS_7: char = '=', const CHAR_BRIGHTNESS_8: char = '!', const CHAR_BRIGHTNESS_9: char = '*', const CHAR_BRIGHTNESS_10: char = '#', const CHAR_BRIGHTNESS_11: char = '$', const CHAR_BRIGHTNESS_12: char = '@'> {
    pub a: f32,
    pub b: f32,
}

A configurable “Donut” that can render ASCII frames without std.

The donut is rendered by sampling points on a torus surface using two angles, and projecting those points into 2D screen space. The brightness of each point is determined by the surface’s orientation relative to a light source.

Fields

a: f32

Rotation angle A (around the vertical axis)

b: f32

Rotation angle B (around the horizontal axis)

Implementations

impl<const WIDTH: u8, const HEIGHT: u8, const J_STEP_VALUE: u8, const J_STEP_DENOM: u8, const I_STEP_VALUE: u8, const I_STEP_DENOM: u8, const C0: char, const C1: char, const C2: char, const C3: char, const C4: char, const C5: char, const C6: char, const C7: char, const C8: char, const C9: char, const C10: char, const C11: char, const C12: char> Donut<WIDTH, HEIGHT, J_STEP_VALUE, J_STEP_DENOM, I_STEP_VALUE, I_STEP_DENOM, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12>

pub const fn new() -> Self

Create a new donut with initial rotation angles set to 0.0.

Examples found in repository

examples/std_console.rs (line 16)

fn main() {
    const WIDTH: u8 = 80;
    const HEIGHT: u8 = 22;
    const SIZE: usize = (WIDTH as usize) * (HEIGHT as usize);

    // Create the donut instance and pre allocate buffers
    let mut donut = Donut::<WIDTH, HEIGHT>::new();
    let mut output = [' '; SIZE];
    let mut zbuf = [0.0_f32; SIZE];

    // Clear the terminal
    print!("\x1B[2J");
    let stdout = stdout();
    let mut handle = stdout.lock();

    loop {
        // Start timing this frame
        let start = Instant::now();

        // Render the donut into output and depth buffers
        donut.render_frame_in_place(&mut output, &mut zbuf);

        // Reset cursor to top left
        write!(handle, "\x1B[H").unwrap();

        // Write output buffer
        for line in output.chunks(WIDTH as usize) {
            for &ch in line {
                handle.write_all(&[ch as u8]).unwrap();
            }

            handle.write_all(b"\n").unwrap();
        }

        // Write the status line with FPS and memory usage.
        writeln!(
            handle,
            "\nFPS: {:>5.1} | Approx Mem: {}",
            1.0 / start.elapsed().as_secs_f32().max(0.0001),
            {
                let u =
                    mem::size_of_val(&output) + mem::size_of_val(&zbuf) + mem::size_of_val(&donut);

                if u < 1024 {
                    format!("{} bytes", u)
                } else if u < 1024 * 1024 {
                    format!("{:.1} KB", u as f32 / 1024.0)
                } else {
                    format!("{:.1} MB", u as f32 / (1024.0 * 1024.0))
                }
            }
        )
        .unwrap();

        handle.flush().unwrap();

        // Rotate for the next frame and sleep briefly.
        donut.rotate(0.07, 0.03);
        sleep(Duration::from_millis(20));
    }
}

pub fn rotate(&mut self, da: f32, db: f32)

Increment the rotation angles by da and db.

Rotating the donut creates the animation effect.

Examples found in repository

examples/std_console.rs (line 67)

fn main() {
    const WIDTH: u8 = 80;
    const HEIGHT: u8 = 22;
    const SIZE: usize = (WIDTH as usize) * (HEIGHT as usize);

    // Create the donut instance and pre allocate buffers
    let mut donut = Donut::<WIDTH, HEIGHT>::new();
    let mut output = [' '; SIZE];
    let mut zbuf = [0.0_f32; SIZE];

    // Clear the terminal
    print!("\x1B[2J");
    let stdout = stdout();
    let mut handle = stdout.lock();

    loop {
        // Start timing this frame
        let start = Instant::now();

        // Render the donut into output and depth buffers
        donut.render_frame_in_place(&mut output, &mut zbuf);

        // Reset cursor to top left
        write!(handle, "\x1B[H").unwrap();

        // Write output buffer
        for line in output.chunks(WIDTH as usize) {
            for &ch in line {
                handle.write_all(&[ch as u8]).unwrap();
            }

            handle.write_all(b"\n").unwrap();
        }

        // Write the status line with FPS and memory usage.
        writeln!(
            handle,
            "\nFPS: {:>5.1} | Approx Mem: {}",
            1.0 / start.elapsed().as_secs_f32().max(0.0001),
            {
                let u =
                    mem::size_of_val(&output) + mem::size_of_val(&zbuf) + mem::size_of_val(&donut);

                if u < 1024 {
                    format!("{} bytes", u)
                } else if u < 1024 * 1024 {
                    format!("{:.1} KB", u as f32 / 1024.0)
                } else {
                    format!("{:.1} MB", u as f32 / (1024.0 * 1024.0))
                }
            }
        )
        .unwrap();

        handle.flush().unwrap();

        // Rotate for the next frame and sleep briefly.
        donut.rotate(0.07, 0.03);
        sleep(Duration::from_millis(20));
    }
}

pub fn render_frame_in_place(&self, output: &mut [char], zbuf: &mut [f32])

Render one ASCII frame in-place:

• output should be (WIDTH*HEIGHT) in length, for storing characters.
• zbuf should also be (WIDTH*HEIGHT) in length, for storing depth.

All these slots will be overwritten with the new frame’s data.

You can then print the output slice as lines of WIDTH characters.

Examples found in repository

examples/std_console.rs (line 30)

fn main() {
    const WIDTH: u8 = 80;
    const HEIGHT: u8 = 22;
    const SIZE: usize = (WIDTH as usize) * (HEIGHT as usize);

    // Create the donut instance and pre allocate buffers
    let mut donut = Donut::<WIDTH, HEIGHT>::new();
    let mut output = [' '; SIZE];
    let mut zbuf = [0.0_f32; SIZE];

    // Clear the terminal
    print!("\x1B[2J");
    let stdout = stdout();
    let mut handle = stdout.lock();

    loop {
        // Start timing this frame
        let start = Instant::now();

        // Render the donut into output and depth buffers
        donut.render_frame_in_place(&mut output, &mut zbuf);

        // Reset cursor to top left
        write!(handle, "\x1B[H").unwrap();

        // Write output buffer
        for line in output.chunks(WIDTH as usize) {
            for &ch in line {
                handle.write_all(&[ch as u8]).unwrap();
            }

            handle.write_all(b"\n").unwrap();
        }

        // Write the status line with FPS and memory usage.
        writeln!(
            handle,
            "\nFPS: {:>5.1} | Approx Mem: {}",
            1.0 / start.elapsed().as_secs_f32().max(0.0001),
            {
                let u =
                    mem::size_of_val(&output) + mem::size_of_val(&zbuf) + mem::size_of_val(&donut);

                if u < 1024 {
                    format!("{} bytes", u)
                } else if u < 1024 * 1024 {
                    format!("{:.1} KB", u as f32 / 1024.0)
                } else {
                    format!("{:.1} MB", u as f32 / (1024.0 * 1024.0))
                }
            }
        )
        .unwrap();

        handle.flush().unwrap();

        // Rotate for the next frame and sleep briefly.
        donut.rotate(0.07, 0.03);
        sleep(Duration::from_millis(20));
    }
}

Trait Implementations

impl Default for Donut

fn default() -> Self

Returns the “default value” for a type.