Struct LinearSpeed

pub struct LinearSpeed<F: Float, P: CurvePoint<F> + Distance<F>, C: Curve<F, P>> { /* private fields */ }

The same curve as a passed one, but with a linear dependency between the time and the distance.

Implementations

impl<F: Float, P: CurvePoint<F> + Distance<F>, C: Curve<F, P>> LinearSpeed<F, P, C>

pub fn new(curve: C, table_size: usize, steps_count: usize) -> Self

Trait Implementations

impl<F: Float, P: CurvePoint<F> + Distance<F>, C: Curve<F, P>> Curve<F, P> for LinearSpeed<F, P, C>

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

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.