use lib8tion::{Fract8, blend8_8bit_full_range, scale8};
use crate::fill::GradientDirection;
use crate::hsv::Chsv;
use crate::rgb::Crgb;
pub fn nblend(existing: &mut Crgb, overlay: Crgb, amount_of_overlay: u8) {
if amount_of_overlay == 0 {
return;
}
if amount_of_overlay == 255 {
*existing = overlay;
return;
}
existing.r = blend8_8bit_full_range(existing.r, overlay.r, amount_of_overlay);
existing.g = blend8_8bit_full_range(existing.g, overlay.g, amount_of_overlay);
existing.b = blend8_8bit_full_range(existing.b, overlay.b, amount_of_overlay);
}
pub fn blend(p1: Crgb, p2: Crgb, amount_of_p2: u8) -> Crgb {
let mut nu = p1;
nblend(&mut nu, p2, amount_of_p2);
nu
}
pub fn nblend_slice(existing: &mut [Crgb], overlay: &[Crgb], amount_of_overlay: u8) {
for (e, o) in existing.iter_mut().zip(overlay.iter()) {
nblend(e, *o, amount_of_overlay);
}
}
pub fn blend_slice(src1: &[Crgb], src2: &[Crgb], dest: &mut [Crgb], amount_of_src2: u8) {
for ((d, a), b) in dest.iter_mut().zip(src1.iter()).zip(src2.iter()) {
*d = blend(*a, *b, amount_of_src2);
}
}
pub fn nblend_hsv(
existing: &mut Chsv,
overlay: Chsv,
amount_of_overlay: u8,
direction: GradientDirection,
) {
if amount_of_overlay == 0 {
return;
}
if amount_of_overlay == 255 {
*existing = overlay;
return;
}
let amount_of_keep = 255 - amount_of_overlay;
let mut huedelta8 = overlay.hue.wrapping_sub(existing.hue);
let direction = match direction {
GradientDirection::Shortest => {
if huedelta8 > 127 {
GradientDirection::Backward
} else {
GradientDirection::Forward
}
}
GradientDirection::Longest => {
if huedelta8 < 128 {
GradientDirection::Backward
} else {
GradientDirection::Forward
}
}
other => other,
};
if direction == GradientDirection::Forward {
existing.hue = existing
.hue
.wrapping_add(scale8(huedelta8, Fract8(amount_of_overlay)));
} else {
huedelta8 = huedelta8.wrapping_neg();
existing.hue = existing
.hue
.wrapping_sub(scale8(huedelta8, Fract8(amount_of_overlay)));
}
existing.sat = scale8(existing.sat, Fract8(amount_of_keep))
.wrapping_add(scale8(overlay.sat, Fract8(amount_of_overlay)));
existing.val = scale8(existing.val, Fract8(amount_of_keep))
.wrapping_add(scale8(overlay.val, Fract8(amount_of_overlay)));
}
pub fn blend_hsv(p1: Chsv, p2: Chsv, amount_of_p2: u8, direction: GradientDirection) -> Chsv {
let mut nu = p1;
nblend_hsv(&mut nu, p2, amount_of_p2, direction);
nu
}
pub fn nblend_hsv_slice(
existing: &mut [Chsv],
overlay: &[Chsv],
amount_of_overlay: u8,
direction: GradientDirection,
) {
for (e, o) in existing.iter_mut().zip(overlay.iter()) {
nblend_hsv(e, *o, amount_of_overlay, direction);
}
}
pub fn blend_hsv_slice(
src1: &[Chsv],
src2: &[Chsv],
dest: &mut [Chsv],
amount_of_src2: u8,
direction: GradientDirection,
) {
for ((d, a), b) in dest.iter_mut().zip(src1.iter()).zip(src2.iter()) {
*d = blend_hsv(*a, *b, amount_of_src2, direction);
}
}