Struct pixel_engine::Engine

pub struct Engine<'a> {
    pub name: String,
    pub size: (u32, u32, u32),
    pub screen: Window,
    pub elapsed: f64,
    pub main: &'a dyn Fn(&mut Engine) -> Result<(), String>,
    // some fields omitted
}

The core of this library Engine handle the backend of drawing and deals with sdl2

Fields

name: String

The name the engine

size: (u32, u32, u32)

The size of the Window, formated (width,height,pixel_size)

screen: Window

The window , where the drawing methods are

elapsed: f64

the time elapsed between the start of this frame and the old one

main: &'a dyn Fn(&mut Engine) -> Result<(), String>

The user code run by the Engine

Methods

impl<'a> Engine<'a>

pub fn new(
    name: &str,
    size: (u32, u32, u32),
    main: &'a dyn Fn(&mut Engine) -> Result<(), String>
) -> Result<Engine<'a>, String>

Create a new game Engine

pub fn new_frame(&mut self) -> Result<bool, String>

The core of the engine, where crucial value are calculated, like elapsed or the key's vector

pub fn start(&mut self) -> Result<(), String>

Start the engine, lanch the "main" function

pub fn get_key_state(&self, key: Keycode) -> KeyState

Return the state of "key" via KeyState enum

pub fn get_pressed(&self) -> HashSet<Keycode>

Return a clone of the vector conataining pressed keys

pub fn get_held(&self) -> HashSet<Keycode>

Return a clone of the vector conataining held keys

pub fn get_released(&self) -> HashSet<Keycode>

Return a clone of the vector conataining released keys

pub fn is_pressed(&self, key: Keycode) -> bool

Return true if "key" is pressed this frame, else, return false

pub fn is_held(&self, key: Keycode) -> bool

Return true if "key" is held this frame, else, return false

pub fn is_released(&self, key: Keycode) -> bool

Return true if "key" is released this frame, else , return false

Trait Implementations

impl<'a> Debug for Engine<'a>

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

Formats the value using the given formatter.