Struct RenderPassBuilder 

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

Builder for creating render passes.

Implementations

impl<'a> RenderPassBuilder<'a>

pub fn new() -> Self

Examples found in repository

examples/batched_renderer.rs (line 434)

    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 label(self, label: &'a str) -> Self

Set a debug label for the render pass.

Examples found in repository

examples/batched_renderer.rs (line 435)

    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 target(self, target: RenderTarget<'a>) -> Self

Set the render target (Surface or Framebuffer).

This is the simplified API - use this instead of manual color_attachment calls.

Examples found in repository

examples/batched_renderer.rs (line 436)

    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 clear_color(self, color: impl Into<ClearOp>) -> Self

Set clear color for the render target.

Pass a wgpu::Color or use ClearOp::Load to preserve existing contents.

Examples found in repository

examples/batched_renderer.rs (line 437)

    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 clear_depth(self, depth: f32) -> Self

Set depth clear operation.

Examples found in repository

examples/batched_renderer.rs (line 438)

    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 load_depth(self) -> Self

Load existing depth values instead of clearing.

pub fn color_attachment( self, view: Option<&'a TextureView>, resolve_target: Option<&'a TextureView>, ops: Operations<Color>, ) -> Self

Add a color attachment manually (advanced API).

For most cases, use .target() instead.

pub fn depth_stencil_attachment( self, view: &'a TextureView, depth_ops: Option<Operations<f32>>, stencil_ops: Option<Operations<u32>>, ) -> Self

Add a depth-stencil attachment manually (advanced API).

For framebuffers with depth, the depth attachment is handled automatically when using .target().

Examples found in repository

examples/batched_renderer.rs (lines 439-446)

    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 build(self, frame_context: &'a mut FrameContext) -> RenderPass<'a>

Builds the render pass and begins it on the provided frame context.

This takes ownership of the CommandEncoder from the FrameContext, and releases it back to the FrameContext when the RenderPass is dropped or finish is called.

Trait Implementations

impl Default for RenderPassBuilder<'_>

fn default() -> Self

Returns the “default value” for a type.