Struct pixel_game_lib::canvas::Canvas

pub struct Canvas<'a> { /* private fields */ }

Simple wrapper around a pixel buffer that can be passed around to rendering calls.

Implementations

impl<'a> Canvas<'a>

pub fn set_pixel(&mut self, position: Vec2<usize>, color: u32)

Set a pixel on the buffer at the coordinate passed.

If the coordinate is out of bounds nothing will be done.

This is quite a slow operation because it needs to calculate the index of the coordinate, if setting multiple pixels it might be more efficient to create a sprite from them.

pub fn fill(&mut self, color: u32)

Fill the canvas with a single color.

pub fn raw_buffer(&mut self) -> &mut [u32]

Get the raw buffer of pixels.

Examples found in repository

examples/window.rs (line 47)

fn main() {
    // Active modifiable state
    let state = GameState { pixels_to_draw: 0 };

    // Window configuration with huge pixels
    let window_config = WindowConfig {
        buffer_size: Extent2::new(64, 64),
        scaling: 8,
        ..Default::default()
    };

    // Open the window and start the game-loop
    pixel_game_lib::window(
        state,
        window_config.clone(),
        // Update loop exposing input events we can handle, this is where you would handle the game logic
        |state, input, _mouse, _dt| {
            // Increment when mouse is clicked
            if input.mouse_held(0) {
                state.pixels_to_draw += 1;
            }

            // Exit when escape is pressed
            input.key_pressed(Key::Escape)
        },
        // Render loop exposing the pixel buffer we can mutate
        move |state, canvas, _dt| {
            // Ensure that we don't draw pixels outside of the canvas
            let max_pixels_to_draw = window_config.buffer_size.product();
            let pixels_to_draw = state.pixels_to_draw.min(max_pixels_to_draw);

            // Draw a red color for each pixel
            canvas.raw_buffer()[0..pixels_to_draw].fill(0xFFFF0000);
        },
    )
    .expect("Error opening window");
}

pub fn width(&self) -> usize

Width in pixels.

pub fn height(&self) -> usize

Height in pixels.

pub fn size(&self) -> Extent2<usize>

Size in pixels.