add curve utilities to create curves interpolating/easing between two values

[RobWalt]

Objective

Citing @mweatherley

There is a lot of shortfall for simple cases— e.g., we should have library functions for making a curve connecting two points, eased versions of that, and so on.

Solution

This PR implements

• a simple Easing trait which is implemented for all impl Curve<f32> types. We can't really guarantee that these curves have unit interval domain, which some people would probably expect, but it is documented that this isn't the case for these types and we redirect to EasingCurve which is used for that purpose
• an EasingCurve struct, which is used to interpolate between two values start and end using a impl Easing curve where the curve will be guaranteed to be reparametrized
• a LinearCurve which linearly interpolates between two values start and end
• a CubicBezierCurve which interpolates between start and end values using a CubicSegment
• a StepCurve which interpolates between start and end with an step-function with n steps
• an ElasticCurve which interpolates between start and end with spring like behavior where the elasticity of the spring is configurable
• some FunctionCurve easing curves for different popular functions including: quadratic_ease_in, quadratic_ease_out, smoothstep, identity

Testing

• there are a few new tests for all of these in the main module

[IQuick143]

Sorry if the comments seem mean! I appreciate the PR even though I nitpicked it a lot.
I'm not necessarily saying stuff should be changed, but I think these suggestions are worth giving a ponder.

[NthTensor]

Hey, first off thanks! You're one of the first people I've seen to start doing stuff with curves, and I think you're doing great. Really appreciate it.

In the discord, @mweatherley suggested that we might want something more like the following

fn eased_curve_between<T>(start: T, end: T, easing: impl Curve<f32>) -> impl Curve<T>
where
    T: VectorSpace 
{
    let span = end - start;
    easing.map(|x| (x * span) + start)
}

Then we define a set of concrete easing curves (like these) which pass through (0, 0) and (1, 1).

We could even define a marker trait which has this invariant in it's docs as a contract.

trait EasingCurve: Curve<f32> {};

However, I don't see anything wrong with the current implementation and I do think it's in a merge-able state pretty much. So if you'd prefer, we can marge and refactor the api as follow-up.

[RobWalt]

Hey, first off thanks! You're one of the first people I've seen to start doing stuff with curves, and I think you're doing great. Really appreciate it.

In the discord, @mweatherley suggested that we might want something more like the following

fn eased_curve_between<T>(start: T, end: T, easing: impl Curve<f32>) -> impl Curve<T>
where
    T: VectorSpace 
{
    let span = end - start;
    easing.map(|x| (x * span) + start)
}

Then we define a set of concrete easing curves (like these) which pass through (0, 0) and (1, 1).

We could even define a marker trait which has this invariant in it's docs as a contract.

trait EasingCurve: Curve<f32> {};

However, I don't see anything wrong with the current implementation and I do think it's in a merge-able state pretty much. So if you'd prefer, we can marge and refactor the api as follow-up.

Thanks for the review comment. That makes sense! Nevertheless I think that #14788 (comment) is also pretty valid. So I'd rather create a new struct EasingCurve which handles this without the impl Curve<Foo> part. I'll go back to the implementing board! 👷🏼

[NthTensor]

LGTM

[alice-i-cecile]

Simple and lovely. @RobWalt when you have a chance, I'd appreciate merge conflict resolution here :)

[alice-i-cecile]

This will be merged before the 0.15 release candidate, but I'll give you a bit of time to clean up those nits if you have the chance.