Struct spirv_std::byte_addressable_buffer::ByteAddressableBuffer

#[repr(transparent)]
pub struct ByteAddressableBuffer<'a> {
    pub data: &'a mut [u32],
}

ByteAddressableBuffer is an untyped blob of data, allowing loads and stores of arbitrary basic data types at arbitrary indicies. However, all data must be aligned to size 4, each element within the data (e.g. struct fields) must have a size and alignment of a multiple of 4, and the byte_index passed to load and store must be a multiple of 4 (byte_index will be rounded down to the nearest multiple of 4). So, it’s not technically a byte addressable buffer, but rather a word buffer, but this naming and behavior was inhereted from HLSL (where it’s UB to pass in an index not a multiple of 4).

Fields

data: &'a mut [u32]

The underlying array of bytes, able to be directly accessed.

Implementations

impl<'a> ByteAddressableBuffer<'a>

pub fn new(data: &'a mut [u32]) -> Self

Creates a ByteAddressableBuffer from the untyped blob of data.

pub unsafe fn load<T>(&self, byte_index: u32) -> T

Loads an arbitrary type from the buffer. byte_index must be a multiple of 4, otherwise, it will get silently rounded down to the nearest multiple of 4.

Safety

This function allows writing a type to an untyped buffer, then reading a different type from the same buffer, allowing all sorts of safety guarantees to be bypassed (effectively a transmute)

pub unsafe fn load_unchecked<T>(&self, byte_index: u32) -> T

Loads an arbitrary type from the buffer. byte_index must be a multiple of 4, otherwise, it will get silently rounded down to the nearest multiple of 4. Bounds checking is not performed.

Safety

This function allows writing a type to an untyped buffer, then reading a different type from the same buffer, allowing all sorts of safety guarantees to be bypassed (effectively a transmute). Additionally, bounds checking is not performed.

pub unsafe fn store<T>(&mut self, byte_index: u32, value: T)

Stores an arbitrary type int the buffer. byte_index must be a multiple of 4, otherwise, it will get silently rounded down to the nearest multiple of 4.

Safety

This function allows writing a type to an untyped buffer, then reading a different type from the same buffer, allowing all sorts of safety guarantees to be bypassed (effectively a transmute)

pub unsafe fn store_unchecked<T>(&mut self, byte_index: u32, value: T)

Stores an arbitrary type int the buffer. byte_index must be a multiple of 4, otherwise, it will get silently rounded down to the nearest multiple of 4. Bounds checking is not performed.

Safety

This function allows writing a type to an untyped buffer, then reading a different type from the same buffer, allowing all sorts of safety guarantees to be bypassed (effectively a transmute). Additionally, bounds checking is not performed.