Struct wgpu::RenderPass

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

In-progress recording of a render pass.

It can be created with CommandEncoder::begin_render_pass.

Corresponds to WebGPU GPURenderPassEncoder.

Implementations

impl<'a> RenderPass<'a>

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

Sets the active bind group for a given bind group index. The bind group layout in the active pipeline when any draw() function is called must match the layout of this bind group.

If the bind group have dynamic offsets, provide them in binding order. These offsets have to be aligned to Limits::min_uniform_buffer_offset_alignment or Limits::min_storage_buffer_offset_alignment appropriately.

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

Sets the active render pipeline.

Subsequent draw calls will exhibit the behavior defined by pipeline.

pub fn set_blend_constant(&mut self, color: Color)

Sets the blend color as used by some of the blending modes.

Subsequent blending tests will test against this value.

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

Sets the active index buffer.

Subsequent calls to draw_indexed on this RenderPass will use buffer as the source index buffer.

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

Assign a vertex buffer to a slot.

Subsequent calls to draw and draw_indexed on this RenderPass will use buffer as one of the source vertex buffers.

The slot refers to the index of the matching descriptor in VertexState::buffers.

pub fn set_scissor_rect(&mut self, x: u32, y: u32, width: u32, height: u32)

Sets the scissor region.

Subsequent draw calls will discard any fragments that fall outside this region.

pub fn set_viewport(
    &mut self,
    x: f32,
    y: f32,
    w: f32,
    h: f32,
    min_depth: f32,
    max_depth: f32
)

Sets the viewport region.

Subsequent draw calls will draw any fragments in this region.

pub fn set_stencil_reference(&mut self, reference: u32)

Sets the stencil reference.

Subsequent stencil tests will test against this value.

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

Draws primitives from the active vertex buffer(s).

The active vertex buffers can be set with RenderPass::set_vertex_buffer.

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

Inserts debug marker.

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

Start record commands and group it into debug marker group.

pub fn pop_debug_group(&mut self)

Stops command recording and creates debug group.

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

Draws indexed primitives using the active index buffer and the active vertex buffers.

The active index buffer can be set with RenderPass::set_index_buffer, while the active vertex buffers can be set with RenderPass::set_vertex_buffer.

pub fn draw_indirect(
    &mut self,
    indirect_buffer: &'a Buffer,
    indirect_offset: BufferAddress
)

Draws primitives from the active vertex buffer(s) based on the contents of the indirect_buffer.

The active vertex buffers can be set with RenderPass::set_vertex_buffer.

The structure expected in indirect_buffer must conform to DrawIndirect.

pub fn draw_indexed_indirect(
    &mut self,
    indirect_buffer: &'a Buffer,
    indirect_offset: BufferAddress
)

Draws indexed primitives using the active index buffer and the active vertex buffers, based on the contents of the indirect_buffer.

The active index buffer can be set with RenderPass::set_index_buffer, while the active vertex buffers can be set with RenderPass::set_vertex_buffer.

The structure expected in indirect_buffer must conform to DrawIndexedIndirect.

pub fn execute_bundles<I: IntoIterator<Item = &'a RenderBundle>>(
    &mut self,
    render_bundles: I
)

Execute a render bundle, which is a set of pre-recorded commands that can be run together.

impl<'a> RenderPass<'a>

Features::MULTI_DRAW_INDIRECT must be enabled on the device in order to call these functions.

pub fn multi_draw_indirect(
    &mut self,
    indirect_buffer: &'a Buffer,
    indirect_offset: BufferAddress,
    count: u32
)

Dispatches multiple draw calls from the active vertex buffer(s) based on the contents of the indirect_buffer. count draw calls are issued.

The active vertex buffers can be set with RenderPass::set_vertex_buffer.

The structure expected in indirect_buffer must conform to DrawIndirect.

These draw structures are expected to be tightly packed.

pub fn multi_draw_indexed_indirect(
    &mut self,
    indirect_buffer: &'a Buffer,
    indirect_offset: BufferAddress,
    count: u32
)

Dispatches multiple draw calls from the active index buffer and the active vertex buffers, based on the contents of the indirect_buffer. count draw calls are issued.

The active index buffer can be set with RenderPass::set_index_buffer, while the active vertex buffers can be set with RenderPass::set_vertex_buffer.

The structure expected in indirect_buffer must conform to DrawIndexedIndirect.

These draw structures are expected to be tightly packed.

impl<'a> RenderPass<'a>

Features::MULTI_DRAW_INDIRECT_COUNT must be enabled on the device in order to call these functions.

pub fn multi_draw_indirect_count(
    &mut self,
    indirect_buffer: &'a Buffer,
    indirect_offset: BufferAddress,
    count_buffer: &'a Buffer,
    count_offset: BufferAddress,
    max_count: u32
)

Disptaches multiple draw calls from the active vertex buffer(s) based on the contents of the indirect_buffer. The count buffer is read to determine how many draws to issue.

The indirect buffer must be long enough to account for max_count draws, however only count will draws will be read. If count is greater than max_count, max_count will be used.

