Struct ascii_forge::renderer::buffer::Buffer

pub struct Buffer { /* private fields */ }

A screen buffer that can be rendered to, has a size

This is the backbone of ascii-forge

Example

use ascii_forge::prelude::*;

// A 30x30 buffer window
let mut buffer = Buffer::new(30, 30);

// Render Hello World to the top left of the buffer
render!(
    buffer, [
        (0, 0) => "Hello World!"
    ]
);

Implementations

impl Buffer

pub fn new(size: impl Into<Vec2>) -> Self

Creates a new buffer of empty cells with the given size.

Examples found in repository

examples/simple.rs (line 12)

    fn run(&mut self, window: &mut Window) -> Result<SceneResult, Box<dyn Error>> {
        // Set up a scene
        let mut ui_buffer = Buffer::new((6, 3));

        let chars = ['┌', '─', '┐', '│', ' ', '│', '└', '─', '┘'];
        let nine_slice = ui::NineSlice::new(chars, (6, 3));

        // Render Some elements to the buffer.
        render!(ui_buffer, [
            vec2(0, 0) => nine_slice,
            vec2(1, 1) => "QUIT".green()
        ]);

        // Loop the current scene.
        loop {
            window.update()?;

            // Renders some elements to the window.
            render!(window, [
                vec2(0, 0) => format!("{:?}", cursor::position()?),
                vec2(window.size().x / 2, window.size().y / 4) => ui_buffer,
            ]);

            // If the `q` key was pressed, quit the application by returning no scene.
            if window.code(KeyCode::Char('q')) {
                return Ok(None);
            }

            // If the buffer was clicked on, quit.
            if window.mouse(MouseEventKind::Down(MouseButton::Left))?
                && window.hover(
                    vec2(window.size().x / 2, window.size().y / 4),
                    ui_buffer.size(),
                )?
            {
                return Ok(None);
            }
        }
    }

pub fn size(&self) -> Vec2

Returns the current size of the buffer.

Examples found in repository

examples/simple.rs (line 42)

    fn run(&mut self, window: &mut Window) -> Result<SceneResult, Box<dyn Error>> {
        // Set up a scene
        let mut ui_buffer = Buffer::new((6, 3));

        let chars = ['┌', '─', '┐', '│', ' ', '│', '└', '─', '┘'];
        let nine_slice = ui::NineSlice::new(chars, (6, 3));

        // Render Some elements to the buffer.
        render!(ui_buffer, [
            vec2(0, 0) => nine_slice,
            vec2(1, 1) => "QUIT".green()
        ]);

        // Loop the current scene.
        loop {
            window.update()?;

            // Renders some elements to the window.
            render!(window, [
                vec2(0, 0) => format!("{:?}", cursor::position()?),
                vec2(window.size().x / 2, window.size().y / 4) => ui_buffer,
            ]);

            // If the `q` key was pressed, quit the application by returning no scene.
            if window.code(KeyCode::Char('q')) {
                return Ok(None);
            }

            // If the buffer was clicked on, quit.
            if window.mouse(MouseEventKind::Down(MouseButton::Left))?
                && window.hover(
                    vec2(window.size().x / 2, window.size().y / 4),
                    ui_buffer.size(),
                )?
            {
                return Ok(None);
            }
        }
    }

pub fn set<C: Into<Cell>>(&mut self, loc: impl Into<Vec2>, cell: C)

Sets a cell at the given location to the given cell

pub fn get(&self, loc: impl Into<Vec2>) -> &Cell

Returns a reverence to the cell at the given location.

pub fn get_mut(&mut self, loc: impl Into<Vec2>) -> &mut Cell

Returns a mutable reference to the cell at the given location.

pub fn clear(&mut self)

Clears the buffer

pub fn diff<'a>(&self, other: &'a Buffer) -> Vec<(Vec2, &'a Cell)>

Returns the cells and locations that are different between the two buffers

pub fn shrink(&mut self)

Shrinks the buffer to the given size by dropping any cells that are only whitespace

pub fn resize(&mut self, new_size: impl Into<Vec2>)

Resizes the buffer while retaining elements that have already been rendered

pub fn sized_element<R: Render>(item: R) -> Self

Creates a Buffer from the given element with the minimum size it could have for that element. Useful for if you want to store any set of render elements in a custom element.

Trait Implementations

impl AsMut<Buffer> for Buffer

fn as_mut(&mut self) -> &mut Buffer

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsMut<Buffer> for Window

fn as_mut(&mut self) -> &mut Buffer

Converts this type into a mutable reference of the (usually inferred) input type.

impl Debug for Buffer

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

Formats the value using the given formatter.

impl Render for Buffer

fn render(&self, loc: Vec2, buffer: &mut Buffer)