Struct truck_polymesh::Faces

pub struct Faces { /* fields omitted */ }

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 Faces

pub fn from_iter<V: Copy + Into<Vertex>, T: AsRef<[V]>, I: IntoIterator<Item = T>>(
    iter: I
) -> Faces

Creates faces of a polygon by iterator of slice.

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

Examples

use truck_polymesh::*;
let slice: &[&[[usize; 3]]] = &[
    &[[0, 0, 0], [1, 1, 1], [2, 2, 2]],
    &[[0, 0, 0], [2, 2, 2], [3, 3, 3]],
    &[[0, 0, 0], [4, 4, 4], [5, 5, 5], [1, 1, 1]],
];
let faces = Faces::from_iter(slice);

pub fn extend<V: Copy + Into<Vertex>, T: AsRef<[V]>, I: IntoIterator<Item = T>>(
    &mut self,
    iter: I
)

Extends faces by an iterator.

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

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<[Vertex; 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<V: Copy + Into<Vertex>, T: AsRef<[V]>>(&mut self, face: T)

Push a face to the faces.

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

Examples

use truck_polymesh::*;
let mut faces = Faces::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 fn tri_faces(&self) -> &Vec<[Vertex; 3]>

Returns the vector of triangles.

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

Returns the mutable slice of triangles.

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

Returns the vector of quadrangles.

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

Returns the mutable slice of quadrangles.

pub fn other_faces(&self) -> &Vec<Vec<Vertex>>

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

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

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

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

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::from_iter(slice);
let mut iter = faces.face_iter();
assert_eq!(iter.next(), Some([
    Vertex { pos: 0, uv: None, nor: None },
    Vertex { pos: 1, uv: None, nor: None },
    Vertex { pos: 2, uv: None, nor: None },
].as_ref()));
assert_eq!(iter.next(), Some([
    Vertex { pos: 0, uv: None, nor: None },
    Vertex { pos: 2, uv: None, nor: None },
    Vertex { pos: 3, uv: None, nor: None },
].as_ref()));
assert_eq!(iter.next(), Some([
    Vertex { pos: 0, uv: None, nor: None },
    Vertex { pos: 4, uv: None, nor: None },
    Vertex { pos: 5, uv: None, nor: None },
    Vertex { pos: 1, uv: None, nor: None },
].as_ref()));
assert_eq!(iter.next(), Some([
    Vertex { pos: 1, uv: None, nor: None },
    Vertex { pos: 2, uv: None, nor: None },
    Vertex { pos: 6, uv: None, nor: None },
    Vertex { pos: 7, uv: None, nor: None },
    Vertex { pos: 8, uv: None, nor: None },
    Vertex { pos: 9, uv: None, nor: None },
].as_ref()));
assert_eq!(iter.next(), None);

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

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 len(&self) -> usize

Returns the number of faces.

pub fn naive_concat(&mut self, other: Self)

Merges other into self.

Trait Implementations

impl Clone for Faces

fn clone(&self) -> Faces

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Faces

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

Formats the value using the given formatter.

impl Default for Faces

fn default() -> Faces

Returns the “default value” for a type.

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

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

Deserialize this value from the given Serde deserializer.

impl Index<usize> for Faces

type Output = [Vertex]

The returned type after indexing.

fn index(&self, idx: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for Faces

fn index_mut(&mut self, idx: usize) -> &mut Self::Output

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

impl PartialEq<Faces> for Faces

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Serialize for Faces

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

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Faces