Enum EdgeRepr 

#[non_exhaustive]
pub enum EdgeRepr {
    Curve3d {
        curve: CurveId,
        location: Location,
        range: (f64, f64),
    },
    PCurve {
        curve: PCurveId,
        surface: SurfaceId,
        location: Location,
        range: (f64, f64),
    },
    Seam {
        forward: PCurveId,
        reversed: PCurveId,
        surface: SurfaceId,
        location: Location,
        range: (f64, f64),
    },
    PolygonOnTriangulation {
        triangulation: TriangulationId,
        indices: Vec<u32>,
        location: Location,
    },
    Polyline {
        points: Vec<Point>,
        parameters: Vec<f64>,
        location: Location,
        deflection: f64,
    },
}

One way of describing where an edge runs.

An edge holds several at once, and they must agree; see EdgeData::same_parameter.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Curve3d

The edge as a curve in space.

Fields

curve: CurveId

The curve.

location: Location

Where the curve sits.

range: (f64, f64)

The portion of the curve this edge covers.

PCurve

The edge as a curve in one surface’s parameter space.

Fields

curve: PCurveId

The curve in (u, v).

surface: SurfaceId

The surface whose parameter space it lives in.

location: Location

Where that surface sits.

range: (f64, f64)

The portion of the curve this edge covers.

Seam

The edge as a seam on a closed surface, needing two pcurves.

A seam runs along a surface’s closure (a cylinder’s join, a sphere’s date line) where the same points have two parameter values. One pcurve per side; a single one could not express both, and using only one leaves the face split open along the seam.

Fields

forward: PCurveId

The pcurve on the side the face’s forward orientation sees.

reversed: PCurveId

The pcurve on the other side.

surface: SurfaceId

The surface.

location: Location

Where that surface sits.

range: (f64, f64)

The portion both curves cover.

PolygonOnTriangulation

The edge’s path through one face’s cached triangulation, as indices.

What a renderer wants to draw a shared edge without hunting for coincident vertices: consecutive indices are consecutive mesh nodes along the edge, in the edge’s own direction. Only meaningful while the named triangulation is the one stored; retessellating replaces both together.

Fields

triangulation: TriangulationId

The face triangulation the indices point into.

indices: Vec<u32>

Node indices along the edge, in curve order.

location: Location

Where the edge occurrence sits.

Polyline

A cached polyline approximation, with the deflection it was built to.

Carried alongside the exact geometry rather than replacing it: display and coarse spatial queries want it, and rebuilding it on every frame would dominate their cost.

Fields

points: Vec<Point>

The points, in order along the edge.

parameters: Vec<f64>

The curve parameter each point came from.

Kept, not discarded. A face’s cached triangulation has to place its boundary vertices where this polyline puts them, and it reaches them through its own pcurve, so it needs the parameters, not just the points. Without them the two caches drift and the stored mesh has gaps that the exact geometry does not.

location: Location

Where they sit.

deflection: f64

The maximum distance from the exact curve.

Implementations

impl EdgeRepr

pub const fn surface(&self) -> Option<SurfaceId>

The surface this representation belongs to, if any.

pub const fn location(&self) -> Option<&Location>

Where this representation sits.

pub const fn range(&self) -> Option<(f64, f64)>

The parameter range this representation covers, if it has one.

pub const fn is_curve3d(&self) -> bool

Whether this is the edge’s curve in space.

pub const fn is_parametric(&self) -> bool

Whether this describes the edge in a surface’s parameter space.

Trait Implementations

impl Clone for EdgeRepr

fn clone(&self) -> EdgeRepr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EdgeRepr

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

Formats the value using the given formatter.

impl PartialEq for EdgeRepr

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