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/textured_window.rs (line 268)

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

        // Render with automatic scoping (no manual {} block needed)
        frame.clear_and_render(
            RenderTarget::Surface,
            Color::rgb(0.1, 0.2, 0.3),
            |pass| {
                let pass = 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 413)

    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.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/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.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 299)

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

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.

impl<'a> RenderPassRawExt<'a> for RenderPass<'a>

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

Get raw access to the underlying wgpu render pass.

fn graphics_context(&self) -> &GraphicsContext

Get the graphics context.