Struct ComputePass 

pub struct ComputePass<'f> { /* private fields */ }

A compute pass wrapper that automatically returns the command buffer to the frame.

This struct mirrors RenderPass in its lifecycle management - it owns its encoder and pushes the command buffer to the frame when dropped.

Implementations

impl<'f> ComputePass<'f>

pub fn wgpu_pass(&mut self) -> &mut ComputePass<'static>

Get the underlying wgpu compute pass (mutable).

pub fn wgpu_pass_ref(&self) -> &ComputePass<'static>

Get the underlying wgpu compute pass (immutable).

pub fn raw_pass(&mut self) -> &mut ComputePass<'static>

Get raw access to the underlying wgpu compute pass.

This is an alias for wgpu_pass() for consistency with RenderPass::raw_pass().

pub fn graphics(&self) -> &GraphicsContext

Get the graphics context.

pub fn set_pipeline(&mut self, pipeline: &ComputePipeline)

Set the compute pipeline to use.

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

Set a bind group.

pub fn dispatch_workgroups(&mut self, x: u32, y: u32, z: u32)

Dispatch workgroups.

Arguments

• x - Number of workgroups in the X dimension
• y - Number of workgroups in the Y dimension
• z - Number of workgroups in the Z dimension

pub fn dispatch_workgroups_1d(&mut self, x: u32)

Dispatch workgroups with a 1D configuration.

Equivalent to dispatch_workgroups(x, 1, 1).

pub fn dispatch_workgroups_2d(&mut self, x: u32, y: u32)

Dispatch workgroups with a 2D configuration.

Equivalent to dispatch_workgroups(x, y, 1).

pub fn dispatch_workgroups_indirect(&mut self, buffer: &Buffer, offset: u64)

Dispatch workgroups indirectly from a buffer.

The buffer should contain a DispatchIndirect struct:

#[repr(C)]
struct DispatchIndirect {
    x: u32,
    y: u32,
    z: u32,
}

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

Insert a debug marker.

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

Push a debug group.

pub fn pop_debug_group(&mut self)

Pop a debug group.

pub fn set_push_constants<T: Pod>(&mut self, offset: u32, data: &T)

Set push constants for the compute shader.

Push constants are a fast way to pass small amounts of data to shaders without using uniform buffers. They require the PUSH_CONSTANTS feature to be enabled on the device.

Arguments

• offset - Byte offset into the push constant range
• data - Data to set (must be Pod for safe byte casting)

Example

#[repr(C)]
#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
struct ComputeConstants {
    workgroup_count: u32,
    time: f32,
}

let constants = ComputeConstants {
    workgroup_count: 64,
    time: 1.5,
};

pass.set_push_constants(0, &constants);

pub fn set_push_constants_raw(&mut self, offset: u32, data: &[u8])

Set push constants from raw bytes.

Use this when you need more control over the data layout.

pub fn finish(self)

Finish the compute pass, pushing the command buffer to the frame.

Trait Implementations

impl<'a> AsWgpu for ComputePass<'a>

type WgpuType = ComputePass<'static>

The underlying wgpu type.

fn as_wgpu(&self) -> &Self::WgpuType

Get a reference to the underlying wgpu type.

impl<'a> AsWgpuMut for ComputePass<'a>

fn as_wgpu_mut(&mut self) -> &mut Self::WgpuType

Get a mutable reference to the underlying wgpu type.

impl Drop for ComputePass<'_>

fn drop(&mut self)

Executes the destructor for this type.