Struct VertexBufferRefMut 

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

See VertexBuffer::modify for more info.

Implementations

impl<'a> VertexBufferRefMut<'a>

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

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 remove_last_vertex(&mut self)

Removes last vertex from the buffer.

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

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: Copy>(&mut self) -> Result<&mut [T], ValidationError>

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: Copy>( &mut self, descriptor: VertexAttributeDescriptor, fill_value: T, ) -> Result<(), ValidationError>

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 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 data_hash(&self) -> u64

Returns cached data hash. Cached value is guaranteed to be in actual state.

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 rg3d::{
    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 rg3d::{
    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 cast_data_ref<T: Copy>(&self) -> Result<&[T], ValidationError>

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.

Trait Implementations

impl<'a> DerefMut for VertexBufferRefMut<'a>

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

Mutably dereferences the value.

impl<'a> Drop for VertexBufferRefMut<'a>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a> Deref for VertexBufferRefMut<'a>

type Target = VertexBuffer

The resulting type after dereferencing.

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

Dereferences the value.