pub struct CubicSegment<P: Point> { /* private fields */ }
Expand description

A segment of a cubic curve, used to hold precomputed coefficients for fast interpolation.

Segments can be chained together to form a longer compound curve.

Implementations§

source§

impl<P: Point> CubicSegment<P>

source

pub fn position(&self, t: f32) -> P

Instantaneous position of a point at parametric value t.

source

pub fn velocity(&self, t: f32) -> P

Instantaneous velocity of a point at parametric value t.

source

pub fn acceleration(&self, t: f32) -> P

Instantaneous acceleration of a point at parametric value t.

source§

impl CubicSegment<Vec2>

The CubicSegment<Vec2> can be used as a 2-dimensional easing curve for animation.

The x-axis of the curve is time, and the y-axis is the output value. This struct provides methods for extremely fast solves for y given x.

source

pub fn new_bezier(p1: impl Into<Vec2>, p2: impl Into<Vec2>) -> Self

Construct a cubic Bezier curve for animation easing, with control points p1 and p2. A cubic Bezier easing curve has control point p0 at (0, 0) and p3 at (1, 1), leaving only p1 and p2 as the remaining degrees of freedom. The first and last control points are fixed to ensure the animation begins at 0, and ends at 1.

This is a very common tool for UI animations that accelerate and decelerate smoothly. For example, the ubiquitous “ease-in-out” is defined as (0.25, 0.1), (0.25, 1.0).

source

pub fn ease(&self, time: f32) -> f32

Given a time within 0..=1, returns an eased value that follows the cubic curve instead of a straight line. This eased result may be outside the range 0..=1, however it will always start at 0 and end at 1: ease(0) = 0 and ease(1) = 1.

let cubic_bezier = CubicSegment::new_bezier((0.25, 0.1), (0.25, 1.0));
assert_eq!(cubic_bezier.ease(0.0), 0.0);
assert_eq!(cubic_bezier.ease(1.0), 1.0);
How cubic easing works

Easing is generally accomplished with the help of “shaping functions”. These are curves that start at (0,0) and end at (1,1). The x-axis of this plot is the current time of the animation, from 0 to 1. The y-axis is how far along the animation is, also from 0 to 1. You can imagine that if the shaping function is a straight line, there is a 1:1 mapping between the time and how far along your animation is. If the time = 0.5, the animation is halfway through. This is known as linear interpolation, and results in objects animating with a constant velocity, and no smooth acceleration or deceleration at the start or end.

y
│         ●
│       ⬈
│     ⬈    
│   ⬈
│ ⬈
●─────────── x (time)

Using cubic Beziers, we have a curve that starts at (0,0), ends at (1,1), and follows a path determined by the two remaining control points (handles). These handles allow us to define a smooth curve. As time (x-axis) progresses, we now follow the curve, and use the y value to determine how far along the animation is.

y
         ⬈➔●
│      ⬈   
│     ↑      
│     ↑
│    ⬈
●➔⬈───────── x (time)

To accomplish this, we need to be able to find the position y on a curve, given the x value. Cubic curves are implicit parametric functions like B(t) = (x,y). To find y, we first solve for t that corresponds to the given x (time). We use the Newton-Raphson root-finding method to quickly find a value of t that is very near the desired value of x. Once we have this we can easily plug that t into our curve’s position function, to find the y component, which is how far along our animation should be. In other words:

Given time in 0..=1

Use Newton’s method to find a value of t that results in B(t) = (x,y) where x == time

Once a solution is found, use the resulting y value as the final result

Trait Implementations§

source§

impl<P: Clone + Point> Clone for CubicSegment<P>

source§

fn clone(&self) -> CubicSegment<P>

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl<P: Debug + Point> Debug for CubicSegment<P>

source§

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

Formats the value using the given formatter. Read more
source§

impl<P: Default + Point> Default for CubicSegment<P>

source§

fn default() -> CubicSegment<P>

Returns the “default value” for a type. Read more
source§

impl<P: PartialEq + Point> PartialEq for CubicSegment<P>

source§

fn eq(&self, other: &CubicSegment<P>) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<P: Point> StructuralPartialEq for CubicSegment<P>

Auto Trait Implementations§

§

impl<P> RefUnwindSafe for CubicSegment<P>
where P: RefUnwindSafe,

§

impl<P> Send for CubicSegment<P>
where P: Send,

§

impl<P> Sync for CubicSegment<P>
where P: Sync,

§

impl<P> Unpin for CubicSegment<P>
where P: Unpin,

§

impl<P> UnwindSafe for CubicSegment<P>
where P: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.