[go: up one dir, main page]
logo

Trait wgpu::util::RenderEncoder[−][src]

pub trait RenderEncoder<'a> {
    fn set_bind_group(
        &mut self, 
        index: u32, 
        bind_group: &'a BindGroup, 
        offsets: &[DynamicOffset]
    );

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

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

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

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

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

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

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

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

Methods shared by RenderPass and RenderBundleEncoder.

Required methods

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 order of their declaration.

Sets the active render pipeline.

Subsequent draw calls will exhibit the behavior defined by pipeline.

Sets the active index buffer.

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

Assign a vertex buffer to a slot.

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

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

Draws primitives from the active vertex buffer(s).

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

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

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

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

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

The structure expected in indirect_buffer is the following:

#[repr(C)]
struct DrawIndirect {
    vertex_count: u32, // The number of vertices to draw.
    instance_count: u32, // The number of instances to draw.
    base_vertex: u32, // The Index of the first vertex to draw.
    base_instance: u32, // The instance ID of the first instance to draw.
}

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 RenderEncoder::set_index_buffer, while the active vertex buffers can be set with RenderEncoder::set_vertex_buffer.

The structure expected in indirect_buffer is the following:

#[repr(C)]
struct DrawIndexedIndirect {
    vertex_count: u32, // The number of vertices to draw.
    instance_count: u32, // The number of instances to draw.
    base_index: u32, // The base index within the index buffer.
    vertex_offset: i32, // The value added to the vertex index before indexing into the vertex buffer.
    base_instance: u32, // The instance ID of the first instance to draw.
}

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

Set push constant data.

Offset is measured in bytes, but must be a multiple of wgt::PUSH_CONSTANT_ALIGNMENT.

Data size must be a multiple of 4 and must be aligned to the 4s, so we take an array of u32. For example, with an offset of 4 and an array of [u32; 3], that will write to the range of 4..16.

For each byte in the range of push constant data written, the union of the stages of all push constant ranges that covers that byte must be exactly stages. There’s no good way of explaining this simply, so here are some examples:

For the given ranges:
- 0..4 Vertex
- 4..8 Fragment

You would need to upload this in two set_push_constants calls. First for the Vertex range, second for the Fragment range.

For the given ranges:
- 0..8  Vertex
- 4..12 Fragment

You would need to upload this in three set_push_constants calls. First for the Vertex only range 0..4, second for the Vertex | Fragment range 4..8, third for the Fragment range 8..12.

Implementors