Struct ComputeBundleBuilder 

pub struct ComputeBundleBuilder<'a, R: Resolver = StandardResolver> {
    pub label: Option<&'a str>,
    pub bind_group_layouts: Vec<&'a BindGroupLayoutDescriptor<'a>>,
    pub pipeline_compile_options: PipelineCompilationOptions<'a>,
    pub entry_point: Option<&'a str>,
    pub main_shader: Option<ModulePath>,
    pub wesl_compile_options: CompileOptions,
    pub resolver: Option<R>,
    pub mangler: Box<dyn Mangler + Send + Sync + 'static>,
    pub workgroup_size: Option<u32>,
}

A builder for ComputeBundle.

The shader is compiled using the WESL compiler,

The following fields should be set before calling ComputeBundleBuilder::build or ComputeBundleBuilder::build_without_bind_groups:

• ComputeBundleBuilder::bind_group_layouts
• ComputeBundleBuilder::resolver
• ComputeBundleBuilder::entry_point
• ComputeBundleBuilder::main_shader

Fields

label: Option<&'a str>

bind_group_layouts: Vec<&'a BindGroupLayoutDescriptor<'a>>

pipeline_compile_options: PipelineCompilationOptions<'a>

entry_point: Option<&'a str>

main_shader: Option<ModulePath>

wesl_compile_options: CompileOptions

resolver: Option<R>

mangler: Box<dyn Mangler + Send + Sync + 'static>

workgroup_size: Option<u32>

Implementations

impl ComputeBundleBuilder<'_>

pub fn new() -> Self

Create a new compute bundle builder.

impl<'a, R: Resolver> ComputeBundleBuilder<'a, R>

pub fn label(self, label: impl Into<&'a str>) -> Self

Set the label of the compute bundle.

pub fn bind_group_layout( self, bind_group_layout: &'a BindGroupLayoutDescriptor<'a>, ) -> Self

Add a wgpu::BindGroupLayoutDescriptor.

pub fn bind_group_layouts( self, bind_group_layouts: impl IntoIterator<Item = &'a BindGroupLayoutDescriptor<'a>>, ) -> Self

Add wgpu::BindGroupLayoutDescriptors.

pub fn pipeline_compile_options( self, compilation_options: PipelineCompilationOptions<'a>, ) -> Self

Set the wgpu::PipelineCompilationOptions.

pub fn entry_point(self, main: &'a str) -> Self

Set the entry point of the compute shader.

This should be the function name of the entry point in the compute shader, which is passed into wgpu::ComputePipelineDescriptor::entry_point.

pub fn main_shader(self, main: ModulePath) -> ComputeBundleBuilder<'a, R>

Set the main shader of the compute bundle.

The shader is required to have an overridable variable workgroup_size of u32, which is set to the workgroup size of at the entry point of the compute pipeline.

pub fn wesl_compile_options(self, options: CompileOptions) -> Self

Set the wesl::CompileOptions.

pub fn resolver<S: Resolver>(self, resolver: S) -> ComputeBundleBuilder<'a, S>

Set the wesl::Resolver.

pub fn mangler( self, mangler: impl Mangler + Send + Sync + 'static, ) -> ComputeBundleBuilder<'a, R>

Set the wesl::Mangler.

pub fn workgroup_size(self, workgroup_size: u32) -> Self

Set the workgroup size.

pub fn build<'b>( self, device: &Device, resources: impl IntoIterator<Item = impl IntoIterator<Item = BindingResource<'a>>>, ) -> Result<ComputeBundle<BindGroup>, ComputeBundleBuildError>

Build the compute bundle with bindings.

pub fn build_without_bind_groups( self, device: &Device, ) -> Result<ComputeBundle<()>, ComputeBundleBuildError>

Build the compute bundle without bind groups.

Trait Implementations

impl Default for ComputeBundleBuilder<'_>

fn default() -> Self

Returns the “default value” for a type.