Struct RenderPass 

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

A render pass that owns its encoder.

When dropped, the render pass:

1. Ends the wgpu render pass
2. Finishes the command encoder
3. Pushes the command buffer to the frame

This design eliminates encoder movement and borrow conflicts.

Implementations

impl<'f> RenderPass<'f>

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

Get the underlying wgpu RenderPass (mutable).

Panics

Panics if the render pass has already been consumed.

Examples found in repository

examples/batched_renderer.rs (line 441)

    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.is_multiple_of(120) {
            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 Some(frame) = window.begin_frame() else {
            return; // Surface not available
        };

        // Create render pass with depth stencil attachment
        {
            let mut pass = frame
                .render_pass()
                .clear_color(Color::rgba(0.08, 0.08, 0.1, 1.0))
                .depth_attachment(&self.depth_view)
                .clear_depth(0.0) // 0.0 = far with GreaterEqual
                .label("batched_example_pass")
                .build();
            self.renderer.render(pass.wgpu_pass());
        }
        // Frame auto-submits on drop
    }

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

Get the underlying wgpu RenderPass (immutable).

Panics

Panics if the render pass has already been consumed.

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

Try to get the underlying wgpu RenderPass.

pub fn is_valid(&self) -> bool

Check if the render pass is still valid.

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

Get raw access to the pass (alias for wgpu_pass).

pub fn encoder(&self) -> Option<&CommandEncoder>

Get the command encoder.

pub fn encoder_mut(&mut self) -> Option<&mut CommandEncoder>

Get mutable access to the command encoder.

pub fn graphics(&self) -> &GraphicsContext

Get the graphics context.

pub fn record_draw_call(&self)

Record a draw call for statistics.

pub fn into_encoder(self) -> CommandEncoder

Consume the pass early and return the encoder for further use.

This ends the render pass but allows the encoder to be used for additional commands before submission.

pub fn finish(self)

Finish the render pass (called automatically on drop).

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

Set the viewport using physical coordinates.

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

Set the viewport using logical coordinates.

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

Set the viewport from a Viewport struct.

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

Set the scissor rectangle using physical coordinates.

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

Set the scissor rectangle using logical coordinates.

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

Set the pipeline.

Examples found in repository

examples/sprite_sheet.rs (line 460)

    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 Some(frame) = window.begin_frame() else {
            return; // Surface not available
        };
        {
            let mut pass = frame
                .render_pass()
                .clear_color(Color::rgb(0.1, 0.1, 0.15))
                .label("sprite_sheet_pass")
                .build();
            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 auto-submits on drop
    }

examples/image_blitting.rs (line 516)

    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 Some(frame) = window.begin_frame() else {
            return; // Surface not available
        };

        {
            let mut pass = frame
                .render_pass()
                .clear_color(Color::rgb(0.05, 0.05, 0.08))
                .label("image_blitting_pass")
                .build();
            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 auto-submits on drop
    }

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 Some(frame) = self.window.begin_frame() else {
            return; // Surface not available
        };

        {
            let mut pass = frame
                .render_pass()
                .clear_color(Color::rgb(0.1, 0.2, 0.3))
                .label("textured_window_pass")
                .build();
            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 auto-submits on drop
    }

