Struct RationalCurve

pub struct RationalCurve<P: VectorSpace> { /* private fields */ }

A collection of RationalSegments chained into a single parametric curve. It is a Curve with domain [0, N], where N is the number of segments.

Use any struct that implements the RationalGenerator trait to create a new curve, such as CubicNurbs, or convert CubicCurve using into/from.

Implementations

impl<P: VectorSpace> RationalCurve<P>

pub fn from_segments( segments: impl Into<Vec<RationalSegment<P>>>, ) -> Option<Self>

Create a new curve from a collection of segments. If the collection of segments is empty, a curve cannot be built and None will be returned instead.

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

Compute the position of a point on the curve at the parametric value t.

Note that t varies from 0 to self.length().

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

Compute the first derivative with respect to t at t. This is the instantaneous velocity of a point on the curve at t.

Note that t varies from 0 to self.length().

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

Compute the second derivative with respect to t at t. This is the instantaneous acceleration of a point on the curve at t.

Note that t varies from 0 to self.length().

pub fn iter_samples<'a, 'b: 'a>( &'b self, subdivisions: usize, sample_function: impl FnMut(&Self, f32) -> P + 'a, ) -> impl Iterator<Item = P> + '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 segments(&self) -> &[RationalSegment<P>]

The list of segments contained in this RationalCurve.

This spline’s global t value is equal to how many segments it has.

All method accepting t on RationalCurve depends on the global t. When sampling over the entire curve, you should either use one of the iter_* methods or account for the segment count using curve.segments().len().

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.

pub fn push_segment(&mut self, segment: RationalSegment<P>)

Adds a segment to the curve.

pub fn length(&self) -> f32

Returns the length of the domain of the parametric curve.

Trait Implementations

impl<P: Clone + VectorSpace> Clone for RationalCurve<P>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P: VectorSpace> Curve<P> for RationalCurve<P>

Available on crate feature curve only.

fn domain(&self) -> Interval

The interval over which this curve is parametrized.

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

Sample a point on this curve at the parameter value t, extracting the associated value. This is the unchecked version of sampling, which should only be used if the sample time t is already known to lie within the curve’s domain.

fn sample(&self, t: f32) -> Option<T>

Sample a point on this curve at the parameter value t, returning None if the point is outside of the curve’s domain.

fn sample_clamped(&self, t: f32) -> T

Sample a point on this curve at the parameter value t, clamping t to lie inside the domain of the curve.

fn sample_iter( &self, iter: impl IntoIterator<Item = f32>, ) -> impl Iterator<Item = Option<T>>

where Self: Sized,

Sample a collection of n >= 0 points on this curve at the parameter values t_n, returning None if the point is outside of the curve’s domain.

fn sample_iter_unchecked( &self, iter: impl IntoIterator<Item = f32>, ) -> impl Iterator<Item = T>

where Self: Sized,

Sample a collection of n >= 0 points on this curve at the parameter values t_n, extracting the associated values. This is the unchecked version of sampling, which should only be used if the sample times t_n are already known to lie within the curve’s domain.

fn sample_iter_clamped( &self, iter: impl IntoIterator<Item = f32>, ) -> impl Iterator<Item = T>

where Self: Sized,

Sample a collection of n >= 0 points on this curve at the parameter values t_n, clamping t_n to lie inside the domain of the curve.

fn map<S, F>(self, f: F) -> MapCurve<T, S, Self, F>

where Self: Sized, F: Fn(T) -> S,

Create a new curve by mapping the values of this curve via a function f; i.e., if the sample at time t for this curve is x, the value at time t on the new curve will be f(x).

fn reparametrize<F>(self, domain: Interval, f: F) -> ReparamCurve<T, Self, F>

where Self: Sized, F: Fn(f32) -> f32,

Create a new Curve whose parameter space is related to the parameter space of this curve by f. For each time t, the sample from the new curve at time t is the sample from this curve at time f(t). The given domain will be the domain of the new curve. The function f is expected to take domain into self.domain().

