use std::sync::Arc;
use unityrs_core::files::SerializedFile;
use unityrs_core::{ObjectRef, RawStr};
use unityrs_texture::Formats;
use unityrs_texture::sprite::SpriteData;
use super::super::attempt::{Attempt, Site, Vars};
use super::super::classify::{self, Class, Reason};
use super::super::kept::Kept;
use super::super::keys::{Template, TemplateKind};
use super::super::read::{self, Texture, top_bundle};
use super::super::table::{self, Map, Set};
use super::super::{Failure, SkipOutput};
use super::atlas::Atlases;
use super::object::{self, Alpha};
use super::{GroupKey, GroupSheet, Resolved, SPRITE, SheetId, SpritePlan, Sprites, follow};
struct Scratch {
names: Set<RawStr>,
answers: Map<SheetId, Option<Kept>>,
atlases: Atlases,
}
pub(super) fn sheet_answers(t: &Texture, obj: &ObjectRef, allowed: Formats) -> Result<(), Class> {
if t.width == 0 || t.height == 0 {
return Ok(());
}
read::object_answer(t, Some(obj), allowed).map(|_| ())
}
impl Attempt<'_> {
pub fn plan_sprites(&mut self, files: &[Arc<SerializedFile>]) -> Result<Sprites, Failure> {
let meter = self.seam.meter;
let mut out = Sprites::new(meter);
let Some(template) = self.options.sprites_key.clone() else {
return Ok(out);
};
let mut scratch = Scratch {
names: Set::new(meter),
answers: Map::new(meter),
atlases: Atlases::new(meter),
};
for f in files {
for obj in f.objects() {
if obj.class_id() != SPRITE {
continue;
}
self.seam.stop()?;
self.plan_sprite(&obj, &template, &mut scratch, &mut out)?;
}
}
Ok(out)
}
fn plan_sprite(
&mut self,
obj: &ObjectRef,
template: &Template,
scratch: &mut Scratch,
out: &mut Sprites,
) -> Result<(), Failure> {
let site = Site {
obj,
output: SkipOutput::Sprite,
sprite: None,
};
let seam = self.seam;
let name = match self.reader.peek_name(&seam, obj) {
Ok(n) => n,
Err(c) => return self.record(c, &site),
};
if scratch.names.contains(&name) {
return self.skip(&site, Reason::plain("duplicate_name"));
}
let names = &mut scratch.names;
self.charged(|| names.insert(name.clone()))?;
let (group, sheet, data) = match self.sheets(obj, scratch) {
Ok(g) => g,
Err(c) => return self.record(c, &site),
};
let vars = Vars {
name: name.as_bytes(),
..Vars::default()
};
self.expand(template, obj, vars);
let Some(key) = self.take(&site)? else {
return Ok(());
};
let members = self.member_paths(TemplateKind::Sprite, obj, vars)?;
let at = self.charged(|| join(out, group, sheet))?;
let plan = SpritePlan {
plan_index: 0,
obj: obj.clone(),
data,
group: at,
key,
members,
};
let sprites = &mut out.planned;
self.charged(|| table::push(sprites, plan))
}
fn sheets(
&mut self,
obj: &ObjectRef,
scratch: &mut Scratch,
) -> Result<(GroupKey, GroupSheet, SpriteData), Class> {
let seam = self.seam;
let resolved = self.resolve(obj, &mut scratch.atlases)?;
let rd = resolved.rd;
let alpha = match rd.alpha {
Alpha::Missing => return Err(object::render()),
Alpha::None => None,
Alpha::Set(p) => Some(p).filter(|p| p.is_set()),
};
let texture_ids = rd.texture.ids().ok_or_else(object::render)?;
let alpha_ids = match alpha {
Some(p) => Some(p.ids().ok_or_else(object::render)?),
None => None,
};
let (texture, texture_ptr) = follow(&seam, &resolved.holder, texture_ids)?;
let _first = top_bundle(texture.file());
let sheet = self.answer(&texture, scratch)?;
drop(texture);
let (alpha, alpha_ptr) = match alpha_ids {
Some(ids) => {
let (alpha, p) = follow(&seam, &resolved.holder, ids)?;
let _second = top_bundle(alpha.file());
(Some(self.answer(&alpha, scratch)?), Some(p))
}
None => (None, None),
};
let record = GroupSheet {
from: obj.file().clone(),
atlas: resolved.atlas,
texture: texture_ptr,
alpha: alpha_ptr,
};
Ok(((sheet, alpha), record, resolved.data))
}
fn resolve(&mut self, obj: &ObjectRef, atlases: &mut Atlases) -> Result<Resolved, Class> {
let seam = self.seam;
let meter = seam.meter;
let parsed = seam.probe(|| {
obj.read_typetree(None, true)
.map_err(|e| classify::parse(&e))
})?;
let sprite = seam.probe(|| object::sprite(&parsed, meter))?;
let (rd, holder, atlas, held) = self.render_data(obj, &sprite, atlases)?;
let data = SpriteData {
texture_rect: rd.texture_rect,
settings_raw: rd.settings_raw,
pixels_to_units: sprite.ppu,
};
Ok(Resolved {
data,
rd,
holder,
atlas,
_held: held,
})
}
fn answer(&mut self, obj: &ObjectRef, scratch: &mut Scratch) -> Result<SheetId, Class> {
let seam = self.seam;
let allowed = self.options.formats;
let meter = seam.meter;
let atlases = &mut scratch.atlases;
let file = seam.probe(|| atlases.files.id(obj.file(), meter))?;
let id = SheetId {
file,
path_id: obj.path_id(),
};
if scratch.answers.get(&id).is_none() {
let answer = seam
.probe(|| read::texture(obj))
.and_then(|t| sheet_answers(&t, obj, allowed));
let kept = match answer {
Ok(()) => None,
Err(c) => Some(Kept::keep(meter, seam.hooks, c)?),
};
let answers = &mut scratch.answers;
seam.probe(|| answers.insert(id, kept))?;
}
match scratch.answers.get(&id) {
Some(Some(k)) => Err(k.class()),
Some(None) => Ok(id),
None => Err(Class::Run(Reason::plain("internal"))),
}
}
}
fn join(out: &mut Sprites, key: GroupKey, sheet: GroupSheet) -> Result<u32, Class> {
if let Some(n) = out.index.get(&key) {
return Ok(*n);
}
let n = u32::try_from(out.groups.len()).map_err(|_| Class::Run(Reason::plain("internal")))?;
out.groups.reserve(1).map_err(|e| table::refused(&e))?;
out.index.insert(key, n)?;
table::push(&mut out.groups, sheet)?;
Ok(n)
}