Struct RenderAdapter 

pub struct RenderAdapter(/* private fields */);

The handle to the physical device being used for rendering. See Adapter for more info.

Implementations

impl RenderAdapter

pub fn new(t: Adapter) -> Self

Constructs a new instance of WgpuWrapper which will wrap the specified value.

pub fn into_inner(self) -> Adapter

Unwraps the value.

Methods from Deref<Target = Adapter>

pub fn request_device( &self, desc: &DeviceDescriptor<Option<&str>>, ) -> 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.

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>( &self, hal_device: OpenDevice<A>, desc: &DeviceDescriptor<Option<&str>>, ) -> Result<(Device, Queue), RequestDeviceError>

where A: Api,

Available on wgpu_core only.

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

Safety

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

pub unsafe fn as_hal<A>( &self, ) -> Option<impl Deref<Target = <A as Api>::Adapter> + WasmNotSendSync>

where A: Api,

Available on wgpu_core only.

Get the wgpu_hal adapter from this Adapter.

Find the Api struct corresponding to the active backend in wgpu_hal::api, and pass that struct to the to the A type parameter.

Returns a guard that dereferences to the type of the hal backend which implements A::Adapter.

Types

The returned type depends on the backend:

• hal::api::Vulkan uses hal::vulkan::Adapter
• hal::api::Metal uses hal::metal::Adapter
• hal::api::Dx12 uses hal::dx12::Adapter
• hal::api::Gles uses hal::gles::Adapter

Errors

This method will return None if:

• The adapter is not from the backend specified by A.
• The adapter is from the webgpu or custom backend.

Safety

• The returned resource must not be destroyed unless the guard is the last reference to it and it is not in use by the GPU. The guard and handle may be dropped at any time however.
• All the safety requirements of wgpu-hal must be upheld.

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;

pub fn cooperative_matrix_properties(&self) -> Vec<CooperativeMatrixProperties>

Returns the supported cooperative matrix configurations for this adapter.

Cooperative matrices enable hardware-accelerated matrix multiply-accumulate operations where threads in a subgroup collectively process matrix tiles.

Returns an empty vector if cooperative matrices are not supported.

Requires Features::EXPERIMENTAL_COOPERATIVE_MATRIX to be meaningful.

Trait Implementations

impl Clone for RenderAdapter

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for RenderAdapter

where Self: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::SparseSet

A constant indicating the storage type used for this component.

type Mutability = Mutable

A marker type to assist Bevy with determining if this component is mutable, or immutable. Mutable components will have Component<Mutability = Mutable>, while immutable components will instead have Component<Mutability = Immutable>.

fn register_required_components( _requiree: ComponentId, required_components: &mut RequiredComponentsRegistrator<'_, '_>, )

Registers required components.

fn clone_behavior() -> ComponentCloneBehavior

Called when registering this component, allowing to override clone function (or disable cloning altogether) for this component.

fn relationship_accessor() -> Option<ComponentRelationshipAccessor<Self>>

Returns ComponentRelationshipAccessor required for working with relationships in dynamic contexts.

fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_add ComponentHook for this Component if one is defined.

fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_insert ComponentHook for this Component if one is defined.

fn on_discard() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_discard ComponentHook for this Component if one is defined.

fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_remove ComponentHook for this Component if one is defined.

fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_despawn ComponentHook for this Component if one is defined.

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)

where E: EntityMapper,

Maps the entities on this component using the given EntityMapper. This is used to remap entities in contexts like scenes and entity cloning. When deriving Component, this is populated by annotating fields containing entities with #[entities]

const HAS_SUMMARY_TICK: bool = false

Set this constant to true if the component should track a summary tick.

impl Debug for RenderAdapter

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

Formats the value using the given formatter.

impl Deref for RenderAdapter

type Target = Adapter

The resulting type after dereferencing.

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

Dereferences the value.

impl DerefMut for RenderAdapter

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Resource for RenderAdapter

where Self: Send + Sync + 'static,

impl Send for RenderAdapter

impl Sync for RenderAdapter