Struct Faces 

pub struct Faces<V = StandardVertex> { /* private fields */ }

Faces of polygon mesh

To optimize for the case where the polygon mesh consists only triangles and quadrangle, there are vectors which consist by each triangles and quadrilaterals, internally.

Implementations

impl<V> Faces<V>

where V: Copy,

pub fn extend<U, T, I>(&mut self, iter: I)

where U: Copy + Into<V>, T: AsRef<[U]>, I: IntoIterator<Item = T>,

Extends faces by an iterator.

pub const fn from_tri_and_quad_faces( tri_faces: Vec<[V; 3]>, quad_faces: Vec<[V; 4]>, ) -> Faces<V>

Creates faces of a polygon mesh by the vectors of triangle and quadrangle.

Examples

// Creates faces consisis only triangles.
use truck_polymesh::*;
let tri_faces: Vec<[StandardVertex; 3]> = vec![
    [[0, 0, 0].into(), [1, 1, 1].into(), [2, 2, 2].into()],
    [[0, 0, 0].into(), [2, 2, 2].into(), [3, 3, 3].into()],
];
let faces = Faces::from_tri_and_quad_faces(tri_faces, Vec::new());

pub fn push<U, T>(&mut self, face: T)

where U: Copy + Into<V>, T: AsRef<[U]>,

Push a face to the faces.

If face.len() < 3, the face is ignored with warning.

Examples

use truck_polymesh::*;
let mut faces = Faces::<StandardVertex>::default(); // empty faces
faces.push(&[[0, 0, 0], [1, 1, 1], [2, 2, 2]]);
faces.push(&[[3, 3, 3], [0, 0, 0], [2, 2, 2]]);
faces.push(&[[0, 0, 0], [4, 4, 4], [5, 5, 5], [1, 1, 1]]);
faces.push(&[[100, 1000, 10]]); // Wargning: ignored one vertex "face"

pub const fn tri_faces(&self) -> &Vec<[V; 3]>

Returns the vector of triangles.

pub fn tri_faces_mut(&mut self) -> &mut [[V; 3]]

Returns the mutable slice of triangles.

pub const fn quad_faces(&self) -> &Vec<[V; 4]>

Returns the vector of quadrangles.

pub fn quad_faces_mut(&mut self) -> &mut [[V; 4]]

Returns the mutable slice of quadrangles.

pub const fn other_faces(&self) -> &Vec<Vec<V>>

Returns the vector of n-gons (n > 4).

pub fn other_faces_mut(&mut self) -> impl Iterator<Item = &mut [V]>

Returns the mutable iterator of n-gons (n > 4).

pub fn face_iter(&self) -> impl Iterator<Item = &[V]>

Returns the iterator of the slice.

By the internal optimization, this iterator does not runs in the simple order in which they are registered, but runs order: triangle, square, and the others.

Examples

use truck_polymesh::*;
let slice: &[&[usize]] = &[
    &[0, 1, 2],
    &[0, 4, 5, 1],
    &[1, 2, 6, 7, 8, 9],
    &[0, 2, 3],
];
let faces = Faces::<usize>::from_iter(slice);
let mut iter = faces.face_iter();
assert_eq!(iter.next(), Some([0, 1, 2].as_ref()));
assert_eq!(iter.next(), Some([0, 2, 3].as_ref()));
assert_eq!(iter.next(), Some([0, 4, 5, 1].as_ref()));
assert_eq!(iter.next(), Some([1, 2, 6, 7, 8, 9].as_ref()));
assert_eq!(iter.next(), None);

pub fn face_iter_mut(&mut self) -> impl Iterator<Item = &mut [V]>

Returns the iterator of the slice.

By the internal optimization, this iterator does not runs in the simple order in which they are registered, but runs order: triangle, square, and the others. cf: Faces:face_iter

pub fn is_empty(&self) -> bool

Returns true if the faces is empty.

pub fn len(&self) -> usize

Returns the number of faces.

pub fn naive_concat(&mut self, other: Faces<V>)

Merges other into self.

pub fn triangle_iter(&self) -> TriangleIterator<'_, V>

Returns iterator with triangulation faces

Examples

use truck_polymesh::*;
let slice: &[&[usize]] = &[
    &[0, 1, 2],
    &[0, 4, 5, 1],
    &[1, 2, 6, 7, 8, 9],
    &[1, 2, 4, 3],
    &[0, 2, 3],
];
let faces = Faces::<usize>::from_iter(slice);
let mut iter = faces.triangle_iter();
assert_eq!(iter.len(), 10);
assert_eq!(iter.next(), Some([0, 1, 2]));
assert_eq!(iter.next(), Some([0, 2, 3]));
assert_eq!(iter.next(), Some([0, 4, 5]));
assert_eq!(iter.next(), Some([0, 5, 1]));
assert_eq!(iter.next(), Some([1, 2, 4]));
assert_eq!(iter.next(), Some([1, 4, 3]));
assert_eq!(iter.next(), Some([1, 2, 6]));
assert_eq!(iter.next(), Some([1, 6, 7]));
assert_eq!(iter.next(), Some([1, 7, 8]));
assert_eq!(iter.next(), Some([1, 8, 9]));
assert_eq!(iter.len(), 0);
assert_eq!(iter.next(), None);

Trait Implementations

impl<V> Clone for Faces<V>

where V: Clone,

fn clone(&self) -> Faces<V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V> Debug for Faces<V>

where V: Debug,

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

Formats the value using the given formatter.

impl<V> Default for Faces<V>

fn default() -> Faces<V>

Returns the “default value” for a type.

impl<'de, V> Deserialize<'de> for Faces<V>

where V: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<Faces<V>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S> FromIterator<S> for Faces<usize>

where S: AsRef<[usize]>,

fn from_iter<I>(iter: I) -> Faces<usize>

where I: IntoIterator<Item = S>,

Creates a value from an iterator.

impl<T> FromIterator<T> for Faces

where T: AsVertexSlice,

fn from_iter<I>(iter: I) -> Faces

where I: IntoIterator<Item = T>,

Creates a value from an iterator.

impl<V> Index<usize> for Faces<V>

type Output = [V]

The returned type after indexing.

fn index(&self, idx: usize) -> &<Faces<V> as Index<usize>>::Output

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for Faces

fn index_mut(&mut self, idx: usize) -> &mut <Faces as Index<usize>>::Output

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

impl<V> Invertible for Faces<V>

where V: Copy,

fn invert(&mut self)

Inverts self

fn inverse(&self) -> Faces<V>

Returns the inverse.

impl<V> PartialEq for Faces<V>

where V: PartialEq,

fn eq(&self, other: &Faces<V>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V> Serialize for Faces<V>

where V: Serialize,

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<V> Eq for Faces<V>

where V: Eq,

impl<V> StructuralPartialEq for Faces<V>