use std::sync::Arc;
use unityrs_core::ObjectRef;
use unityrs_core::files::{BundleFile, SerializedFile};
use unityrs_core::limits::{Charge, Meter, MeteredVec};
use super::super::attempt::Attempt;
use super::super::classify::{self, Class, Reason};
use super::super::kept::Kept;
use super::super::read::{self, top_bundle};
use super::super::table::{self, Map};
use super::files::Files;
use super::object::{self, Item, Key, Ptr, RenderData, SpriteRead, Tag};
use super::{SPRITE_ATLAS, follow};
struct List {
objects: MeteredVec<u32>,
names: Map<Vec<u8>, usize>,
read: usize,
failed: Option<Kept>,
held: Charge,
}
#[derive(Clone, Copy)]
enum Walked {
Atlas(u32),
NoAtlas,
Raised,
}
#[derive(Clone, Copy)]
enum Want<'t> {
Name(&'t [u8]),
Nothing,
Raise,
}
struct Index {
entries: Map<Key, Result<RenderData, Kept>>,
tail: Option<Kept>,
}
pub(super) struct Atlases {
pub files: Files,
lists: Map<u32, List>,
read: Map<(u32, i64), Result<Index, Kept>>,
}
impl Atlases {
pub fn new(meter: &Arc<Meter>) -> Self {
Self {
files: Files::new(meter),
lists: Map::new(meter),
read: Map::new(meter),
}
}
}
pub(super) type Found = (
RenderData,
Arc<SerializedFile>,
Option<unityrs_core::env::PPtr>,
Option<Arc<BundleFile>>,
);
fn hashed(name: &[u8]) -> u64 {
1 + u64::try_from(name.len()).unwrap_or(u64::MAX)
}
fn internal() -> Class {
Class::Run(Reason::plain("internal"))
}
fn counted(meter: &Meter, n: u64) -> Result<(), Class> {
meter.count_decode(n).map_err(|e| classify::charge(&e))
}
impl Attempt<'_> {
pub(super) fn render_data(
&mut self,
obj: &ObjectRef,
sprite: &SpriteRead<'_>,
at: &mut Atlases,
) -> Result<Found, Class> {
let seam = self.seam;
let meter = seam.meter;
match sprite.atlas.filter(|p| p.is_set()) {
Some(Ptr::Other(_)) => return Err(object::render()),
Some(Ptr::Ids(ids)) => {
let (atlas, pptr) = follow(&seam, obj.file(), ids)?;
let held = top_bundle(atlas.file());
let id = seam.probe(|| at.files.id(atlas.file(), meter))?;
let rd = self.atlas_data(&atlas, id, sprite.key, at)?;
return Ok((rd, atlas.file().clone(), Some(pptr), held));
}
None => {}
}
let own = obj.file().clone();
let want = match sprite.tag {
Tag::None => return Ok((sprite.rd, own, None, None)),
Tag::Name(t) => Want::Name(t),
Tag::NoMatch => Want::Nothing,
Tag::Raises => Want::Raise,
};
let id = seam.probe(|| at.files.id(&own, meter))?;
match self.walk(&own, id, want, at)? {
Walked::Atlas(index) => {
let atlas = ObjectRef::new(own.clone(), index).ok_or_else(internal)?;
let rd = self.atlas_data(&atlas, id, sprite.key, at)?;
Ok((rd, own, None, None))
}
Walked::NoAtlas => Ok((sprite.rd, own, None, None)),
Walked::Raised => Err(object::render()),
}
}
fn listed(&self, own: &Arc<SerializedFile>, file: u32, at: &mut Atlases) -> Result<(), Class> {
if at.lists.get(&file).is_some() {
return Ok(());
}
let seam = self.seam;
let meter = seam.meter;
let mut objects = MeteredVec::new(meter);
for o in own.objects() {
counted(meter, 1)?;
if o.class_id() == SPRITE_ATLAS {
seam.probe(|| table::push(&mut objects, o.index()))?;
}
}
let list = List {
objects,
names: Map::new(meter),
read: 0,
failed: None,
held: Charge::zero(meter),
};
let lists = &mut at.lists;
seam.probe(|| lists.insert(file, list))
}
fn walk(
&mut self,
own: &Arc<SerializedFile>,
file: u32,
want: Want<'_>,
at: &mut Atlases,
) -> Result<Walked, Class> {
let seam = self.seam;
let meter = seam.meter;
self.listed(own, file, at)?;
if let Want::Name(t) = want {
counted(meter, hashed(t))?;
let list = at.lists.get(&file).ok_or_else(internal)?;
if let Some(p) = list.names.get(t) {
let index = list.objects.as_slice().get(*p).ok_or_else(internal)?;
return Ok(Walked::Atlas(*index));
}
}
loop {
let list = at.lists.get_mut(&file).ok_or_else(internal)?;
if matches!(want, Want::Raise) && list.read > 0 {
return Ok(Walked::Raised);
}
if let Some(k) = &list.failed {
return Err(k.class());
}
let place = list.read;
let Some(index) = list.objects.as_slice().get(place).copied() else {
return Ok(Walked::NoAtlas);
};
counted(meter, 1)?;
let o = ObjectRef::new(own.clone(), index).ok_or_else(internal)?;
let mut matched = false;
match self.reader.atlas_name(&seam, &o) {
Ok(Some(name)) => {
let name = name.as_bytes();
counted(meter, hashed(name))?;
if let Want::Name(t) = want {
counted(meter, hashed(name.get(..t.len()).unwrap_or(name)))?;
#[cfg(feature = "test-counters")]
crate::testing::tag_walk(name.len().min(t.len()));
matched = t == name;
}
if list.names.get(name).is_none() {
let cost = table::string(name.len());
let (names, held) = (&mut list.names, &mut list.held);
let copy = || table::copied(name);
seam.probe(|| names.insert_held(held, cost, copy, place))?;
}
}
Ok(None) => {}
Err(c) => {
list.failed = Some(Kept::keep(meter, seam.hooks, c)?);
continue;
}
}
list.read = place + 1;
if matched {
return Ok(Walked::Atlas(index));
}
}
}
fn atlas_data(
&self,
atlas: &ObjectRef,
file: u32,
key: Option<Key>,
at: &mut Atlases,
) -> Result<RenderData, Class> {
let seam = self.seam;
let id = (file, atlas.path_id());
if at.read.get(&id).is_none() {
let built = self.index(atlas)?;
let read = &mut at.read;
seam.probe(|| read.insert(id, built))?;
}
let index = match at.read.get(&id) {
Some(Ok(index)) => index,
Some(Err(k)) => return Err(k.class()),
None => return Err(internal()),
};
match key.as_ref().and_then(|k| index.entries.get(k)) {
Some(Ok(rd)) => Ok(*rd),
Some(Err(k)) => Err(k.class()),
None => Err(index.tail.as_ref().map_or_else(object::render, Kept::class)),
}
}
fn index(&self, atlas: &ObjectRef) -> Result<Result<Index, Kept>, Class> {
let seam = self.seam;
let meter = seam.meter;
let hooks = seam.hooks;
let parsed = match seam.probe(|| {
atlas
.read_typetree(None, true)
.map_err(|e| classify::parse(&e))
.and_then(|p| {
if object::attaches(&p, meter)? {
Ok(p)
} else {
Err(read::shape())
}
})
}) {
Ok(p) => p,
Err(c) => return Ok(Err(Kept::keep(meter, hooks, c)?)),
};
let mut entries: Map<Key, Result<RenderData, Kept>> = Map::new(meter);
let walked = seam.probe(|| {
object::walk(&parsed, meter, |item| {
let Item::Entry(Some(k), v) = item else {
return Ok(true);
};
if entries.get(&k).is_some() {
return Ok(true);
}
let value = match object::atlas_data(&parsed, v, meter) {
Ok(rd) => Ok(rd),
Err(c) => Err(Kept::keep(meter, hooks, c)?),
};
entries.insert(k, value)?;
Ok(true)
})
});
let tail = match walked {
Ok(None) => None,
Ok(Some(c)) => Some(Kept::keep(meter, hooks, c)?),
Err(c) => return Ok(Err(Kept::keep(meter, hooks, c)?)),
};
Ok(Ok(Index { entries, tail }))
}
}