#![allow(
clippy::many_single_char_names,
clippy::similar_names,
clippy::float_cmp
)]
use std::sync::Arc;
use unityrs_core::limits::{Meter, MeteredVec};
use unityrs_meshdecode::{Component, Processed, Triangles, VertexArray};
use super::affine::{Map, solve};
use super::canvas::{
self, Canvas, Sheet, bpp, c_int, c_int_of, c_trunc, crop_size, py_round, width_cap,
};
use super::exact::Int;
use super::raster::{self, Mask};
use super::{PackingMode, Rotation, Settings, SpriteData, SpriteError, contained};
use crate::decode::Image;
use crate::format::Mode;
use unityrs_meshdecode::MeshError;
#[derive(Clone, Copy, Debug)]
enum Num {
F(f64),
I(i128),
}
impl Num {
fn of(c: Component) -> Self {
match c {
Component::Int(i) => Self::I(i128::from(i)),
other => Self::F(other.as_f64()),
}
}
fn lt(self, b: Self) -> bool {
match (self, b) {
(Self::F(a), Self::F(b)) => a < b,
(Self::I(a), Self::I(b)) => a < b,
#[allow(clippy::cast_precision_loss)]
(Self::I(a), Self::F(b)) => (a as f64) < b,
#[allow(clippy::cast_precision_loss)]
(Self::F(a), Self::I(b)) => a < b as f64,
}
}
fn eq(self, b: Self) -> bool {
!self.lt(b) && !b.lt(self) && !self.is_nan() && !b.is_nan()
}
fn is_nan(self) -> bool {
matches!(self, Self::F(f) if f.is_nan())
}
#[allow(clippy::cast_precision_loss)]
fn sub_mul(self, b: Self, f: f64) -> f64 {
match (self, b) {
(Self::I(a), Self::I(b)) => (a - b) as f64 * f,
(Self::F(a), Self::F(b)) => (a - b) * f,
(Self::I(a), Self::F(b)) => (a as f64 - b) * f,
(Self::F(a), Self::I(b)) => (a - b as f64) * f,
}
}
}
fn extreme(values: impl Iterator<Item = Num>, want_max: bool) -> Option<Num> {
let mut best: Option<Num> = None;
for v in values {
best = Some(match best {
None => v,
Some(b) if (want_max && b.lt(v)) || (!want_max && v.lt(b)) => v,
Some(b) => b,
});
}
best
}
fn comp(a: &VertexArray, t: usize, c: usize) -> Num {
a.component(t, c).map_or(Num::F(0.0), Num::of)
}
fn unpack(a: &VertexArray, expected: usize) -> Result<(), SpriteError> {
let d = a.dimension();
if d == expected {
Ok(())
} else {
Err(SpriteError::Unpack {
expected,
got: (d < expected).then_some(d),
})
}
}
pub(super) fn render<'p>(
sheet: &Sheet<'_>,
data: &SpriteData,
mesh: impl FnOnce() -> Result<Processed<'p>, MeshError>,
meter: &Arc<Meter>,
) -> Result<Image, SpriteError> {
let crop_box = canvas::crop_box(data.texture_rect)?;
let (crop_w, crop_h) = crop_size(crop_box);
width_cap(crop_w)?;
let settings = Settings::parse(data.settings_raw)?;
if settings.packed && settings.packing_rotation == Rotation::Rotate90 {
width_cap(crop_h)?;
}
let mut out = if settings.packing_mode == PackingMode::Tight {
let processed = mesh()?;
if uv_truthy(processed.uv(0), meter)? {
mesh_render(sheet, &processed, data.pixels_to_units, meter)?
} else {
let crop = cropped(sheet, crop_box, settings, meter)?;
mask(&crop, &processed, data.pixels_to_units, meter)?
}
} else {
cropped(sheet, crop_box, settings, meter)?
};
out.flip_top_bottom(meter)?;
Ok(out.into_image())
}
fn uv_truthy(uv: Option<&VertexArray>, meter: &Arc<Meter>) -> Result<bool, SpriteError> {
let Some(uv) = uv.filter(|u| !u.is_empty()) else {
return Ok(false);
};
unpack(uv, 2)?;
meter.count_decode(uv.len() as u64)?;
for t in 0..uv.len() {
let truthy = |c| uv.component(t, c).is_some_and(Component::is_truthy);
if truthy(0) || truthy(1) {
return Ok(true);
}
}
Ok(false)
}
fn cropped(
sheet: &Sheet<'_>,
crop_box: [i32; 4],
settings: Settings,
meter: &Arc<Meter>,
) -> Result<Canvas, SpriteError> {
let mut crop = canvas::crop(sheet, crop_box, meter)?;
if settings.packed {
match settings.packing_rotation {
Rotation::None => {}
Rotation::FlipHorizontal => crop.flip_left_right(meter)?,
Rotation::FlipVertical => crop.flip_top_bottom(meter)?,
Rotation::Rotate180 => crop.rotate_180(meter)?,
Rotation::Rotate90 => crop = crop.rotate_270(meter)?,
}
}
Ok(crop)
}
fn collect<T>(
n: usize,
meter: &Arc<Meter>,
mut f: impl FnMut(usize) -> Result<T, SpriteError>,
) -> Result<MeteredVec<T>, SpriteError> {
meter.count_decode(n as u64)?;
let mut v = MeteredVec::with_capacity(meter, n)?;
for i in 0..n {
let item = f(i)?;
v.push(item)?;
}
Ok(v)
}
fn mask(
crop: &Canvas,
mesh: &Processed<'_>,
ppu: f64,
meter: &Arc<Meter>,
) -> Result<Canvas, SpriteError> {
mask_parts(
crop,
mesh.vertices(),
|| mesh.get_triangles(meter),
ppu,
meter,
)
}
pub(super) fn mask_parts(
crop: &Canvas,
positions: Option<&VertexArray>,
triangles: impl FnOnce() -> Result<Triangles, MeshError>,
ppu: f64,
meter: &Arc<Meter>,
) -> Result<Canvas, SpriteError> {
let positions = positions
.filter(|p| !p.is_empty())
.ok_or(SpriteError::NoVertices)?;
unpack(positions, 3)?;
let n = positions.len();
meter.count_decode(2 * n as u64)?;
let min_of = |c| extreme((0..n).map(|t| comp(positions, t, c)), false).unwrap_or(Num::F(0.0));
let (min_x, min_y) = (min_of(0), min_of(1));
let points = collect(n, meter, |t| {
Ok((
comp(positions, t, 0).sub_mul(min_x, ppu),
comp(positions, t, 1).sub_mul(min_y, ppu),
))
})?;
let triangles = triangles()?;
for sm in triangles.submeshes() {
meter.count_decode(sm.len())?;
for tri in sm.triangles() {
if tri.iter().any(|&i| i as usize >= n) {
return Err(SpriteError::Index { tuple: false });
}
}
if !sm.cut().is_empty() {
return Err(SpriteError::Unpack {
expected: 3,
got: Some(sm.cut().len()),
});
}
if sm.empty() > 0 {
return Err(SpriteError::Unpack {
expected: 3,
got: Some(0),
});
}
}
let (w, h) = (crop.width, crop.height);
let mut out = Canvas::new(Mode::Rgba, w, h, meter)?;
meter.count_decode(u64::from(h))?;
if w == 0 || h == 0 {
return Ok(out);
}
let rgba = crop.mode == Mode::Rgba;
contained(|| -> Result<(), SpriteError> {
if !rgba {
for y in 0..h {
for x in 0..w {
let p = crop.get(x, y);
if let Some(o) = out.get_mut(x, y).get_mut(..3) {
o.copy_from_slice(p.get(..3).unwrap_or(&[0; 3]));
}
}
}
}
let (xsize, ysize) = (
i32::try_from(w).unwrap_or(i32::MAX),
i32::try_from(h).unwrap_or(i32::MAX),
);
let mut span = |y: i32, x0: i32, x1: i32| -> Result<(), SpriteError> {
meter.count_decode(u64::try_from(x1 - x0 + 1).unwrap_or(0))?;
for x in x0..=x1 {
let (x, y) = (x.cast_unsigned(), y.cast_unsigned());
if rgba {
let p = crop.get(x, y);
out.get_mut(x, y).copy_from_slice(p);
} else if let Some(a) = out.get_mut(x, y).get_mut(3) {
*a = 255;
}
}
Ok(())
};
let mut work = |n: u64| meter.count_decode(n).map_err(SpriteError::from);
for sm in triangles.submeshes() {
for tri in sm.triangles() {
let corner = |i: u32| {
let (x, y) = points
.as_slice()
.get(i as usize)
.copied()
.unwrap_or_default();
(c_trunc(x), c_trunc(y))
};
let xy = [corner(tri[0]), corner(tri[1]), corner(tri[2])];
raster::fill(
&xy,
&mut Mask {
xsize,
ysize,
span: &mut span,
work: &mut work,
},
)?;
}
}
Ok(())
})??;
Ok(out)
}
fn mesh_render(
sheet: &Sheet<'_>,
mesh: &Processed<'_>,
ppu: f64,
meter: &Arc<Meter>,
) -> Result<Canvas, SpriteError> {
mesh_parts(
sheet,
mesh.vertices(),
mesh.uv(0),
|| mesh.get_triangles(meter),
ppu,
meter,
)
}
pub(super) fn mesh_parts(
sheet: &Sheet<'_>,
positions: Option<&VertexArray>,
uv: Option<&VertexArray>,
triangles: impl FnOnce() -> Result<Triangles, MeshError>,
ppu: f64,
meter: &Arc<Meter>,
) -> Result<Canvas, SpriteError> {
let triangles = triangles()?;
let positions = positions.filter(|p| !p.is_empty());
let (Some(first), Some(positions)) = (triangles.submeshes().first(), positions) else {
return Err(SpriteError::NoTriangles);
};
let uv = uv.filter(|u| !u.is_empty()).ok_or(SpriteError::NoUv)?;
if positions.dimension() < 3 {
return Err(SpriteError::Index { tuple: true });
}
let n = positions.len();
meter.count_decode(7 * n as u64)?;
let constant = |c: usize| {
let first = comp(positions, 0, c);
n == 1 || (0..n).all(|t| comp(positions, t, c).eq(first))
};
let dropped = (0..3)
.rev()
.find(|&c| constant(c))
.ok_or(SpriteError::Sprite3d)?;
let mut axes = (0..3).filter(|&c| c != dropped);
let (ax, ay) = (axes.next().unwrap_or(0), axes.next().unwrap_or(1));
let x_min = extreme((0..n).map(|t| comp(positions, t, ax)), false).unwrap_or(Num::F(0.0));
let y_min = extreme((0..n).map(|t| comp(positions, t, ay)), false).unwrap_or(Num::F(0.0));
let x_max = extreme((0..n).map(|t| comp(positions, t, ax)), true).unwrap_or(Num::F(0.0));
let y_max = extreme((0..n).map(|t| comp(positions, t, ay)), true).unwrap_or(Num::F(0.0));
let positions_abs = collect(n, meter, |t| {
Ok([
py_round(comp(positions, t, ax).sub_mul(x_min, ppu))?,
py_round(comp(positions, t, ay).sub_mul(y_min, ppu))?,
])
})?;
let (sw, sh) = (sheet.width(), sheet.height());
unpack(uv, 2)?;
let uv_abs = collect(uv.len(), meter, |t| {
let scaled = |c: usize, side: u32| -> Result<Int, SpriteError> {
match comp(uv, t, c) {
Num::I(i) => Ok(Int::I(i.saturating_mul(i128::from(side)))),
Num::F(f) => Ok(Int::of_f64(py_round(f * f64::from(side))?)),
}
};
Ok([scaled(0, sw)?, scaled(1, sh)?])
})?;
let size = [
py_round(x_max.sub_mul(x_min, ppu))?,
py_round(y_max.sub_mul(y_min, ppu))?,
];
if size[0] < 0.0 || size[1] < 0.0 {
return Err(SpriteError::NegativeSize);
}
let w = u32::try_from(c_int(size[0])?).unwrap_or(0);
let h = u32::try_from(c_int(size[1])?).unwrap_or(0);
let mut out = Canvas::new(sheet.mode(), w, h, meter)?;
let tuples = first
.triangles()
.iter()
.map(|t| &t[..])
.chain((!first.cut().is_empty()).then_some(first.cut()))
.chain((0..first.empty()).map(|_| &[][..]));
for tri in tuples {
meter.count_decode(1)?;
let mut src = [[Int::I(0); 2]; 3];
let mut dst = [[0.0; 2]; 3];
for (k, &i) in tri.iter().enumerate() {
let s = uv_abs
.as_slice()
.get(i as usize)
.ok_or(SpriteError::Index { tuple: false })?;
if let Some(slot) = src.get_mut(k) {
*slot = *s;
}
}
for (k, &i) in tri.iter().enumerate() {
let d = positions_abs
.as_slice()
.get(i as usize)
.ok_or(SpriteError::Index { tuple: false })?;
if let Some(slot) = dst.get_mut(k) {
*slot = *d;
}
}
if tri.len() < 3 {
return Err(SpriteError::Index { tuple: true });
}
copy_triangle(sheet, src, &mut out, dst, meter)?;
}
Ok(out)
}
fn to_float64(v: Int) -> Option<f64> {
match v {
#[allow(clippy::cast_precision_loss)] Int::I(i) if i >= i128::from(i64::MIN) && i <= i128::from(u64::MAX) => Some(i as f64),
_ => None,
}
}
pub(super) fn copy_triangle(
sheet: &Sheet<'_>,
src: [[Int; 2]; 3],
out: &mut Canvas,
dst: [[f64; 2]; 3],
meter: &Arc<Meter>,
) -> Result<(), SpriteError> {
let d = dst.map(|p| p.map(Int::of_f64));
let off = |t: &[[Int; 2]; 3]| {
[
[t[1][0].sub(t[0][0]), t[1][1].sub(t[0][1])],
[t[2][0].sub(t[0][0]), t[2][1].sub(t[0][1])],
]
};
if off(&src) == off(&d) {
return copy_unchanged(sheet, &src, out, &d, meter);
}
let mut y = [0.0; 6];
for (o, v) in y.iter_mut().zip([
src[0][0], src[1][0], src[2][0], src[0][1], src[1][1], src[2][1],
]) {
*o = to_float64(v).ok_or(SpriteError::SolveCast)?;
}
let m = [
[dst[0][0], dst[0][1], 1.0, 0.0, 0.0, 0.0],
[dst[1][0], dst[1][1], 1.0, 0.0, 0.0, 0.0],
[dst[2][0], dst[2][1], 1.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, dst[0][0], dst[0][1], 1.0],
[0.0, 0.0, 0.0, dst[1][0], dst[1][1], 1.0],
[0.0, 0.0, 0.0, dst[2][0], dst[2][1], 1.0],
];
let Some(a) = solve(&m, &y) else {
return Ok(());
};
meter.count_decode(u64::from(out.height))?;
if out.width == 0 || out.height == 0 {
return Ok(());
}
let mut map = Map::new(a, out.width, out.height, sheet, meter)?;
let xy = dst.map(|p| (c_trunc(p[0]), c_trunc(p[1])));
let (xsize, ysize) = (
i32::try_from(out.width).unwrap_or(i32::MAX),
i32::try_from(out.height).unwrap_or(i32::MAX),
);
contained(|| -> Result<(), SpriteError> {
let mut span = |y: i32, x0: i32, x1: i32| -> Result<(), SpriteError> {
meter.count_decode(u64::try_from(x1 - x0 + 1).unwrap_or(0))?;
map.sample(sheet, y, x0, x1, meter, &mut |x, p| {
let o = out.get_mut(x.cast_unsigned(), y.cast_unsigned());
paste_pixel(o, p, sheet.mode());
})
};
let mut work = |n: u64| meter.count_decode(n).map_err(SpriteError::from);
raster::fill(
&xy,
&mut Mask {
xsize,
ysize,
span: &mut span,
work: &mut work,
},
)
})?
}
fn copy_unchanged(
sheet: &Sheet<'_>,
s: &[[Int; 2]; 3],
out: &mut Canvas,
d: &[[Int; 2]; 3],
meter: &Arc<Meter>,
) -> Result<(), SpriteError> {
type Axis = fn(&[Int; 2]) -> Int;
let pick = |t: &[[Int; 2]; 3], at: Axis, max: bool| {
let [first, rest @ ..] = t;
let mut best = at(first);
for p in rest {
let ord = at(p).cmp(best);
if (max && ord.is_gt()) || (!max && ord.is_lt()) {
best = at(p);
}
}
best
};
let (x, y): (Axis, Axis) = (|p| p[0], |p| p[1]);
let (ul, lr) = (
[pick(s, x, false), pick(s, y, false)],
[pick(s, x, true), pick(s, y, true)],
);
canvas::bomb_check([ul[0], ul[1], lr[0], lr[1]])?;
let (x0, y0, x1, y1) = (
c_int_of(ul[0])?,
c_int_of(ul[1])?,
c_int_of(lr[0])?,
c_int_of(lr[1])?,
);
let (cw, ch) = crop_size([x0, y0, x1, y1]);
width_cap(cw)?;
let (w, h) = (cw.cast_signed(), ch.cast_signed());
let (dx, dy) = (c_int_of(pick(d, x, false))?, c_int_of(pick(d, y, false))?);
c_int_of(Int::I(i128::from(dx) + i128::from(w)))?;
c_int_of(Int::I(i128::from(dy) + i128::from(h)))?;
let (ow, oh) = (
i32::try_from(out.width).unwrap_or(i32::MAX),
i32::try_from(out.height).unwrap_or(i32::MAX),
);
let xsize = w.min(ow.saturating_sub(dx));
let ysize = h.min(oh.saturating_sub(dy));
meter.count_decode(u64::from(ch))?;
if xsize <= 0 || ysize <= 0 {
return Ok(());
}
let rel = |v: Int, origin: Int| {
#[allow(clippy::cast_precision_loss)] v.sub(origin).map_or(i32::MIN, |r| c_trunc(r as f64))
};
let xy = s.map(|[x, y]| (rel(x, ul[0]), rel(y, ul[1])));
contained(|| -> Result<(), SpriteError> {
let mut span = |y: i32, a: i32, b: i32| -> Result<(), SpriteError> {
if y >= ysize {
return Ok(());
}
let b = b.min(xsize - 1);
meter.count_decode(u64::try_from(b - a + 1).unwrap_or(0))?;
for x in a..=b {
let p = sheet.pixel(i64::from(x0) + i64::from(x), i64::from(y0) + i64::from(y));
let o = out.get_mut((dx + x).cast_unsigned(), (dy + y).cast_unsigned());
paste_pixel(o, p, sheet.mode());
}
Ok(())
};
let mut work = |n: u64| meter.count_decode(n).map_err(SpriteError::from);
raster::fill(
&xy,
&mut Mask {
xsize: w,
ysize: h,
span: &mut span,
work: &mut work,
},
)
})?
}
fn paste_pixel(out: &mut [u8], source: Option<&[u8]>, mode: Mode) {
out.fill(0);
let count = out.len().min(bpp(mode));
if let Some(source) = source.and_then(|p| p.get(..count))
&& let Some(target) = out.get_mut(..count)
{
target.copy_from_slice(source);
}
if mode == Mode::Rgb
&& let Some(alpha) = out.get_mut(3)
{
*alpha = 255;
}
}