Struct RenderWindow 

pub struct RenderWindow { /* private fields */ }

A renderable window that combines a winit Window with a WindowContext.

This is the primary type for rendering to a window. It implements Deref<Target = WindowContext>, so all WindowContext methods are available directly.

GPU Profiling

Attach a GpuFrameProfiler via set_gpu_profiler to automatically profile render passes. Once attached, all frames created via begin_frame will include GPU profiling.

Example

let mut render_window = RenderWindow::builder()
    .with_depth_default()
    .build(window, graphics)
    .expect("Failed to create window");

// In render loop:
let frame = render_window.begin_frame().expect("Surface available");
{
    let mut pass = frame.render_pass()
        .clear_color(Color::BLACK)
        .with_window_depth()
        .clear_depth(0.0)
        .build();
    // Render commands...
}
// Frame auto-submits on drop

Implementations

impl RenderWindow

pub fn builder() -> RenderWindowBuilder

Create a new builder for configuring a render window.

pub fn new( window: Window, context: Arc<GraphicsContext>, ) -> Result<Self, GraphicsError>

Create a new renderable window with default settings.

pub fn new_with_depth( window: Window, context: Arc<GraphicsContext>, ) -> Result<Self, GraphicsError>

Create a new renderable window with an auto-resizing depth texture.

This is equivalent to using builder() with with_depth_default().

pub fn new_with_descriptor( window: Window, context: Arc<GraphicsContext>, descriptor: WindowContextDescriptor, ) -> Result<Self, GraphicsError>

Create a new renderable window with a descriptor.

pub fn begin_frame(&mut self) -> Option<Frame<'_>>

Begin a new frame for rendering.

Returns Some(Frame) if the surface is available, or None if the surface is temporarily unavailable (e.g., window minimized).

Example

if let Some(frame) = window.begin_frame() {
    let mut pass = frame.render_pass()
        .clear_color(Color::BLACK)
        .build();
    // Render commands...
}

Examples found in repository

examples/camera_demo.rs (line 103)

    fn render(&mut self, _ctx: &mut AppCtx, window_id: WindowId, events: &mut EventBatch) {
        if window_id != self.window_id {
            return;
        }

        events.dispatch(|event| {
            if let astrelis_winit::event::Event::WindowResized(size) = event {
                self.window.resized(*size);
                astrelis_winit::event::HandleStatus::consumed()
            } else {
                astrelis_winit::event::HandleStatus::ignored()
            }
        });

        let Some(frame) = self.window.begin_frame() else {
            return; // Surface not available
        };
        {
            let _pass = frame
                .render_pass()
                .clear_color(Color::from_rgb_u8(20, 30, 40))
                .label("camera_demo_pass")
                .build();
        }
        // Frame auto-submits on drop
    }

examples/mesh_primitives.rs (line 105)

    fn render(&mut self, _ctx: &mut AppCtx, window_id: WindowId, events: &mut EventBatch) {
        if window_id != self.window_id {
            return;
        }

        events.dispatch(|event| {
            if let astrelis_winit::event::Event::WindowResized(size) = event {
                self.window.resized(*size);
                astrelis_winit::event::HandleStatus::consumed()
            } else {
                astrelis_winit::event::HandleStatus::ignored()
            }
        });

        let Some(frame) = self.window.begin_frame() else {
            return; // Surface not available
        };
        {
            let _pass = frame
                .render_pass()
                .clear_color(Color::from_rgb_u8(20, 30, 40))
                .label("mesh_primitives_pass")
                .build();
        }
        // Frame auto-submits on drop
    }

examples/render_graph_demo.rs (line 103)

    fn render(&mut self, _ctx: &mut AppCtx, window_id: WindowId, events: &mut EventBatch) {
        if window_id != self.window_id {
            return;
        }

        events.dispatch(|event| {
            if let astrelis_winit::event::Event::WindowResized(size) = event {
                self.window.resized(*size);
                astrelis_winit::event::HandleStatus::consumed()
            } else {
                astrelis_winit::event::HandleStatus::ignored()
            }
        });

        let Some(frame) = self.window.begin_frame() else {
            return; // Surface not available
        };
        {
            let _pass = frame
                .render_pass()
                .clear_color(Color::from_rgb_u8(20, 30, 40))
                .label("render_graph_demo_pass")
                .build();
        }
        // Frame auto-submits on drop
    }

