Struct Buffer

Source

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

Expand description

Smart pointer handle to a buffer object.

Also contains information about the object.

let info = BufferInfo::device_mem(1_024, vk::BufferUsageFlags::STORAGE_BUFFER);
let my_buf = Buffer::create(&device, info)?;

assert_eq!(my_buf.info, info);
assert_ne!(my_buf.handle, vk::Buffer::null());

Fields§

§device: Device

The device which owns this buffer resource.

Note: This field is read-only.

§handle: Buffer

The native Vulkan resource handle of this buffer.

Note: This field is read-only.

§info: BufferInfo

Information used to create this resource.

Note: This field is read-only.

§name: Option<String>

A name for debugging purposes.

Implementations§

Source §

impl Buffer

Source

pub fn create( device: &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.handle, vk::Buffer::null());
assert_eq!(buf.info.size, SIZE);

Source

pub fn create_from_slice( device: &Device, usage: BufferUsageFlags, data: &[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.handle, vk::Buffer::null());
assert_eq!(buf.info.size, 4);
assert_eq!(Buffer::mapped_slice(&buf), &DATA);

Source

pub fn access( &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 vk-graph-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

Source

pub fn copy_from_slice(&mut self, offset: DeviceSize, data: &[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);

Source

pub fn device_address(&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 = my_buf.device_address();

assert_ne!(addr, 0);

Source

pub fn mapped_slice(&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);

Source

pub fn mapped_slice_mut(&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);

Source