Struct truck_rendimpl::polymesh::PolygonMesh

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

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, Global>> 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 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 fn attributes(&self) -> &A

Returns attributes

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

Returns the faces of the polygon.

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

Returns the vector of all triangles of the polygon.

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

Returns the vector of all quadrangles.

pub fn other_faces(&self) -> &[Vec<V, Global>]

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<StandardVertex, StandardAttributes>

pub fn merge(&mut self, mesh: PolygonMesh<StandardVertex, StandardAttributes>)

Returns polygonmesh merged self and mesh.

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

Creates the bounding box of the polygon mesh.

impl PolygonMesh<StandardVertex, StandardAttributes>

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

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 fn uv_coords(&self) -> &Vec<Vector2<f64>, Global>

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 fn normals(&self) -> &Vec<Vector3<f64>, Global>

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, 

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

Returns a copy 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, 

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

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

Returns the “default value” for a type.

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

pub 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<StandardVertex, StandardAttributes>

pub fn from_iter<I>(iter: I) -> PolygonMesh<StandardVertex, StandardAttributes> where
    I: IntoIterator<Item = STLFace>, 

Creates a value from an iterator.

impl<'a> IntoSTLIterator for &'a PolygonMesh<StandardVertex, StandardAttributes>

type IntoIter = PolygonMeshSTLFaceIterator<'a>

Which kind of iterator are we turning this into?

pub fn into_iter(
    self
) -> <&'a PolygonMesh<StandardVertex, StandardAttributes> as IntoSTLIterator>::IntoIter

Creates an iterator from a value.

impl Invertible for PolygonMesh<StandardVertex, StandardAttributes>

pub fn invert(&mut self)

Inverts self

pub fn inverse(&self) -> PolygonMesh<StandardVertex, StandardAttributes>

Returns the inverse.

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

pub fn eq(&self, other: &PolygonMesh<V, A>) -> bool

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

pub fn ne(&self, other: &PolygonMesh<V, A>) -> bool

This method tests for !=.

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

type State = PolygonState

Configuation deacriptor 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

Configuation deacriptor for instance.

fn to_instance(
    &self,
    handler: &DeviceHandler,
    shaders: &I::Shaders,
    desc: &Self::State
) -> I

Creates Instance from self.

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