Struct UnevenCore 

pub struct UnevenCore<T> {
    pub times: Vec<f32>,
    pub samples: Vec<T>,
}

The data core of a curve defined by unevenly-spaced samples or keyframes. The intention is to use this in concert with implicitly or explicitly-defined interpolation in user-space in order to implement the curve interface using domain and sample_with.

The internals are made transparent to give curve authors freedom, but the provided constructor enforces the required invariants, and the methods maintain those invariants.

Example

// Let's make a curve formed by interpolating rotations.
// We'll support two common modes of interpolation:
// - Normalized linear: First do linear interpolation, then normalize to get a valid rotation.
// - Spherical linear: Interpolate through valid rotations with constant angular velocity.
enum InterpolationMode {
    NormalizedLinear,
    SphericalLinear,
}

// Our interpolation modes will be driven by traits.
trait NormalizedLinearInterpolate {
    fn nlerp(&self, other: &Self, t: f32) -> Self;
}

trait SphericalLinearInterpolate {
    fn slerp(&self, other: &Self, t: f32) -> Self;
}

// Omitted: These traits would be implemented for `Rot2`, `Quat`, and other rotation representations.

// The curve itself just needs to use the curve core for keyframes, `UnevenCore`, which handles
// everything except for the explicit interpolation used.
struct RotationCurve<T> {
    core: UnevenCore<T>,
    interpolation_mode: InterpolationMode,
}

impl<T> Curve<T> for RotationCurve<T>
where
    T: NormalizedLinearInterpolate + SphericalLinearInterpolate + Clone,
{
    fn domain(&self) -> Interval {
        self.core.domain()
    }
     
    fn sample_unchecked(&self, t: f32) -> T {
        // To sample the curve, we just look at the interpolation mode and
        // dispatch accordingly.
        match self.interpolation_mode {
            InterpolationMode::NormalizedLinear =>
                self.core.sample_with(t, <T as NormalizedLinearInterpolate>::nlerp),
            InterpolationMode::SphericalLinear =>
                self.core.sample_with(t, <T as SphericalLinearInterpolate>::slerp),
        }
    }
}

Fields

times: Vec<f32>

The times for the samples of this curve.

Invariants

This must always have a length of at least 2, be sorted, and have no duplicated or non-finite times.

samples: Vec<T>

The samples corresponding to the times for this curve.

Invariants

This must always have the same length as times.

Implementations

impl<T> UnevenCore<T>

pub fn new( timed_samples: impl IntoIterator<Item = (f32, T)>, ) -> Result<Self, UnevenCoreError>

Create a new UnevenCore. The given samples are filtered to finite times and sorted internally; if there are not at least 2 valid timed samples, an error will be returned.

pub fn domain(&self) -> Interval

The domain of the curve derived from this core.

Panics

This method may panic if the type’s invariants aren’t satisfied.

pub fn sample_with<I>(&self, t: f32, interpolation: I) -> T

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

Obtain a value from the held samples using the given interpolation to interpolate between adjacent samples.

The interpolation takes two values by reference together with a scalar parameter and produces an owned value. The expectation is that interpolation(&x, &y, 0.0) and interpolation(&x, &y, 1.0) are equivalent to x and y respectively.

pub fn sample_interp(&self, t: f32) -> InterpolationDatum<&T>

Given a time t, obtain a InterpolationDatum which governs how interpolation might recover a sample at time t. For example, when a Between value is returned, its contents can be used to interpolate between the two contained values with the given parameter. The other variants give additional context about where the value is relative to the family of samples.

pub fn sample_interp_timed(&self, t: f32) -> InterpolationDatum<(f32, &T)>

Like sample_interp, but the returned values include the sample times. This can be useful when sample interpolation is not scale-invariant.

pub fn map_sample_times(self, f: impl Fn(f32) -> f32) -> UnevenCore<T>

This core, but with the sample times moved by the map f. In principle, when f is monotone, this is equivalent to CurveExt::reparametrize, but the function inputs to each are inverses of one another.

The samples are re-sorted by time after mapping and deduplicated by output time, so the function f should generally be injective over the set of sample times, otherwise data will be deleted.

Trait Implementations

impl<T: Clone> Clone for UnevenCore<T>

fn clone(&self) -> UnevenCore<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for UnevenCore<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for UnevenCore<T>

where T: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Serialize for UnevenCore<T>

where T: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.