use std::cell::{OnceCell, RefCell};
use unityrs_core::Parsed;
use unityrs_core::limits::MeteredVec;
use unityrs_meshdecode::{MeshError, MeshHandler, Source, Version};
use unityrs_texture::sprite::{Sheet, render};
use unityrs_texture::{Format, Image, Mode};
use super::super::attempt::{Attempt, Site};
use super::super::classify::{self, Class, Reason};
use super::super::export::{Made, Pixels, decoded, png};
use super::super::plan::too_wide;
use super::super::read::{self, top_bundle};
use super::super::table;
use super::super::{Failure, OutputKind, SkipOutput};
use super::plan::sheet_answers;
use super::{GroupSheet, SpritePlan, Sprites};
fn slot(v: &mut MeteredVec<u32>, i: usize) -> Result<&mut u32, Failure> {
v.as_mut_slice()
.get_mut(i)
.ok_or_else(|| Failure::Run(Reason::plain("internal")))
}
fn bpp(mode: Mode) -> u64 {
match mode {
Mode::L => 1,
Mode::Rgb => 3,
Mode::Rgba => 4,
}
}
impl Attempt<'_> {
pub(in super::super) fn export_sprites(&mut self, planned: &Sprites) -> Result<(), Failure> {
let meter = self.seam.meter;
let sprites = planned.planned.as_slice();
let groups = planned.groups.as_slice();
if sprites.is_empty() {
return Ok(());
}
let internal = || Failure::Run(Reason::plain("internal"));
let units = sprites.len().saturating_mul(2).saturating_add(groups.len());
meter
.count_decode(u64::try_from(units).unwrap_or(u64::MAX))
.map_err(|e| Failure::from(classify::charge(&e)))?;
let mut ends: MeteredVec<u32> =
self.charged(|| table::with_capacity(meter, groups.len() + 1))?;
for _ in 0..=groups.len() {
self.charged(|| table::push(&mut ends, 0))?;
}
for s in sprites {
let g = usize::try_from(s.group).map_err(|_| internal())?;
*slot(&mut ends, g + 1)? += 1;
}
for g in 1..=groups.len() {
let before = *slot(&mut ends, g - 1)?;
*slot(&mut ends, g)? += before;
}
let mut order: MeteredVec<u32> =
self.charged(|| table::with_capacity(meter, sprites.len()))?;
for _ in 0..sprites.len() {
self.charged(|| table::push(&mut order, 0))?;
}
for (j, s) in sprites.iter().enumerate() {
let g = usize::try_from(s.group).map_err(|_| internal())?;
let next = slot(&mut ends, g)?;
let at = usize::try_from(*next).map_err(|_| internal())?;
*next += 1;
*slot(&mut order, at)? = u32::try_from(j).map_err(|_| internal())?;
}
let order = order.as_slice();
let ends = ends.as_slice();
for (g, sheet) in groups.iter().enumerate() {
self.seam.stop()?;
let start = if g == 0 {
0
} else {
ends.get(g - 1).copied().ok_or_else(internal)?
};
let end = ends.get(g).copied().ok_or_else(internal)?;
let run = usize::try_from(start)
.ok()
.zip(usize::try_from(end).ok())
.and_then(|(a, b)| order.get(a..b))
.ok_or_else(internal)?;
let at = |j: &u32| sprites.get(usize::try_from(*j).unwrap_or(usize::MAX));
for s in run.iter().filter_map(at) {
self.seam
.hooks
.sprite_group(g, s.obj.file().name(), s.obj.path_id());
}
self.export_group(sheet, run, sprites)?;
}
Ok(())
}
fn export_group(
&mut self,
record: &GroupSheet,
run: &[u32],
sprites: &[SpritePlan],
) -> Result<(), Failure> {
let (texture, alpha) = match self.group_sheet(record) {
Ok(images) => images,
Err(c) => return self.skip_group(c, run, sprites),
};
let Some(alpha) = alpha else {
return match Sheet::new(&texture, None, self.seam.meter) {
Ok(sheet) => self.export_run(&sheet, run, sprites),
Err(e) => self.skip_group(classify::render(&e), run, sprites),
};
};
let same = (texture.width(), texture.height()) == (alpha.width(), alpha.height());
if same {
let pixels = u64::from(texture.width())
.saturating_mul(u64::from(texture.height()))
.saturating_mul(4);
if let Err(c) = self.seam.work(pixels) {
return Err(c.into());
}
}
let seam = self.seam;
let merged = seam.probe(|| {
Sheet::merged(&texture, &alpha, seam.meter).map_err(|e| classify::render(&e))
});
drop(alpha);
drop(texture);
match merged {
Ok(sheet) => self.export_run(&sheet, run, sprites),
Err(c) => self.skip_group(c, run, sprites),
}
}
fn export_run(
&mut self,
sheet: &Sheet<'_>,
run: &[u32],
sprites: &[SpritePlan],
) -> Result<(), Failure> {
let at = |j: &u32| sprites.get(usize::try_from(*j).unwrap_or(usize::MAX));
for s in run.iter().filter_map(at) {
self.seam.stop()?;
self.export_sprite(sheet, s)?;
}
Ok(())
}
fn skip_group(&mut self, c: Class, run: &[u32], sprites: &[SpritePlan]) -> Result<(), Failure> {
let Class::Skip(reason) = c else {
return Err(c.into());
};
for s in run
.iter()
.filter_map(|j| sprites.get(usize::try_from(*j).unwrap_or(usize::MAX)))
{
let site = Site {
obj: &s.obj,
output: SkipOutput::Sprite,
sprite: None,
};
self.skip(&site, reason.clone())?;
}
Ok(())
}
fn group_sheet(&mut self, record: &GroupSheet) -> Result<(Image, Option<Image>), Class> {
let seam = self.seam;
let (holder, _held) = match record.atlas {
Some(p) => {
let atlas = read::deref(&seam, &record.from, p)?;
let held = top_bundle(atlas.file());
(atlas.file().clone(), held)
}
None => (record.from.clone(), None),
};
let texture = read::deref(&seam, &holder, record.texture)?;
let held = top_bundle(texture.file());
let image = self.decode_texture(&texture)?;
drop(texture);
drop(held);
let alpha = match record.alpha {
Some(p) => {
let alpha = read::deref(&seam, &holder, p)?;
let _held = top_bundle(alpha.file());
Some(self.decode_texture(&alpha)?)
}
None => None,
};
Ok((image, alpha))
}
fn decode_texture(&self, obj: &unityrs_core::ObjectRef) -> Result<Image, Class> {
let seam = self.seam;
let t = seam.probe(|| read::texture(obj))?;
sheet_answers(&t, obj, self.options.formats)?;
let format = if t.width == 0 || t.height == 0 {
Format::Rgba32
} else {
read::object_answer(&t, Some(obj), self.options.formats)?
};
decoded(&seam, obj.file(), &t, format, false)
}
fn export_sprite(&mut self, sheet: &Sheet<'_>, s: &SpritePlan) -> Result<(), Failure> {
let site = Site {
obj: &s.obj,
output: SkipOutput::Sprite,
sprite: None,
};
let image = match self.render_sprite(sheet, s) {
Ok(i) => i,
Err(c) => return self.record(c, &site),
};
if image.width() == 0 || image.height() == 0 {
return self.skip(&site, Reason::plain("empty_image"));
}
if too_wide(image.width(), image.mode()) {
return self.skip(&site, Reason::decode_error("pillow_memory_error"));
}
let pixels = u64::from(image.width())
.saturating_mul(u64::from(image.height()))
.saturating_mul(bpp(image.mode()));
if let Err(c) = self.seam.work(pixels) {
return self.record(c, &site);
}
let p = Pixels {
mode: image.mode(),
width: image.width(),
height: image.height(),
data: image.pixels(),
};
let seam = self.seam;
let file = seam.probe(|| png(&p, seam.meter, self.options.image));
drop(image);
match file {
Ok((bytes, charge, picture)) => {
let made = Made {
plan_index: s.plan_index,
kind: OutputKind::Sprite,
key: &s.key,
unit: None,
members: s.members.as_slice(),
};
self.output(&made, &site, (bytes, charge, Some(picture)))?;
Ok(())
}
Err(c) => self.record(c, &site),
}
}
fn render_sprite(&self, sheet: &Sheet<'_>, s: &SpritePlan) -> Result<Image, Class> {
let seam = self.seam;
let meter = seam.meter;
let cell: OnceCell<Parsed> = OnceCell::new();
let failed: RefCell<Option<Class>> = RefCell::new(None);
let fail = |c: Class| {
*failed.borrow_mut() = Some(c);
MeshError::NoAttribute("m_RD")
};
let mesh = || {
if cell.get().is_none() {
let read = seam.probe(|| {
s.obj
.read_typetree(None, true)
.map_err(|e| classify::parse(&e))
});
match read {
Ok(p) => {
let _ = cell.set(p);
}
Err(c) => return Err(fail(c)),
}
}
let Some(version) = s.obj.file().version().map(|v| Version::of(&v.version)) else {
return Err(fail(Class::Skip(Reason::decode_error("version"))));
};
let Some(parsed) = cell.get() else {
return Err(fail(Class::Run(Reason::plain("internal"))));
};
MeshHandler::new(Source::sprite(parsed), version).process(None, meter)
};
let image =
seam.probe(|| render(sheet, &s.data, mesh, meter).map_err(|e| classify::render(&e)));
if let Some(c) = failed.into_inner() {
return Err(c);
}
image
}
}