use alloc::vec::Vec;
use super::path::{zf, Path};
use super::raster::Raster;
use super::{Dc, Surface, CAP_BUTT, CAP_ROUND, CAP_SQUARE, JOIN_MITER, JOIN_ROUND};
use rt::fx::{maxss, minss, sqrt};
const EPS: f32 = 0.0001;
struct St<'a> {
hw: f32,
p: (f32, f32),
di: (f32, f32),
dout: (f32, f32),
cs: f32,
sn: f32,
join: u32,
cap: u32,
pts: &'a [(f32, f32)],
base: usize,
n: usize,
v: (f32, f32),
t: (f32, f32),
spts: Vec<(f32, f32)>,
}
impl St<'_> {
fn pt(&self, i: usize) -> (f32, f32) {
self.pts[self.base + i]
}
fn dir(&self, i: usize, j: usize) -> (f32, f32) {
let a = self.pt(i);
let b = self.pt(j);
let dx = b.0 - a.0;
let dy = b.1 - a.1;
let len = sqrt(dx * dx + dy * dy);
if zf(len, 0.0) {
return (1.0, 0.0);
}
(dx / len, dy / len)
}
fn add(&mut self, x: f32, y: f32) {
if let Some(&l) = self.spts.last() {
if zf(x, l.0) && zf(y, l.1) {
return;
}
}
self.spts.push((x, y));
}
fn emit_off(&mut self, sign: f32, d: (f32, f32)) {
let x = d.1 * self.hw * sign + self.p.0;
let y = (0.0 - d.0) * self.hw * sign + self.p.1;
self.add(x, y);
}
fn join(&mut self) {
let cross = self.di.0 * self.dout.1 - self.di.1 * self.dout.0;
let dot = self.di.0 * self.dout.0 + self.di.1 * self.dout.1;
if !(cross.abs() >= EPS) && dot >= 0.0 {
let d = self.dout;
self.emit_off(1.0, d); return;
}
if !(cross >= 0.0) {
let di = self.di;
self.emit_off(1.0, di);
let p = self.p;
self.add(p.0, p.1);
let d = self.dout;
self.emit_off(1.0, d);
return;
}
let di = self.di;
self.emit_off(1.0, di);
if self.join == JOIN_ROUND {
self.v = (self.di.1, 0.0 - self.di.0);
self.t = (self.dout.1, 0.0 - self.dout.0);
self.arc();
} else if self.join == JOIN_MITER {
let m = dot + 1.0;
if m >= 0.125 {
let nx = self.di.1 + self.dout.1;
let ny = 0.0 - (self.di.0 + self.dout.0);
let k = self.hw / m;
let p = self.p;
self.add(nx * k + p.0, ny * k + p.1);
}
}
let d = self.dout;
self.emit_off(1.0, d);
}
fn arc(&mut self) {
for _ in 0..64 {
let nx = self.v.0 * self.cs - self.v.1 * self.sn;
let ny = self.v.0 * self.sn + self.v.1 * self.cs;
if !(nx * self.t.1 - ny * self.t.0 >= EPS) {
return;
}
self.v = (nx, ny);
let p = self.p;
self.add(nx * self.hw + p.0, ny * self.hw + p.1);
}
}
fn cap(&mut self, d: (f32, f32)) {
let (dx, dy) = d;
if self.cap == CAP_SQUARE {
let p = self.p;
self.add((dy + dx) * self.hw + p.0, (dy - dx) * self.hw + p.1);
self.add((dx - dy) * self.hw + p.0, (dy + dx) * self.hw + p.1);
} else if self.cap == CAP_ROUND {
self.v = (dy, 0.0 - dx);
self.t = (dx, dy);
self.arc();
let p = self.p;
self.add(dx * self.hw + p.0, dy * self.hw + p.1);
self.v = (dx, dy);
self.t = (0.0 - dy, dx);
self.arc();
}
self.emit_off(-1.0, d);
}
fn flush(&mut self, ras: &mut Raster) {
let n = self.spts.len();
if n >= 2 {
for i in 0..n {
let a = self.spts[i];
let b = self.spts[if i + 1 < n { i + 1 } else { 0 }];
ras.emit_line(a.0, a.1, b.0, b.1);
}
}
self.spts.clear();
}
fn open(&mut self, ras: &mut Raster) {
self.spts.clear();
let last = self.n - 1;
let d0 = self.dir(0, 1);
self.p = self.pt(0);
self.emit_off(1.0, d0);
for i in 1..last {
self.di = self.dir(i - 1, i);
self.dout = self.dir(i, i + 1);
self.p = self.pt(i);
self.join();
}
let dl = self.dir(last - 1, last);
self.p = self.pt(last);
self.emit_off(1.0, dl);
self.cap(dl);
let mut i = last as isize - 1;
while i >= 1 {
let k = i as usize;
self.di = self.dir(k + 1, k);
self.dout = self.dir(k, k - 1);
self.p = self.pt(k);
self.join();
i -= 1;
}
self.p = self.pt(0);
let back = (0.0 - d0.0, 0.0 - d0.1);
self.emit_off(1.0, back);
self.cap(back);
self.flush(ras);
}
fn closed(&mut self, ras: &mut Raster) {
let n = self.n;
if n < 2 {
return;
}
self.spts.clear();
for i in 0..n {
self.di = self.dir((i + n - 1) % n, i);
self.dout = self.dir(i, (i + 1) % n);
self.p = self.pt(i);
self.join();
}
self.flush(ras);
self.spts.clear();
for i in (0..n).rev() {
self.di = self.dir((i + 1) % n, i);
self.dout = self.dir(i, (i + n - 1) % n);
self.p = self.pt(i);
self.join();
}
self.flush(ras);
}
fn dot(&mut self, ras: &mut Raster) {
self.p = self.pt(0);
if self.cap == CAP_BUTT {
return;
}
self.spts.clear();
self.emit_off(1.0, (1.0, 0.0));
self.cap((1.0, 0.0));
self.cap((-1.0, 0.0));
self.flush(ras);
}
}
impl Path {
pub fn stroke_lines(&self, ras: &mut Raster, width: i32, style: u32) {
let hw = maxss(width as f32 * 0.001953125, 0.25); let mut s = sqrt(0.4 / hw);
s = s + s;
let s = minss(s, 0.5);
let s2 = s * s;
let cs = (s2 * 0.041666668 - 0.5) * s2 + 1.0;
let sn = ((s2 * 0.008333334 - 0.16666667) * s2 + 1.0) * s;
let mut st = St {
hw,
p: (0.0, 0.0),
di: (0.0, 0.0),
dout: (0.0, 0.0),
cs,
sn,
join: style & 15,
cap: (style >> 4) & 15,
pts: &self.pts,
base: 0,
n: 0,
v: (0.0, 0.0),
t: (0.0, 0.0),
spts: Vec::new(),
};
ras.lines_begin();
for sub in &self.subs {
let mut n = sub.count;
if n == 0 {
continue;
}
st.base = sub.start;
if n >= 2 && sub.closed {
let a = self.pts[sub.start];
let b = self.pts[sub.start + n - 1];
if zf(a.0, b.0) && zf(a.1, b.1) {
n -= 1;
}
}
st.n = n;
if n == 1 {
st.dot(ras);
} else if sub.closed {
st.closed(ras);
} else {
st.open(ras);
}
}
}
pub fn stroke(&self, ras: &mut Raster, dc: &Dc, sf: &mut Surface, width: i32, style: u32) {
self.stroke_lines(ras, width, style);
ras.fill(dc, sf, 0);
}
}