Struct Window 

pub struct Window {
    pub graphics: Graphics,
    pub audio: Audio,
    pub resource_manager: Arc<Mutex<ResourceManager>>,
}

Main window struct

Holds basic metadata and a reference to the graphics subsystem. User must create a Window in order to feed it to the EventHandler

Fields

graphics: Graphics

Graphics subsystem used to render frames.

audio: Audio

Audio subsystem

resource_manager: Arc<Mutex<ResourceManager>>

Resource manager

Implementations

impl Window

pub fn new( graphics: Graphics, resource_manager: Arc<Mutex<ResourceManager>>, ) -> Window

Create a new Window instance.

Parameters

• name: title of the window
• graphics: initialized graphics subsystem

Returns

A Window instance ready to be used by an [EventHandler].

Examples found in repository

examples/hello.rs (line 73)

async fn main() {
    let resource_manager = Arc::new(Mutex::new(ResourceManager::new()));
    let graphics = graphics::GraphicsBuilder::new()
        .window_name(String::from("game"))
        .dimensions((500, 500))
        .resource_manager(resource_manager.clone())
        // we bulk load resources here because either we'll have to deal with
        // ownership of `graphics` (the actual `let graphics`, not the closure
        // argument)
        // you may think of it like about just some initialization func
        .initializer(|graphics| {
            resource_manager.lock().unwrap().load_dir(PathBuf::from("assets"), graphics).unwrap();
        })
        .build();
    let mut window = Window::new(graphics.unwrap(), resource_manager);

    // because events::run takes a `&'static mut dyn WindowEventHandler` as a second argument we
    // need to do this seemingly weird thing (while `app.rs` in fennel-engine has an ass solution
    // with raw pointers lmfao) 
    let handler: &'static mut dyn WindowEventHandler = {
        let boxed = Box::new(State);
        Box::leak(boxed) as &'static mut dyn WindowEventHandler
    };
    events::run(&mut window, handler).await;
}

Trait Implementations

impl HasWindow for Window

fn window_mut(&mut self) -> &mut Self

impl Send for Window

impl Sync for Window