Struct bevy::prelude::CubicSegment

``````pub struct CubicSegment<P>where
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§

§

impl<P> CubicSegment<P>where P: Point,

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

§

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( 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((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 + Point,

§

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
§

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

§

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

Formats the value using the given formatter. Read more
§

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

§

fn default() -> CubicSegment<P>

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

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

§

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

§

§

§

§

§

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
§

§

fn as_bind_group_shader_type(&self, _images: &RenderAssets<Image>) -> U

Return the `T` `ShaderType` for `self`. When used in `AsBindGroup` derives, it is safe to assume that all images in `self` exist.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

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

Mutably borrows from an owned value. Read more
§

§

§

impl<T> Downcast for Twhere T: Any,

§

fn into_any(self: Box<T, Global>) -> Box<dyn Any, Global>

Convert `Box<dyn Trait>` (where `Trait: Downcast`) to `Box<dyn Any>`. `Box<dyn Any>` can then be further `downcast` into `Box<ConcreteType>` where `ConcreteType` implements `Trait`.
§

fn into_any_rc(self: Rc<T, Global>) -> Rc<dyn Any, Global>

Convert `Rc<Trait>` (where `Trait: Downcast`) to `Rc<Any>`. `Rc<Any>` can then be further `downcast` into `Rc<ConcreteType>` where `ConcreteType` implements `Trait`.
§

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

Convert `&Trait` (where `Trait: Downcast`) to `&Any`. This is needed since Rust cannot generate `&Any`’s vtable from `&Trait`’s.
§

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

Convert `&mut Trait` (where `Trait: Downcast`) to `&Any`. This is needed since Rust cannot generate `&mut Any`’s vtable from `&mut Trait`’s.
§

impl<T> DowncastSync for Twhere T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T, Global>) -> Arc<dyn Any + Sync + Send, Global>

Convert `Arc<Trait>` (where `Trait: Downcast`) to `Arc<Any>`. `Arc<Any>` can then be further `downcast` into `Arc<ConcreteType>` where `ConcreteType` implements `Trait`.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

§

§

impl<T> FromWorld for Twhere T: Default,

§

fn from_world(_world: &mut World) -> T

Creates `Self` using data from the given `World`.
§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self> ⓘ

Instruments this type with the provided `Span`, returning an `Instrumented` wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self> ⓘ

Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more
source§

impl<T, U> Into<U> for Twhere 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.

§

§

§

impl<T> NoneValue for Twhere T: Default,

§

§

fn null_value() -> T

The none-equivalent value.
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

source§

Read this value from the supplied reader. Same as `ReadEndian::read_from_little_endian()`.
source§

Read this value from the supplied reader. Same as `ReadEndian::read_from_big_endian()`.
source§

Read this value from the supplied reader. Same as `ReadEndian::read_from_native_endian()`.
source§

impl<T> Same<T> for T

§

type Output = T

Should always be `Self`
source§

impl<T> ToOwned for Twhere 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 Twhere 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 Twhere 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.
§

§

§

§

§

§

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘwhere S: Into<Dispatch>,

Attaches the provided `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ

Attaches the current default `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
§

§

§

§