Enum Handle

pub enum Handle<BL = MaybeDynMemLayout> {
    Opaque(Type),
    Buffer(AddrSpace, BL),
}

“Abstract resource” handle, that can be found in non-memory GlobalVars.

This largely corresponds to the Vulkan concept of a “descriptor”, and arrays of handles (e.g. GlobalVarShape::Handles with fixed_count != Some(1)) map to the “descriptor indexing” usecase.

Variants

Opaque(Type)

Fully opaque resources (e.g. samplers, images).

Buffer(AddrSpace, BL)

Buffer resources, describing ranges of (technically) untyped memory in some address space (e.g. Uniform, StorageBuffer), but being limited by SPIR-V logical addressing (unlike e.g. PhysicalStorageBuffer).

SPIR-V makes this particularly painful, through a couple of design flaws:

• forcing a static type (for the buffer contents) and disallowing any pointer casts, despite the fact that any plausible representation for “logical pointer into a buffer” (e.g. (BufferDescriptor, Offset)) must be fundamentally untyped (as it must allow access to relatively large amounts of memory, and also support dynamic array indexing), even when not a “GPU memory address” (like PhysicalStorageBuffer)
• encoding the buffer type using a (GLSL-style) “interface block”, where instead of a special type (or a pointer with the right storage class), an OpTypeStruct (having the statically typed buffer contents as fields) with the Block decoration is used, and then this “interface block” type can be further nested in OpTypeArray or OpTypeRuntimeArray to allow descriptor indexing - which leads to constructs like a GLSL buffer { uint data[]; } bufs[]; being encoded with two levels of OpTypeRuntimeArray, separated not by any explicit indirection, but only by the Block decoration on the OpTypeStruct for buffer {...}

Trait Implementations

impl<BL: Clone> Clone for Handle<BL>

fn clone(&self) -> Handle<BL>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<BL: Hash> Hash for Handle<BL>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<BL: PartialEq> PartialEq for Handle<BL>

fn eq(&self, other: &Handle<BL>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<BL: Copy> Copy for Handle<BL>

impl<BL: Eq> Eq for Handle<BL>

impl<BL> StructuralPartialEq for Handle<BL>