examples/window_manager_demo.rs (line 102)

    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
            });
    }

examples/material_system.rs (line 125)

    fn render(&mut self, _ctx: &mut AppCtx, window_id: WindowId, events: &mut EventBatch) {
        if window_id != self.window_id {
            return;
        }

        // Handle resize
        events.dispatch(|event| {
            if let astrelis_winit::event::Event::WindowResized(size) = event {
                self.window.resized(*size);
                astrelis_winit::event::HandleStatus::consumed()
            } else {
                astrelis_winit::event::HandleStatus::ignored()
            }
        });

        // In a real application, materials would be bound during rendering:
        // material.bind(&mut render_pass);
        // draw_mesh(&mesh);

        // Begin frame
        let Some(frame) = self.window.begin_frame() else {
            return; // Surface not available
        };

        {
            let _pass = frame
                .render_pass()
                .clear_color(Color::from_rgb_u8(20, 30, 40))
                .label("material_system_pass")
                .build();
            // Materials would be applied here in actual rendering
            // This is a conceptual demonstration
        }
        // Frame auto-submits on drop
    }

examples/sprite_sheet.rs (line 451)

    fn render(
        &mut self,
        _ctx: &mut astrelis_winit::app::AppCtx,
        window_id: WindowId,
        events: &mut astrelis_winit::event::EventBatch,
    ) {
        let Some(window) = self.windows.get_mut(&window_id) else {
            return;
        };

        // Handle resize
        events.dispatch(|event| {
            if let astrelis_winit::event::Event::WindowResized(size) = event {
                window.resized(*size);
                astrelis_winit::event::HandleStatus::consumed()
            } else {
                astrelis_winit::event::HandleStatus::ignored()
            }
        });

        let Some(frame) = window.begin_frame() else {
            return; // Surface not available
        };
        {
            let mut pass = frame
                .render_pass()
                .clear_color(Color::rgb(0.1, 0.1, 0.15))
                .label("sprite_sheet_pass")
                .build();
            pass.set_pipeline(&self.pipeline);
            pass.set_bind_group(0, &self.bind_group, &[]);
            pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
            pass.draw(0..6, 0..1);
        }
        // Frame auto-submits on drop
    }

Additional examples can be found in:

• examples/image_blitting.rs
• examples/textured_window.rs
• examples/multi_window.rs
• examples/profiling_demo.rs
• examples/renderer_api.rs
• examples/batched_renderer.rs
• examples/performance_benchmark.rs

pub fn try_begin_frame(&mut self) -> Result<Frame<'_>, GraphicsError>

Try to begin a new frame, returning an error on failure.

Unlike begin_frame, this returns the actual error for debugging or error handling.

pub fn id(&self) -> WindowId

Get the window ID.

Examples found in repository

examples/multi_window.rs (line 71)

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

    run_app(|ctx| {
        let graphics_ctx =
            GraphicsContext::new_owned_sync().expect("Failed to create graphics context");

        let mut windows = HashMap::new();

        // Create 3 windows with different colors
        let colors = [
            wgpu::Color {
                r: 0.8,
                g: 0.2,
                b: 0.2,
                a: 1.0,
            },
            wgpu::Color {
                r: 0.2,
                g: 0.8,
                b: 0.2,
                a: 1.0,
            },
            wgpu::Color {
                r: 0.2,
                g: 0.2,
                b: 0.8,
                a: 1.0,
            },
        ];

        for (i, color) in colors.iter().enumerate() {
            let window = ctx
                .create_window(WindowDescriptor {
                    title: format!("Window {} - Multi-Window Example", i + 1),
                    size: Some(WinitPhysicalSize::new(400.0, 300.0)),
                    ..Default::default()
                })
                .expect("Failed to create window");

            let renderable_window = RenderWindowBuilder::new()
                .color_format(wgpu::TextureFormat::Bgra8UnormSrgb)
                .with_depth_default()
                .build(window, graphics_ctx.clone())
                .expect("Failed to create render window");

            let window_id = renderable_window.id();
            windows.insert(window_id, (renderable_window, *color));
        }

        Box::new(App { windows })
    });
}

