Struct bevy_render::batching::gpu_preprocessing::IndirectParameters

#[repr(C)]
pub struct IndirectParameters {
    pub vertex_or_index_count: u32,
    pub instance_count: u32,
    pub first_vertex: u32,
    pub base_vertex_or_first_instance: u32,
    pub first_instance: u32,
}

The wgpu indirect parameters structure.

This is actually a union of the two following structures:

#[repr(C)]
struct ArrayIndirectParameters {
    vertex_count: u32,
    instance_count: u32,
    first_vertex: u32,
    first_instance: u32,
}

#[repr(C)]
struct ElementIndirectParameters {
    index_count: u32,
    instance_count: u32,
    first_vertex: u32,
    base_vertex: u32,
    first_instance: u32,
}

We actually generally treat these two variants identically in code. To do that, we make the following two observations:

1. instance_count is in the same place in both structures. So we can access it regardless of the structure we’re looking at.

2. The second structure is one word larger than the first. Thus we need to pad out the first structure by one word in order to place both structures in an array. If we pad out ArrayIndirectParameters by copying the first_instance field into the padding, then the resulting union structure will always have a read-only copy of first_instance in the final word. We take advantage of this in the shader to reduce branching.

Fields

vertex_or_index_count: u32

For ArrayIndirectParameters, vertex_count; for ElementIndirectParameters, index_count.

instance_count: u32

The number of instances we’re going to draw.

This field is in the same place in both structures.

first_vertex: u32

The index of the first vertex we’re to draw.

base_vertex_or_first_instance: u32

For ArrayIndirectParameters, first_instance; for ElementIndirectParameters, base_vertex.

first_instance: u32

For ArrayIndirectParameters, this is padding; for ElementIndirectParameters, this is first_instance.

Conventionally, we copy first_instance into this field when padding out ArrayIndirectParameters. That way, shader code can read this value at the same place, regardless of the specific structure this represents.

Trait Implementations

impl Clone for IndirectParameters

fn clone(&self) -> IndirectParameters

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CreateFrom for IndirectParameters

where Self: ShaderType<ExtraMetadata = StructMetadata<5usize>>, for<'__, '__, '__, '__, '__> u32: CreateFrom,

fn create_from<B: BufferRef>(reader: &mut Reader<B>) -> Self

impl ReadFrom for IndirectParameters

where Self: ShaderType<ExtraMetadata = StructMetadata<5usize>>, for<'__, '__, '__, '__, '__> u32: ReadFrom,

fn read_from<B: BufferRef>(&mut self, reader: &mut Reader<B>)

impl ShaderSize for IndirectParameters

where u32: ShaderSize,

const SHADER_SIZE: NonZero<u64> = _

Represents WGSL Size (equivalent to ShaderType::min_size)

impl ShaderType for IndirectParameters

where u32: ShaderType + ShaderSize,

fn size(&self) -> NonZeroU64

Returns the size of Self at runtime

fn min_size() -> NonZero<u64>

Represents the minimum size of Self (equivalent to GPUBufferBindingLayout.minBindingSize)

fn assert_uniform_compat()

Asserts that Self meets the requirements of the uniform address space restrictions on stored values and the uniform address space layout constraints

impl WriteInto for IndirectParameters

where Self: ShaderType<ExtraMetadata = StructMetadata<5usize>>, for<'__, '__, '__, '__, '__> u32: WriteInto,

fn write_into<B: BufferMut>(&self, writer: &mut Writer<B>)

impl Zeroable for IndirectParameters

fn zeroed() -> Self

Calls zeroed.

impl Copy for IndirectParameters

impl Pod for IndirectParameters