The active vertex buffers can be set with RenderPass::set_vertex_buffer.

The structure expected in indirect_buffer must conform to DrawIndirect.

These draw structures are expected to be tightly packed.

The structure expected in count_buffer is the following:

#[repr(C)]
struct DrawIndirectCount {
    count: u32, // Number of draw calls to issue.
}

pub fn multi_draw_indexed_indirect_count(
    &mut self,
    indirect_buffer: &'a Buffer,
    indirect_offset: BufferAddress,
    count_buffer: &'a Buffer,
    count_offset: BufferAddress,
    max_count: u32
)

Dispatches multiple draw calls from the active index buffer and the active vertex buffers, based on the contents of the indirect_buffer. The count buffer is read to determine how many draws to issue.

The indirect buffer must be long enough to account for max_count draws, however only count will draws will be read. If count is greater than max_count, max_count will be used.

The active index buffer can be set with RenderPass::set_index_buffer, while the active vertex buffers can be set with RenderPass::set_vertex_buffer.

The structure expected in indirect_buffer must conform to DrawIndexedIndirect.

These draw structures are expected to be tightly packed.

The structure expected in count_buffer is the following:

#[repr(C)]
struct DrawIndexedIndirectCount {
    count: u32, // Number of draw calls to issue.
}

impl<'a> RenderPass<'a>

Features::PUSH_CONSTANTS must be enabled on the device in order to call these functions.

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

Set push constant data for subsequent draw calls.

Write the bytes in data at offset offset within push constant storage, all of which are accessible by all the pipeline stages in stages, and no others. Both offset and the length of data must be multiples of PUSH_CONSTANT_ALIGNMENT, which is always 4.

For example, if offset is 4 and data is eight bytes long, this call will write data to bytes 4..12 of push constant storage.

Stage matching

Every byte in the affected range of push constant storage must be accessible to exactly the same set of pipeline stages, which must match stages. If there are two bytes of storage that are accessible by different sets of pipeline stages - say, one is accessible by fragment shaders, and the other is accessible by both fragment shaders and vertex shaders - then no single set_push_constants call may affect both of them; to write both, you must make multiple calls, each with the appropriate stages value.

Which pipeline stages may access a given byte is determined by the pipeline’s PushConstant global variable and (if it is a struct) its members’ offsets.

For example, suppose you have twelve bytes of push constant storage, where bytes 0..8 are accessed by the vertex shader, and bytes 4..12 are accessed by the fragment shader. This means there are three byte ranges each accessed by a different set of stages:

• Bytes 0..4 are accessed only by the fragment shader.

• Bytes 4..8 are accessed by both the fragment shader and the vertex shader.

• Bytes `8..12 are accessed only by the vertex shader.

To write all twelve bytes requires three set_push_constants calls, one for each range, each passing the matching stages mask.

impl<'a> RenderPass<'a>

Features::WRITE_TIMESTAMP_INSIDE_PASSES must be enabled on the device in order to call these functions.

pub fn write_timestamp(&mut self, query_set: &QuerySet, query_index: u32)

Issue a timestamp command at this point in the queue. The timestamp will be written to the specified query set, at the specified index.

Must be multiplied by Queue::get_timestamp_period to get the value in nanoseconds. Absolute values have no meaning, but timestamps can be subtracted to get the time it takes for a string of operations to complete.

impl<'a> RenderPass<'a>

Features::PIPELINE_STATISTICS_QUERY must be enabled on the device in order to call these functions.

pub fn begin_pipeline_statistics_query(
    &mut self,
    query_set: &QuerySet,
    query_index: u32
)

Start a pipeline statistics query on this render pass. It can be ended with end_pipeline_statistics_query. Pipeline statistics queries may not be nested.

pub fn end_pipeline_statistics_query(&mut self)

End the pipeline statistics query on this render pass. It can be started with begin_pipeline_statistics_query. Pipeline statistics queries may not be nested.

Trait Implementations

impl<'a> Debug for RenderPass<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Drop for RenderPass<'a>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a> RenderEncoder<'a> for RenderPass<'a>

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

Sets the active bind group for a given bind group index. The bind group layout in the active pipeline when any draw() function is called must match the layout of this bind group.

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

Sets the active render pipeline.

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

Sets the active index buffer.

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

Assign a vertex buffer to a slot.

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

Draws primitives from the active vertex buffer(s).

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

Draws indexed primitives using the active index buffer and the active vertex buffers.

fn draw_indirect(
    &mut self,
    indirect_buffer: &'a Buffer,
    indirect_offset: BufferAddress
)

Draws primitives from the active vertex buffer(s) based on the contents of the indirect_buffer.

fn draw_indexed_indirect(
    &mut self,
    indirect_buffer: &'a Buffer,
    indirect_offset: BufferAddress
)

Draws indexed primitives using the active index buffer and the active vertex buffers, based on the contents of the indirect_buffer.

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

wgt::Features::PUSH_CONSTANTS must be enabled on the device in order to call this function.