examples/performance_benchmark.rs (line 57)

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

    run_app(|ctx| {
        let graphics_ctx =
            GraphicsContext::new_owned_sync().expect("Failed to create graphics context");

        let window = ctx
            .create_window(WindowDescriptor {
                title: "Performance Benchmark - Render Stress Test".to_string(),
                size: Some(WinitPhysicalSize::new(1280.0, 720.0)),
                ..Default::default()
            })
            .expect("Failed to create window");

        let window = RenderWindowBuilder::new()
            .color_format(wgpu::TextureFormat::Bgra8UnormSrgb)
            .with_depth_default()
            .build(window, graphics_ctx.clone())
            .expect("Failed to create render window");

        let window_id = window.id();

        println!("\n═══════════════════════════════════════════════════════");
        println!("  ⚡ PERFORMANCE BENCHMARK - Render Stress Test");
        println!("═══════════════════════════════════════════════════════");
        println!("  CONTROLS:");
        println!("    [Space]  Toggle rendering on/off");
        println!("    [+/-]    Increase/decrease object count");
        println!("  Starting with 1000 objects");
        println!("═══════════════════════════════════════════════════════\n");

        Box::new(PerformanceBenchmark {
            _context: graphics_ctx,
            window,
            window_id,
            object_count: 1000,
            rendering: true,
            frame_count: 0,
            last_fps_time: Instant::now(),
            fps: 0.0,
            last_frame_time: 0.0,
        })
    });
}

examples/camera_demo.rs (line 51)

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

    run_app(|ctx| {
        let graphics_ctx =
            GraphicsContext::new_owned_sync().expect("Failed to create graphics context");

        let window = ctx
            .create_window(WindowDescriptor {
                title: "Camera Demo - View & Projection".to_string(),
                size: Some(WinitPhysicalSize::new(1024.0, 768.0)),
                ..Default::default()
            })
            .expect("Failed to create window");

        let window = RenderWindowBuilder::new()
            .color_format(wgpu::TextureFormat::Bgra8UnormSrgb)
            .with_depth_default()
            .build(window, graphics_ctx.clone())
            .expect("Failed to create render window");

        let window_id = window.id();

        println!("\n═══════════════════════════════════════════════════════");
        println!("  📹 CAMERA DEMO - View & Projection");
        println!("═══════════════════════════════════════════════════════");
        println!("\n  CAMERA API FEATURES:");
        println!("    • Orthographic cameras (2D, UI, isometric)");
        println!("    • Perspective cameras (3D scenes)");
        println!("    • View matrix (position, rotation, look-at)");
        println!("    • Projection matrix (FOV, aspect, near/far planes)");
        println!("    • Screen-to-world coordinate conversion");
        println!("    • Camera movement helpers");
        println!("\n  CAMERA TYPES:");
        println!("    • OrthographicCamera - 2D games, UI overlays");
        println!("      camera.orthographic(left, right, bottom, top, near, far)");
        println!("    • PerspectiveCamera - 3D scenes");
        println!("      camera.perspective(fov, aspect, near, far)");
        println!("\n  Camera API Usage:");
        println!("    let camera = Camera::new()");
        println!("        .position(Vec3::new(0.0, 5.0, 10.0))");
        println!("        .look_at(Vec3::ZERO)");
        println!("        .perspective(60.0, aspect, 0.1, 100.0);");
        println!("    let view_proj = camera.view_projection_matrix();");
        println!("═══════════════════════════════════════════════════════\n");

        tracing::info!("Camera demo initialized");

        Box::new(CameraDemo {
            _context: graphics_ctx,
            window,
            window_id,
        })
    });
}

