Struct wgpu::Instance

source ·

pub struct Instance { /* private fields */ }

Expand description

Context for all other wgpu objects. Instance of wgpu.

This is the first thing you create when using wgpu. Its primary use is to create Adapters and Surfaces.

Does not have to be kept alive.

Corresponds to WebGPU GPU.

Implementations§

source §

impl Instance

source

pub const fn enabled_backend_features() -> Backends

Returns which backends can be picked for the current build configuration.

The returned set depends on a combination of target platform and enabled features. This does not do any runtime checks and is exclusively based on compile time information.

InstanceDescriptor::backends does not need to be a subset of this, but any backend that is not in this set, will not be picked.

TODO: Right now it’s otherwise not possible yet to opt-out of all features on some platforms. See https://github.com/gfx-rs/wgpu/issues/3514

Windows/Linux/Android: always enables Vulkan and GLES with no way to opt out

source

pub fn new(_instance_desc: InstanceDescriptor) -> Self

Create an new instance of wgpu.

Arguments

instance_desc - Has fields for which backends wgpu will choose during instantiation, and which DX12 shader compiler wgpu will use.

Backends::BROWSER_WEBGPU takes a special role: If it is set and WebGPU support is detected, this instance will only be able to create WebGPU adapters. If you instead want to force use of WebGL, either disable the webgpu compile-time feature or do add the Backends::BROWSER_WEBGPU flag to the the instance_desc’s backends field. If it is set and WebGPU support is not detected, the instance will use wgpu-core to create adapters. Meaning that if the webgl feature is enabled, it is able to create a WebGL adapter.

Panics

If no backend feature for the active target platform is enabled, this method will panic, see Instance::enabled_backend_features().

source

pub unsafe fn from_hal<A: HalApi>(hal_instance: A::Instance) -> Self

Available on wgpu_core only.

Create an new instance of wgpu from a wgpu-hal instance.

Safety

Refer to the creation of wgpu-hal Instance for every backend.

source

pub unsafe fn as_hal<A: HalApi>(&self) -> Option<&A::Instance>

Available on wgpu_core only.

Return a reference to a specific backend instance, if available.

If this Instance has a wgpu-hal Instance for backend A, return a reference to it. Otherwise, return None.

Safety

The raw instance handle returned must not be manually destroyed.

source

pub unsafe fn from_core(core_instance: Instance) -> Self

Available on wgpu_core only.

Create an new instance of wgpu from a wgpu-core instance.

Safety

Refer to the creation of wgpu-core Instance.

source

pub fn enumerate_adapters(&self, backends: Backends) -> Vec<Adapter>

Available on wgpu_core only.

Retrieves all available Adapters that match the given Backends.

Always returns an empty vector if the instance decided upon creation to target WebGPU since adapter creation is always async on WebGPU.

Arguments

backends - Backends from which to enumerate adapters.

source

pub fn request_adapter( &self, options: &RequestAdapterOptions<'_, '_> ) -> impl Future<Output = Option<Adapter>> + WasmNotSend

Retrieves an Adapter which matches the given RequestAdapterOptions.

Some options are “soft”, so treated as non-mandatory. Others are “hard”.

If no adapters are found that suffice all the “hard” options, None is returned.

source

pub unsafe fn create_adapter_from_hal<A: HalApi>( &self, hal_adapter: ExposedAdapter<A> ) -> Adapter

Available on wgpu_core only.

Converts a wgpu-hal ExposedAdapter to a wgpu Adapter.

Safety

hal_adapter must be created from this instance internal handle.

source

pub fn create_surface<'window>( &self, target: impl Into<SurfaceTarget<'window>> ) -> Result<Surface<'window>, CreateSurfaceError>

Creates a new surface targeting a given window/canvas/surface/etc..

Internally, this creates surfaces for all backends that are enabled for this instance.

See SurfaceTarget for what targets are supported. See Instance::create_surface_unsafe for surface creation with unsafe target variants.

Most commonly used are window handles (or provider of windows handles) which can be passed directly as they’re automatically converted to SurfaceTarget.

source

pub unsafe fn create_surface_unsafe<'window>( &self, target: SurfaceTargetUnsafe ) -> Result<Surface<'window>, CreateSurfaceError>

Creates a new surface targeting a given window/canvas/surface/etc. using an unsafe target.

Internally, this creates surfaces for all backends that are enabled for this instance.

See SurfaceTargetUnsafe for what targets are supported. See Instance::create_surface for surface creation with safe target variants.

Safety

See respective SurfaceTargetUnsafe variants for safety requirements.

source

pub fn poll_all(&self, force_wait: bool) -> bool

Polls all devices.

If force_wait is true and this is not running on the web, then this function will block until all in-flight buffers have been mapped and all submitted commands have finished execution.

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

On the web, this is a no-op. Devices are automatically polled.

source