Struct AsyncDevice 

pub struct AsyncDevice { /* private fields */ }

A wrapper around a wgpu::Device which shadows some methods to allow for callback-and-poll methods to be made async.

Implementations

impl AsyncDevice

pub fn do_async<F, R>(&self, f: F) -> WgpuFuture<R>

where F: FnOnce(Box<dyn FnOnce(R) + Send>), R: Send + 'static,

Converts a callback-and-poll wgpu method pair into a future.

The function given is called immediately, usually initiating work on the GPU immediately, however the device is only polled once the future is awaited.

Example

The Buffer::map_async method is made async using this method:

let future = device.do_async(|callback|
    buffer_slice.map_async(mode, callback)
);
let result = future.await;

pub fn create_buffer(&self, desc: &BufferDescriptor<'_>) -> AsyncBuffer

Creates an AsyncBuffer.

pub fn create_buffer_init(&self, desc: &BufferInitDescriptor<'_>) -> AsyncBuffer

Creates an AsyncBuffer with data to initialize it.

Methods from Deref<Target = Device>

pub fn poll(&self, maintain: Maintain<SubmissionIndex>) -> MaintainResult

Check for resource cleanups and mapping callbacks. Will block if Maintain::Wait is passed.

Return true if the queue is empty, or false if there are more queue submissions still in flight. (Note that, unless access to the Queue is coordinated somehow, this information could be out of date by the time the caller receives it. Queues can be shared between threads, so other threads could submit new work at any time.)

When running on WebGPU, this is a no-op. Devices are automatically polled.

pub fn features(&self) -> Features

The features which can be used on this device.

No additional features can be used, even if the underlying adapter can support them.

pub fn limits(&self) -> Limits

The limits which can be used on this device.

No better limits can be used, even if the underlying adapter can support them.

pub fn create_shader_module( &self, desc: ShaderModuleDescriptor<'_>, ) -> ShaderModule

Creates a shader module.

This function may consume a lot of stack space. Compiler-enforced limits for parsing recursion exist; if shader compilation runs into them, it will return an error gracefully. However, on some build profiles and platforms, the default stack size for a thread may be exceeded before this limit is reached during parsing. Callers should ensure that there is enough stack space for this, particularly if calls to this method are exposed to user input.

pub unsafe fn create_shader_module_unchecked( &self, desc: ShaderModuleDescriptor<'_>, ) -> ShaderModule

👎Deprecated since 24.0.0: Use Device::create_shader_module_trusted(desc, wgpu::ShaderRuntimeChecks::unchecked()) instead.

Deprecated: Use create_shader_module_trusted instead.

Safety

See create_shader_module_trusted.

pub unsafe fn create_shader_module_trusted( &self, desc: ShaderModuleDescriptor<'_>, runtime_checks: ShaderRuntimeChecks, ) -> ShaderModule

Creates a shader module with flags to dictate runtime checks.

When running on WebGPU, this will merely call create_shader_module.

Safety

In contrast with create_shader_module this function creates a shader module with user-customizable runtime checks which allows shaders to perform operations which can lead to undefined behavior like indexing out of bounds, thus it’s the caller responsibility to pass a shader which doesn’t perform any of this operations.

See the documentation for ShaderRuntimeChecks for more information about specific checks.

pub unsafe fn create_shader_module_spirv( &self, desc: &ShaderModuleDescriptorSpirV<'_>, ) -> ShaderModule

Creates a shader module from SPIR-V binary directly.

Safety

This function passes binary data to the backend as-is and can potentially result in a driver crash or bogus behaviour. No attempt is made to ensure that data is valid SPIR-V.

See also include_spirv_raw! and util::make_spirv_raw.

pub fn create_command_encoder( &self, desc: &CommandEncoderDescriptor<Option<&str>>, ) -> CommandEncoder

Creates an empty CommandEncoder.

pub fn create_render_bundle_encoder<'a>( &self, desc: &RenderBundleEncoderDescriptor<'_>, ) -> RenderBundleEncoder<'a>

Creates an empty RenderBundleEncoder.

pub fn create_bind_group(&self, desc: &BindGroupDescriptor<'_>) -> BindGroup

Creates a new BindGroup.

pub fn create_bind_group_layout( &self, desc: &BindGroupLayoutDescriptor<'_>, ) -> BindGroupLayout

Creates a BindGroupLayout.

pub fn create_pipeline_layout( &self, desc: &PipelineLayoutDescriptor<'_>, ) -> PipelineLayout

Creates a PipelineLayout.

pub fn create_render_pipeline( &self, desc: &RenderPipelineDescriptor<'_>, ) -> RenderPipeline

Creates a RenderPipeline.

pub fn create_compute_pipeline( &self, desc: &ComputePipelineDescriptor<'_>, ) -> ComputePipeline

Creates a ComputePipeline.

pub fn create_buffer(&self, desc: &BufferDescriptor<Option<&str>>) -> Buffer

Creates a Buffer.

pub fn create_texture( &self, desc: &TextureDescriptor<Option<&str>, &[TextureFormat]>, ) -> Texture

Creates a new Texture.

desc specifies the general format of the texture.

pub unsafe fn create_texture_from_hal<A>( &self, hal_texture: <A as Api>::Texture, desc: &TextureDescriptor<Option<&str>, &[TextureFormat]>, ) -> Texture

where A: HalApi,

Creates a Texture from a wgpu-hal Texture.

Safety

• hal_texture must be created from this device internal handle
• hal_texture must be created respecting desc
• hal_texture must be initialized

pub unsafe fn create_buffer_from_hal<A>( &self, hal_buffer: <A as Api>::Buffer, desc: &BufferDescriptor<Option<&str>>, ) -> Buffer

where A: HalApi,

Creates a Buffer from a wgpu-hal Buffer.

Safety

• hal_buffer must be created from this device internal handle
• hal_buffer must be created respecting desc
• hal_buffer must be initialized

pub fn create_sampler(&self, desc: &SamplerDescriptor<Option<&str>>) -> Sampler

Creates a new Sampler.

desc specifies the behavior of the sampler.

pub fn create_query_set( &self, desc: &QuerySetDescriptor<Option<&str>>, ) -> QuerySet

Creates a new QuerySet.

pub fn on_uncaptured_error( &self, handler: Box<dyn UncapturedErrorHandler<Output = ()>>, )

Set a callback for errors that are not handled in error scopes.

pub fn push_error_scope(&self, filter: ErrorFilter)

Push an error scope.

pub fn pop_error_scope( &self, ) -> impl Future<Output = Option<Error>> + WasmNotSend

Pop an error scope.

pub fn start_capture(&self)

Starts frame capture.

pub fn stop_capture(&self)

Stops frame capture.

pub fn get_internal_counters(&self) -> InternalCounters

Query internal counters from the native backend for debugging purposes.

Some backends may not set all counters, or may not set any counter at all. The counters cargo feature must be enabled for any counter to be set.

If a counter is not set, its contains its default value (zero).

pub fn generate_allocator_report(&self) -> Option<AllocatorReport>

Generate an GPU memory allocation report if the underlying backend supports it.

Backends that do not support producing these reports return None. A backend may Support it and still return None if it is not using performing sub-allocation, for example as a workaround for driver issues.

pub unsafe fn as_hal<A, F, R>(&self, hal_device_callback: F) -> R

where A: HalApi, F: FnOnce(Option<&<A as Api>::Device>) -> R,

Apply a callback to this Device’s underlying backend device.

If this Device is implemented by the backend API given by A (Vulkan, Dx12, etc.), then apply hal_device_callback to Some(&device), where device is the underlying backend device type, A::Device.

If this Device uses a different backend, apply hal_device_callback to None.

The device is locked for reading while hal_device_callback runs. If the callback attempts to perform any wgpu operations that require write access to the device (destroying a buffer, say), deadlock will occur. The locks are automatically released when the callback returns.

Safety

• The raw handle passed to the callback must not be manually destroyed.

pub fn destroy(&self)

Destroy this device.

pub fn set_device_lost_callback( &self, callback: impl Fn(DeviceLostReason, String) + Send + 'static, )

Set a DeviceLostCallback on this device.

pub unsafe fn create_pipeline_cache( &self, desc: &PipelineCacheDescriptor<'_>, ) -> PipelineCache

Create a PipelineCache with initial data

This can be passed to Device::create_compute_pipeline and Device::create_render_pipeline to either accelerate these or add the cache results from those.

Safety

If the data field of desc is set, it must have previously been returned from a call to PipelineCache::get_data¹. This data will only be used if it came from an adapter with the same util::pipeline_cache_key. This is compatible across wgpu versions, as any data format change will be accounted for.

It is not supported to bring caches from previous direct uses of backend APIs into this method.

Errors

Returns an error value if:

• the PIPELINE_CACHE feature is not enabled
• this device is invalid; or
• the device is out of memory

This method also returns an error value if:

• The fallback field on desc is false; and
• the data provided would not be used²

If an error value is used in subsequent calls, default caching will be used.

---

1. We do recognise that saving this data to disk means this condition is impossible to fully prove. Consider the risks for your own application in this case. ↩

2. This data may be not used if: the data was produced by a prior version of wgpu; or was created for an incompatible adapter, or there was a GPU driver update. In some cases, the data might not be used and a real value is returned, this is left to the discretion of GPU drivers. ↩

pub fn create_blas( &self, desc: &CreateBlasDescriptor<Option<&str>>, sizes: BlasGeometrySizeDescriptors, ) -> Blas

Create a bottom level acceleration structure, used inside a top level acceleration structure for ray tracing.

• desc: The descriptor of the acceleration structure.
• sizes: Size descriptor limiting what can be built into the acceleration structure.

Validation

If any of the following is not satisfied a validation error is generated

The device must have Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE enabled. if sizes is BlasGeometrySizeDescriptors::Triangles then the following must be satisfied

• For every geometry descriptor (for the purposes this is called geo_desc) of sizes.descriptors the following must be satisfied:
  • geo_desc.vertex_format must be within allowed formats (allowed formats for a given feature set may be queried with Features::allowed_vertex_formats_for_blas).
  • Both or neither of geo_desc.index_format and geo_desc.index_count must be provided.

pub fn create_tlas(&self, desc: &CreateTlasDescriptor<Option<&str>>) -> Tlas

Create a top level acceleration structure, used for ray tracing.

• desc: The descriptor of the acceleration structure.

Validation

If any of the following is not satisfied a validation error is generated

The device must have Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE enabled.

Trait Implementations

impl<T> AsRef<T> for AsyncDevice

where T: ?Sized, <AsyncDevice as Deref>::Target: AsRef<T>,

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for AsyncDevice

fn clone(&self) -> AsyncDevice

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AsyncDevice

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

Formats the value using the given formatter.

impl Deref for AsyncDevice

type Target = Device

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.