Enum DeviceTier 

pub enum DeviceTier {
    WebGpu,
    Native,
    WebGl2,
}

How much of the WebGPU baseline to ask a device for.

A device is requested with a set of limits, so the tier is what decides how large a device the frame has to work within. Self::WebGpu is the baseline every WebGPU implementation guarantees, and is the default, so a frame asks for no more than it has to and runs wherever the API does. Self::WebGl2 reproduces a WebGL2 device’s shape on hardware that is capable of much more, which is the only way to exercise the paths a browser takes from a machine that has storage buffers and base_vertex; it is Self::WebGpu with downlevel_webgl2_defaults as its floor.

Self::from_env reads the tier from UNLIT3D_DEVICE_TIER, so a test run can pick the tier without recompiling.

Variants

WebGpu

The limits the WebGPU baseline guarantees, lowered where the adapter offers even less. The default.

Native

The adapter’s own limits, which on a desktop backend are its full capabilities rather than the baseline’s floor.

WebGl2

WebGL2’s limits and capabilities.

Implementations

impl DeviceTier

pub const ALL: &'static [DeviceTier]

Every tier, for a caller that has to enumerate them.

Display and FromStr are inverses over exactly these, and a test asserts it, so the set cannot grow without the environment variable learning the new name.

pub fn from_env() -> DeviceTier

The tier named by UNLIT3D_DEVICE_TIER, or Self::WebGpu when it is unset.

The value is parsed by FromStr, so an unrecognized one — a typo like webgl — panics rather than silently selecting the default. Running the wrong tier is the failure this variable exists to prevent: it would pass while exercising none of the paths under test, which is worse than not running.

Panics

If the variable is set to a value that names no tier.

pub fn limits(self, adapter_limits: &Limits) -> Limits

The limits to request from an adapter whose own limits are adapter_limits.

Self::Native asks for the adapter’s own limits, and so can. Self::WebGpu asks for the baseline’s guaranteed values, which is what keeps the device the frame is recorded against within reach of every implementation — but an adapter may offer less than the baseline, an adapter narrowed to a browser’s WebGL2 most of all, and a request above what the adapter supports is refused outright. Every other limit is therefore lowered to the adapter’s, which leaves a compliant adapter’s request exactly the baseline and lets a weaker one through on its own terms.

Both narrowed tiers keep the adapter’s texture resolution: a tier is a floor, and lowering the texture sizes below what the adapter has would test a device smaller than any browser ships.

pub fn capabilities(self) -> DeviceCapabilities

The capabilities a device of this tier has.

Independent of the adapter: the tier is the set of flags, and a forced tier has to report what the real device of that tier would.

pub fn capabilities_of(self, adapter: &Adapter) -> DeviceCapabilities

The capabilities a device of this tier ends up with.

A narrowed tier is a request, so what it can rely on is the tier’s own capabilities intersected with what the adapter really reports: a forced WebGL2 tier is only as capable as WebGL2, and an adapter that is even more limited is only as capable as itself.

The WebGPU baseline is a floor every implementation claims to meet, so for Self::WebGpu the intersection is whatever the adapter reports — which is also what Self::Native yields, since a tier narrowed by limits does not change the adapter’s flags.

Trait Implementations

impl Clone for DeviceTier

fn clone(&self) -> DeviceTier

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for DeviceTier

impl Debug for DeviceTier

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

Formats the value using the given formatter.

impl Default for DeviceTier

fn default() -> DeviceTier

Returns the “default value” for a type.

impl Display for DeviceTier

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

Formats the value using the given formatter.

impl Eq for DeviceTier

impl FromStr for DeviceTier

fn from_str(name: &str) -> Result<DeviceTier, ()>

Parse a tier name, case-insensitively.

This is the inverse of Display, and the two are written against the same names so a value printed by one is accepted by the other.

type Err = ()

The associated error which can be returned from parsing.

impl PartialEq for DeviceTier

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for DeviceTier