Struct RenderQueue 

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

This queue is used to enqueue tasks for the GPU to execute asynchronously.

Implementations

impl RenderQueue

pub fn new(t: Queue) -> RenderQueue

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

pub fn into_inner(self) -> Queue

Unwraps the value.

Methods from Deref<Target = Queue>

pub fn write_buffer(&self, buffer: &Buffer, offset: u64, data: &[u8])

Copies the bytes of data into buffer starting at offset.

The data must be written fully in-bounds, that is, offset + data.len() <= buffer.len().

Performance considerations

• Calls to write_buffer() do not submit the transfer to the GPU immediately. They begin GPU execution only on the next call to Queue::submit(), just before the explicitly submitted commands. To get a set of scheduled transfers started immediately, it’s fine to call submit with no command buffers at all:

  queue.write_buffer(&buffer, 0, &data);
  queue.submit([]);

  However, data will be immediately copied into staging memory, so the caller may discard it any time after this call completes.

• Consider using Queue::write_buffer_with() instead. That method allows you to prepare your data directly within the staging memory, rather than first placing it in a separate [u8] to be copied. That is, queue.write_buffer(b, offset, data) is approximately equivalent to queue.write_buffer_with(b, offset, data.len()).copy_from_slice(data), so use write_buffer_with() if you can do something smarter than that copy_from_slice(). However, for small values (e.g. a typical uniform buffer whose contents come from a struct), there will likely be no difference, since the compiler will be able to optimize out unnecessary copies regardless.

• Currently on native platforms, for both of these methods, the staging memory will be a new allocation. This will then be released after the next submission finishes. To entirely avoid short-lived allocations, you might be able to use StagingBelt, or buffers you explicitly create, map, and unmap yourself.

pub fn write_buffer_with( &self, buffer: &Buffer, offset: u64, size: NonZero<u64>, ) -> Option<QueueWriteBufferView>

Prepares to write data to a buffer via a mapped staging buffer.

This operation allocates a temporary buffer and then returns a QueueWriteBufferView, which

• dereferences to a [u8] of length size, and
• when dropped, schedules a copy of its contents into buffer at offset.

Therefore, this obtains the same result as Queue::write_buffer(), but may allow you to skip one allocation and one copy of your data, if you are able to assemble your data directly into the returned QueueWriteBufferView instead of into a separate allocation like a Vec first.

The data must be written fully in-bounds, that is, offset + size <= buffer.len().

Performance considerations

• For small data not separately heap-allocated, there is no advantage of this over Queue::write_buffer().

• Reading from the returned view may be slow, and will not yield the current contents of buffer. You should treat it as “write-only”.

• Dropping the QueueWriteBufferView does not submit the transfer to the GPU immediately. The transfer begins only on the next call to Queue::submit() after the view is dropped, just before the explicitly submitted commands. To get a set of scheduled transfers started immediately, it’s fine to call queue.submit([]) with no command buffers at all.

• Currently on native platforms, the staging memory will be a new allocation, which will then be released after the next submission finishes. To entirely avoid short-lived allocations, you might be able to use StagingBelt, or buffers you explicitly create, map, and unmap yourself.

pub fn write_texture( &self, texture: TexelCopyTextureInfo<&Texture>, data: &[u8], data_layout: TexelCopyBufferLayout, size: Extent3d, )

Copies the bytes of data into a texture.

• data contains the texels to be written, which must be in the same format as the texture.
• data_layout describes the memory layout of data, which does not necessarily have to have tightly packed rows.
• texture specifies the texture to write into, and the location within the texture (coordinate offset, mip level) that will be overwritten.
• size is the size, in texels, of the region to be written.

This method fails if size overruns the size of texture, or if data is too short.

Performance considerations

This operation has the same performance considerations as Queue::write_buffer(); see its documentation for details.

However, since there is no “mapped texture” like a mapped buffer, alternate techniques for writing to textures will generally consist of first copying the data to a buffer, then using CommandEncoder::copy_buffer_to_texture(), or in some cases a compute shader, to copy texels from that buffer to the texture.

pub fn submit<I>(&self, command_buffers: I) -> SubmissionIndex

where I: IntoIterator<Item = CommandBuffer>,

Submits a series of finished command buffers for execution.

pub fn get_timestamp_period(&self) -> f32

Gets the amount of nanoseconds each tick of a timestamp query represents.

Returns zero if timestamp queries are unsupported.

Timestamp values are represented in nanosecond values on WebGPU, see https://gpuweb.github.io/gpuweb/#timestamp Therefore, this is always 1.0 on the web, but on wgpu-core a manual conversion is required.

pub fn on_submitted_work_done(&self, callback: impl FnOnce() + Send + 'static)

Registers a callback that is invoked when the previous Queue::submit finishes executing on the GPU. When this callback runs, all mapped-buffer callbacks registered for the same submission are guaranteed to have been called.

For the callback to run, either queue.submit(..), instance.poll_all(..), or device.poll(..) must be called elsewhere in the runtime, possibly integrated into an event loop or run on a separate thread.

The callback runs on the thread that first calls one of the above functions after the GPU work completes. There are no restrictions on the code you can run in the callback; however, on native the polling call will not return until the callback finishes, so keep callbacks short (set flags, send messages, etc.).

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

where A: Api,

Get the wgpu_hal device from this Queue.

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::Queue.

Types

The returned type depends on the backend:

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

Errors

This method will return None if:

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

On the webgpu backend, use as_webgpu instead.

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 present(&self, surface_texture: SurfaceTexture)

Schedule a surface texture to be presented on the owning surface.

Should be called after any work on the texture is submitted via Queue::submit. If no work was submitted, the texture will be cleared automatically before presenting.

Platform dependent behavior

On Wayland, present will attach a wl_buffer to the underlying wl_surface and commit the new surface state. If it is desired to do things such as request a frame callback, scale the surface using the viewporter or synchronize other double buffered state, then these operations should be done before the call to present.

pub fn compact_blas(&self, blas: &Blas) -> Blas

Compact a BLAS, it must have had Blas::prepare_compaction_async called on it and had the callback provided called.

The returned BLAS is more restricted than a normal BLAS because it may not be rebuilt or compacted.

Trait Implementations

impl Clone for RenderQueue

fn clone(&self) -> RenderQueue

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for RenderQueue

where RenderQueue: 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<RenderQueue>>

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 Deref for RenderQueue

type Target = Queue

The resulting type after dereferencing.

fn deref(&self) -> &<RenderQueue as Deref>::Target

Dereferences the value.

impl DerefMut for RenderQueue

fn deref_mut(&mut self) -> &mut <RenderQueue as Deref>::Target

Mutably dereferences the value.

impl Resource for RenderQueue

where RenderQueue: Send + Sync + 'static,

impl Send for RenderQueue

impl Sync for RenderQueue