Struct CubicSegment

pub struct CubicSegment<P>
where
    P: VectorSpace,
{
    pub coeff: [P; 4],
}

A segment of a cubic curve, used to hold precomputed coefficients for fast interpolation. It is a Curve with domain [0, 1].

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

Fields

coeff: [P; 4]

Polynomial coefficients for the segment.

Implementations

impl<P> CubicSegment<P>

where P: VectorSpace,

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

Instantaneous position of a point at parametric value t.

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

Instantaneous velocity of a point at parametric value t.

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

Instantaneous acceleration of a point at parametric value t.

pub fn new_bezier(points: [P; 4]) -> CubicSegment<P>

Creates a cubic segment from four points, representing a Bezier curve.

pub fn iter_samples<'a, 'b>( &'b self, subdivisions: usize, sample_function: impl FnMut(&CubicSegment<P>, f32) -> P + 'a, ) -> impl Iterator<Item = P> + 'a

where 'b: 'a,

A flexible iterator used to sample curves with arbitrary functions.

This splits the curve into subdivisions of evenly spaced t values across the length of the curve from start (t = 0) to end (t = n), where n = self.segment_count(), returning an iterator evaluating the curve with the supplied sample_function at each t.

For subdivisions = 2, this will split the curve into two lines, or three points, and return an iterator with 3 items, the three points, one at the start, middle, and end.

pub fn iter_positions(&self, subdivisions: usize) -> impl Iterator<Item = P>

Iterate over the curve split into subdivisions, sampling the position at each step.

pub fn iter_velocities(&self, subdivisions: usize) -> impl Iterator<Item = P>

Iterate over the curve split into subdivisions, sampling the velocity at each step.

pub fn iter_accelerations(&self, subdivisions: usize) -> impl Iterator<Item = P>

Iterate over the curve split into subdivisions, sampling the acceleration at each step.

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.

pub fn new_bezier_easing( p1: impl Into<Vec2>, p2: impl Into<Vec2>, ) -> CubicSegment<Vec2>

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).

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_easing((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

impl<P> Clone for CubicSegment<P>

where P: Clone + VectorSpace,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P> Debug for CubicSegment<P>

where P: Debug + VectorSpace,

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

Formats the value using the given formatter.

impl<P> Default for CubicSegment<P>

where P: Default + VectorSpace,

fn default() -> CubicSegment<P>

Returns the “default value” for a type.

impl<P> Extend<CubicSegment<P>> for CubicCurve<P>

where P: VectorSpace,

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = CubicSegment<P>>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<P> From<CubicSegment<P>> for RationalSegment<P>

where P: VectorSpace,

fn from(value: CubicSegment<P>) -> RationalSegment<P>

Converts to this type from the input type.

impl<P> FromReflect for CubicSegment<P>

where P: VectorSpace + TypePath, CubicSegment<P>: Any + Send + Sync, [P; 4]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn from_reflect( reflect: &(dyn PartialReflect + 'static), ) -> Option<CubicSegment<P>>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl<P> GetTypeRegistration for CubicSegment<P>

where P: VectorSpace + TypePath, CubicSegment<P>: Any + Send + Sync, [P; 4]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl<P> PartialEq for CubicSegment<P>

where P: PartialEq + VectorSpace,

fn eq(&self, other: &CubicSegment<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<P> PartialReflect for CubicSegment<P>

where P: VectorSpace + TypePath, CubicSegment<P>: Any + Send + Sync, [P; 4]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<CubicSegment<P>>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<CubicSegment<P>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

Attempts to cast this type to a mutable, fully-reflected value.

fn into_partial_reflect(self: Box<CubicSegment<P>>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

Casts this type to a mutable, reflected value.

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

Returns a “partial equality” comparison result.

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

Debug formatter for the value.

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection.

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value.

fn clone_value(&self) -> Box<dyn PartialReflect>

👎Deprecated since 0.16.0: to clone reflected values, prefer using reflect_clone. To convert reflected values to dynamic ones, use to_dynamic.

Clones Self into its dynamic representation.

fn to_dynamic(&self) -> Box<dyn PartialReflect>

Converts this reflected value into its dynamic representation based on its kind.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl<P> Reflect for CubicSegment<P>

where P: VectorSpace + TypePath, CubicSegment<P>: Any + Send + Sync, [P; 4]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn into_any(self: Box<CubicSegment<P>>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<CubicSegment<P>>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

Casts this type to a mutable, fully-reflected value.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

impl<P> Struct for CubicSegment<P>

where P: VectorSpace + TypePath, CubicSegment<P>: Any + Send + Sync, [P; 4]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn field(&self, name: &str) -> Option<&(dyn PartialReflect + 'static)>

Returns a reference to the value of the field named name as a &dyn PartialReflect.

fn field_mut( &mut self, name: &str, ) -> Option<&mut (dyn PartialReflect + 'static)>

Returns a mutable reference to the value of the field named name as a &mut dyn PartialReflect.

fn field_at(&self, index: usize) -> Option<&(dyn PartialReflect + 'static)>

Returns a reference to the value of the field with index index as a &dyn PartialReflect.

fn field_at_mut( &mut self, index: usize, ) -> Option<&mut (dyn PartialReflect + 'static)>

Returns a mutable reference to the value of the field with index index as a &mut dyn PartialReflect.

fn name_at(&self, index: usize) -> Option<&str>

Returns the name of the field with index index.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

fn iter_fields(&self) -> FieldIter<'_>

Returns an iterator over the values of the reflectable fields for this struct.

fn to_dynamic_struct(&self) -> DynamicStruct

fn clone_dynamic(&self) -> DynamicStruct

👎Deprecated since 0.16.0: use to_dynamic_struct instead

Clones the struct into a DynamicStruct.

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

Will return None if TypeInfo is not available.

impl<P> TypePath for CubicSegment<P>

where P: VectorSpace + TypePath, CubicSegment<P>: Any + Send + Sync,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl<P> Typed for CubicSegment<P>

where P: VectorSpace + TypePath, CubicSegment<P>: Any + Send + Sync, [P; 4]: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl<P> Copy for CubicSegment<P>

where P: Copy + VectorSpace,

impl<P> StructuralPartialEq for CubicSegment<P>

where P: VectorSpace,