Struct RenderPass 

pub struct RenderPass<'a> { /* private fields */ }

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

Implementations

impl<'a> RenderPass<'a>

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

Get the underlying wgpu RenderPass.

Panics

Panics if the render pass has already been consumed (dropped or finished). Use try_wgpu_pass() for fallible access.

Examples found in repository

examples/sprite_sheet.rs (line 417)

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

        // Render with automatic scoping (no manual {} block needed)
        frame.clear_and_render(
            RenderTarget::Surface,
            Color::rgb(0.1, 0.1, 0.15),
            |pass| {
                let pass = pass.wgpu_pass();
                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/image_blitting.rs (line 471)

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

        // Render with automatic scoping (no manual {} block needed)
        frame.clear_and_render(
            RenderTarget::Surface,
            Color::rgb(0.05, 0.05, 0.08),
            |pass| {
                let pass = pass.wgpu_pass();
                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 291)

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

        // --- Render Loop ---
        let mut frame = self.window.begin_drawing();

        // clear_and_render handles render pass scoping automatically:
        // the pass is created, the closure runs, then the pass drops.
        frame.clear_and_render(
            RenderTarget::Surface,
            Color::rgb(0.1, 0.2, 0.3),
            |pass| {
                let pass = pass.wgpu_pass();
                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 308)

    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 with automatic scoping
        frame.clear_and_render(
            RenderTarget::Framebuffer(&self.offscreen_fb),
            Color::rgb(0.2, 0.1, 0.3),
            |pass| {
                let pass = pass.wgpu_pass();
                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 with automatic scoping
        frame.clear_and_render(
            RenderTarget::Surface,
            Color::rgb(0.1, 0.2, 0.3),
            |pass| {
                let pass = pass.wgpu_pass();
                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();
    }

examples/batched_renderer.rs (line 448)

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

        // Use RenderPassBuilder with depth stencil attachment
        frame.with_pass(
            astrelis_render::RenderPassBuilder::new()
                .label("batched_example_pass")
                .target(astrelis_render::RenderTarget::Surface)
                .clear_color(astrelis_render::Color::rgba(0.08, 0.08, 0.1, 1.0))
                .clear_depth(0.0) // 0.0 = far with GreaterEqual
                .depth_stencil_attachment(
                    &self.depth_view,
                    Some(wgpu::Operations {
                        load: wgpu::LoadOp::Clear(0.0),
                        store: wgpu::StoreOp::Store,
                    }),
                    None,
                ),
            |pass| {
                self.renderer.render(pass.wgpu_pass());
            },
        );

        frame.finish();
    }

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

Try to get the underlying wgpu RenderPass.

Returns None if the render pass has already been consumed.

pub fn is_valid(&self) -> bool

Check if the render pass is still valid and can be used.

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

Get raw access to the underlying wgpu render pass.

pub fn graphics_context(&self) -> &GraphicsContext

Get the graphics context.

pub fn frame_context(&self) -> &FrameContext

Get the frame context.

pub fn finish(self)

pub fn set_viewport_physical( &mut self, rect: PhysicalRect<f32>, min_depth: f32, max_depth: f32, )

Set the viewport using physical coordinates.

The viewport defines the transformation from normalized device coordinates to window coordinates.

Arguments

• rect - The viewport rectangle in physical (pixel) coordinates
• min_depth - Minimum depth value (typically 0.0)
• max_depth - Maximum depth value (typically 1.0)

pub fn set_viewport_logical( &mut self, rect: LogicalRect<f32>, min_depth: f32, max_depth: f32, scale: ScaleFactor, )

Set the viewport using logical coordinates (converts with scale factor).

Arguments

• rect - The viewport rectangle in logical coordinates
• min_depth - Minimum depth value (typically 0.0)
• max_depth - Maximum depth value (typically 1.0)
• scale - Scale factor for logical to physical conversion

pub fn set_viewport(&mut self, viewport: &Viewport)

Set the viewport from a Viewport struct.

Uses the viewport’s position and size, with depth range 0.0 to 1.0.

pub fn set_scissor_physical(&mut self, rect: PhysicalRect<u32>)

Set the scissor rectangle using physical coordinates.

The scissor rectangle defines the area of the render target that can be modified by drawing commands.

Arguments

• rect - The scissor rectangle in physical (pixel) coordinates

pub fn set_scissor_logical( &mut self, rect: LogicalRect<f32>, scale: ScaleFactor, )

Set the scissor rectangle using logical coordinates.

Arguments

• rect - The scissor rectangle in logical coordinates
• scale - Scale factor for logical to physical conversion

pub fn set_pipeline(&mut self, pipeline: &'a RenderPipeline)

Set the pipeline for this render pass.

pub fn set_bind_group( &mut self, index: u32, bind_group: &'a BindGroup, offsets: &[u32], )

Set a bind group for this render pass.

pub fn set_vertex_buffer(&mut self, slot: u32, buffer_slice: BufferSlice<'a>)

Set the vertex buffer for this render pass.

pub fn set_index_buffer( &mut self, buffer_slice: BufferSlice<'a>, format: IndexFormat, )

Set the index buffer for this render pass.

pub fn draw(&mut self, vertices: Range<u32>, instances: Range<u32>)

Draw primitives.

pub fn draw_indexed( &mut self, indices: Range<u32>, base_vertex: i32, instances: Range<u32>, )

Draw indexed primitives.

pub fn insert_debug_marker(&mut self, label: &str)

Insert a debug marker.

pub fn push_debug_group(&mut self, label: &str)

Push a debug group.

pub fn pop_debug_group(&mut self)

Pop a debug group.

pub fn set_push_constants<T: Pod>( &mut self, stages: ShaderStages, offset: u32, data: &T, )

Set push constants for a range of shader stages.

Push constants are a fast way to pass small amounts of data to shaders without the overhead of buffer updates. They are limited in size (typically 128-256 bytes depending on the GPU).

Requires the PUSH_CONSTANTS feature to be enabled.

Arguments

• stages - Which shader stages can access this data
• offset - Byte offset within the push constant range
• data - The data to set (must be Pod)

Example

#[repr(C)]
#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
struct PushConstants {
    transform: [[f32; 4]; 4],
    color: [f32; 4],
}

let constants = PushConstants {
    transform: /* ... */,
    color: [1.0, 0.0, 0.0, 1.0],
};

pass.set_push_constants(
    wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
    0,
    &constants,
);

pub fn set_push_constants_raw( &mut self, stages: ShaderStages, offset: u32, data: &[u8], )

Set push constants from raw bytes.

Use this when you need more control over the data layout.

Trait Implementations

impl<'a> AsWgpu for RenderPass<'a>

type WgpuType = RenderPass<'static>

The underlying wgpu type.

fn as_wgpu(&self) -> &Self::WgpuType

Get a reference to the underlying wgpu type.

impl<'a> AsWgpuMut for RenderPass<'a>

fn as_wgpu_mut(&mut self) -> &mut Self::WgpuType

Get a mutable reference to the underlying wgpu type.

impl Drop for RenderPass<'_>

fn drop(&mut self)

Executes the destructor for this type.