Struct WindowManager 

pub struct WindowManager { /* private fields */ }

Manages multiple renderable windows with automatic event handling.

The WindowManager eliminates the boilerplate of manually managing a HashMap<WindowId, RenderWindow> and handling common events like resizing.

Example

use astrelis_render::{WindowManager, GraphicsContext, Color};
use astrelis_winit::app::{App, AppCtx};
use astrelis_winit::{WindowId, FrameTime};
use astrelis_winit::event::EventBatch;

struct MyApp {
    window_manager: WindowManager,
}

impl App for MyApp {
    fn update(&mut self, _ctx: &mut AppCtx, _time: &FrameTime) {}
    fn render(&mut self, _ctx: &mut AppCtx, window_id: WindowId, events: &mut EventBatch) {
        self.window_manager.render_window(window_id, events, |window, _events| {
            // Resize already handled automatically!
            let Some(frame) = window.begin_frame() else { return };
            {
                let mut pass = frame.render_pass()
                    .clear_color(Color::BLACK)
                    .build();
                // Your rendering here
            }
        });
    }
}

Implementations

impl WindowManager

pub fn new(graphics: Arc<GraphicsContext>) -> Self

Creates a new WindowManager with the given graphics context.

Example

use astrelis_render::{WindowManager, GraphicsContext};
use std::sync::Arc;

let graphics = GraphicsContext::new_owned_sync().expect("Failed to create graphics context");
let window_manager = WindowManager::new(graphics);

Examples found in repository

examples/window_manager_demo.rs (line 44)

fn main() {
    logging::init();

    run_app(|ctx| {
        let graphics_ctx =
            GraphicsContext::new_owned_sync().expect("Failed to create graphics context");
        let mut window_manager = WindowManager::new(graphics_ctx);
        let mut window_colors = HashMap::new();

        // Create 3 windows with different colors
        let colors = [
            Color::rgb(0.8, 0.2, 0.2), // Red
            Color::rgb(0.2, 0.8, 0.2), // Green
            Color::rgb(0.2, 0.2, 0.8), // Blue
        ];

        for (i, color) in colors.iter().enumerate() {
            let window_id = window_manager
                .create_window_with_descriptor(
                    ctx,
                    WindowDescriptor {
                        title: format!("Window {} - WindowManager Demo", i + 1),
                        size: Some(WinitPhysicalSize::new(400.0, 300.0)),
                        ..Default::default()
                    },
                    WindowContextDescriptor {
                        format: Some(wgpu::TextureFormat::Bgra8UnormSrgb),
                        ..Default::default()
                    },
                )
                .expect("Failed to create window");

            window_colors.insert(window_id, *color);
        }

        Box::new(WindowManagerApp {
            window_manager,
            window_colors,
        })
    });
}

