Struct Buffer

pub struct Buffer {
    pub info: BufferInfo,
    pub name: Option<String>,
    /* private fields */
}

Smart pointer handle to a buffer object.

Also contains information about the object.

Deref behavior

Buffer automatically dereferences to vk::Buffer (via the Deref trait), so you can call vk::Buffer’s methods on a value of type Buffer. To avoid name clashes with vk::Buffer’s methods, the methods of Buffer itself are associated functions, called using fully qualified syntax:

let addr = Buffer::device_address(&my_buf);

Fields

info: BufferInfo

Information used to create this object.

name: Option<String>

A name for debugging purposes.

Implementations

impl Buffer

pub fn create( device: &Arc<Device>, info: impl Into<BufferInfo>, ) -> Result<Self, DriverError>

Creates a new buffer on the given device.

Examples

Basic usage:

const SIZE: vk::DeviceSize = 1024;
let info = BufferInfo::host_mem(SIZE, vk::BufferUsageFlags::UNIFORM_BUFFER);
let buf = Buffer::create(&device, info)?;

assert_ne!(*buf, vk::Buffer::null());
assert_eq!(buf.info.size, SIZE);

pub fn create_from_slice( device: &Arc<Device>, usage: BufferUsageFlags, slice: impl AsRef<[u8]>, ) -> Result<Self, DriverError>

Creates a new mappable buffer on the given device and fills it with the data in slice.

Examples

Basic usage:

const DATA: [u8; 4] = [0xfe, 0xed, 0xbe, 0xef];
let buf = Buffer::create_from_slice(&device, vk::BufferUsageFlags::UNIFORM_BUFFER, &DATA)?;

assert_ne!(*buf, vk::Buffer::null());
assert_eq!(buf.info.size, 4);
assert_eq!(Buffer::mapped_slice(&buf), &DATA);

pub fn access( this: &Self, access: AccessType, access_range: impl Into<BufferSubresourceRange>, ) -> impl Iterator<Item = (AccessType, BufferSubresourceRange)> + '_

Keeps track of some next_access which affects this object.

Returns the previous access for which a pipeline barrier should be used to prevent data corruption.

Note

Used to maintain object state when passing a Screen 13-created vk::Buffer handle to external code such as Ash or Erupt bindings.

Examples

Basic usage:

// Initially we want to "write"
let access = AccessType::ComputeShaderWrite;
let access_range = BufferSubresourceRange { start: 0, end: SIZE };
let mut accesses = Buffer::access(&my_buf, access, access_range);

assert_eq!(accesses.next(), Some((AccessType::Nothing, access_range)));
assert!(accesses.next().is_none());

// External code may now "write"; no barrier required in this case

// Subsequently we want to "read"
let access = AccessType::ComputeShaderReadOther;
let mut accesses = Buffer::access(&my_buf, access, access_range);

assert_eq!(accesses.next(), Some((AccessType::ComputeShaderWrite, access_range)));
assert!(accesses.next().is_none());

// A barrier on "write" before "read" is required! A render graph will do this
// automatically when resovled, but manual access like this requires manual barriers

pub fn copy_from_slice( this: &mut Self, offset: DeviceSize, slice: impl AsRef<[u8]>, )

Updates a mappable buffer starting at offset with the data in slice.

Panics

Panics if the buffer was not created with the mappable flag set to true.

Examples

Basic usage:

const DATA: [u8; 4] = [0xde, 0xad, 0xc0, 0xde];
Buffer::copy_from_slice(&mut my_buf, 0, &DATA);

assert_eq!(Buffer::mapped_slice(&my_buf), &DATA);

pub fn device_address(this: &Self) -> DeviceAddress

Returns the device address of this object.

Panics

Panics if the buffer was not created with the SHADER_DEVICE_ADDRESS usage flag.

Examples

Basic usage:

let addr = Buffer::device_address(&my_buf);

assert_ne!(addr, 0);

pub fn mapped_slice(this: &Self) -> &[u8]

Returns a mapped slice.

Panics

Panics if the buffer was not created with the mappable flag set to true.

Examples

Basic usage:

// my_buf is mappable and filled with four zeroes
let data = Buffer::mapped_slice(&my_buf);

assert_eq!(data.len(), 4);
assert_eq!(data[0], 0x00);

pub fn mapped_slice_mut(this: &mut Self) -> &mut [u8]

Returns a mapped mutable slice.

Panics

Panics if the buffer was not created with the mappable flag set to true.

Examples

Basic usage:

let mut data = Buffer::mapped_slice_mut(&mut my_buf);
data.copy_from_slice(&42f32.to_be_bytes());

assert_eq!(data.len(), 4);
assert_eq!(data[0], 0x42);

Trait Implementations

impl<T> Alias<BufferInfo, Buffer> for AliasPool<T>

where T: Pool<BufferInfo, Buffer>,

fn alias(&mut self, info: BufferInfo) -> Result<Arc<Lease<Buffer>>, DriverError>

Aliases a resource.

impl Bind<&mut RenderGraph, BufferNode> for Buffer

fn bind(self, graph: &mut RenderGraph) -> BufferNode

Binds the resource to a graph-like object.

impl Debug for Buffer

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

Formats the value using the given formatter.

impl Deref for Buffer

type Target = Buffer

The resulting type after dereferencing.

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

Dereferences the value.

impl Drop for Buffer

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Pool<BufferInfo, Buffer> for AliasPool<T>

where T: Pool<BufferInfo, Buffer>,

fn lease(&mut self, info: BufferInfo) -> Result<Lease<Buffer>, DriverError>

Lease a resource.

impl Pool<BufferInfo, Buffer> for FifoPool

fn lease(&mut self, info: BufferInfo) -> Result<Lease<Buffer>, DriverError>

Lease a resource.

impl Pool<BufferInfo, Buffer> for HashPool

fn lease(&mut self, info: BufferInfo) -> Result<Lease<Buffer>, DriverError>

Lease a resource.

impl Pool<BufferInfo, Buffer> for LazyPool

fn lease(&mut self, info: BufferInfo) -> Result<Lease<Buffer>, DriverError>

Lease a resource.