Struct MeshPipelineDescriptor

pub struct MeshPipelineDescriptor<'a> {
    pub label: Label<'a>,
    pub layout: Option<&'a PipelineLayout>,
    pub task: Option<TaskState<'a>>,
    pub mesh: MeshState<'a>,
    pub primitive: PrimitiveState,
    pub depth_stencil: Option<DepthStencilState>,
    pub multisample: MultisampleState,
    pub fragment: Option<FragmentState<'a>>,
    pub multiview: Option<NonZeroU32>,
    pub cache: Option<&'a PipelineCache>,
}

Describes a mesh shader (graphics) pipeline.

For use with Device::create_mesh_pipeline. A mesh pipeline is very much like a render pipeline, except that instead of RenderPass::draw it is invoked with RenderPass::draw_mesh_tasks, and instead of a vertex shader and a fragment shader:

• task specifies an optional task shader entry point, which determines how many groups of mesh shaders to dispatch.

• mesh specifies a mesh shader entry point, which generates groups of primitives to draw

• fragment specifies as fragment shader for drawing those primitives, just like in an ordinary render pipeline.

The key difference is that, whereas a vertex shader is invoked on the elements of vertex buffers, the task shader gets to decide how many mesh shader workgroups to make, and then each mesh shader workgroup gets to decide which primitives it wants to generate, and what their vertex attributes are. Task and mesh shaders can use whatever they please as inputs, like a compute shader. However, they cannot use specialized vertex or index buffers.

A mesh pipeline is invoked by RenderPass::draw_mesh_tasks, which looks like a compute shader dispatch with ComputePass::dispatch_workgroups: you pass x, y, and z values indicating the number of task shaders to invoke in parallel. The output value of the first thread in a task shader workgroup determines how many mesh workgroups should be dispatched from there. Those mesh workgroups also get a special payload passed from the task shader.

If the task shader is omitted, then the (x, y, z) parameters to draw_mesh_tasks are used to decide how many invocations of the mesh shader to invoke directly, without a task payload.

Fields

label: Label<'a>

Debug label of the pipeline. This will show up in graphics debuggers for easy identification.

layout: Option<&'a PipelineLayout>

The layout of bind groups for this pipeline.

If this is set, then Device::create_render_pipeline will raise a validation error if the layout doesn’t match what the shader module(s) expect.

Using the same PipelineLayout for many RenderPipeline or ComputePipeline pipelines guarantees that you don’t have to rebind any resources when switching between those pipelines.

Default pipeline layout

If layout is None, then the pipeline has a default layout created and used instead. The default layout is deduced from the shader modules.

You can use RenderPipeline::get_bind_group_layout to create bind groups for use with the default layout. However, these bind groups cannot be used with any other pipelines. This is convenient for simple pipelines, but using an explicit layout is recommended in most cases.

task: Option<TaskState<'a>>

The mesh pipeline’s task shader.

If this is None, the mesh pipeline has no task shader. Executing a mesh drawing command simply dispatches a grid of mesh shaders directly.

mesh: MeshState<'a>

The compiled mesh stage and its entry point

primitive: PrimitiveState

The properties of the pipeline at the primitive assembly and rasterization level.

depth_stencil: Option<DepthStencilState>

The effect of draw calls on the depth and stencil aspects of the output target, if any.

multisample: MultisampleState

The multi-sampling properties of the pipeline.

fragment: Option<FragmentState<'a>>

The compiled fragment stage, its entry point, and the color targets.

multiview: Option<NonZeroU32>

If the pipeline will be used with a multiview render pass, this indicates how many array layers the attachments will have.

cache: Option<&'a PipelineCache>

The pipeline cache to use when creating this pipeline.

Trait Implementations

impl<'a> Clone for MeshPipelineDescriptor<'a>

fn clone(&self) -> MeshPipelineDescriptor<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for MeshPipelineDescriptor<'a>

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

Formats the value using the given formatter.