Struct rin_graphics::Mesh

pub struct Mesh<T> { /* fields omitted */ }

A Mesh with any vertex type

Contains vertices that can be of any type although rin define a few of the most commonly used and optionally indices

Also a primitive type that defines how the vertices / indices should be parsed

Implementations

impl<T> Mesh<T>

pub fn new(
    vertices: Vec<T>,
    indices: Vec<IndexT>,
    primitive_type: PrimitiveType
) -> Mesh<T>

Mesh from vertices, indices and primitive type

pub fn from_vertices(vertices: Vec<T>) -> Mesh<T>

Triangles mesh from vertices with no indices

pub fn from_vertices_and_type(vertices: Vec<T>, ty: PrimitiveType) -> Mesh<T>

Mesh with no indices from vertices and primitive type

pub fn from_iter_and_type<I: Iterator<Item = T>>(
    vertices: I,
    ty: PrimitiveType
) -> Mesh<T>

Mesh with no indices from vertices iterator and primitive type

pub fn from_vertices_indices(vertices: Vec<T>, indices: Vec<IndexT>) -> Mesh<T>

Triangles mesh from vertices and indices

pub fn with_type(ty: PrimitiveType) -> Mesh<T>

Empty mesh with the specified primitive type

pub fn set_vertices(&mut self, vertices: Vec<T>)

Set the mesh vertices

pub fn set_indices(&mut self, indices: Vec<IndexT>)

Set the mesh vertices

pub fn indices(&self) -> &Vec<IndexT>

pub fn indices_mut(&mut self) -> &mut Vec<IndexT>

pub fn vertices(&self) -> &[T]

pub fn vertices_mut(&mut self) -> &mut Vec<T>

pub fn vertices_indices_mut(&mut self) -> (&mut Vec<T>, &mut Vec<IndexT>)

pub fn iter(&self) -> Iter<'_, T>

Iterator over the mesh vertices in the order they where inserted

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Mutable iterator over the mesh vertices in the order they where inserted

pub fn into_iter(self) -> IntoIter<T>

Consume the mesh into an iterator over it’s vertices in the order they where inserted

pub fn pop(&mut self) -> Option<T>

Pop the last vertex

pub fn push(&mut self, value: T)

Push a vertex at the end of the mesh

pub fn extend<I: IntoIterator<Item = T>>(&mut self, other: I)

Extend the mesh with an iterator of new vertices

pub fn insert(&mut self, index: usize, element: T)

Insert a vertex at a certain position

pub fn get_mut(&mut self, index: usize) -> &mut T

Mutably get the vertex at the specified position.

Will panic if the vertex doesn’t exist

pub fn reserve(&mut self, capacity: usize)

Reserve as much capacity for vertices

pub unsafe fn set_len(&mut self, len: usize)

Unsafe operation that sets the len of the vertices collection

pub fn truncate(&mut self, len: usize)

Truncate the mesh vertices at the specified len

pub fn last(&self) -> Option<&T>

Last vertex if there’s any

pub fn last_mut(&mut self) -> Option<&mut T>

Last vertex mutably if there’s any

pub fn primitive_type(&self) -> PrimitiveType

Primitive type

pub fn set_primitive_type(&mut self, ty: PrimitiveType)

pub fn add_face(&mut self, i0: IndexT, i1: IndexT, i2: IndexT)

Add a triangle face (only for Triangles primitive type)

pub fn clear(&mut self)

Clear the mesh vertices and indices

pub fn clear_vertices(&mut self)

Clear the vertices

pub fn clear_indices(&mut self)

Clear the indices

pub fn len(&self) -> usize

Number of vertices

pub fn is_empty(&self) -> bool

Contains any vertices

pub fn as_slice(&self) -> MeshSlice<'_, T>

pub fn faces(&self) -> Box<dyn Iterator<Item = [&T; 3]>>

pub fn faces_mut(&mut self) -> Box<dyn Iterator<Item = [&mut T; 3]>>

impl<T: Clone> Mesh<T>

pub fn into_faces(self) -> Box<dyn Iterator<Item = [T; 3]>> where
    T: 'static, 

impl<T: Clone> Mesh<T>

pub fn extend_from_mesh(&mut self, other: &Mesh<T>)

Extend the mesh with another mesh

The vertices and indices will just be inserted at the end without taking into account the primitive types

pub fn extend_from_slice(&mut self, other: &[T])

Extend the mesh with a slice of new vertices

Trait Implementations

impl<T> AsMut<[T]> for Mesh<T>

fn as_mut(&mut self) -> &mut [T]

Performs the conversion.

impl<T> AsRef<[T]> for Mesh<T>

fn as_ref(&self) -> &[T]

Performs the conversion.

impl<T> Borrow<[T]> for Mesh<T>

fn borrow(&self) -> &[T]

Immutably borrows from an owned value.

impl<T> BorrowMut<[T]> for Mesh<T>

fn borrow_mut(&mut self) -> &mut [T]

Mutably borrows from an owned value.

impl<T: Clone> Clone for Mesh<T>

fn clone(&self) -> Mesh<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Mesh<T>

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

Formats the value using the given formatter.

impl<T> Default for Mesh<T>

fn default() -> Mesh<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Mesh<T> where
    T: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T> FromIterator<T> for Mesh<T>

fn from_iter<I>(iter: I) -> Mesh<T> where
    I: IntoIterator<Item = T>, 

Creates a value from an iterator.

impl<T> Index<usize> for Mesh<T>

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &T

Performs the indexing (container[index]) operation.

impl<T> IndexMut<usize> for Mesh<T>

fn index_mut(&mut self, index: usize) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl<T> Into<(Vec<T, Global>, Vec<u32, Global>)> for Mesh<T>

fn into(self) -> (Vec<T>, Vec<IndexT>)

Performs the conversion.

impl<'a, T: Clone> Into<Data<'a, T>> for &'a Mesh<T>

fn into(self) -> Data<'a, T>

Performs the conversion.

impl<T> Into<Vec<T, Global>> for Mesh<T>

fn into(self) -> Vec<T>

Performs the conversion.

impl<T> Serialize for Mesh<T> where
    T: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.