examples/render_graph_demo.rs (line 50)

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

    run_app(|ctx| {
        let graphics_ctx =
            GraphicsContext::new_owned_sync().expect("Failed to create graphics context");

        let window = ctx
            .create_window(WindowDescriptor {
                title: "Render Graph Demo - Multi-Pass Rendering".to_string(),
                size: Some(WinitPhysicalSize::new(1024.0, 768.0)),
                ..Default::default()
            })
            .expect("Failed to create window");

        let window = RenderWindowBuilder::new()
            .color_format(wgpu::TextureFormat::Bgra8UnormSrgb)
            .with_depth_default()
            .build(window, graphics_ctx.clone())
            .expect("Failed to create render window");

        let window_id = window.id();

        println!("\n═══════════════════════════════════════════════════════");
        println!("  🔀 RENDER GRAPH DEMO - Multi-Pass Rendering");
        println!("═══════════════════════════════════════════════════════");
        println!("\n  RENDER GRAPH FEATURES:");
        println!("    • Declarative pass definition");
        println!("    • Automatic dependency resolution");
        println!("    • Resource lifetime management");
        println!("    • Parallel pass execution");
        println!("    • Automatic optimization");
        println!("\n  EXAMPLE PIPELINE:");
        println!("    1. Shadow Pass → depth texture");
        println!("    2. Geometry Pass → color + normal + depth");
        println!("    3. Lighting Pass → lit scene");
        println!("    4. Post-Processing → bloom, tone mapping");
        println!("    5. UI Pass → final composite");
        println!("\n  Render Graph API Usage:");
        println!("    let mut graph = RenderGraph::new();");
        println!("    graph.add_pass(\"shadow\", shadow_pass_descriptor);");
        println!("    graph.add_pass(\"geometry\", geometry_pass_descriptor);");
        println!("    graph.add_dependency(\"lighting\", \"geometry\");");
        println!("    graph.compile();");
        println!("    graph.execute(&mut encoder);");
        println!("═══════════════════════════════════════════════════════\n");

        tracing::info!("Render graph demo initialized");

        Box::new(RenderGraphDemo {
            _context: graphics_ctx,
            window,
            window_id,
        })
    });
}

examples/mesh_primitives.rs (line 50)

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

    run_app(|ctx| {
        let graphics_ctx =
            GraphicsContext::new_owned_sync().expect("Failed to create graphics context");

        let window = ctx
            .create_window(WindowDescriptor {
                title: "Mesh Primitives Demo - Geometry API".to_string(),
                size: Some(WinitPhysicalSize::new(1024.0, 768.0)),
                ..Default::default()
            })
            .expect("Failed to create window");

        let window = RenderWindowBuilder::new()
            .color_format(wgpu::TextureFormat::Bgra8UnormSrgb)
            .with_depth_default()
            .build(window, graphics_ctx.clone())
            .expect("Failed to create render window");

        let window_id = window.id();

        println!("\n═══════════════════════════════════════════════════════");
        println!("  📐 MESH PRIMITIVES DEMO - Geometry API");
        println!("═══════════════════════════════════════════════════════");
        println!("\n  MESH API FEATURES:");
        println!("    • MeshBuilder for custom geometry");
        println!("    • Primitive generation (cube, sphere, plane, etc.)");
        println!("    • Flexible vertex formats (Position, Normal, UV, Color)");
        println!("    • Index buffer optimization");
        println!("    • Instanced rendering support");
        println!("\n  EXAMPLE PRIMITIVES:");
        println!("    • Cube - box with 24 vertices (6 faces × 4 vertices)");
        println!("    • Sphere - tessellated sphere with UV mapping");
        println!("    • Plane - quad with optional subdivisions");
        println!("    • Cylinder - sides + caps");
        println!("    • Custom - arbitrary vertex/index data");
        println!("\n  Mesh API Usage:");
        println!("    let mesh = MeshBuilder::new()");
        println!("        .with_positions(vertices)");
        println!("        .with_normals(normals)");
        println!("        .with_uvs(uvs)");
        println!("        .with_indices(indices)");
        println!("        .build(&ctx);");
        println!("    mesh.draw(&mut pass);");
        println!("    mesh.draw_instanced(&mut pass, instance_count);");
        println!("═══════════════════════════════════════════════════════\n");

        tracing::info!("Mesh primitives demo initialized");

        Box::new(MeshPrimitivesDemo {
            _context: graphics_ctx,
            window,
            window_id,
        })
    });
}

