Struct bevy_math::cubic_splines::CubicSegment
source · pub struct CubicSegment<P: VectorSpace> {
pub coeff: [P; 4],
}
Expand description
A segment of a cubic curve, used to hold precomputed coefficients for fast interpolation.
Can be evaluated as a parametric curve over the domain [0, 1)
.
Segments can be chained together to form a longer compound curve.
Fields§
§coeff: [P; 4]
Coefficients of the segment
Implementations§
source§impl<P: VectorSpace> CubicSegment<P>
impl<P: VectorSpace> CubicSegment<P>
sourcepub fn acceleration(&self, t: f32) -> P
pub fn acceleration(&self, t: f32) -> P
Instantaneous acceleration of a point at parametric value t
.
source§impl CubicSegment<Vec2>
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.
sourcepub fn new_bezier(p1: impl Into<Vec2>, p2: impl Into<Vec2>) -> Self
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)
.
sourcepub fn ease(&self, time: f32) -> f32
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
in0..=1
Use Newton’s method to find a value of
t
that results in B(t) = (x,y) wherex == time
Once a solution is found, use the resulting
y
value as the final result
Trait Implementations§
source§impl<P: Clone + VectorSpace> Clone for CubicSegment<P>
impl<P: Clone + VectorSpace> Clone for CubicSegment<P>
source§fn clone(&self) -> CubicSegment<P>
fn clone(&self) -> CubicSegment<P>
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moresource§impl<P: Debug + VectorSpace> Debug for CubicSegment<P>
impl<P: Debug + VectorSpace> Debug for CubicSegment<P>
source§impl<P: Default + VectorSpace> Default for CubicSegment<P>
impl<P: Default + VectorSpace> Default for CubicSegment<P>
source§fn default() -> CubicSegment<P>
fn default() -> CubicSegment<P>
source§impl<P: VectorSpace> Extend<CubicSegment<P>> for CubicCurve<P>
impl<P: VectorSpace> Extend<CubicSegment<P>> for CubicCurve<P>
source§fn extend<T: IntoIterator<Item = CubicSegment<P>>>(&mut self, iter: T)
fn extend<T: IntoIterator<Item = CubicSegment<P>>>(&mut self, iter: T)
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)source§impl<P: VectorSpace> From<CubicSegment<P>> for RationalSegment<P>
impl<P: VectorSpace> From<CubicSegment<P>> for RationalSegment<P>
source§fn from(value: CubicSegment<P>) -> Self
fn from(value: CubicSegment<P>) -> Self
source§impl<P> FromReflect for CubicSegment<P>where
Self: Any + Send + Sync,
P: TypePath + VectorSpace,
[P; 4]: FromReflect + TypePath + RegisterForReflection,
impl<P> FromReflect for CubicSegment<P>where
Self: Any + Send + Sync,
P: TypePath + VectorSpace,
[P; 4]: FromReflect + TypePath + RegisterForReflection,
source§fn from_reflect(reflect: &dyn Reflect) -> Option<Self>
fn from_reflect(reflect: &dyn Reflect) -> Option<Self>
Self
from a reflected value.source§fn take_from_reflect(
reflect: Box<dyn Reflect>
) -> Result<Self, Box<dyn Reflect>>
fn take_from_reflect( reflect: Box<dyn Reflect> ) -> Result<Self, Box<dyn Reflect>>
Self
using,
constructing the value using from_reflect
if that fails. Read moresource§impl<P> GetTypeRegistration for CubicSegment<P>where
Self: Any + Send + Sync,
P: TypePath + VectorSpace,
[P; 4]: FromReflect + TypePath + RegisterForReflection,
impl<P> GetTypeRegistration for CubicSegment<P>where
Self: Any + Send + Sync,
P: TypePath + VectorSpace,
[P; 4]: FromReflect + TypePath + RegisterForReflection,
source§fn get_type_registration() -> TypeRegistration
fn get_type_registration() -> TypeRegistration
TypeRegistration
for this type.source§fn register_type_dependencies(registry: &mut TypeRegistry)
fn register_type_dependencies(registry: &mut TypeRegistry)
source§impl<P: PartialEq + VectorSpace> PartialEq for CubicSegment<P>
impl<P: PartialEq + VectorSpace> PartialEq for CubicSegment<P>
source§fn eq(&self, other: &CubicSegment<P>) -> bool
fn eq(&self, other: &CubicSegment<P>) -> bool
self
and other
values to be equal, and is used
by ==
.source§impl<P> Reflect for CubicSegment<P>where
Self: Any + Send + Sync,
P: TypePath + VectorSpace,
[P; 4]: FromReflect + TypePath + RegisterForReflection,
impl<P> Reflect for CubicSegment<P>where
Self: Any + Send + Sync,
P: TypePath + VectorSpace,
[P; 4]: FromReflect + TypePath + RegisterForReflection,
source§fn get_represented_type_info(&self) -> Option<&'static TypeInfo>
fn get_represented_type_info(&self) -> Option<&'static TypeInfo>
source§fn as_any_mut(&mut self) -> &mut dyn Any
fn as_any_mut(&mut self) -> &mut dyn Any
&mut dyn Any
.source§fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>
fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>
source§fn as_reflect(&self) -> &dyn Reflect
fn as_reflect(&self) -> &dyn Reflect
source§fn as_reflect_mut(&mut self) -> &mut dyn Reflect
fn as_reflect_mut(&mut self) -> &mut dyn Reflect
source§fn clone_value(&self) -> Box<dyn Reflect>
fn clone_value(&self) -> Box<dyn Reflect>
Reflect
trait object. Read moresource§fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>
fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>
source§fn reflect_kind(&self) -> ReflectKind
fn reflect_kind(&self) -> ReflectKind
source§fn reflect_ref(&self) -> ReflectRef<'_>
fn reflect_ref(&self) -> ReflectRef<'_>
source§fn reflect_mut(&mut self) -> ReflectMut<'_>
fn reflect_mut(&mut self) -> ReflectMut<'_>
source§fn reflect_owned(self: Box<Self>) -> ReflectOwned
fn reflect_owned(self: Box<Self>) -> ReflectOwned
source§fn reflect_partial_eq(&self, value: &dyn Reflect) -> Option<bool>
fn reflect_partial_eq(&self, value: &dyn Reflect) -> Option<bool>
source§fn apply(&mut self, value: &(dyn Reflect + 'static))
fn apply(&mut self, value: &(dyn Reflect + 'static))
source§fn reflect_hash(&self) -> Option<u64>
fn reflect_hash(&self) -> Option<u64>
source§fn serializable(&self) -> Option<Serializable<'_>>
fn serializable(&self) -> Option<Serializable<'_>>
source§fn is_dynamic(&self) -> bool
fn is_dynamic(&self) -> bool
source§impl<P> Struct for CubicSegment<P>where
Self: Any + Send + Sync,
P: TypePath + VectorSpace,
[P; 4]: FromReflect + TypePath + RegisterForReflection,
impl<P> Struct for CubicSegment<P>where
Self: Any + Send + Sync,
P: TypePath + VectorSpace,
[P; 4]: FromReflect + TypePath + RegisterForReflection,
source§fn field(&self, name: &str) -> Option<&dyn Reflect>
fn field(&self, name: &str) -> Option<&dyn Reflect>
name
as a &dyn Reflect
.source§fn field_mut(&mut self, name: &str) -> Option<&mut dyn Reflect>
fn field_mut(&mut self, name: &str) -> Option<&mut dyn Reflect>
name
as a
&mut dyn Reflect
.source§fn field_at(&self, index: usize) -> Option<&dyn Reflect>
fn field_at(&self, index: usize) -> Option<&dyn Reflect>
index
as a
&dyn Reflect
.source§fn field_at_mut(&mut self, index: usize) -> Option<&mut dyn Reflect>
fn field_at_mut(&mut self, index: usize) -> Option<&mut dyn Reflect>
index
as a &mut dyn Reflect
.source§fn name_at(&self, index: usize) -> Option<&str>
fn name_at(&self, index: usize) -> Option<&str>
index
.source§fn iter_fields(&self) -> FieldIter<'_>
fn iter_fields(&self) -> FieldIter<'_>
source§fn clone_dynamic(&self) -> DynamicStruct
fn clone_dynamic(&self) -> DynamicStruct
DynamicStruct
.source§impl<P> TypePath for CubicSegment<P>
impl<P> TypePath for CubicSegment<P>
source§fn type_path() -> &'static str
fn type_path() -> &'static str
source§fn short_type_path() -> &'static str
fn short_type_path() -> &'static str
source§fn type_ident() -> Option<&'static str>
fn type_ident() -> Option<&'static str>
source§fn crate_name() -> Option<&'static str>
fn crate_name() -> Option<&'static str>
source§impl<P> Typed for CubicSegment<P>where
Self: Any + Send + Sync,
P: TypePath + VectorSpace,
[P; 4]: FromReflect + TypePath + RegisterForReflection,
impl<P> Typed for CubicSegment<P>where
Self: Any + Send + Sync,
P: TypePath + VectorSpace,
[P; 4]: FromReflect + TypePath + RegisterForReflection,
impl<P: Copy + VectorSpace> Copy for CubicSegment<P>
impl<P: VectorSpace> StructuralPartialEq for CubicSegment<P>
Auto Trait Implementations§
impl<P> Freeze for CubicSegment<P>where
P: Freeze,
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> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
source§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
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
.source§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
.source§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s.source§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s.source§impl<T> DowncastSync for T
impl<T> DowncastSync for T
source§impl<T> DynamicTypePath for Twhere
T: TypePath,
impl<T> DynamicTypePath for Twhere
T: TypePath,
source§fn reflect_type_path(&self) -> &str
fn reflect_type_path(&self) -> &str
TypePath::type_path
.source§fn reflect_short_type_path(&self) -> &str
fn reflect_short_type_path(&self) -> &str
source§fn reflect_type_ident(&self) -> Option<&str>
fn reflect_type_ident(&self) -> Option<&str>
TypePath::type_ident
.source§fn reflect_crate_name(&self) -> Option<&str>
fn reflect_crate_name(&self) -> Option<&str>
TypePath::crate_name
.source§fn reflect_module_path(&self) -> Option<&str>
fn reflect_module_path(&self) -> Option<&str>
source§impl<S> GetField for Swhere
S: Struct,
impl<S> GetField for Swhere
S: Struct,
source§impl<T> GetPath for T
impl<T> GetPath for T
source§fn reflect_path<'p>(
&self,
path: impl ReflectPath<'p>
) -> Result<&(dyn Reflect + 'static), ReflectPathError<'p>>
fn reflect_path<'p>( &self, path: impl ReflectPath<'p> ) -> Result<&(dyn Reflect + 'static), ReflectPathError<'p>>
path
. Read moresource§fn reflect_path_mut<'p>(
&mut self,
path: impl ReflectPath<'p>
) -> Result<&mut (dyn Reflect + 'static), ReflectPathError<'p>>
fn reflect_path_mut<'p>( &mut self, path: impl ReflectPath<'p> ) -> Result<&mut (dyn Reflect + 'static), ReflectPathError<'p>>
path
. Read moresource§fn path<'p, T>(
&self,
path: impl ReflectPath<'p>
) -> Result<&T, ReflectPathError<'p>>where
T: Reflect,
fn path<'p, T>(
&self,
path: impl ReflectPath<'p>
) -> Result<&T, ReflectPathError<'p>>where
T: Reflect,
path
. Read moresource§fn path_mut<'p, T>(
&mut self,
path: impl ReflectPath<'p>
) -> Result<&mut T, ReflectPathError<'p>>where
T: Reflect,
fn path_mut<'p, T>(
&mut self,
path: impl ReflectPath<'p>
) -> Result<&mut T, ReflectPathError<'p>>where
T: Reflect,
path
. Read more