Struct PolygonMesh 

pub struct PolygonMesh<V = StandardVertex, A = StandardAttributes> { /* private fields */ }

Polygon mesh

The polygon data is held in a method compliant with wavefront obj. Position, uv (texture) coordinates, and normal vectors are held in separate arrays, and each face vertex accesses those values by an indices triple.

Implementations

impl<V, A> PolygonMesh<V, A>

where V: Copy + Hash + Debug + Eq, A: Attributes<V>,

pub fn expands<T>( &self, contraction: impl Fn(<A as Attributes<V>>::Output) -> T, ) -> PolygonMesh<usize, Vec<T>>

where T: Copy,

Contract attributes and expand polygon.

Examples

use truck_polymesh::*;
let polygon = PolygonMesh::new(
    StandardAttributes {
        positions: vec![
            Point3::new(0.0, 0.0, 0.0),
            Point3::new(1.0, 0.0, 0.0),
            Point3::new(0.0, 1.0, 0.0),
            Point3::new(1.0, 1.0, 0.0),
        ],
        normals: vec![
            Vector3::new(0.0, 0.0, 1.0),
            Vector3::new(0.0, 0.0, -1.0),
        ],
        ..Default::default()
    },
    Faces::from_iter(&[
        &[(0, None, Some(0)), (1, None, Some(0)), (2, None, Some(0))],
        &[(3, None, Some(1)), (1, None, Some(1)), (2, None, Some(1))],
    ])
);
let expands = polygon.expands(|attr| (attr.position, attr.normal.unwrap()));
assert_eq!(
    expands,
    PolygonMesh::<usize, Vec<(Point3, Vector3)>>::new(
        vec![
           (Point3::new(0.0, 0.0, 0.0), Vector3::new(0.0, 0.0, 1.0)),
           (Point3::new(1.0, 0.0, 0.0), Vector3::new(0.0, 0.0, 1.0)),
           (Point3::new(0.0, 1.0, 0.0), Vector3::new(0.0, 0.0, 1.0)),
           (Point3::new(1.0, 1.0, 0.0), Vector3::new(0.0, 0.0, -1.0)),
           (Point3::new(1.0, 0.0, 0.0), Vector3::new(0.0, 0.0, -1.0)),
           (Point3::new(0.0, 1.0, 0.0), Vector3::new(0.0, 0.0, -1.0)),
        ],
        Faces::from_iter(&[[0, 1, 2], [3, 4, 5]]),
    )
);

impl<V, A> PolygonMesh<V, A>

where V: Copy + Debug, A: Attributes<V>,

pub fn new(attributes: A, faces: Faces<V>) -> PolygonMesh<V, A>

complete constructor

Panics

Panic occurs if there is an index is out of range.

Remarks

This method does not check whether the normal is normalized or not.

pub fn try_new( attributes: A, faces: Faces<V>, ) -> Result<PolygonMesh<V, A>, Error<V>>

complete constructor

Errors

Returns Error::OutOfRange if there is an index is out of range.

Remarks

This method does not check whether the normal is normalized or not.

pub const fn new_unchecked(attributes: A, faces: Faces<V>) -> PolygonMesh<V, A>

constructor without boundary check

pub fn debug_new(attributes: A, faces: Faces<V>) -> PolygonMesh<V, A>

constructor, boundary check is acrivated only in debug mode.

pub const fn attributes(&self) -> &A

Returns attributes

pub const fn faces(&self) -> &Faces<V>

Returns the faces of the polygon.

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

Returns the vector of all triangles of the polygon.

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

Returns the vector of all quadrangles.

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

Returns the vector 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. cf: Faces::face_iter

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 editor(&mut self) -> PolygonMeshEditor<'_, V, A>

Creates an editor that performs boundary checking on dropped.

pub fn uncheck_editor(&mut self) -> PolygonMeshEditor<'_, V, A>

Creates an editor that does NOT perform boundary checking on dropped.

pub fn debug_editor(&mut self) -> PolygonMeshEditor<'_, V, A>

Creates an editor that performs boundary checking on dropped ONLY in debug build.

impl PolygonMesh

pub fn merge(&mut self, mesh: PolygonMesh)