examples/batched_renderer.rs (line 319)

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

    run_app(|ctx| {
        let tier_override = parse_tier();

        // Use the capability API to configure GPU requirements.
        // For auto-detect, request the best capability (graceful degradation).
        // For a specific tier, require that tier's capability.
        let descriptor = match tier_override {
            None => GraphicsContextDescriptor::new().request_capability::<BestBatchCapability2D>(),
            Some(RenderTier::Direct) => {
                GraphicsContextDescriptor::new().require_capability::<DirectBatchCapability2D>()
            }
            Some(RenderTier::Indirect) => {
                GraphicsContextDescriptor::new().require_capability::<IndirectBatchCapability2D>()
            }
            Some(RenderTier::Bindless) => {
                GraphicsContextDescriptor::new().require_capability::<BindlessBatchCapability2D>()
            }
        };
        let graphics_ctx =
            pollster::block_on(GraphicsContext::new_owned_with_descriptor(descriptor))
                .expect("Failed to create graphics context");

        let window = ctx
            .create_window(WindowDescriptor {
                title: "Batched Renderer Example".to_string(),
                size: Some(WinitPhysicalSize::new(800.0, 600.0)),
                ..Default::default()
            })
            .expect("Failed to create window");

        let surface_format = wgpu::TextureFormat::Bgra8UnormSrgb;

        let renderable_window = RenderWindowBuilder::new()
            .color_format(surface_format)
            .with_depth_default()
            .build(window, graphics_ctx.clone())
            .expect("Failed to create render window");

        let window_id = renderable_window.id();

        let renderer =
            create_batch_renderer_2d(graphics_ctx.clone(), surface_format, tier_override);

        tracing::info!("Using render tier: {}", renderer.tier());

        // Create initial depth buffer
        let depth_texture = graphics_ctx
            .device()
            .create_texture(&wgpu::TextureDescriptor {
                label: Some("example_depth"),
                size: wgpu::Extent3d {
                    width: 1,
                    height: 1,
                    depth_or_array_layers: 1,
                },
                mip_level_count: 1,
                sample_count: 1,
                dimension: wgpu::TextureDimension::D2,
                format: DEPTH_FORMAT,
                usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
                view_formats: &[],
            });
        let depth_view = depth_texture.create_view(&wgpu::TextureViewDescriptor::default());

        let mut windows = HashMap::new();
        windows.insert(window_id, renderable_window);

        Box::new(App {
            context: graphics_ctx,
            windows,
            renderer,
            depth_texture,
            depth_view,
            depth_width: 1,
            depth_height: 1,
            frame_count: 0,
        })
    });
}

Additional examples can be found in:

• examples/material_system.rs
• examples/profiling_demo.rs
• examples/sprite_sheet.rs
• examples/textured_window.rs
• examples/renderer_api.rs
• examples/image_blitting.rs

pub fn window(&self) -> &Window

Get the underlying window.

pub fn context(&self) -> &WindowContext

Get the window context.

Examples found in repository

examples/sprite_sheet.rs (line 422)

    fn update(
        &mut self,
        _ctx: &mut astrelis_winit::app::AppCtx,
        _time: &astrelis_winit::FrameTime,
    ) {
        let now = Instant::now();
        let dt = now.duration_since(self.last_update).as_secs_f32();
        self.last_update = now;

        // Update animation
        if self.animation.update(dt) {
            // Frame changed - update vertex buffer with new UVs
            let frame = self.animation.current_frame();
            let uv = self.sprite_sheet.sprite_uv(frame);
            let vertices = create_quad_vertices(uv.u_min, uv.v_min, uv.u_max, uv.v_max);

            // Get context from first window
            if let Some(window) = self.windows.values().next() {
                window.context().graphics_context().queue().write_buffer(
                    &self.vertex_buffer,
                    0,
                    bytemuck::cast_slice(&vertices),
                );
            }
        }
    }

pub fn context_mut(&mut self) -> &mut WindowContext

Get mutable access to the window context.

pub fn graphics(&self) -> &GraphicsContext

Get the graphics context.

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

Get the Arc-wrapped graphics context.

pub fn surface_format(&self) -> TextureFormat

Get the surface texture format.

pub fn resized(&mut self, new_size: LogicalSize<u32>)

Handle window resize event (logical size).

Examples found in repository

