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, Global>,
    indices: Vec<u32, Global>,
    primitive_type: PrimitiveType
) -> Mesh<T>

Mesh from vertices, indices and primitive type

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

Triangles mesh from vertices with no indices

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

Mesh with no indices from vertices and primitive type

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

Mesh with no indices from vertices iterator and primitive type

pub fn from_vertices_indices(
    vertices: Vec<T, Global>,
    indices: Vec<u32, Global>
) -> 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, Global>)

Set the mesh vertices

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

Set the mesh vertices

pub fn indices(&self) -> &Vec<u32, Global>

pub fn indices_mut(&mut self) -> &mut Vec<u32, Global>

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

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

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

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, Global>

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>(&mut self, other: I) where
    I: IntoIterator<Item = T>, 

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: u32, i1: u32, i2: u32)

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]>, Global>

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

impl<T> Mesh<T> where
    T: Clone, 

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

impl<T> Mesh<T> where
    T: Clone, 

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>

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Immutably borrows from an owned value.

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

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

Mutably borrows from an owned value.

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

pub 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 for Mesh<T> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<T> Default for Mesh<T>

pub fn default() -> Mesh<T>

Returns the “default value” for a type.

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

pub fn deserialize<__D>(
    __deserializer: __D
) -> Result<Mesh<T>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

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

pub 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.

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

Performs the indexing (container[index]) operation.

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

pub 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>

pub fn into(self) -> (Vec<T, Global>, Vec<u32, Global>)

Performs the conversion.

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

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

Performs the conversion.

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

pub fn into(self) -> Vec<T, Global>

Performs the conversion.

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

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

Serialize this value into the given Serde serializer.

impl ToSimpleVao<Matrix<f32, U2, U1, <DefaultAllocator as Allocator<f32, U2, U1>>::Buffer>, Matrix<f32, U2, U1, <DefaultAllocator as Allocator<f32, U2, U1>>::Buffer>> for Mesh<Matrix<f32, U2, U1, <DefaultAllocator as Allocator<f32, U2, U1>>::Buffer>>

pub fn to_simple_vao<C, B>(
    &self,
    gl: &C,
    bindings: &B,
    usage: u32
) -> Result<SimpleVao<Matrix<f32, U2, U1, <DefaultAllocator as Allocator<f32, U2, U1>>::Buffer>>, Error> where
    C: CreationContext,
    B: Bindings, 

pub fn as_simple_vao_data(
    &self
) -> Data<'_, Matrix<f32, U2, U1, <DefaultAllocator as Allocator<f32, U2, U1>>::Buffer>>

impl ToSimpleVao<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>, Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>> for Mesh<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>>

pub fn to_simple_vao<C, B>(
    &self,
    gl: &C,
    bindings: &B,
    usage: u32
) -> Result<SimpleVao<Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>>, Error> where
    C: CreationContext,
    B: Bindings, 

pub fn as_simple_vao_data(
    &self
) -> Data<'_, Matrix<f32, U3, U1, <DefaultAllocator as Allocator<f32, U3, U1>>::Buffer>>

impl<T> ToSimpleVao<T, Mesh<T>> for Mesh<T> where
    T: 'static + VertexFormat + Clone, 

pub fn to_simple_vao<C, B>(
    &self,
    gl: &C,
    bindings: &B,
    usage: u32
) -> Result<SimpleVao<T>, Error> where
    C: CreationContext,
    B: Bindings, 

pub fn as_simple_vao_data(&self) -> Data<'_, T>