[orx-easing] Fix easeInOutQuintic, tweak demo (#233)

orx-easing/README.md

@@ -4,37 +4,99 @@ Provides easing functions for smooth animation or non-linear interpolation.
 
 Similar to those on https://easings.net
 
- - `easeLinear`
- - `easeBackIn`, `easeBackInOut`, `easeBackOut`
- - `easeBounceIn`, `easeBounceInOut`, `easeBounceOut`
- - `easeCircIn`, `easeCircInOut`, `easeCircOut`
- - `easeCubicIn`, `easeCubicInOut` `easeCubicOut`
- - `easeElasticIn`, `easeElasticInOut`, `easeElasticOut`
- - `easeExpoIn`, `easeExpoInOut`, `easeExpoOut`
- - `easeQuadIn`, `easeQuadInOut`, `easeQuadOut`
- - `easeQuartIn`, `easeQuartInOut`, `easeQuartOut`
- - `easeQuintIn`, `easeQuintInOut`, `easeQuintOut`
- - `easeSineIn`, `easeSineInOut`, `easeSineOut`
+| type       |              |
+|:-----------|:-------------|
+| linear     | `easeLinear` |
+| constant 0 | `easeZero`   |
+| constant 1 | `easeOne`    |
 
-## usage
+| type    |              in |             in out |              out |
+|---------|----------------:|-------------------:|-----------------:|
+| quad    |    `easeQuadIn` |    `easeQuadInOut` |    `easeQuadOut` |
+| cubic   |   `easeCubicIn` |   `easeCubicInOut` |   `easeCubicOut` |
+| quart   |   `easeQuartIn` |   `easeQuartInOut` |   `easeQuartOut` |
+| quint   |   `easeQuintIn` |   `easeQuintInOut` |   `easeQuintOut` |
+| circ    |    `easeCircIn` |    `easeCircInOut` |    `easeCircOut` |
+| expo    |    `easeExpoIn` |    `easeExpoInOut` |    `easeExpoOut` |
+| sine    |    `easeSineIn` |    `easeSineInOut` |    `easeSineOut` |
+| back    |    `easeBackIn` |    `easeBackInOut` |    `easeBackOut` |
+| bounce  |  `easeBounceIn` |  `easeBounceInOut` |  `easeBounceOut` |
+| elastic | `easeElasticIn` | `easeElasticInOut` | `easeElasticOut` |
 
-`fun easeX(time: Double, bias: Double = 0.0, scale: Double = 1.0, duration : Double = 1.0)`
+## Usage
 
-```kotlin
-// -- when t is in [0, 1]
-val et = easeQuadIn(t)
-val et = easeQuadIn(t, 0.0, 1.0, 10.0)
+```
+fun easeX(
+  t: Double,       // current time
+  b: Double = 0.0, // beginning (output value when t is 0.0)
+  c: Double = 1.0, // change (output delta)
+  d: Double = 1.0  // duration = end time
+)
 ```
 
-Using the `Easing` enumeration
+The most common usage involves repeatedly calling the easing function increasing
+the `t` argument while keeping other arguments unchanged.  When `t` increases from 0.0 up to `d`, the returned value slides from `b` to `b + c`.
+
+### Example
+
+For accelerating from 40.0 down to 10.0 in 10 steps:
+
+```kotlin
+repeat(10) {
+    val y = easeQuadIn(it.toDouble(), 40.0, -30.0, 9.0)
+    println("$it -> $y")
+}
+```
+
+Outputs
+
+```
+0 -> 40.0
+1 -> 39.629629629629626
+2 -> 38.51851851851852
+3 -> 36.666666666666664
+4 -> 34.074074074074076
+5 -> 30.74074074074074
+6 -> 26.666666666666668
+7 -> 21.85185185185185
+8 -> 16.2962962962963
+9 -> 10.0
+```
+
+Note how most result values are closer to 40.0 than to 10.0, due to the usage of
+an `In` easing function. `easeCubicIn`, `easeQuartIn` and `easeQuinticIn` functions would make this even more obvious.
+
+### Default arguments
+
+When `t` is in `[0, 1]` we can omit most arguments
+
+```kotlin
+val e0 = easeQuadIn(t, 0.0, 1.0, 1.0)
+val e1 = easeQuadIn(t)
+```
+
+### Using the `Easing` enumeration
+
+The `Easing` enum contains all easing functions.
 
 ```kotlin
 val et = Easing.QuadIn.function(t, 0.0, 1.0, 1.0)
+
+// list all easing function names
+Easing.values().forEach { easing ->
+    println(easing.name)
+}
+
+// find out how many easing functions are available
+println(Easing.values().size)
 ```
 
 <!-- __demos__ -->
+
 ## Demos
+
 ### DemoEasings01
+
 [source code](src/demo/kotlin/DemoEasings01.kt)
 
 ![DemoEasings01Kt](https://raw.githubusercontent.com/openrndr/orx/media/orx-easing/images/DemoEasings01Kt.png)