examples/camera_demo.rs (line 96)

    fn render(&mut self, _ctx: &mut AppCtx, window_id: WindowId, events: &mut EventBatch) {
        if window_id != self.window_id {
            return;
        }

        events.dispatch(|event| {
            if let astrelis_winit::event::Event::WindowResized(size) = event {
                self.window.resized(*size);
                astrelis_winit::event::HandleStatus::consumed()
            } else {
                astrelis_winit::event::HandleStatus::ignored()
            }
        });

        let Some(frame) = self.window.begin_frame() else {
            return; // Surface not available
        };
        {
            let _pass = frame
                .render_pass()
                .clear_color(Color::from_rgb_u8(20, 30, 40))
                .label("camera_demo_pass")
                .build();
        }
        // Frame auto-submits on drop
    }

examples/mesh_primitives.rs (line 98)

    fn render(&mut self, _ctx: &mut AppCtx, window_id: WindowId, events: &mut EventBatch) {
        if window_id != self.window_id {
            return;
        }

        events.dispatch(|event| {
            if let astrelis_winit::event::Event::WindowResized(size) = event {
                self.window.resized(*size);
                astrelis_winit::event::HandleStatus::consumed()
            } else {
                astrelis_winit::event::HandleStatus::ignored()
            }
        });

        let Some(frame) = self.window.begin_frame() else {
            return; // Surface not available
        };
        {
            let _pass = frame
                .render_pass()
                .clear_color(Color::from_rgb_u8(20, 30, 40))
                .label("mesh_primitives_pass")
                .build();
        }
        // Frame auto-submits on drop
    }

examples/render_graph_demo.rs (line 96)

    fn render(&mut self, _ctx: &mut AppCtx, window_id: WindowId, events: &mut EventBatch) {
        if window_id != self.window_id {
            return;
        }

        events.dispatch(|event| {
            if let astrelis_winit::event::Event::WindowResized(size) = event {
                self.window.resized(*size);
                astrelis_winit::event::HandleStatus::consumed()
            } else {
                astrelis_winit::event::HandleStatus::ignored()
            }
        });

        let Some(frame) = self.window.begin_frame() else {
            return; // Surface not available
        };
        {
            let _pass = frame
                .render_pass()
                .clear_color(Color::from_rgb_u8(20, 30, 40))
                .label("render_graph_demo_pass")
                .build();
        }
        // Frame auto-submits on drop
    }

examples/material_system.rs (line 113)

    fn render(&mut self, _ctx: &mut AppCtx, window_id: WindowId, events: &mut EventBatch) {
        if window_id != self.window_id {
            return;
        }

        // Handle resize
        events.dispatch(|event| {
            if let astrelis_winit::event::Event::WindowResized(size) = event {
                self.window.resized(*size);
                astrelis_winit::event::HandleStatus::consumed()
            } else {
                astrelis_winit::event::HandleStatus::ignored()
            }
        });

        // In a real application, materials would be bound during rendering:
        // material.bind(&mut render_pass);
        // draw_mesh(&mesh);

        // Begin frame
        let Some(frame) = self.window.begin_frame() else {
            return; // Surface not available
        };

        {
            let _pass = frame
                .render_pass()
                .clear_color(Color::from_rgb_u8(20, 30, 40))
                .label("material_system_pass")
                .build();
            // Materials would be applied here in actual rendering
            // This is a conceptual demonstration
        }
        // Frame auto-submits on drop
    }

examples/sprite_sheet.rs (line 444)

    fn render(
        &mut self,
        _ctx: &mut astrelis_winit::app::AppCtx,
        window_id: WindowId,
        events: &mut astrelis_winit::event::EventBatch,
    ) {
        let Some(window) = self.windows.get_mut(&window_id) else {
            return;
        };

        // Handle resize
        events.dispatch(|event| {
            if let astrelis_winit::event::Event::WindowResized(size) = event {
                window.resized(*size);
                astrelis_winit::event::HandleStatus::consumed()
            } else {
                astrelis_winit::event::HandleStatus::ignored()
            }
        });

        let Some(frame) = window.begin_frame() else {
            return; // Surface not available
        };
        {
            let mut pass = frame
                .render_pass()
                .clear_color(Color::rgb(0.1, 0.1, 0.15))
                .label("sprite_sheet_pass")
                .build();
            pass.set_pipeline(&self.pipeline);
            pass.set_bind_group(0, &self.bind_group, &[]);
            pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
            pass.draw(0..6, 0..1);
        }
        // Frame auto-submits on drop
    }

