Struct Bezier0

pub struct Bezier0<F: Float, P: CurvePoint<F>> {
    pub point: P,
    /* private fields */
}

Single point

Fields

point: P

Implementations

impl<F: Float, P: CurvePoint<F>> Bezier0<F, P>

pub fn new(point: P) -> Self

Trait Implementations

impl<F: Clone + Float, P: Clone + CurvePoint<F>> Clone for Bezier0<F, P>

fn clone(&self) -> Bezier0<F, P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: Float, P: CurvePoint<F>> Curve<F, P> for Bezier0<F, P>

fn value_at(&self, _t: F) -> P

Get the point at a given value t in range from 0 to 1.

fn tangent_at(&self, _t: F) -> P

Get the derivative at a given value t in range from 0 to 1.

fn start_point(&self) -> P

fn end_point(&self) -> P

fn estimate_length(&self, _precision: F) -> F

where P: Distance<F>,

Estimate the length of the curve as an average between min and max estimation. The precision parameter is the maximum ration of min and max estimation.

fn dot(p0: P) -> Bezier0<F, P>

Create a dot, at any t it will return the same value

fn line(p0: P, p1: P) -> Bezier1<F, P>

Create a line

fn quad_bezier(p0: P, p1: P, p2: P) -> Bezier2<F, P>

Create a quadratic bezier curve

fn cubic_bezier(p0: P, p1: P, p2: P, p3: P) -> Bezier3<F, P>

Create a cubic bezier curve

fn into_iter(self, steps_count: usize) -> CurveIterator<F, P, Self>

where Self: Sized,

Create an iterator that will generate points on the curve.

fn into_iter_inclusive(self, steps_count: usize) -> CurveIterator<F, P, Self>

where Self: Sized,

Create an iterator that will generate points on the curve, including the last point.

fn composed_curve(start_point: P) -> ComposedCurve<F, P>

Create a composed curve that will be a sequence of curves. Each segment of the curve will be represented by equal t range. For example, if you have 3 curves, they will take t ranges: 0 - 0.33, 0.33 - 0.66 and 0.66 - 1.0.

fn linear_speed( self, table_size: usize, steps_count: usize, ) -> LinearSpeed<F, P, Self>

where P: Distance<F>, Self: Sized,

Create a linear speed curve that will allow to move with a constant speed along the curve. It’s especially useful when you want to animate the movement along a composed curve.

impl<F: Float, P> Debug for Bezier0<F, P>

where P: Debug + CurvePoint<F>,

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

Formats the value using the given formatter.

impl<F: PartialEq + Float, P: PartialEq + CurvePoint<F>> PartialEq for Bezier0<F, P>

fn eq(&self, other: &Bezier0<F, P>) -> 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<F: Float, P> Copy for Bezier0<F, P>

where P: Copy + CurvePoint<F>,

impl<F: Float, P: CurvePoint<F>> StructuralPartialEq for Bezier0<F, P>