Struct wgpu::Adapter

pub struct Adapter { /* private fields */ }

Handle to a physical graphics and/or compute device.

Adapters can be created using Instance::request_adapter or other Instance methods.

Adapters can be used to open a connection to the corresponding Device on the host system by using Adapter::request_device.

Does not have to be kept alive.

Corresponds to WebGPU GPUAdapter.

Implementations

impl Adapter

pub fn request_device( &self, desc: &DeviceDescriptor<'_>, trace_path: Option<&Path> ) -> impl Future<Output = Result<(Device, Queue), RequestDeviceError>> + WasmNotSend

Requests a connection to a physical device, creating a logical device.

Returns the Device together with a Queue that executes command buffers.

Per the WebGPU specification, an Adapter may only be used once to create a device. If another device is wanted, call Instance::request_adapter() again to get a fresh Adapter. However, wgpu does not currently enforce this restriction.

Arguments

• desc - Description of the features and limits requested from the given device.
• trace_path - Can be used for API call tracing, if that feature is enabled in wgpu-core.

Panics

• request_device() was already called on this Adapter.
• Features specified by desc are not supported by this adapter.
• Unsafe features were requested but not enabled when requesting the adapter.
• Limits requested exceed the values provided by the adapter.
• Adapter does not support all features wgpu requires to safely operate.

pub unsafe fn create_device_from_hal<A: HalApi>( &self, hal_device: OpenDevice<A>, desc: &DeviceDescriptor<'_>, trace_path: Option<&Path> ) -> Result<(Device, Queue), RequestDeviceError>

Available on wgpu_core only.

Create a wgpu Device and Queue from a wgpu-hal OpenDevice

Safety

• hal_device must be created from this adapter internal handle.
• desc.features must be a subset of hal_device features.

pub unsafe fn as_hal<A: HalApi, F: FnOnce(Option<&A::Adapter>) -> R, R>( &self, hal_adapter_callback: F ) -> R

Available on wgpu_core only.

Apply a callback to this Adapter’s underlying backend adapter.

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

If this Adapter uses a different backend, apply hal_adapter_callback to None.

The adapter is locked for reading while hal_adapter_callback runs. If the callback attempts to perform any wgpu operations that require write access to the adapter, 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 is_surface_supported(&self, surface: &Surface<'_>) -> bool

Returns whether this adapter may present to the passed surface.

pub fn features(&self) -> Features

The features which can be used to create devices on this adapter.

pub fn limits(&self) -> Limits

The best limits which can be used to create devices on this adapter.

pub fn get_info(&self) -> AdapterInfo

Get info about the adapter itself.

pub fn get_downlevel_capabilities(&self) -> DownlevelCapabilities

Get info about the adapter itself.

pub fn get_texture_format_features( &self, format: TextureFormat ) -> TextureFormatFeatures

Returns the features supported for a given texture format by this adapter.

Note that the WebGPU spec further restricts the available usages/features. To disable these restrictions on a device, request the Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES feature.

pub fn get_presentation_timestamp(&self) -> PresentationTimestamp

Generates a timestamp using the clock used by the presentation engine.

When comparing completely opaque timestamp systems, we need a way of generating timestamps that signal the exact same time. You can do this by calling your own timestamp function immediately after a call to this function. This should result in timestamps that are 0.5 to 5 microseconds apart. There are locks that must be taken during the call, so don’t call your function before.

use std::time::{Duration, Instant};
let presentation = adapter.get_presentation_timestamp();
let instant = Instant::now();

// We can now turn a new presentation timestamp into an Instant.
let some_pres_timestamp = some_code();
let duration = Duration::from_nanos((some_pres_timestamp.0 - presentation.0) as u64);
let new_instant: Instant = instant + duration;

Trait Implementations

impl Debug for Adapter

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

Formats the value using the given formatter.

impl Hash for Adapter

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Adapter

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Adapter

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Adapter

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for Adapter