Struct VertexBufferRefMut

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

See VertexBuffer::modify for more info.

Implementations

impl VertexBufferRefMut<'_>

pub fn push_vertex<T>(&mut self, vertex: &T) -> Result<(), ValidationError>

where T: VertexTrait + Pod,

Tries to append a vertex to the buffer.

Safety and validation

This method accepts any type that has appropriate size, the size must be equal with the size defined by layout. The Copy trait bound is required to ensure that the type does not have any custom destructors.

pub fn push_vertices<T>( &mut self, vertices: &[T], ) -> Result<(), ValidationError>

where T: VertexTrait + Pod,

Tries to append a slice of vertices to the buffer.

Safety and validation

This method accepts any type that has appropriate size, the size must be equal with the size defined by layout. The Copy trait bound is required to ensure that the type does not have any custom destructors.

pub fn push_vertex_raw(&mut self, data: &[u8]) -> Result<(), ValidationError>

Tries to append a raw vertex data to the vertex buffer. This method will fail if the data size does not match the vertex size of the buffer.

pub fn push_vertices_iter<T>( &mut self, vertices: impl Iterator<Item = T>, ) -> Result<(), ValidationError>

where T: VertexTrait + Pod,

Tries to append the vertices that the given iterator produces.

Safety and validation

This method accepts any type that has appropriate size, the size must be equal with the size defined by layout. The Copy trait bound is required to ensure that the type does not have any custom destructors.

pub fn push_vertices_transform<T, F>( &mut self, vertices: &[T], transformer: F, ) -> Result<(), ValidationError>

where T: VertexTrait + Pod, F: FnMut(&T) -> T,

Tries to append a slice of vertices to the buffer. Each vertex will be transformed using transformer callback.

Safety and validation

This method accepts any type that has appropriate size, the size must be equal with the size defined by layout. The Copy trait bound is required to ensure that the type does not have any custom destructors.

pub fn remove_last_vertex(&mut self)

Removes last vertex from the buffer.

pub fn pop_vertex<T>(&mut self) -> Result<T, ValidationError>

where T: VertexTrait,

Copies data of last vertex from the buffer to an instance of variable of a type.

Safety and validation

This method accepts any type that has appropriate size, the size must be equal with the size defined by layout. The Copy trait bound is required to ensure that the type does not have any custom destructors.

pub fn cast_data_mut<T>(&mut self) -> Result<&mut [T], ValidationError>

where T: VertexTrait,

Tries to cast internal data buffer to a slice of given type. It may fail if size of type is not equal with claimed size (which is set by the layout).

pub fn iter_mut(&mut self) -> impl Iterator<Item = VertexViewMut<'_>> + '_

Creates iterator that emits read/write accessors for vertices.

pub fn get_mut(&mut self, n: usize) -> Option<VertexViewMut<'_>>

Returns a read/write accessor of n-th vertex.

pub fn duplicate(&mut self, n: usize)

Duplicates n-th vertex and puts it at the back of the buffer.

pub fn add_attribute<T>( &mut self, descriptor: VertexAttributeDescriptor, fill_value: T, ) -> Result<(), ValidationError>

where T: Copy + Pod,

Adds new attribute at the end of layout, reorganizes internal data storage to be able to contain new attribute. Default value of the new attribute in the buffer becomes fill_value. Graphically this could be represented like so:

Add secondary texture coordinates: Before: P1_N1_TC1_P2_N2_TC2… After: P1_N1_TC1_TC2(fill_value)_P2_N2_TC2_TC2(fill_value)…

pub fn clear(&mut self)

Clears the buffer making it empty.

Methods from Deref<Target = VertexBuffer>

pub const DENSE_LAYOUT: &'static str = "dense_layout"

pub const SPARSE_LAYOUT: &'static str = "sparse_layout"

pub const VERTEX_SIZE: &'static str = "vertex_size"

pub const VERTEX_COUNT: &'static str = "vertex_count"

pub const DATA: &'static str = "data"

pub const LAYOUT_HASH: &'static str = "layout_hash"

pub const MODIFICATIONS_COUNTER: &'static str = "modifications_counter"