examples/image_blitting.rs (line 499)

    fn render(
        &mut self,
        _ctx: &mut astrelis_winit::app::AppCtx,
        window_id: WindowId,
        events: &mut astrelis_winit::event::EventBatch,
    ) {
        let Some(window) = self.windows.get_mut(&window_id) else {
            return;
        };

        // Handle resize
        events.dispatch(|event| {
            if let astrelis_winit::event::Event::WindowResized(size) = event {
                window.resized(*size);
                astrelis_winit::event::HandleStatus::consumed()
            } else {
                astrelis_winit::event::HandleStatus::ignored()
            }
        });

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

        {
            let mut pass = frame
                .render_pass()
                .clear_color(Color::rgb(0.05, 0.05, 0.08))
                .label("image_blitting_pass")
                .build();
            pass.set_pipeline(&self.pipeline);
            pass.set_bind_group(0, &self.bind_group, &[]);
            pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
            pass.draw(0..6, 0..1);
        }
        // Frame auto-submits on drop
    }

Additional examples can be found in:

• examples/textured_window.rs
• examples/multi_window.rs
• examples/profiling_demo.rs
• examples/renderer_api.rs
• examples/batched_renderer.rs
• examples/performance_benchmark.rs

pub fn resized_physical(&mut self, new_size: PhysicalSize<u32>)

Handle window resize event (physical size).

pub fn physical_size(&self) -> PhysicalSize<u32>

Get the physical size of the window.

Examples found in repository

examples/batched_renderer.rs (line 391)

    fn render(
        &mut self,
        _ctx: &mut astrelis_winit::app::AppCtx,
        window_id: WindowId,
        events: &mut astrelis_winit::event::EventBatch,
    ) {
        // Handle resize and get dimensions (scoped to release window borrow)
        let (phys_width, phys_height) = {
            let Some(window) = self.windows.get_mut(&window_id) else {
                return;
            };

            events.dispatch(|event| {
                if let astrelis_winit::event::Event::WindowResized(size) = event {
                    window.resized(*size);
                    astrelis_winit::event::HandleStatus::consumed()
                } else {
                    astrelis_winit::event::HandleStatus::ignored()
                }
            });

            let phys = window.physical_size();
            (phys.width, phys.height)
        };

        let width = phys_width as f32;
        let height = phys_height as f32;

        if width < 1.0 || height < 1.0 {
            return;
        }

        // Ensure depth buffer matches viewport
        self.ensure_depth_buffer(phys_width, phys_height);

        // Build instances and prepare GPU data
        let instances = self.build_instances(width, height);
        let batch = DrawBatch2D {
            instances,
            textures: vec![],
            projection: Self::ortho_projection(width, height),
        };
        self.renderer.prepare(&batch);

        let stats = self.renderer.stats();
        if self.frame_count.is_multiple_of(120) {
            tracing::info!(
                "Frame {}: {} instances ({} opaque, {} transparent), {} draw calls",
                self.frame_count,
                stats.instance_count,
                stats.opaque_count,
                stats.transparent_count,
                stats.draw_calls,
            );
        }

        // Re-borrow window for rendering
        let window = self.windows.get_mut(&window_id).unwrap();
        let Some(frame) = window.begin_frame() else {
            return; // Surface not available
        };

        // Create render pass with depth stencil attachment
        {
            let mut pass = frame
                .render_pass()
                .clear_color(Color::rgba(0.08, 0.08, 0.1, 1.0))
                .depth_attachment(&self.depth_view)
                .clear_depth(0.0) // 0.0 = far with GreaterEqual
                .label("batched_example_pass")
                .build();
            self.renderer.render(pass.wgpu_pass());
        }
        // Frame auto-submits on drop
    }

pub fn size(&self) -> (u32, u32)

Get the surface size in pixels.

pub fn scale_factor(&self) -> ScaleFactor

Get the scale factor.

pub fn viewport(&self) -> Viewport

Get the viewport for this window.

pub fn set_gpu_profiler(&mut self, profiler: Arc<GpuFrameProfiler>)

