Struct half_edge_mesh::vert::Vert

pub struct Vert {
    pub edge: EdgePtr,
    pub pos: Point3<f32>,
    pub id: u32,
}

Fields

edge: EdgePtr

pos: Point3<f32>

id: u32

Methods

impl Vert

pub fn empty(id: u32, pos: Point3<f32>) -> Vert

All structure of the mesh revolves around vertex positions and their connectivity. (Faces are just an abstraction). All vertices must therefore have a concrete position.

pub fn with_edge(id: u32, pos: Point3<f32>, edge: EdgePtr) -> Vert

Vertex connected to an existing edge

pub fn take_edge(&mut self, edge: EdgePtr)

pub fn set_edge(&mut self, edge: &EdgePtr)

pub fn set_edge_rc(&mut self, edge: &EdgeRc)

pub fn move_to(&mut self, pos: Point3<f32>)

pub fn get_pos(&self) -> Point3<f32>

pub fn is_valid(&self) -> bool

pub fn get_edge(&self) -> Option<EdgeRc>

Important traits for VertAdjacentVertIterator

impl Iterator for VertAdjacentVertIterator type Item = VertPtr;

pub fn adjacent_verts(&self) -> VertAdjacentVertIterator

Important: Iterates over the vertices connected to a vertex in clockwise order

Important traits for VertAdjacentEdgeIterator

impl Iterator for VertAdjacentEdgeIterator type Item = EdgePtr;

pub fn adjacent_edges(&self) -> VertAdjacentEdgeIterator

Important: Iterates over the edges connected to a vertex in clockwise order

Important traits for VertAdjacentFaceIterator

impl Iterator for VertAdjacentFaceIterator type Item = FacePtr;

pub fn adjacent_faces(&self) -> VertAdjacentFaceIterator

Important: Iterates over the faces connected to a vertex in clockwise order

Trait Implementations

impl Debug for Vert

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

Formats the value using the given formatter.

impl PartialEq<Vert> for Vert

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

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

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

This method tests for !=.

impl Eq for Vert

impl Hash for Vert

fn hash<H>(&self, state: &mut H) where     H: Hasher,

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where     H: Hasher,

Feeds a slice of this type into the given [Hasher].