use rt::fx::sqrtd;
use simd::{Kernel, Simd};
pub const GT_LINEAR: u8 = 0;
pub const GT_LINEAR_REFLECTED: u8 = 1;
pub const GT_DIAMOND: u8 = 2;
pub const GT_RADIAL: u8 = 3;
pub const GT_CONICAL: u8 = 4;
pub const GT_SPIRAL_CW: u8 = 5;
pub const GT_SPIRAL_CCW: u8 = 6;
pub const GT_COUNT: u8 = 7;
pub const GR_NONE: u8 = 0;
pub const GR_WRAP: u8 = 1;
pub const GR_REFLECT: u8 = 2;
pub const GF_ALPHA_MODE: u16 = 1;
pub const GF_DITHER: u16 = 2;
pub const GT_ONE: i32 = 16384;
#[derive(Clone, Copy, Default)]
pub struct Grad {
pub typ: u8,
pub repeat: u8,
pub flags: u16,
pub col_a: u32,
pub col_b: u32,
pub sx: f64,
pub sy: f64,
pub ex: f64,
pub ey: f64,
}
const SIGN: u64 = 0x8000_0000_0000_0000;
const DBL_MIN: f64 = f64::from_bits(0x0010_0000_0000_0000);
const HPI: f64 = f64::from_bits(0x3FF9_21FB_5444_2D18);
const PI: f64 = f64::from_bits(0x4009_21FB_5444_2D18);
const IPI: f64 = f64::from_bits(0x3FD4_5F30_6DC9_C883);
const I2PI: f64 = f64::from_bits(0x3FC4_5F30_6DC9_C883);
const AT1: f64 = f64::from_bits(0x3FEF_FEE6_FB4C_3C19);
const AT3: f64 = f64::from_bits(0xBFD5_23A0_8398_A655);
const AT5: f64 = f64::from_bits(0x3FC7_0EDC_3BD5_9924);
const AT7: f64 = f64::from_bits(0xBFB5_CB46_BACF_7447);
const AT9: f64 = f64::from_bits(0x3F95_55CB_E46F_80C1);
const LO: f64 = -1073741824.0; const HI: f64 = 1073741824.0;
static BAYER: [u32; 16] = [512, 8704, 2560, 10752, 12800, 4608, 14848, 6656, 3584, 11776, 1536, 9728, 15872, 7680, 13824, 5632];
const CHUNK: usize = 64;
static I0123: [i32; 8] = [0, 1, 2, 3, 4, 5, 6, 7];
enum Out<'a> {
Color(&'a mut [u8]), AlphaMul(&'a mut [u8]), A8(&'a mut [u8]), T(&'a mut [i32]), }
struct GradK<'a> {
out: Out<'a>,
x: i32,
y: i32,
g: &'a Grad,
}
impl Kernel for GradK<'_> {
type Out = ();
#[inline(always)]
fn run<S: Simd>(self, s: S) {
span(s, self);
}
}
#[inline(always)]
fn vfrac<S: Simd>(s: S, v: S::V) -> S::V {
let v = s.mind(s.maxd(v, s.splatd(LO)), s.splatd(HI));
let t = s.cvt_i32_f64(s.cvtt_f64_i32(v));
let fl = s.subd(t, s.and(s.cmpltd(v, t), s.splatd(1.0)));
s.subd(v, fl)
}
#[inline(always)]
fn vatan2<S: Simd>(s: S, y: S::V, x: S::V) -> S::V {
let abs = s.splat64(!SIGN);
let ax = s.and(x, abs);
let ay = s.and(y, abs);
let mx = s.maxd(s.maxd(ax, ay), s.splatd(DBL_MIN));
let z = s.divd(s.mind(ax, ay), mx);
let lt = s.cmpltd(ax, ay); let q = s.muld(z, z);
let mut p = s.splatd(AT9);
for c in [AT7, AT5, AT3, AT1] {
p = s.addd(s.muld(p, q), s.splatd(c));
}
let p = s.muld(p, z);
let r = s.or(s.and(s.subd(s.splatd(HPI), p), lt), s.andnot(lt, p));
let xn = s.cmpltd(x, s.zero()); let r = s.or(s.and(s.subd(s.splatd(PI), r), xn), s.andnot(xn, r));
let yn = s.cmpltd(y, s.zero()); s.xor(r, s.and(yn, s.splat64(SIGN)))
}
#[inline(always)]
fn span<S: Simd>(s: S, k: GradK) {
let GradK { mut out, x, y, g } = k;
let n = match &out {
Out::Color(d) | Out::AlphaMul(d) => d.len() / 4,
Out::A8(d) => d.len(),
Out::T(d) => d.len(),
};
let typ = if g.typ >= GT_COUNT { GT_LINEAR } else { g.typ };
let dx = g.ex - g.sx;
let dy = g.ey - g.sy;
let l2 = dx * dx + dy * dy;
#[allow(clippy::eq_op)] let degenerate = !(l2 > 0.0) || (l2 - l2).is_nan();
let vy = (y as f64 + 0.5) - g.sy;
let (vdx, vdy, vsx) = (s.splatd(dx), s.splatd(dy), s.splatd(g.sx));
let (vydy, vydx, vyvy) = (s.splatd(vy * dy), s.splatd(vy * dx), s.splatd(vy * vy));
let (il2, il) = (s.splatd(1.0 / l2), s.splatd(1.0 / sqrtd(l2)));
let (half, one, absm) = (s.splatd(0.5), s.splatd(1.0), s.splat64(!SIGN));
let dl = S::BYTES / 8; let (aa, ba) = (g.col_a >> 24, g.col_b >> 24);
let mut tb = [0i32; CHUNK + 4];
let mut done = 0;
while done < n {
let m = (n - done).min(CHUNK);
let x0 = x.wrapping_add(done as i32);
if degenerate {
tb[..m].fill(GT_ONE);
} else {
let mut i = 0;
while i < m {
let xi = s.add32(s.splat32(x0.wrapping_add(i as i32) as u32), s.load_i32(&I0123));
let vx = s.subd(s.addd(s.cvt_i32_f64(xi), half), vsx);
let t = match typ {
GT_RADIAL => s.muld(s.sqrtd(s.addd(s.muld(vx, vx), vyvy)), il),
GT_CONICAL | GT_SPIRAL_CW | GT_SPIRAL_CCW => {
let dot = s.addd(s.muld(vx, vdx), vydy);
let cross = s.subd(vydx, s.muld(vx, vdy));
let rl = s.muld(s.sqrtd(s.addd(s.muld(vx, vx), vyvy)), il);
let a = vatan2(s, cross, dot);
if typ == GT_CONICAL {
s.muld(s.and(a, absm), s.splatd(IPI))
} else {
let mut sa = s.muld(a, s.splatd(I2PI));
if typ == GT_SPIRAL_CCW {
sa = s.xor(sa, s.splat64(SIGN));
}
vfrac(s, s.addd(sa, rl))
}
}
_ => {
let mut dot = s.addd(s.muld(vx, vdx), vydy);
if typ != GT_LINEAR {
dot = s.and(dot, absm);
}
if typ == GT_DIAMOND {
dot = s.addd(dot, s.and(s.subd(vydx, s.muld(vx, vdy)), absm));
}
s.muld(dot, il2)
}
};
let t = match g.repeat {
GR_WRAP => vfrac(s, t),
GR_REFLECT => {
let f = vfrac(s, s.muld(t, half));
let f = s.and(s.subd(s.addd(f, f), one), absm);
s.subd(one, f)
}
_ => s.mind(s.maxd(t, s.zero()), one),
};
let tv = s.cvtt_f64_i32(s.addd(s.muld(t, s.splatd(16384.0)), half));
s.store_i32_half(&mut tb[i..], tv);
i += dl;
}
}
match &mut out {
Out::Color(d) => {
let x2 = simd::Sse2; let z = x2.zero();
let ab = x2.unpacklo16(x2.unpacklo8(x2.from_i32(g.col_a as i32), z), x2.unpacklo8(x2.from_i32(g.col_b as i32), z));
for j in 0..m {
let t = tb[j];
let w = x2.splat32((t as u32) << 16 | (GT_ONE - t) as u32);
let b = x2.splat32(bias(g, x0.wrapping_add(j as i32), y));
let v = x2.sra32::<14>(x2.add32(x2.madd16(ab, w), b));
let px = x2.to_i32(x2.packus16(x2.packs32(v, v), z));
let o = (done + j) * 4;
d[o..o + 4].copy_from_slice(&px.to_le_bytes());
}
}
Out::AlphaMul(d) => {
for j in 0..m {
let t = tb[j] as u32;
let ramp = ((16384 - t) * aa + t * ba + bias(g, x0.wrapping_add(j as i32), y)) >> 14;
let o = (done + j) * 4 + 3;
d[o] = (((d[o] as u32 * ramp + 128) * 257) >> 16) as u8;
}
}
Out::A8(d) => {
for j in 0..m {
let t = tb[j] as u32;
d[done + j] = (((16384 - t) * aa + t * ba + bias(g, x0.wrapping_add(j as i32), y)) >> 14) as u8;
}
}
Out::T(d) => d[done..done + m].copy_from_slice(&tb[..m]),
}
done += m;
}
}
fn bias(g: &Grad, x: i32, y: i32) -> u32 {
if g.flags & GF_DITHER != 0 { BAYER[((y & 3) * 4 + (x & 3)) as usize] } else { 8192 }
}
pub fn grad_span(dst: &mut [u8], x: i32, y: i32, g: &Grad) {
let out = if g.flags & GF_ALPHA_MODE != 0 { Out::AlphaMul(dst) } else { Out::Color(dst) };
simd::dispatch(GradK { out, x, y, g });
}
pub fn grad_alpha_span(dst: &mut [u8], x: i32, y: i32, g: &Grad) {
simd::dispatch(GradK { out: Out::A8(dst), x, y, g });
}
pub fn grad_t_span(dst: &mut [i32], x: i32, y: i32, g: &Grad) {
simd::dispatch(GradK { out: Out::T(dst), x, y, g });
}