Enum rafx_api::RafxDescriptorSetArray

pub enum RafxDescriptorSetArray {
    Empty(RafxDescriptorSetArrayEmpty),
}

An array of descriptor sets. These are expected to be pooled and reused.

Managing descriptor sets can be challenging and there are many strategies that may be used. So a RafxDescriptorSetArray is intended to be allocated in blocks and pooled. This allows downstream code to provide more fine-grained allocation strategies appropriate to their needs.

Higher level crates in rafx-framework provide ref-counted descriptor sets and pooling.

Once a RafxDescriptorSetArray is allocated, depending on the backend, it may remain allocated for the duration of the API object, even if the descriptor set array is dropped. So rather than drop them, pool and reuse them.

Descriptor sets are like pointers to GPU memory. A command buffer can bind a descriptor set, meaning that other command may access resources that the descriptor set references.

Once a command buffer using a descriptor set has been submitted, it must not be modified until the command buffer is finished executing. Fine-grained synchronization primitives allow this restriction to be loosened.

Using an incorrectly configured descriptor set can result in undefined behavior. In practice, this can include GPU hangs, driver crashes, and kernel panics.

Variants

Empty(RafxDescriptorSetArrayEmpty)

Implementations

impl RafxDescriptorSetArray

pub fn handle(&self, index: u32) -> Option<RafxDescriptorSetHandle>

Create a lightweight, opaque pointer to a particular set in the array. This pointer can only be used for binding the given set in a command buffer.

pub fn root_signature(&self) -> &RafxRootSignature

Get the root signature that this descriptor set is created from

pub fn update_descriptor_set(
    &mut self,
    params: &[RafxDescriptorUpdate<'_>]
) -> RafxResult<()>

Update one or more descriptor sets with new values. This is the same as calling queue_descriptor_set_update, followed by flush_descriptor_set_updates

pub fn queue_descriptor_set_update(
    &mut self,
    update: &RafxDescriptorUpdate<'_>
) -> RafxResult<()>

Update a CPU-only copy of the descriptor set, but does not apply the write to the descriptor set until flush_descriptor_set_updates() is called.

The main reason for allowing queueing/flushing in separate calls is to help calling code avoid borrow-checking difficulties.

pub fn flush_descriptor_set_updates(&mut self) -> RafxResult<()>

Flush all queued descriptor set writes

pub fn empty_descriptor_set_array(&self) -> Option<&RafxDescriptorSetArrayEmpty>

Get the underlying metal API object. This provides access to any internally created metal objects.

Trait Implementations

impl Debug for RafxDescriptorSetArray

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

Formats the value using the given formatter.