Returns a polygon mesh merged self and mesh.

pub fn bounding_box(&self) -> BoundingBox<Point3<f64>>

Creates the bounding box of the polygon mesh.

pub fn to_positions_mesh(&self) -> PolygonMesh<usize, Vec<Point3<f64>>>

Returns a polygon mesh with only positions information.

impl PolygonMesh

pub const fn positions(&self) -> &Vec<Point3<f64>>

Returns the vector of all positions.

pub fn positions_mut(&mut self) -> &mut [Point3<f64>]

Returns the mutable slice of all positions.

pub fn push_position(&mut self, position: Point3<f64>)

Adds a position.

pub fn extend_positions<I>(&mut self, iter: I)

where I: IntoIterator<Item = Point3<f64>>,

Extend positions by iterator.

pub const fn uv_coords(&self) -> &Vec<Vector2<f64>>

Returns the vector of all uv (texture) coordinates.

pub fn uv_coords_mut(&mut self) -> &mut [Vector2<f64>]

Returns the mutable slice of all uv (texture) coordinates.

pub fn push_uv_coord(&mut self, uv_coord: Vector2<f64>)

Adds a uv (texture) coordinate.

pub fn extend_uv_coords<I>(&mut self, iter: I)

where I: IntoIterator<Item = Vector2<f64>>,

Extend uv (texture) coordinates by iterator.

pub const fn normals(&self) -> &Vec<Vector3<f64>>

Returns the vector of all normals.

pub fn normals_mut(&mut self) -> &mut [Vector3<f64>]

Returns the mutable slice of all normals.

pub fn extend_normals<I>(&mut self, iter: I)

where I: IntoIterator<Item = Vector3<f64>>,

Extend normals by iterator

Trait Implementations

impl<V, A> Clone for PolygonMesh<V, A>

where V: Clone, A: Clone,

fn clone(&self) -> PolygonMesh<V, A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CreateBuffers for PolygonMesh

fn buffers( &self, vertex_usage: BufferUsages, index_usage: BufferUsages, device: &Device, ) -> (BufferHandler, BufferHandler)

Creates buffer handlers of attributes and indices.

impl<V, A> Debug for PolygonMesh<V, A>

where V: Debug, A: Debug,

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

Formats the value using the given formatter.

impl<V, A> Default for PolygonMesh<V, A>

where A: Default,

fn default() -> PolygonMesh<V, A>

Returns the “default value” for a type.

impl<'de, V, A> Deserialize<'de> for PolygonMesh<V, A>

where V: Copy + Debug + Deserialize<'de>, A: Attributes<V> + Deserialize<'de>,

fn deserialize<D>( deserializer: D, ) -> Result<PolygonMesh<V, A>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromIterator<StlFace> for PolygonMesh

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

where I: IntoIterator<Item = StlFace>,

Creates a value from an iterator.

impl<'a> IntoStlIterator for &'a PolygonMesh

type IntoIter = PolygonMeshStlFaceIterator<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a PolygonMesh as IntoStlIterator>::IntoIter

Creates an iterator from a value.

impl Invertible for PolygonMesh

fn invert(&mut self)

Inverts self

fn inverse(&self) -> PolygonMesh

Returns the inverse.

impl<V, A> PartialEq for PolygonMesh<V, A>

where V: PartialEq, A: PartialEq,

fn eq(&self, other: &PolygonMesh<V, A>) -> 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, A> Serialize for PolygonMesh<V, A>

where V: Serialize, A: 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 ToInstance<PolygonInstance> for PolygonMesh

type State = PolygonState

Configuration descriptor for instance.

fn to_instance( &self, handler: &DeviceHandler, shaders: &PolygonShaders, state: &PolygonState, ) -> PolygonInstance

Creates Instance from self.

impl ToInstance<WireFrameInstance> for PolygonMesh

type State = WireFrameState

Configuration descriptor for instance.

fn to_instance( &self, handler: &DeviceHandler, shaders: &WireShaders, state: &WireFrameState, ) -> WireFrameInstance

Creates Instance from self.

impl<V, A> Eq for PolygonMesh<V, A>

where V: Eq, A: Eq,

impl<V, A> StructuralPartialEq for PolygonMesh<V, A>