use crate::convert::lerp;
pub fn smoothstep(t: f32, s: f32) -> f32 {
s * if t > 1.0 {
1.0
} else {
3.0 * t * t - 2.0 * t * t * t
}
}
pub fn smoothstep_dt(t: f32, s: f32) -> f32 {
s * if t > 1.0 { 0.0 } else { 6.0 * t - 6.0 * t * t }
}
pub fn smoothstep_solve(t: &mut f32, s: &mut f32, x: f32, v: f32, overshoot: f32, eps: f32) {
if v.abs() < 1e-8 {
*t = 0.0;
*s = x;
return;
}
if x < 0.0 {
smoothstep_solve(t, s, -x, -v, 0.05, 1e-8);
*s = -*s;
return;
}
let rad = ((6.0 * x - v) * (6.0 * x - v) + 8.0 * v * v)
.max(eps)
.sqrt();
let t0 = (v - 6.0 * x + rad) / (4.0 * v);
let t1 = (v - 6.0 * x - rad) / (4.0 * v);
*t = if -0.5 > t1 && t1 > -(0.5 + overshoot) {
t1
} else {
t0
};
let vt = smoothstep_dt(*t, 1.0);
*s = if vt.abs() < eps { 0.0 } else { v / vt };
}
pub fn cubic(t: f32, v: f32, g: f32) -> f32 {
if t > 1.0 {
g
} else {
(3.0 * t * t - 2.0 * t * t * t) * g + (t * t * t - 2.0 * t * t + t) * v
}
}
pub fn cubic_dt(t: f32, v: f32, g: f32) -> f32 {
if t > 1.0 {
0.0
} else {
(6.0 * t - 6.0 * t * t) * g + (3.0 * t * t - 4.0 * t + 1.0) * v
}
}
pub fn piecewise_interpolation(x: &mut f32, v: &mut f32, t: f32, pnts: &[f32]) {
assert!(!pnts.is_empty());
let t = t.max(0.0) * (pnts.len() - 1) as f32;
let i0 = (t.floor() as usize).min(pnts.len() - 1);
let i1 = (i0 + 1).min(pnts.len() - 1);
*x = lerp(pnts[i0], pnts[i1], t % 1.0);
*v = (pnts[i0] - pnts[i1]) / pnts.len() as f32;
}