Struct RenderPass 

pub struct RenderPass<'a> {
    pub context: &'a mut FrameContext,
    /* private fields */
}

A render pass wrapper that automatically returns the encoder to the frame context.

Fields

context: &'a mut FrameContext

Implementations

impl<'a> RenderPass<'a>

pub fn descriptor(&mut self) -> &mut RenderPass<'static>

Examples found in repository

examples/image_blitting.rs (line 478)

    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 420)

    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 276)

    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 306)

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

pub fn finish(self)

Trait Implementations

impl Drop for RenderPass<'_>

fn drop(&mut self)

Executes the destructor for this type.