pub fn create_window( &mut self, ctx: &mut AppCtx<'_>, descriptor: WindowDescriptor, ) -> Result<WindowId, GraphicsError>

Creates a new window and adds it to the manager.

Returns the WindowId of the created window.

Example

use astrelis_render::WindowManager;
use astrelis_winit::window::{WindowDescriptor, WindowBackend};

let window_id = window_manager.create_window(
    ctx,
    WindowDescriptor {
        title: "My Window".to_string(),
        ..Default::default()
    },
);

pub fn create_window_with_descriptor( &mut self, ctx: &mut AppCtx<'_>, descriptor: WindowDescriptor, window_descriptor: WindowContextDescriptor, ) -> Result<WindowId, GraphicsError>

Creates a new window with a custom rendering context descriptor.

Example

use astrelis_render::{WindowManager, WindowContextDescriptor, wgpu};
use astrelis_winit::window::{WindowDescriptor, WindowBackend};

let window_id = window_manager.create_window_with_descriptor(
    ctx,
    WindowDescriptor::default(),
    WindowContextDescriptor {
        present_mode: Some(wgpu::PresentMode::Mailbox),
        ..Default::default()
    },
);

Examples found in repository

examples/window_manager_demo.rs (lines 56-67)

fn main() {
    logging::init();

    run_app(|ctx| {
        let graphics_ctx =
            GraphicsContext::new_owned_sync().expect("Failed to create graphics context");
        let mut window_manager = WindowManager::new(graphics_ctx);
        let mut window_colors = HashMap::new();

        // Create 3 windows with different colors
        let colors = [
            Color::rgb(0.8, 0.2, 0.2), // Red
            Color::rgb(0.2, 0.8, 0.2), // Green
            Color::rgb(0.2, 0.2, 0.8), // Blue
        ];

        for (i, color) in colors.iter().enumerate() {
            let window_id = window_manager
                .create_window_with_descriptor(
                    ctx,
                    WindowDescriptor {
                        title: format!("Window {} - WindowManager Demo", i + 1),
                        size: Some(WinitPhysicalSize::new(400.0, 300.0)),
                        ..Default::default()
                    },
                    WindowContextDescriptor {
                        format: Some(wgpu::TextureFormat::Bgra8UnormSrgb),
                        ..Default::default()
                    },
                )
                .expect("Failed to create window");

            window_colors.insert(window_id, *color);
        }

        Box::new(WindowManagerApp {
            window_manager,
            window_colors,
        })
    });
}

pub fn get_window(&self, id: WindowId) -> Option<&RenderWindow>

Gets a reference to a window by its ID.

Returns None if the window doesn’t exist.

pub fn get_window_mut(&mut self, id: WindowId) -> Option<&mut RenderWindow>

Gets a mutable reference to a window by its ID.

Returns None if the window doesn’t exist.

pub fn remove_window(&mut self, id: WindowId) -> Option<RenderWindow>

Removes a window from the manager.

Returns the removed window if it existed.

pub fn window_count(&self) -> usize

Returns the number of windows being managed.

pub fn window_ids(&self) -> impl Iterator<Item = WindowId> + '_

Returns an iterator over all window IDs.

pub fn render_window<F>( &mut self, id: WindowId, events: &mut EventBatch, render_fn: F, )

where F: FnMut(&mut RenderWindow, &mut EventBatch),

Renders a window with automatic event handling.

This method:

1. Automatically handles common events (resize, etc.)
2. Calls your render closure with the window and remaining events
3. Returns immediately if the window doesn’t exist

Example

use astrelis_render::{WindowManager, Color};

window_manager.render_window(window_id, events, |window, events| {
    // Handle custom events if needed
    events.dispatch(|_event| {
        // Your event handling
        astrelis_winit::event::HandleStatus::ignored()
    });

    // Render
    let Some(frame) = window.begin_frame() else { return };
    {
        let mut pass = frame.render_pass()
            .clear_color(Color::BLACK)
            .build();
        // Your rendering
    }
});

Examples found in repository

examples/window_manager_demo.rs (lines 97-115)

    fn render(&mut self, _ctx: &mut AppCtx, window_id: WindowId, events: &mut EventBatch) {
        // Get the color for this window
        let Some(&color) = self.window_colors.get(&window_id) else {
            return;
        };

        // WindowManager automatically handles:
        // 1. Window lookup (no manual HashMap.get_mut)
        // 2. Resize events (automatic)
        // 3. Event dispatching
        self.window_manager
            .render_window(window_id, events, |window, _events| {
                // No need to manually handle resize events!
                // WindowManager already did that for us

                // Just render!
                let Some(frame) = window.begin_frame() else {
                    return; // Surface not available
                };

                {
                    let _pass = frame
                        .render_pass()
                        .clear_color(color)
                        .label("window_manager_pass")
                        .build();
                    // Additional rendering would go here
                }
                // Frame auto-submits on drop
            });
    }

pub fn render_window_result<F, E>( &mut self, id: WindowId, events: &mut EventBatch, render_fn: F, ) -> Result<(), E>

where F: FnMut(&mut RenderWindow, &mut EventBatch) -> Result<(), E>,

Renders a window with automatic event handling, passing a closure that returns a result.

This is useful when rendering might fail and you want to propagate errors.

Example

use astrelis_render::{WindowManager, Color};

window_manager.render_window_result(window_id, events, |window, _events| {
    let Some(frame) = window.begin_frame() else { return Ok(()) };
    {
        let mut pass = frame.render_pass()
            .clear_color(Color::BLACK)
            .build();
        // Rendering that might fail
    }
    Ok(())
})

pub fn graphics(&self) -> &Arc<GraphicsContext>

Gets the shared graphics context.

pub fn iter(&self) -> impl Iterator<Item = (WindowId, &RenderWindow)>

Iterates over all windows with their IDs.

pub fn iter_mut( &mut self, ) -> impl Iterator<Item = (WindowId, &mut RenderWindow)>

Iterates mutably over all windows with their IDs.