use crate::scale8::{scale8, scale16};
use crate::{Fract8, Fract16};
#[inline]
pub const fn ease8_in_out_quad(i: u8) -> u8 {
let mut j = i;
if j & 0x80 != 0 {
j = 255 - j;
}
let jj = scale8(j, Fract8(j));
let mut jj2 = jj << 1;
if i & 0x80 != 0 {
jj2 = 255 - jj2;
}
jj2
}
#[inline]
pub const fn ease16_in_out_quad(i: u16) -> u16 {
let mut j = i;
if j & 0x8000 != 0 {
j = 65535 - j;
}
let jj = scale16(j, Fract16(j));
let mut jj2 = jj << 1;
if i & 0x8000 != 0 {
jj2 = 65535 - jj2;
}
jj2
}
#[inline]
pub const fn ease8_in_out_cubic(i: u8) -> u8 {
let ii = scale8(i, Fract8(i));
let iii = scale8(ii, Fract8(i));
let r1 = (3 * ii as u16).wrapping_sub(2 * iii as u16);
if r1 & 0x100 != 0 { 255 } else { r1 as u8 }
}
#[inline]
pub const fn ease16_in_out_cubic(i: u16) -> u16 {
let ii = scale16(i, Fract16(i)) as u32;
let iii = scale16(ii as u16, Fract16(i)) as u32;
let r1 = (3 * ii).wrapping_sub(2 * iii);
if r1 > 65535 { 65535 } else { r1 as u16 }
}
#[inline]
pub const fn ease8_in_out_approx(i: u8) -> u8 {
if i < 64 {
i / 2
} else if i > 255 - 64 {
255 - ((255 - i) / 2)
} else {
let mut j = i - 64;
j += j / 2;
j + 32
}
}
#[inline]
pub const fn triwave8(i: u8) -> u8 {
let j = if i & 0x80 != 0 { 255 - i } else { i };
j << 1
}
#[inline]
pub const fn quadwave8(i: u8) -> u8 {
ease8_in_out_quad(triwave8(i))
}
#[inline]
pub const fn cubicwave8(i: u8) -> u8 {
ease8_in_out_cubic(triwave8(i))
}
#[inline]
pub const fn squarewave8(i: u8, pulse_width: u8) -> u8 {
if i < pulse_width || pulse_width == 255 {
255
} else {
0
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn ease8_in_out_quad_is_a_symmetric_s_curve() {
assert_eq!(ease8_in_out_quad(0), 0);
assert_eq!(ease8_in_out_quad(255), 255);
assert_eq!(ease8_in_out_quad(128), 129);
for i in 0..=127u8 {
assert_eq!(
ease8_in_out_quad(i),
255 - ease8_in_out_quad(255 - i),
"i={i}"
);
}
}
#[test]
fn ease16_in_out_quad_is_a_symmetric_s_curve() {
assert_eq!(ease16_in_out_quad(0), 0);
assert_eq!(ease16_in_out_quad(65535), 65535);
for i in (0..=32767u16).step_by(733) {
assert_eq!(
ease16_in_out_quad(i),
65535 - ease16_in_out_quad(65535 - i),
"i={i}"
);
}
}
#[test]
fn ease8_in_out_cubic_anchors_and_midpoint() {
assert_eq!(ease8_in_out_cubic(0), 0);
assert_eq!(ease8_in_out_cubic(255), 255);
assert_eq!(ease8_in_out_cubic(128), 128);
}
#[test]
fn ease16_in_out_cubic_anchors_and_midpoint() {
assert_eq!(ease16_in_out_cubic(0), 0);
assert_eq!(ease16_in_out_cubic(65535), 65535);
}
#[test]
fn ease8_in_out_approx_anchors_and_midpoint() {
assert_eq!(ease8_in_out_approx(0), 0);
assert_eq!(ease8_in_out_approx(255), 255);
assert_eq!(ease8_in_out_approx(128), 128);
for i in 0..=255u8 {
let exact = ease8_in_out_cubic(i) as i16;
let approx = ease8_in_out_approx(i) as i16;
assert!(
(exact - approx).abs() <= 8,
"i={i} exact={exact} approx={approx}"
);
}
}
#[test]
fn triwave8_ramps_up_then_down() {
assert_eq!(triwave8(0), 0);
assert_eq!(triwave8(64), 128);
assert_eq!(triwave8(127), 254);
assert_eq!(triwave8(128), 254);
assert_eq!(triwave8(192), 126);
assert_eq!(triwave8(255), 0);
}
#[test]
fn quad_and_cubic_waves_are_bounded_and_periodic() {
for i in 0..=255u8 {
let _ = quadwave8(i);
let _ = cubicwave8(i);
}
assert_eq!(quadwave8(0), quadwave8(255));
assert_eq!(cubicwave8(0), cubicwave8(255));
}
#[test]
fn squarewave8_switches_at_pulse_width() {
for i in 0..100u8 {
assert_eq!(squarewave8(i, 100), 255);
}
for i in 100..=255u8 {
assert_eq!(squarewave8(i, 100), 0);
}
for i in 0..=255u8 {
assert_eq!(squarewave8(i, 255), 255);
}
}
}