Struct UniformBuffer 

pub struct UniformBuffer<S>
where
    S: ByteStorage,
{ /* private fields */ }

Uniform buffer is a special byte storage that ensures correct data alignment suitable for GPU. Current implementation supports std140 data layout scheme.

Examples

let bytes = StaticUniformBuffer::<256>::new()
    .with(&Matrix4::identity())
    .with(&Color::WHITE)
    .with(&Vector3::new(0.0, 1.0, 0.0))
    .finish();

Implementations

impl<S> UniformBuffer<S>

where S: ByteStorage + Default,

pub fn new() -> UniformBuffer<S>

Creates a new uniform buffer with an empty storage.

pub fn with_storage(storage: S) -> UniformBuffer<S>

Creates a new uniform buffer with the given storage.

pub fn clear(&mut self)

Clears the uniform buffer.

pub fn len(&self) -> usize

Returns total number of bytes stored in the uniform buffer. Keep in mind, that the number in the vast majority of cases won’t match the sum of all pushed elements due to alignment requirements.

pub fn is_empty(&self) -> bool

Checks if the buffer is empty or not.

pub fn push_padding(&mut self, alignment: usize)

Pushes the given amount of padding bytes to the storage.

pub fn push<T>(&mut self, value: &T) -> &mut UniformBuffer<S>

where T: Std140,

Pushes a value to the storage. This method ensures that the correct alignment for the pushed value is preserved.

pub fn with<T>(self, value: &T) -> UniformBuffer<S>

where T: Std140,

The same as Self::push, but allows chained calls in a builder manner.

pub fn push_slice<T>(&mut self, slice: &[T]) -> &mut UniformBuffer<S>

where T: Std140,

Pushes a slice of given values. Keep in mind, that this method is not the same as pushing individual slice elements one by one. Instead, this method preserves alignment requirements for arrays as std140 rule set requires.

pub fn push_slice_with_max_size<T>( &mut self, slice: &[T], max_len: usize, ) -> &mut UniformBuffer<S>

where T: Std140 + Default,

Pushes the given slice into the uniform buffer and pads the rest of the space (max_len - slice_len) with the default value of the underlying type.

pub fn with_slice_with_max_size<T>( self, slice: &[T], max_len: usize, ) -> UniformBuffer<S>

where T: Std140 + Default,

Same as Self::push_slice_with_max_size, but allows changed calls with builder-like style.

pub fn with_slice<T>(self, slice: &[T]) -> UniformBuffer<S>

where T: Std140,

The same as Self::push_slice, but allows chained calls in a builder manner.

pub fn storage(&self) -> &S

Returns a reference to the internal bytes storage of the uniform buffer.

pub fn finish(self) -> S

Finishes buffer filling process and returns the backing storage by consuming the buffer. This method must be called before sending the data GPU, otherwise the buffer may contain misaligned data.

pub fn next_write_aligned_position(&self, alignment: usize) -> usize

Calculates position for the next element including the given alignment.

pub fn write_bytes_with_alignment( &mut self, bytes: &[u8], alignment: usize, ) -> usize

Writes bytes directly to the buffer with the given alignment. Important: this method could be dangerous if misused, the alignment argument must be correct and comply with std140 data layout rules.

Trait Implementations

impl<S> Default for UniformBuffer<S>

where S: Default + ByteStorage,

fn default() -> UniformBuffer<S>

Returns the “default value” for a type.