examples/renderer_api.rs (line 311)

    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 Some(frame) = self.window.begin_frame() else {
            return; // Surface not available
        };

        // Pass 1: Render to offscreen framebuffer
        {
            let mut pass = frame
                .render_pass()
                .target(RenderTarget::Framebuffer(&self.offscreen_fb))
                .clear_color(Color::rgb(0.2, 0.1, 0.3))
                .label("offscreen_pass")
                .build();
            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
        {
            let mut pass = frame
                .render_pass()
                .clear_color(Color::rgb(0.1, 0.2, 0.3))
                .label("blit_pass")
                .build();
            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 auto-submits on drop
    }

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

Set a bind group.

Examples found in repository

examples/sprite_sheet.rs (line 461)

    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 Some(frame) = window.begin_frame() else {
            return; // Surface not available
        };
        {
            let mut pass = frame
                .render_pass()
                .clear_color(Color::rgb(0.1, 0.1, 0.15))
                .label("sprite_sheet_pass")
                .build();
            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 auto-submits on drop
    }

examples/image_blitting.rs (line 517)

    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 Some(frame) = window.begin_frame() else {
            return; // Surface not available
        };

        {
            let mut pass = frame
                .render_pass()
                .clear_color(Color::rgb(0.05, 0.05, 0.08))
                .label("image_blitting_pass")
                .build();
            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 auto-submits on drop
    }

examples/textured_window.rs (line 292)

    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 Some(frame) = self.window.begin_frame() else {
            return; // Surface not available
        };

        {
            let mut pass = frame
                .render_pass()
                .clear_color(Color::rgb(0.1, 0.2, 0.3))
                .label("textured_window_pass")
                .build();
            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 auto-submits on drop
    }

examples/renderer_api.rs (line 312)

    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 Some(frame) = self.window.begin_frame() else {
            return; // Surface not available
        };

        // Pass 1: Render to offscreen framebuffer
        {
            let mut pass = frame
                .render_pass()
                .target(RenderTarget::Framebuffer(&self.offscreen_fb))
                .clear_color(Color::rgb(0.2, 0.1, 0.3))
                .label("offscreen_pass")
                .build();
            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
        {
            let mut pass = frame
                .render_pass()
                .clear_color(Color::rgb(0.1, 0.2, 0.3))
                .label("blit_pass")
                .build();
            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 auto-submits on drop
    }

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

Set a vertex buffer.

Examples found in repository

examples/sprite_sheet.rs (line 462)

    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 Some(frame) = window.begin_frame() else {
            return; // Surface not available
        };
        {
            let mut pass = frame
                .render_pass()
                .clear_color(Color::rgb(0.1, 0.1, 0.15))
                .label("sprite_sheet_pass")
                .build();
            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 auto-submits on drop
    }

examples/image_blitting.rs (line 518)

    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 Some(frame) = window.begin_frame() else {
            return; // Surface not available
        };

        {
            let mut pass = frame
                .render_pass()
                .clear_color(Color::rgb(0.05, 0.05, 0.08))
                .label("image_blitting_pass")
                .build();
            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 auto-submits on drop
    }

examples/textured_window.rs (line 293)

    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 Some(frame) = self.window.begin_frame() else {
            return; // Surface not available
        };

        {
            let mut pass = frame
                .render_pass()
                .clear_color(Color::rgb(0.1, 0.2, 0.3))
                .label("textured_window_pass")
                .build();
            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 auto-submits on drop
    }

examples/renderer_api.rs (line 313)

    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 Some(frame) = self.window.begin_frame() else {
            return; // Surface not available
        };

        // Pass 1: Render to offscreen framebuffer
        {
            let mut pass = frame
                .render_pass()
                .target(RenderTarget::Framebuffer(&self.offscreen_fb))
                .clear_color(Color::rgb(0.2, 0.1, 0.3))
                .label("offscreen_pass")
                .build();
            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
        {
            let mut pass = frame
                .render_pass()
                .clear_color(Color::rgb(0.1, 0.2, 0.3))
                .label("blit_pass")
                .build();
            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 auto-submits on drop
    }

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

Set the index buffer.

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

Draw primitives.

Examples found in repository

examples/sprite_sheet.rs (line 463)

    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 Some(frame) = window.begin_frame() else {
            return; // Surface not available
        };
        {
            let mut pass = frame
                .render_pass()
                .clear_color(Color::rgb(0.1, 0.1, 0.15))
                .label("sprite_sheet_pass")
                .build();
            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 auto-submits on drop
    }

examples/image_blitting.rs (line 519)

    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 Some(frame) = window.begin_frame() else {
            return; // Surface not available
        };

        {
            let mut pass = frame
                .render_pass()
                .clear_color(Color::rgb(0.05, 0.05, 0.08))
                .label("image_blitting_pass")
                .build();
            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 auto-submits on drop
    }

examples/textured_window.rs (line 294)

    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 Some(frame) = self.window.begin_frame() else {
            return; // Surface not available
        };

        {
            let mut pass = frame
                .render_pass()
                .clear_color(Color::rgb(0.1, 0.2, 0.3))
                .label("textured_window_pass")
                .build();
            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 auto-submits on drop
    }

examples/renderer_api.rs (line 314)

    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 Some(frame) = self.window.begin_frame() else {
            return; // Surface not available
        };

        // Pass 1: Render to offscreen framebuffer
        {
            let mut pass = frame
                .render_pass()
                .target(RenderTarget::Framebuffer(&self.offscreen_fb))
                .clear_color(Color::rgb(0.2, 0.1, 0.3))
                .label("offscreen_pass")
                .build();
            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
        {
            let mut pass = frame
                .render_pass()
                .clear_color(Color::rgb(0.1, 0.2, 0.3))
                .label("blit_pass")
                .build();
            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 auto-submits on drop
    }

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.

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

Set push constants from raw bytes.

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.