fn reparametrize_linear( self, domain: Interval, ) -> Result<LinearReparamCurve<T, Self>, LinearReparamError>

where Self: Sized,

Linearly reparametrize this Curve, producing a new curve whose domain is the given domain instead of the current one. This operation is only valid for curves with bounded domains; if either this curve’s domain or the given domain is unbounded, an error is returned.

fn reparametrize_by_curve<C>(self, other: C) -> CurveReparamCurve<T, Self, C>

where Self: Sized, C: Curve<f32>,

Reparametrize this Curve by sampling from another curve.

fn graph(self) -> GraphCurve<T, Self>

where Self: Sized,

Create a new Curve which is the graph of this one; that is, its output echoes the sample time as part of a tuple.

fn zip<S, C>( self, other: C, ) -> Result<ZipCurve<T, S, Self, C>, InvalidIntervalError>

where Self: Sized, C: Curve<S> + Sized,

Create a new Curve by zipping this curve together with another.

fn chain<C>(self, other: C) -> Result<ChainCurve<T, Self, C>, ChainError>

where Self: Sized, C: Curve<T>,

Create a new Curve by composing this curve end-to-start with another, producing another curve with outputs of the same type. The domain of the other curve is translated so that its start coincides with where this curve ends.

fn reverse(self) -> Result<ReverseCurve<T, Self>, ReverseError>

where Self: Sized,

Create a new Curve inverting this curve on the x-axis, producing another curve with outputs of the same type, effectively playing backwards starting at self.domain().end() and transitioning over to self.domain().start(). The domain of the new curve is still the same.

fn repeat(self, count: usize) -> Result<RepeatCurve<T, Self>, RepeatError>

where Self: Sized,

Create a new Curve repeating this curve N times, producing another curve with outputs of the same type. The domain of the new curve will be bigger by a factor of n + 1.

fn forever(self) -> Result<ForeverCurve<T, Self>, RepeatError>

where Self: Sized,

Create a new Curve repeating this curve forever, producing another curve with outputs of the same type. The domain of the new curve will be unbounded.

fn ping_pong(self) -> Result<PingPongCurve<T, Self>, PingPongError>

where Self: Sized,

Create a new Curve chaining the original curve with its inverse, producing another curve with outputs of the same type. The domain of the new curve will be twice as long. The transition point is guaranteed to not make any jumps.

fn chain_continue<C>( self, other: C, ) -> Result<ContinuationCurve<T, Self, C>, ChainError>

where Self: Sized, T: VectorSpace, C: Curve<T>,

Create a new Curve by composing this curve end-to-start with another, producing another curve with outputs of the same type. The domain of the other curve is translated so that its start coincides with where this curve ends.

fn resample<I>( &self, segments: usize, interpolation: I, ) -> Result<SampleCurve<T, I>, ResamplingError>

where Self: Sized, I: Fn(&T, &T, f32) -> T,

Resample this Curve to produce a new one that is defined by interpolation over equally spaced sample values, using the provided interpolation to interpolate between adjacent samples. The curve is interpolated on segments segments between samples. For example, if segments is 1, only the start and end points of the curve are used as samples; if segments is 2, a sample at the midpoint is taken as well, and so on. If segments is zero, or if this curve has an unbounded domain, then a ResamplingError is returned.

fn resample_auto( &self, segments: usize, ) -> Result<SampleAutoCurve<T>, ResamplingError>

where Self: Sized, T: StableInterpolate,

Resample this Curve to produce a new one that is defined by interpolation over equally spaced sample values, using automatic interpolation to interpolate between adjacent samples. The curve is interpolated on segments segments between samples. For example, if segments is 1, only the start and end points of the curve are used as samples; if segments is 2, a sample at the midpoint is taken as well, and so on. If segments is zero, or if this curve has an unbounded domain, then a ResamplingError is returned.

fn samples( &self, samples: usize, ) -> Result<impl Iterator<Item = T>, ResamplingError>

where Self: Sized,

Extract an iterator over evenly-spaced samples from this curve. If samples is less than 2 or if this curve has unbounded domain, then an error is returned instead.

