Struct BezierSpline 

pub struct BezierSpline<T>(/* private fields */);

A curve composed of one or more concatenated cubic Bézier curves.

Implementations

impl<T> BezierSpline<T>

where T: Affine<Diff: Linear<Scalar = f32> + Clone> + Clone,

pub fn new(pts: &[T]) -> Self

Creates a Bézier spline from the given control points. The number of elements in pts must be 3n + 1 for some positive integer n.

Consecutive points in pts make up Bézier curves such that:

• pts[0..=3] define the first curve,
• pts[3..=6] define the second curve,

and so on.

Panics

If pts.len() < 4 or if pts.len() % 3 != 1.

pub fn from_rays<I>(rays: I) -> Self

where I: IntoIterator<Item = Ray<T>>,

Constructs a Bézier spline

pub fn eval(&self, t: f32) -> T

Evaluates self at position t.

Returns the first point if t < 0 and the last point if t > 1.

pub fn tangent(&self, t: f32) -> T::Diff

Returns the tangent of self at t.

Clamps t to the range [0, 1].

pub fn approximate(&self, halt: impl Fn(&T::Diff) -> bool) -> Polyline<T>

Approximates self as a sequence of line segments.

Recursively subdivides the curve into two half-curves, stopping once the approximation error is small enough, as determined by the halt function.

Given a curve segment between some points p and r, the parameter passed to halt is the distance to the real midpoint q from its linear approximation q'. If halt returns true, the line segment pr is returned as the approximation of this curve segment, otherwise the bisection continues.

Note that this heuristic does not work well in certain edge cases (consider, for example, an S-shaped curve where q' is very close to q, yet a straight line would be a poor approximation). However, in practice it tends to give reasonable results.

                ___--- q ---___
            _--´       |       `--_
        _--´           |           `--_
     _-p ------------- q' ------------ r-_
  _-´                                     `-_

Examples

use retrofire_core::math::{BezierSpline, vec2, Vec2};

let curve = BezierSpline::<Vec2>::new(
    &[vec2(0.0, 0.0), vec2(0.0, 1.0), vec2(1.0, 1.0), vec2(1.0, 0.0)]
);
let approx = curve.approximate(|err| err.len_sqr() < 0.01*0.01);
assert_eq!(approx.0.len(), 17);

Trait Implementations

impl<T: Clone> Clone for BezierSpline<T>

fn clone(&self) -> BezierSpline<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for BezierSpline<T>

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

Formats the value using the given formatter.

impl<T> Parametric<T> for BezierSpline<T>

where T: Affine<Diff: Linear<Scalar = f32> + Clone> + Clone,

fn eval(&self, t: f32) -> T

Returns the value of self at t.

impl<T: PartialEq> PartialEq for BezierSpline<T>

fn eq(&self, other: &BezierSpline<T>) -> 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<T: Eq> Eq for BezierSpline<T>

impl<T> StructuralPartialEq for BezierSpline<T>