mirror of
https://github.com/Ed94/Odin.git
synced 2026-08-06 23:58:50 +00:00
Add ease inverse procedures
This commit is contained in:
thetarnav
@@ -0,0 +1,248 @@
|
||||
// Inverse easing procedures
|
||||
// These are the mathematical inverses of the corresponding easing functions,
|
||||
// allowing you to reverse the transformation:
|
||||
// if y = ease_fn(x), then x = ease_fn_inverse(y) + some_imprecision
|
||||
package ease
|
||||
|
||||
@require import "core:math"
|
||||
import "base:intrinsics"
|
||||
|
||||
// Helper for handling negative bases with fractional exponents
|
||||
// since math.pow(negative, fraction) returns NaN
|
||||
@(private="file")
|
||||
_signed_pow :: proc "contextless" (x, exp: $T) -> T where intrinsics.type_is_float(T) {
|
||||
if x >= 0 {
|
||||
return math.pow(x, exp)
|
||||
} else {
|
||||
return -math.pow(-x, exp)
|
||||
}
|
||||
}
|
||||
|
||||
// Inverse of quadratic_in
|
||||
// x = sqrt(y)
|
||||
@(require_results)
|
||||
quadratic_in_inverse :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) {
|
||||
return math.sqrt(p)
|
||||
}
|
||||
|
||||
// Inverse of quadratic_out
|
||||
// x = 1 - sqrt(1 - y)
|
||||
@(require_results)
|
||||
quadratic_out_inverse :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) {
|
||||
return 1 - math.sqrt(1 - p)
|
||||
}
|
||||
|
||||
// Inverse of quadratic_in_out
|
||||
// x = sqrt(y/2) ; [0, 0.5)
|
||||
// x = 1 - sqrt((1-y)/2) ; [0.5, 1]
|
||||
@(require_results)
|
||||
quadratic_in_out_inverse :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) {
|
||||
if p < 0.5 {
|
||||
return math.sqrt(p / 2)
|
||||
} else {
|
||||
return 1 - math.sqrt((1 - p) / 2)
|
||||
}
|
||||
}
|
||||
|
||||
// Inverse of cubic_in
|
||||
// x = y^(1/3)
|
||||
@(require_results)
|
||||
cubic_in_inverse :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) {
|
||||
return math.pow(p, 1.0/3.0)
|
||||
}
|
||||
|
||||
// Inverse of cubic_out
|
||||
// x = (y - 1)^(1/3) + 1
|
||||
@(require_results)
|
||||
cubic_out_inverse :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) {
|
||||
return _signed_pow(p - 1, 1.0/3.0) + 1
|
||||
}
|
||||
|
||||
// Inverse of cubic_in_out
|
||||
// x = (y/4)^(1/3) ; [0, 0.5)
|
||||
// x = ((y-1)*2)^(1/3)/2 + 1 ; [0.5, 1]
|
||||
@(require_results)
|
||||
cubic_in_out_inverse :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) {
|
||||
if p < 0.5 {
|
||||
return math.pow(p / 4, 1.0/3.0)
|
||||
} else {
|
||||
return _signed_pow((p - 1) * 2, 1.0/3.0) / 2 + 1
|
||||
}
|
||||
}
|
||||
|
||||
// Inverse of quartic_in
|
||||
// x = y^(1/4)
|
||||
@(require_results)
|
||||
quartic_in_inverse :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) {
|
||||
return math.pow(p, 0.25)
|
||||
}
|
||||
|
||||
// Inverse of quartic_out
|
||||
// x = 1 - (1 - y)^(1/4)
|
||||
@(require_results)
|
||||
quartic_out_inverse :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) {
|
||||
return 1 - math.pow(1 - p, 0.25)
|
||||
}
|
||||
|
||||
// Inverse of quartic_in_out
|
||||
// x = (y/8)^(1/4) ; [0, 0.5)
|
||||
// x = 1 - ((1-y)/8)^(1/4) ; [0.5, 1]
|
||||
@(require_results)
|
||||
quartic_in_out_inverse :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) {
|
||||
if p < 0.5 {
|
||||
return math.pow(p / 8, 0.25)
|
||||
} else {
|
||||
return 1 - math.pow((1 - p) / 8, 0.25)
|
||||
}
|
||||
}
|
||||
|
||||
// Inverse of quintic_in
|
||||
// x = y^(1/5)
|
||||
@(require_results)
|
||||
quintic_in_inverse :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) {
|
||||
return math.pow(p, 0.2)
|
||||
}
|
||||
|
||||
// Inverse of quintic_out
|
||||
// x = (y - 1)^(1/5) + 1
|
||||
@(require_results)
|
||||
quintic_out_inverse :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) {
|
||||
return _signed_pow(p - 1, 0.2) + 1
|
||||
}
|
||||
|
||||
// Inverse of quintic_in_out
|
||||
// x = (y/16)^(1/5) ; [0, 0.5)
|
||||
// x = ((y-1)*2)^(1/5)/2 + 1 ; [0.5, 1]
|
||||
@(require_results)
|
||||
quintic_in_out_inverse :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) {
|
||||
if p < 0.5 {
|
||||
return math.pow(p / 16, 0.2)
|
||||
} else {
|
||||
return _signed_pow((p - 1) * 2, 0.2) / 2 + 1
|
||||
}
|
||||
}
|
||||
|
||||
// Inverse of sine_in
|
||||
// x = asin(y - 1) * 2/π + 1
|
||||
@(require_results)
|
||||
sine_in_inverse :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) {
|
||||
return math.asin(p - 1) * 2/math.PI + 1
|
||||
}
|
||||
|
||||
// Inverse of sine_out
|
||||
// x = asin(y) * 2/π
|
||||
@(require_results)
|
||||
sine_out_inverse :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) {
|
||||
return math.asin(p) * 2/math.PI
|
||||
}
|
||||
|
||||
// Inverse of sine_in_out
|
||||
// x = acos(1 - 2y) / π
|
||||
@(require_results)
|
||||
sine_in_out_inverse :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) {
|
||||
return math.acos(1 - 2*p) / math.PI
|
||||
}
|
||||
|
||||
// Inverse of circular_in
|
||||
// x = sqrt(2y - y²)
|
||||
@(require_results)
|
||||
circular_in_inverse :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) {
|
||||
return math.sqrt(2*p - p*p)
|
||||
}
|
||||
|
||||
// Inverse of circular_out
|
||||
// x = 1 - sqrt(1 - y²)
|
||||
@(require_results)
|
||||
circular_out_inverse :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) {
|
||||
return 1 - math.sqrt(1 - p*p)
|
||||
}
|
||||
|
||||
// Inverse of circular_in_out
|
||||
// x = sqrt(1 - (1-2y)²) / 2 ; [0, 0.5)
|
||||
// x = 1 - sqrt(1 - (2y-1)²) / 2 ; [0.5, 1]
|
||||
@(require_results)
|
||||
circular_in_out_inverse :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) {
|
||||
if p < 0.5 {
|
||||
q := 1 - 2*p
|
||||
return math.sqrt(1 - q*q) / 2
|
||||
} else {
|
||||
q := 2*p - 1
|
||||
return 1 - math.sqrt(1 - q*q) / 2
|
||||
}
|
||||
}
|
||||
|
||||
// Inverse of exponential_in
|
||||
// x = log₂(y) / 10 + 1
|
||||
@(require_results)
|
||||
exponential_in_inverse :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) {
|
||||
return p == 0.0 ? 0.0 : math.log2(p) / 10 + 1
|
||||
}
|
||||
|
||||
// Inverse of exponential_out
|
||||
// x = -log₂(1 - y) / 10
|
||||
@(require_results)
|
||||
exponential_out_inverse :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) {
|
||||
return p == 1.0 ? 1.0 : -math.log2(1 - p) / 10
|
||||
}
|
||||
|
||||
// Inverse of exponential_in_out
|
||||
// x = (log₂(2y) + 10) / 20 ; [0, 0.5)
|
||||
// x = (10 - log₂(2(1-y))) / 20 ; [0.5, 1]
|
||||
@(require_results)
|
||||
exponential_in_out_inverse :: proc "contextless" (p: $T) -> T where intrinsics.type_is_float(T) {
|
||||
if p == 0.0 || p == 1.0 {
|
||||
return p
|
||||
}
|
||||
|
||||
if p < 0.5 {
|
||||
return (math.log2(2*p) + 10) / 20
|
||||
} else {
|
||||
return (10 - math.log2(2*(1-p))) / 20
|
||||
}
|
||||
}
|
||||
|
||||
// Additional enum variant
|
||||
|
||||
@(require_results)
|
||||
ease_inverse :: proc "contextless" (type: Ease, p: $T) -> T where intrinsics.type_is_float(T) {
|
||||
switch type {
|
||||
case .Linear: return p
|
||||
|
||||
case .Quadratic_In: return quadratic_in_inverse(p)
|
||||
case .Quadratic_Out: return quadratic_out_inverse(p)
|
||||
case .Quadratic_In_Out: return quadratic_in_out_inverse(p)
|
||||
|
||||
case .Cubic_In: return cubic_in_inverse(p)
|
||||
case .Cubic_Out: return cubic_out_inverse(p)
|
||||
case .Cubic_In_Out: return cubic_in_out_inverse(p)
|
||||
|
||||
case .Quartic_In: return quartic_in_inverse(p)
|
||||
case .Quartic_Out: return quartic_out_inverse(p)
|
||||
case .Quartic_In_Out: return quartic_in_out_inverse(p)
|
||||
|
||||
case .Quintic_In: return quintic_in_inverse(p)
|
||||
case .Quintic_Out: return quintic_out_inverse(p)
|
||||
case .Quintic_In_Out: return quintic_in_out_inverse(p)
|
||||
|
||||
case .Sine_In: return sine_in_inverse(p)
|
||||
case .Sine_Out: return sine_out_inverse(p)
|
||||
case .Sine_In_Out: return sine_in_out_inverse(p)
|
||||
|
||||
case .Circular_In: return circular_in_inverse(p)
|
||||
case .Circular_Out: return circular_out_inverse(p)
|
||||
case .Circular_In_Out: return circular_in_out_inverse(p)
|
||||
|
||||
case .Exponential_In: return exponential_in_inverse(p)
|
||||
case .Exponential_Out: return exponential_out_inverse(p)
|
||||
case .Exponential_In_Out: return exponential_in_out_inverse(p)
|
||||
|
||||
case .Elastic_In, .Elastic_Out, .Elastic_In_Out,
|
||||
.Back_In, .Back_Out, .Back_In_Out,
|
||||
.Bounce_In, .Bounce_Out, .Bounce_In_Out:
|
||||
// These do not have simple closed-form inverses
|
||||
return 0
|
||||
}
|
||||
|
||||
// In case type was invalid
|
||||
return 0
|
||||
}
|
||||
Reference in New Issue
Block a user