pub fn clone_empty(&self, capacity: usize) -> Self

Creates a new empty vertex buffer with the same layout and vertex size, but with an empty inner buffer of the specified capacity.

pub fn raw_data(&self) -> &[u8]

Returns a reference to underlying data buffer slice.

pub fn is_empty(&self) -> bool

Returns true if buffer does not contain any vertex, false - otherwise.

pub fn modifications_count(&self) -> u64

Returns the total amount of times the buffer was modified.

pub fn content_hash(&self) -> u64

Calculates inner data hash.

pub fn layout_hash(&self) -> u64

Returns hash of vertex buffer layout. Cached value is guaranteed to be in actual state. The hash could be used to check if the layout has changed.

pub fn modify(&mut self) -> VertexBufferRefMut<'_>

Provides mutable access to content of the buffer.

Performance

This method returns special structure which has custom destructor that calculates hash of the data once modification is over. You must hold this structure as long as possible while modifying contents of the buffer. Do not even try to do this:

use fyrox_impl::{
    scene::mesh::buffer::{VertexBuffer, VertexWriteTrait, VertexAttributeUsage},
    core::algebra::Vector3
};
fn do_something(buffer: &mut VertexBuffer) {
    for i in 0..buffer.vertex_count() {
        buffer
            .modify() // Doing this in a loop will cause HUGE performance issues!
            .get_mut(i as usize)
            .unwrap()
            .write_3_f32(VertexAttributeUsage::Position, Vector3::<f32>::default())
            .unwrap();
    }
}

Instead do this:

use fyrox_impl::{
    scene::mesh::buffer::{VertexBuffer, VertexWriteTrait, VertexAttributeUsage},
    core::algebra::Vector3
};
fn do_something(buffer: &mut VertexBuffer) {
    let mut buffer_modifier = buffer.modify();
    for mut vertex in buffer_modifier.iter_mut() {
        vertex
            .write_3_f32(VertexAttributeUsage::Position, Vector3::<f32>::default())
            .unwrap();
    }
}

Why do we even need such complications? It is used for lazy hash calculation which is used for automatic upload of contents to GPU in case if content has changed.

pub fn has_attribute(&self, usage: VertexAttributeUsage) -> bool

Checks if an attribute of usage exists.

pub fn layout(&self) -> &[VertexAttribute]

Returns vertex buffer layout.

pub fn layout_descriptor( &self, ) -> impl Iterator<Item = VertexAttributeDescriptor> + '_

Returns vertex buffer layout.

pub fn cast_data_ref<T>(&self) -> Result<&[T], ValidationError>

where T: VertexTrait,

Tries to cast internal data buffer to a slice of given type. It may fail if size of type is not equal with claimed size (which is set by the layout).

pub fn iter(&self) -> impl Iterator<Item = VertexViewRef<'_>> + '_

Creates iterator that emits read accessors for vertices.

pub fn get(&self, n: usize) -> Option<VertexViewRef<'_>>

Returns a read accessor of n-th vertex.

pub fn vertex_count(&self) -> u32

Returns exact amount of vertices in the buffer.

pub fn vertex_size(&self) -> u8

Return vertex size of the buffer.

pub fn find_free_shader_location(&self) -> u8

Finds free location for an attribute in the layout.

pub fn attribute_view<T>( &self, usage: VertexAttributeUsage, ) -> Option<AttributeViewRef<'_, T>>

where T: Copy,

Tries to find an attribute with the given usage and if it exists, returns its “view”, that allows you to fetch data like in ordinary array.

pub fn attribute_view_mut<T: Copy>( &mut self, usage: VertexAttributeUsage, ) -> Option<AttributeViewRefMut<'_, T>>

Tries to find an attribute with the given usage and if it exists, returns its “view”, that allows you to fetch data like in ordinary array.

Trait Implementations

impl DerefMut for VertexBufferRefMut<'_>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Drop for VertexBufferRefMut<'_>

fn drop(&mut self)

Executes the destructor for this type.

impl Deref for VertexBufferRefMut<'_>

type Target = VertexBuffer

The resulting type after dereferencing.

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

Dereferences the value.