Struct BufferSlice

pub struct BufferSlice<'a> { /* private fields */ }

Implementations

impl<'a> BufferSlice<'a>

pub fn id(&self) -> BufferId

pub fn offset(&self) -> BufferAddress

pub fn size(&self) -> BufferAddress

Methods from Deref<Target = BufferSlice<'a>>

pub fn slice<S>(&self, bounds: S) -> BufferSlice<'a>

where S: RangeBounds<u64>,

Return another BufferSlice referring to the portion of self’s contents indicated by bounds.

The range argument can be half or fully unbounded: for example, buffer.slice(..) refers to the entire buffer, and buffer.slice(n..) refers to the portion starting at the nth byte and extending to the end of the buffer.

Panics

• If bounds is outside of the bounds of self.
• If bounds has a length less than 1.

pub fn map_async( &self, mode: MapMode, callback: impl FnOnce(Result<(), BufferAsyncError>) + WasmNotSend + 'static, )

Map the buffer to host (CPU) memory, making it available for reading or writing via get_mapped_range(). It is available once the callback is called with an Ok response.

For the callback to complete, either queue.submit(..), instance.poll_all(..), or device.poll(..) must be called elsewhere in the runtime, possibly integrated into an event loop or run on a separate thread.

The callback will be called on the thread that first calls the above functions after the GPU work has completed. There are no restrictions on the code you can run in the callback, however on native the call to the function will not complete until the callback returns, so prefer keeping callbacks short and used to set flags, send messages, etc.

As long as a buffer is mapped, it is not available for use by any other commands; at all times, either the GPU or the CPU has exclusive access to the contents of the buffer.

This can also be performed using Buffer::map_async().

Panics

• If the buffer is already mapped.
• If the buffer’s BufferUsages do not allow the requested MapMode.
• If the endpoints of this slice are not aligned to MAP_ALIGNMENT within the buffer.

pub fn get_mapped_range(&self) -> BufferView<'a>

Gain read-only access to the bytes of a mapped Buffer.

Returns a BufferView referring to the buffer range represented by self. See the documentation for BufferView for details.

Multiple views may be obtained and used simultaneously as long as they are from non-overlapping slices.

This can also be performed using Buffer::get_mapped_range().

Panics

• If the endpoints of this slice are not aligned to MAP_ALIGNMENT within the buffer.
• If the buffer to which self refers is not currently mapped.
• If you try to create overlapping views of a buffer, mutable or otherwise.

pub fn get_mapped_range_mut(&self) -> BufferViewMut<'a>

Gain write access to the bytes of a mapped Buffer.

Returns a BufferViewMut referring to the buffer range represented by self. See the documentation for BufferViewMut for more details.

Multiple views may be obtained and used simultaneously as long as they are from non-overlapping slices.

This can also be performed using Buffer::get_mapped_range_mut().

Panics

• If the endpoints of this slice are not aligned to MAP_ALIGNMENT.
• If the buffer to which self refers is not currently mapped.
• If you try to create overlapping views of a buffer, mutable or otherwise.

pub fn buffer(&self) -> &'a Buffer

Returns the buffer this is a slice of.

You should usually not need to call this, and if you received the buffer from code you do not control, you should refrain from accessing the buffer outside the bounds of the slice. Nevertheless, it’s possible to get this access, so this method makes it simple.

pub fn offset(&self) -> u64

Returns the offset in Self::buffer() this slice starts at.

pub fn size(&self) -> NonZero<u64>

Returns the size of this slice.

Trait Implementations

impl<'a> Clone for BufferSlice<'a>

fn clone(&self) -> BufferSlice<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for BufferSlice<'a>

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

Formats the value using the given formatter.

impl<'a> Deref for BufferSlice<'a>

type Target = BufferSlice<'a>

The resulting type after dereferencing.

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

Dereferences the value.