use crate::scale8::{scale8, scale16, scale16by8};
use crate::{Fract8, Fract16};
#[inline]
pub const fn lerp8by8(a: u8, b: u8, frac: Fract8) -> u8 {
if b > a {
let delta = b - a;
let scaled = scale8(delta, frac);
a + scaled
} else {
let delta = a - b;
let scaled = scale8(delta, frac);
a - scaled
}
}
#[inline]
pub const fn lerp16by16(a: u16, b: u16, frac: Fract16) -> u16 {
if b > a {
let delta = b - a;
let scaled = scale16(delta, frac);
a + scaled
} else {
let delta = a - b;
let scaled = scale16(delta, frac);
a - scaled
}
}
#[inline]
pub const fn lerp16by8(a: u16, b: u16, frac: Fract8) -> u16 {
if b > a {
let delta = b - a;
let scaled = scale16by8(delta, frac);
a + scaled
} else {
let delta = a - b;
let scaled = scale16by8(delta, frac);
a - scaled
}
}
#[inline]
pub const fn lerp15by8(a: i16, b: i16, frac: Fract8) -> i16 {
if b > a {
let delta = (b as i32 - a as i32) as u16;
let scaled = scale16by8(delta, frac);
(a as i32 + scaled as i32) as i16
} else {
let delta = (a as i32 - b as i32) as u16;
let scaled = scale16by8(delta, frac);
(a as i32 - scaled as i32) as i16
}
}
#[inline]
pub const fn lerp15by16(a: i16, b: i16, frac: Fract16) -> i16 {
if b > a {
let delta = (b as i32 - a as i32) as u16;
let scaled = scale16(delta, frac);
(a as i32 + scaled as i32) as i16
} else {
let delta = (a as i32 - b as i32) as u16;
let scaled = scale16(delta, frac);
(a as i32 - scaled as i32) as i16
}
}
#[inline]
pub const fn map8(input: u8, range_start: u8, range_end: u8) -> u8 {
let range_width = range_end.wrapping_sub(range_start);
let out = scale8(input, Fract8(range_width));
out.wrapping_add(range_start)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn lerp8by8_interpolates_between_endpoints() {
assert_eq!(lerp8by8(0, 255, Fract8(0)), 0);
assert_eq!(lerp8by8(0, 255, Fract8(255)), 255);
assert_eq!(lerp8by8(0, 255, Fract8(128)), 128);
assert_eq!(
lerp8by8(10, 200, Fract8(64)),
lerp8by8(200, 10, Fract8(255 - 64))
);
}
#[test]
fn lerp16by16_interpolates_between_endpoints() {
assert_eq!(lerp16by16(0, 65535, Fract16(0)), 0);
assert_eq!(lerp16by16(0, 65535, Fract16(65535)), 65535);
assert_eq!(lerp16by16(1000, 100, Fract16(65535)), 100);
}
#[test]
fn lerp16by8_interpolates_between_endpoints() {
assert_eq!(lerp16by8(0, 65535, Fract8(0)), 0);
assert_eq!(lerp16by8(0, 65535, Fract8(255)), 65535);
assert_eq!(lerp16by8(1000, 100, Fract8(255)), 100);
}
#[test]
fn lerp15by8_handles_signed_endpoints() {
assert_eq!(lerp15by8(-1000, 1000, Fract8(0)), -1000);
assert_eq!(lerp15by8(-1000, 1000, Fract8(255)), 1000);
assert_eq!(lerp15by8(1000, -1000, Fract8(255)), -1000);
assert_eq!(lerp15by8(-1000, 1000, Fract8(128)), 7);
}
#[test]
fn lerp15by16_handles_signed_endpoints() {
assert_eq!(lerp15by16(-1000, 1000, Fract16(0)), -1000);
assert_eq!(lerp15by16(-1000, 1000, Fract16(65535)), 1000);
assert_eq!(lerp15by16(1000, -1000, Fract16(65535)), -1000);
}
#[test]
fn map8_remaps_full_range_into_a_narrower_one() {
assert_eq!(map8(0, 100, 200), 100);
assert_eq!(map8(255, 100, 200), 200);
assert_eq!(map8(128, 0, 255), 128);
for input in 0..=255u8 {
let out = map8(input, 100, 200);
assert!((100..=200).contains(&out), "input={input} out={out}");
}
}
}