mod interpolator

module interpolator

InterpolationFunction trait and some interpolation functions.

Traits

trait DurationCalculable<A, T>

An interpolation-function that is parameterized to allow calculating the time it should take to interpolate from from to to.

The passed argument is the same as for the InterpolationFunction.

Functions

fn duration(&self, argument: A, from: T, to: T) -> f32

Implemented for

impl<A, CJ: ConstantJerkImpl<A>> DurationCalculable<A, f32> for CJ

trait InterpolationFunction<A, T>

An interpolation function which can interpolate values of type T, using values of type A as arguments.

Variables

const ENDPOINT: Endpoint

The Endpoint of this InterpolationFunction (i.e., whether it will loop back to the start value or not).

Functions

fn interpolate(&self, fraction: Time, argument: A, from: T, to: T) -> T

Interpolate between two values based on the passed normalized fraction.

The passed argument can be used by this interpolation-functions.

Implemented for

impl<A: Copy, T: ConstantJerkImpl<A>> InterpolationFunction<A, f32> for T

Enums

enum ConstantTransitionPoint

Optional argument for Constant to describe when the constant jump should happen.

Start

Jump at start of interpolation

End

Jump at end of interpolation

enum Endpoint

The endpoint of an interpolation function

FROM

The interpolation-function ends back at the from-point

TO

The interpolation function ends at the to-point (most interpolation functions)

Implementations

impl Endpoint

Functions

fn get<T>(self, from: T, to: T) -> T

Gets the passed argument based on the value of this Endpoint

Structs and Unions

struct AverageVelocity(f32)

Implementations

impl AverageVelocity

Functions

fn for_2d_move(source: Position, destination: Position, time: f32) -> Self

Gets the average velocity for a 2d move from source to destination in time

struct ComponentWise<I>(I)

Component-Wise interpolator for a Position. Interpolates x- and y-coordinates separately using the same passed interpolator. The components are both interpreted in the same duration.

Note that while it is possible to wrap any types here, only wrapped InterpolationFunctions will make this type be an InterpolationFunction.

Traits implemented

impl<A: Copy, I: InterpolationFunction<A, f32>> InterpolationFunction<(A, A), Position> for ComponentWise<I>

struct ComponentWiseMinTime<I>(I)

Component-Wise interpolator for a Position. Interpolates x- and y-coordinates separately using the same passed interpolator. The duration must be calculable so that each component may take its specified time. The components therefore only take as long as necessary.

Note that while it is possible to wrap any types here, only wrapped InterpolationFunctions will make this type be an InterpolationFunction.

Traits implemented

impl<A: Copy, I: DurationCalculable<A, f32>> DurationCalculable<A, Position> for ComponentWiseMinTime<I>

impl<A: Copy, I: InterpolationFunction<A, f32> + DurationCalculable<A, f32>> InterpolationFunction<A, Position> for ComponentWiseMinTime<I>

struct Constant)

Constant interpolation

Will switch from from to to at the specified point. The time can be specified by the argument:

• (): Will jump at start of the interpolation (i.e., always be true).

• ConstantTransitionPoint: Will use the ConstantTransitionPoint to decide.

• Time: Will jump at the specified Time.

Traits implemented

impl<T> InterpolationFunction<(), T> for Constant

impl<T> InterpolationFunction<ConstantTransitionPoint, T> for Constant

impl<T> InterpolationFunction<Time, T> for Constant

struct ConstantJerk)

A ConstantJerkImpl with a constant jerk.

Implementations

impl ConstantJerk

Functions

fn new_fixed(jerk: Jerk) -> FixedArgument<Jerk, Self>

Creates a new ConstantJerk interpolation-function with the specified fixed jerk.

Traits implemented

impl ConstantJerkImpl<Jerk> for ConstantJerk

struct ConstantJerkFixedAverageVelocity)

A ConstantJerkImpl with a set average velocity. The jerk value is calculated from the average velocity for a given interpolation.

Implementations

impl ConstantJerkFixedAverageVelocity

Functions

fn jerk_for_diagonal_move(from: Position, to: Position, duration: f32) -> Jerk

Calculates the jerk for a diagonal move from from to to in the passed duration.

fn jerk_for_move(from: f32, to: f32, duration: f32) -> Jerk

Calculates the jerk for a one-dimensional move from from to to in the passed duration.

fn new_fixed(average_velocity: AverageVelocity) -> FixedArgument<AverageVelocity, Self>

Traits implemented

impl ConstantJerkImpl<AverageVelocity> for ConstantJerkFixedAverageVelocity

Implementation using AverageVelocity. Use this when needing the correct values..

impl ConstantJerkImpl<()> for ConstantJerkFixedAverageVelocity

Implementation using no argument, as the AverageVelocity reduces in the final interpolation. Use this for interpolation in the timeline.

struct ConstantJerkFixedMaxVelocity)

A ConstantJerkImpl with a set maximum velocity. The jerk value is calculated from the maximum velocity for a given interpolation.

Implementations

impl ConstantJerkFixedMaxVelocity

Functions

fn new_fixed(max_velocity: MaxVelocity) -> FixedArgument<MaxVelocity, Self>

Traits implemented

impl ConstantJerkImpl<MaxVelocity> for ConstantJerkFixedMaxVelocity

struct Cubic)

A cubic interpolation

Will interpolate from from to to using cubic functions. Taken from easings.net

Traits implemented

impl<T: Mul<f32, Output = I>, I: Add<Output = T>> InterpolationFunction<(), T> for Cubic

struct Diagonal<I>(I)

Diagonal interpolator for a Position. Interpolates the direct (diagonal) connection between from and to.

Note that while it is possible to wrap any types here, only wrapped InterpolationFunctions will make this type be an InterpolationFunction.

Traits implemented

impl<A, I: DurationCalculable<A, f32>> DurationCalculable<A, Position> for Diagonal<I>

impl<A, I: InterpolationFunction<A, f32>> InterpolationFunction<A, Position> for Diagonal<I>

struct FixedArgument<A: Copy, I>

A wrapper around a Interpolation-Function that fixes the argument

Note that while it is possible to wrap any types here, only wrapped InterpolationFunctions will make this type be an InterpolationFunction and only wrapped DurationCalculables will make this type be an DurationCalculable.

argument: A

The fixed argument

interpolator: I

The interpolator

Traits implemented

impl<A: Copy, T, I: DurationCalculable<A, T>> DurationCalculable<(), T> for FixedArgument<A, I>

impl<A: Copy, T, I: InterpolationFunction<A, T>> InterpolationFunction<(), T> for FixedArgument<A, I>

struct Jerk(f32)

struct Linear)

Linear interpolation

Will interpolate linearly from from to to

Traits implemented

impl<T: Mul<f32, Output = I>, I: Add<Output = T>> InterpolationFunction<(), T> for Linear

struct MaxVelocity(f32)

struct Triangle)

Triangle interpolation

Will interpolate linearly from from to to in the first half and then back from to to from in the second half. This will always cycle back to the initial value.

Traits implemented

impl<T: Mul<f32, Output = I>, I: Add<Output = T>> InterpolationFunction<(), T> for Triangle