Struct RequestAdapterOptions 

#[repr(C)]
pub struct RequestAdapterOptions<S> {
    pub power_preference: PowerPreference,
    pub force_fallback_adapter: bool,
    pub compatible_surface: Option<S>,
    pub apply_limit_buckets: bool,
}

Options for requesting adapter.

Corresponds to WebGPU GPURequestAdapterOptions, with some wgpu extensions.

Fields

power_preference: PowerPreference

Power preference for the adapter.

force_fallback_adapter: bool

Indicates that only a fallback adapter can be returned. This is generally a “software” implementation on the system.

compatible_surface: Option<S>

Surface that is required to be presentable with the requested adapter. This does not create the surface, only guarantees that the adapter can present to said surface. For WebGL, this is strictly required, as an adapter can not be created without a surface.

apply_limit_buckets: bool

Requests that the returned adapter’s limits are mapped to one of several pre-defined buckets, as described in limit bucketing. If your application exposes wgpu to untrusted content (e.g. a web browser), this can reduce the potential for fingerprinting via adapter characteristics.

To be effective, control of this option must not be available to the untrusted content. Instead, set this option unconditionally in trusted code.

Trait Implementations

impl<S: Clone> Clone for RequestAdapterOptions<S>

fn clone(&self) -> RequestAdapterOptions<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug> Debug for RequestAdapterOptions<S>

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

Formats the value using the given formatter.

impl<S> Default for RequestAdapterOptions<S>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, S> Deserialize<'de> for RequestAdapterOptions<S>

where S: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S: Hash> Hash for RequestAdapterOptions<S>

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<S: PartialEq> PartialEq for RequestAdapterOptions<S>

fn eq(&self, other: &RequestAdapterOptions<S>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<S> Serialize for RequestAdapterOptions<S>

where S: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<S: Eq> Eq for RequestAdapterOptions<S>

impl<S> StructuralPartialEq for RequestAdapterOptions<S>