fn resample_uneven<I>( &self, sample_times: impl IntoIterator<Item = f32>, interpolation: I, ) -> Result<UnevenSampleCurve<T, I>, ResamplingError>

where Self: Sized, I: Fn(&T, &T, f32) -> T,

Resample this Curve to produce a new one that is defined by interpolation over samples taken at a given set of times. The given interpolation is used to interpolate adjacent samples, and the sample_times are expected to contain at least two valid times within the curve’s domain interval.

fn resample_uneven_auto( &self, sample_times: impl IntoIterator<Item = f32>, ) -> Result<UnevenSampleAutoCurve<T>, ResamplingError>

where Self: Sized, T: StableInterpolate,

Resample this Curve to produce a new one that is defined by automatic interpolation over samples taken at the given set of times. The given sample_times are expected to contain at least two valid times within the curve’s domain interval.

fn by_ref(&self) -> &Self

where Self: Sized,

Borrow this curve rather than taking ownership of it. This is essentially an alias for a prefix &; the point is that intermediate operations can be performed while retaining access to the original curve.

fn flip<U, V>(self) -> impl Curve<(V, U)>

where Self: Sized + Curve<(U, V)>,

Flip this curve so that its tuple output is arranged the other way.

impl<P: Debug + VectorSpace> Debug for RationalCurve<P>

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

Formats the value using the given formatter.

impl<'de, P> Deserialize<'de> for RationalCurve<P>

where P: Deserialize<'de> + VectorSpace,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<P: VectorSpace> Extend<RationalSegment<P>> for RationalCurve<P>

fn extend<T: IntoIterator<Item = RationalSegment<P>>>(&mut self, iter: T)

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: VectorSpace> From<CubicCurve<P>> for RationalCurve<P>

fn from(value: CubicCurve<P>) -> Self

Converts to this type from the input type.

impl<P> FromReflect for RationalCurve<P>

where RationalCurve<P>: Any + Send + Sync, P: TypePath + VectorSpace, Vec<RationalSegment<P>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self>

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 RationalCurve<P>

where RationalCurve<P>: Any + Send + Sync, P: TypePath + VectorSpace, Vec<RationalSegment<P>>: 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: VectorSpace> IntoIterator for RationalCurve<P>

type IntoIter = <Vec<RationalSegment<P>> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

type Item = RationalSegment<P>

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<P: PartialEq + VectorSpace> PartialEq for RationalCurve<P>

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

where RationalCurve<P>: Any + Send + Sync, P: TypePath + VectorSpace, Vec<RationalSegment<P>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

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

Returns the TypeInfo of the type represented by this value.

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

Clones the value as a Reflect trait object.

fn try_apply(&mut self, value: &dyn PartialReflect) -> 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<Self>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<Self>, ) -> 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>

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

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

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

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

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &dyn PartialReflect

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut dyn PartialReflect

Casts this type to a mutable, reflected value.

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

Returns a “partial equality” comparison result.

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

Debug formatter for the value.

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

Applies a reflected value to this value.

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

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

fn serializable(&self) -> Option<Serializable<'_>>

Returns a serializable version of the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl<P> Reflect for RationalCurve<P>

where RationalCurve<P>: Any + Send + Sync, P: TypePath + VectorSpace, Vec<RationalSegment<P>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

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

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &dyn Any

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut dyn Any

Returns the value as a &mut dyn Any.

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

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

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut dyn Reflect

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> Serialize for RationalCurve<P>

where P: Serialize + VectorSpace,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<P> Struct for RationalCurve<P>

where RationalCurve<P>: Any + Send + Sync, P: TypePath + VectorSpace, Vec<RationalSegment<P>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

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

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>

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>

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>

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 clone_dynamic(&self) -> DynamicStruct

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 RationalCurve<P>

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

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 RationalCurve<P>

where RationalCurve<P>: Any + Send + Sync, P: TypePath + VectorSpace, Vec<RationalSegment<P>>: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl<P: VectorSpace> StructuralPartialEq for RationalCurve<P>