Attach a GPU profiler to this window.

pub fn remove_gpu_profiler(&mut self) -> Option<Arc<GpuFrameProfiler>>

Remove the GPU profiler from this window.

pub fn gpu_profiler(&self) -> Option<&Arc<GpuFrameProfiler>>

Get a reference to the GPU profiler, if attached.

pub fn has_depth(&self) -> bool

Check if this window has a depth texture.

pub fn depth_view(&self) -> Option<Arc<TextureView>>

Get the depth texture view if available (Arc-wrapped).

pub fn depth_view_ref(&self) -> Option<&TextureView>

Get a reference to the depth texture view (without Arc).

pub fn depth_format(&self) -> Option<TextureFormat>

Get the depth texture format, if depth is enabled.

Returns the format used for the depth texture, or None if depth is not enabled. Use this to configure renderers that need to match the depth format.

pub fn ensure_depth(&mut self, format: TextureFormat)

Ensure a depth texture exists for this window.

Methods from Deref<Target = WindowContext>

pub fn resized(&mut self, new_size: LogicalSize<u32>)

Handle window resize event (logical size).

pub fn resized_physical(&mut self, new_size: PhysicalSize<u32>)

Handle window resize event (physical size).

pub fn window(&self) -> &Window

pub fn graphics_context(&self) -> &GraphicsContext

Examples found in repository

examples/sprite_sheet.rs (line 422)

    fn update(
        &mut self,
        _ctx: &mut astrelis_winit::app::AppCtx,
        _time: &astrelis_winit::FrameTime,
    ) {
        let now = Instant::now();
        let dt = now.duration_since(self.last_update).as_secs_f32();
        self.last_update = now;

        // Update animation
        if self.animation.update(dt) {
            // Frame changed - update vertex buffer with new UVs
            let frame = self.animation.current_frame();
            let uv = self.sprite_sheet.sprite_uv(frame);
            let vertices = create_quad_vertices(uv.u_min, uv.v_min, uv.u_max, uv.v_max);

            // Get context from first window
            if let Some(window) = self.windows.values().next() {
                window.context().graphics_context().queue().write_buffer(
                    &self.vertex_buffer,
                    0,
                    bytemuck::cast_slice(&vertices),
                );
            }
        }
    }

pub fn surface(&self) -> &Surface<'static>

pub fn surface_config(&self) -> &SurfaceConfiguration

pub fn surface_format(&self) -> TextureFormat

Get the surface texture format.

This is the format that render pipelines must use when rendering to this window’s surface. Pass this to renderer constructors like LineRenderer::new.

pub fn logical_size(&self) -> LogicalSize<u32>

Get the logical size of the window.

pub fn physical_size(&self) -> PhysicalSize<u32>

Get the physical size of the window.

pub fn logical_size_f32(&self) -> LogicalSize<f32>

Get the logical size as f32.

pub fn physical_size_f32(&self) -> PhysicalSize<f32>

Get the physical size as f32.

pub fn reconfigure_surface(&mut self, config: SurfaceConfiguration)

Reconfigure the surface with a new configuration.

pub fn has_depth(&self) -> bool

Check if this window has a depth texture.

pub fn depth_view(&self) -> Option<Arc<TextureView>>

Get the depth texture view if available.

Returns an Arc-wrapped view for cheap, lifetime-free sharing.

pub fn depth_format(&self) -> Option<TextureFormat>

Get the depth texture format, if depth is enabled.

Returns the format used for the depth texture, or None if depth is not enabled. Use this to configure renderers that need to match the depth format.

pub fn ensure_depth(&mut self, format: TextureFormat)

Ensure a depth texture exists for this window.

If no depth texture exists, creates one with the given format. If a depth texture already exists, this is a no-op.

Trait Implementations

impl Deref for RenderWindow

type Target = WindowContext

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for RenderWindow

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl WindowBackend for RenderWindow

type FrameContext = Frame<'static>

type Error = GraphicsError

fn try_begin_drawing(&mut self) -> Result<Self::FrameContext, Self::Error>

Begin drawing a new frame.

fn begin_drawing(&mut self) -> Self::FrameContext

where Self::Error: Debug,

Begin drawing a new frame, panicking on error.