Struct half_edge_mesh::edge::Edge

pub struct Edge {
    pub next: EdgePtr,
    pub pair: EdgePtr,
    pub origin: VertPtr,
    pub face: FacePtr,
    pub id: u32,
}

Fields

next: EdgePtr

pair: EdgePtr

origin: VertPtr

face: FacePtr

id: u32

Methods

impl Edge

fn empty(id: u32) -> Edge

fn with_origin(id: u32, origin: VertPtr) -> Edge

fn take_next(&mut self, next: EdgePtr)

fn set_next(&mut self, next: &EdgePtr)

fn set_next_rc(&mut self, next: &EdgeRc)

fn take_pair(&mut self, pair: EdgePtr)

fn set_pair(&mut self, pair: &EdgePtr)

fn set_pair_rc(&mut self, pair: &EdgeRc)

fn take_origin(&mut self, origin: VertPtr)

fn set_origin(&mut self, origin: &VertPtr)

fn set_origin_rc(&mut self, origin: &VertRc)

fn set_face(&mut self, face: &FacePtr)

fn take_face(&mut self, face: FacePtr)

fn set_face_rc(&mut self, face: &FaceRc)

fn is_valid(&self) -> bool

fn get_next(&self) -> Option<EdgeRc>

fn get_pair(&self) -> Option<EdgeRc>

fn get_origin(&self) -> Option<VertRc>

fn get_face(&self) -> Option<FaceRc>

fn get_next_next(&self) -> Option<EdgeRc>

fn get_next_pair(&self) -> Option<EdgeRc>

fn get_target(&self) -> Option<VertRc>

fn get_pair_face(&self) -> Option<FaceRc>

fn adjacent_verts<'a>(&'a self) -> EdgeAdjacentVertIterator<'a>

Yields edge.origin, then edge.next.origin Gives you first the source of the half-edge, and then its target

fn adjacent_edges(&self) -> EdgeAdjacentEdgeIterator

Gives you the edges connected to the source of the half-edge first (in clockwise order) and then the edges connected to the target of the half-edge (also clockwise order)

fn adjacent_faces<'a>(&'a self) -> EdgeAdjacentFaceIterator<'a>

Yields edge.face, then edge.pair.face Gives you the "left" face to the half edge, and then the "right" face Note that the "right" face is not connected to this edge, but to its pair

Trait Implementations

impl Debug for Edge

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

Formats the value using the given formatter.

impl PartialEq<Edge> for Edge

fn eq(&self, other: &Edge) -> 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 Edge

impl Hash for Edge

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

Feeds this value into the state given, updating the hasher as necessary.

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

Feeds a slice of this type into the state provided.