Struct FrameContext 

pub struct FrameContext { /* private fields */ }

Context for a single frame of rendering.

Implementations

impl FrameContext

pub fn surface(&self) -> &Surface

pub fn surface_format(&self) -> TextureFormat

pub fn increment_passes(&mut self)

pub fn increment_draw_calls(&mut self)

pub fn stats(&self) -> &FrameStats

pub fn graphics_context(&self) -> &'static GraphicsContext

pub fn encoder(&mut self) -> &mut CommandEncoder

pub fn encoder_and_surface(&mut self) -> (&mut CommandEncoder, &Surface)

pub fn finish(self)

Examples found in repository

examples/multi_window.rs (line 125)

    fn render(
        &mut self,
        _ctx: &mut astrelis_winit::app::AppCtx,
        window_id: WindowId,
        events: &mut astrelis_winit::event::EventBatch,
    ) {
        // Get the window and color for this specific window
        let Some((window, color)) = self.windows.get_mut(&window_id) else {
            return;
        };

        // Handle window-specific resize events
        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()
            }
        });

        // Render this specific window
        let mut frame = window.begin_drawing();

        {
            let _render_pass = RenderPassBuilder::new()
                .label("Multi-Window Render Pass")
                .target(RenderTarget::Surface)
                .clear_color(*color)
                .build(&mut frame);
        }

        frame.finish();
    }

examples/image_blitting.rs (line 485)

    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 mut frame = window.begin_drawing();

        {
            let mut render_pass = RenderPassBuilder::new()
                .label("Blit Render Pass")
                .target(RenderTarget::Surface)
                .clear_color(wgpu::Color {
                    r: 0.05,
                    g: 0.05,
                    b: 0.08,
                    a: 1.0,
                })
                .build(&mut frame);

            let pass = render_pass.descriptor();
            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.finish();
    }

examples/sprite_sheet.rs (line 427)

    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 mut frame = window.begin_drawing();

        {
            let mut render_pass = RenderPassBuilder::new()
                .label("Sprite Render Pass")
                .target(RenderTarget::Surface)
                .clear_color(wgpu::Color {
                    r: 0.1,
                    g: 0.1,
                    b: 0.15,
                    a: 1.0,
                })
                .build(&mut frame);

            let pass = render_pass.descriptor();
            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.finish();
    }

examples/textured_window.rs (line 283)

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

        // Handle window resize events
        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 mut frame = self.window.begin_drawing();

        // Using new simplified RenderPassBuilder API with RenderTarget
        {
            let mut render_pass = RenderPassBuilder::new()
                .label("Render Pass")
                .target(RenderTarget::Surface)
                .clear_color(wgpu::Color {
                    r: 0.1,
                    g: 0.2,
                    b: 0.3,
                    a: 1.0,
                })
                .build(&mut frame);

            let pass = render_pass.descriptor();
            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.finish();
    }

examples/renderer_api.rs (line 333)

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

        // Handle window-specific resize events
        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 mut frame = self.window.begin_drawing();

        // Pass 1: Render to offscreen framebuffer using new simplified API
        {
            let mut render_pass = RenderPassBuilder::new()
                .label("Offscreen Pass")
                .target(RenderTarget::Framebuffer(&self.offscreen_fb))
                .clear_color(wgpu::Color {
                    r: 0.2,
                    g: 0.1,
                    b: 0.3,
                    a: 1.0,
                })
                .build(&mut frame);

            let pass = render_pass.descriptor();
            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);
        }

        // Pass 2: Blit framebuffer to surface using new simplified API
        {
            let mut render_pass = RenderPassBuilder::new()
                .label("Surface Pass")
                .target(RenderTarget::Surface)
                .clear_color(wgpu::Color {
                    r: 0.1,
                    g: 0.2,
                    b: 0.3,
                    a: 1.0,
                })
                .build(&mut frame);

            let pass = render_pass.descriptor();
            pass.set_pipeline(&self.blit_pipeline);
            pass.set_bind_group(0, &self.blit_bind_group, &[]);
            // Draw fullscreen triangle
            pass.draw(0..3, 0..1);
        }

        frame.finish();
    }

Trait Implementations

impl ComputePassExt for FrameContext

fn compute_pass<'a>(&'a mut self, label: &'a str) -> ComputePass<'a>

Create a compute pass with a label.

fn compute_pass_unlabeled(&mut self) -> ComputePass<'_>

Create a compute pass without a label.

impl Drop for FrameContext

fn drop(&mut self)

Executes the destructor for this type.

impl RenderPassExt for FrameContext

fn clear_pass<'a>( &'a mut self, target: RenderTarget<'a>, clear_color: Color, ) -> RenderPass<'a>

Create a render pass that clears to the given color.

fn load_pass<'a>(&'a mut self, target: RenderTarget<'a>) -> RenderPass<'a>

Create a render pass that loads existing content.