use std::io::Write as _;
use std::sync::Arc;
use unityrs_core::classid::class_name;
use unityrs_core::files::SerializedFile;
use unityrs_core::limits::{Charge, MeteredVec};
use unityrs_core::{ObjectRef, RawStr};
use unityrs_texture::Format;
use super::classify::{self, Class, Reason};
use super::kept::Kept;
use super::keys::{
KeyRule, KeyTable, STOP, Template, TemplateKind, Var, check_member, check_prefixed,
};
use super::read::{self, Reader, Texture};
use super::seam::Seam;
use super::table;
use super::{Cut, Failure, MemberPath, Options, Output, Rejected, SheetRow, Skip, SkipOutput};
pub(super) const UNKNOWN_PLATFORM: i32 = 3716;
pub(super) struct Tex {
pub obj: ObjectRef,
pub name: Option<Result<RawStr, Kept>>,
read: Option<Result<Texture, Kept>>,
}
impl Tex {
pub fn new(obj: ObjectRef) -> Self {
Self {
obj,
name: None,
read: None,
}
}
fn named(&self) -> Option<&[u8]> {
match &self.name {
Some(Ok(n)) => Some(n.as_bytes()),
_ => None,
}
}
}
#[derive(Clone, Copy, Default)]
pub(super) struct Vars<'v> {
pub name: &'v [u8],
pub atlas: &'v [u8],
pub sprite: &'v [u8],
}
pub(super) struct Site<'o> {
pub obj: &'o ObjectRef,
pub output: SkipOutput,
pub sprite: Option<usize>,
}
pub(super) struct Records {
plan_skips: MeteredVec<Skip>,
pub(super) glb_diagnostics: MeteredVec<super::GlbDiagnostic>,
pub(super) prefab_plan_skips: MeteredVec<super::PrefabSkip>,
pub(super) prefab_export_skips: MeteredVec<super::PrefabSkip>,
export_skips: MeteredVec<Skip>,
sheets: MeteredVec<SheetRow>,
nested: MeteredVec<RawStr>,
pub(super) strings: Charge,
unresolved: u64,
}
pub(super) struct Scratch {
pub(super) key: Vec<u8>,
tail: usize,
full: Vec<u8>,
_charge: Charge,
}
pub(super) fn unwritable(rule: KeyRule) -> Reason {
Reason::plain(format!("unwritable_key({})", rule.name()))
}
pub(super) fn expand(
input: &str,
template: &Template,
obj: &ObjectRef,
vars: Vars<'_>,
out: &mut Vec<u8>,
) -> usize {
let mut id = [0u8; 24];
let n = {
let mut w = id.as_mut_slice();
let _ = write!(w, "{}", obj.path_id());
24 - w.len()
};
let id = id.get(..n).unwrap_or_default();
let ty = class_name(obj.class_id()).unwrap_or_default().as_bytes();
template.expand(
|v| match v {
Var::Input | Var::SafeInput => input.as_bytes(),
Var::PathId => id,
Var::Type => ty,
Var::Name | Var::SafeName => vars.name,
Var::Atlas | Var::SafeAtlas => vars.atlas,
Var::Sprite | Var::SafeSprite => vars.sprite,
Var::ContainerPath | Var::SafeContainerPath => &[],
},
out,
)
}
pub(super) struct Attempt<'a> {
pub seam: Seam<'a>,
pub options: &'a Options,
pub input: &'a str,
pub(super) keys: &'a mut KeyTable,
sink: &'a mut dyn FnMut(Output) -> Result<(), Failure>,
pub reader: Reader,
pub texs: MeteredVec<Tex>,
owners: Option<MeteredVec<usize>>,
late: MeteredVec<usize>,
late_read: usize,
late_named: usize,
pub exporting: bool,
pub(super) records: Records,
pub(super) scratch: Scratch,
pub plan_strings: Charge,
}
impl<'a> Attempt<'a> {
pub fn new(
seam: Seam<'a>,
options: &'a Options,
input: &'a str,
keys: &'a mut KeyTable,
sink: &'a mut dyn FnMut(Output) -> Result<(), Failure>,
) -> Result<Self, Failure> {
let meter = seam.meter;
let scratch = seam.probe(|| {
let charge = meter
.charge(table::string(STOP).saturating_mul(2))
.map_err(|e| table::refused(&e))?;
let buffer = || {
let mut v = Vec::new();
v.try_reserve_exact(STOP)
.map_err(|_| table::host_memory())?;
Ok::<_, Class>(v)
};
Ok(Scratch {
key: buffer()?,
tail: 0,
full: buffer()?,
_charge: charge,
})
})?;
Ok(Self {
seam,
options,
input,
keys,
sink,
reader: Reader::new(meter)?,
texs: MeteredVec::new(meter),
owners: None,
late: MeteredVec::new(meter),
late_read: 0,
late_named: 0,
exporting: false,
records: Records {
plan_skips: MeteredVec::new(meter),
glb_diagnostics: MeteredVec::new(meter),
prefab_plan_skips: MeteredVec::new(meter),
prefab_export_skips: MeteredVec::new(meter),
export_skips: MeteredVec::new(meter),
sheets: MeteredVec::new(meter),
nested: MeteredVec::new(meter),
strings: Charge::zero(meter),
unresolved: 0,
},
scratch,
plan_strings: Charge::zero(meter),
})
}
pub fn finish(self) -> Cut {
let Records {
plan_skips,
glb_diagnostics,
prefab_plan_skips,
prefab_export_skips,
export_skips,
sheets,
nested,
mut strings,
unresolved,
} = self.records;
let mut parts = |v: (Vec<_>, Charge)| {
strings.absorb(v.1);
v.0
};
let plan_skips = parts(plan_skips.into_parts());
let export_skips = parts(export_skips.into_parts());
let (sheets, c) = sheets.into_parts();
strings.absorb(c);
let (nested_containers, c) = nested.into_parts();
strings.absorb(c);
let (glb_diagnostics, charge) = glb_diagnostics.into_parts();
strings.absorb(charge);
let (prefab_plan_skips, charge) = prefab_plan_skips.into_parts();
strings.absorb(charge);
let (prefab_export_skips, charge) = prefab_export_skips.into_parts();
strings.absorb(charge);
Cut {
glb_diagnostics,
prefab_plan_skips,
prefab_export_skips,
plan_skips,
export_skips,
unresolved_scripts: unresolved,
sheets,
nested_containers,
_charge: Some(strings),
}
}
pub fn charged<T>(&self, f: impl FnOnce() -> Result<T, Class>) -> Result<T, Failure> {
self.seam.probe(f).map_err(Failure::from)
}
pub fn hold(&mut self, bytes: u64) -> Result<(), Failure> {
let held = &mut self.plan_strings;
self.seam
.probe(|| held.grow(bytes).map_err(|e| table::refused(&e)))
.map_err(Failure::from)
}
pub fn select(&mut self) -> Result<MeteredVec<Arc<SerializedFile>>, Failure> {
let seam = self.seam;
let nested = &mut self.records.nested;
super::select_own(&seam.registered.own, seam.meter, seam.hooks, &mut |path| {
seam.probe(|| table::push(nested, path.clone()))
.map_err(Failure::from)
})
}
pub fn unresolved(&mut self) {
self.records.unresolved += 1;
}
pub fn sheet(&mut self, row: SheetRow) -> Result<(), Failure> {
let sheets = &mut self.records.sheets;
self.seam
.probe(|| table::push(sheets, row))
.map_err(Failure::from)
}
pub fn emit(&mut self, output: Output) -> Result<(), Failure> {
self.seam.stop()?;
(self.sink)(output)
}
pub fn record(&mut self, class: Class, site: &Site<'_>) -> Result<(), Failure> {
match class {
Class::Skip(reason) => self.skip(site, reason),
Class::Input(r) => Err(Failure::Input(r)),
Class::Run(r) => Err(Failure::Run(r)),
}
}
pub fn skip(&mut self, site: &Site<'_>, reason: Reason) -> Result<(), Failure> {
let seam = self.seam;
let id = site.obj.class_id();
let mut digits = [0u8; 12];
let n = {
let mut w = digits.as_mut_slice();
let _ = write!(w, "{id}");
12 - w.len()
};
let class: &[u8] = match class_name(id) {
Some(c) => c.as_bytes(),
None => digits.get(..n).unwrap_or_default(),
};
let detail = reason.detail.as_ref().map_or(0, String::len);
let cost = table::string(class.len())
.saturating_add(table::string(reason.reason.len()))
.saturating_add(table::string(detail));
let records = &mut self.records;
let rows = if self.exporting {
&mut records.export_skips
} else {
&mut records.plan_skips
};
let strings = &mut records.strings;
seam.probe(|| rows.reserve(1).map_err(|e| table::refused(&e)))
.map_err(Failure::from)?;
seam.probe(|| strings.grow(cost).map_err(|e| table::refused(&e)))
.map_err(Failure::from)?;
let row = Skip {
serialized_file: site.obj.file().name().clone(),
path_id: site.obj.path_id(),
class: String::from_utf8_lossy(class).into_owned(),
output: site.output,
sprite: site.sprite,
reason,
};
seam.probe(|| table::push(rows, row))
.map_err(Failure::from)?;
#[cfg(feature = "test-hooks")]
seam.hooks.skipped(self.exporting);
Ok(())
}
pub fn names(&mut self) -> Result<(), Failure> {
if self.owners.is_some() {
return Ok(());
}
let seam = self.seam;
let mut named = 0usize;
for i in 0..self.texs.len() {
seam.stop()?;
let Some(t) = self.texs.as_slice().get(i) else {
continue;
};
let obj = t.obj.clone();
let name = match self.reader.peek_name(&seam, &obj) {
Ok(n) => {
named += 1;
Ok(n)
}
Err(c) => match Kept::keep(seam.meter, seam.hooks, c) {
Ok(k) => Err(k),
Err(c) if Kept::metered(&c) => {
let late = &mut self.late;
seam.probe(|| table::push(late, i)).map_err(Failure::from)?;
continue;
}
Err(c) => return Err(c.into()),
},
};
if let Some(t) = self.texs.as_mut_slice().get_mut(i) {
t.name = Some(name);
}
}
let mut owners = self.charged(|| table::with_capacity(seam.meter, named))?;
for (i, t) in self.texs.as_slice().iter().enumerate() {
if t.named().is_some() {
self.charged(|| table::push(&mut owners, i))?;
}
}
let texs = self.texs.as_slice();
let name = |i: usize| texs.get(i).and_then(Tex::named).unwrap_or_default();
owners
.as_mut_slice()
.sort_unstable_by(|a, b| name(*a).cmp(name(*b)).then(a.cmp(b)));
self.owners = Some(owners);
Ok(())
}
pub fn name(&mut self, i: usize) -> Result<(), Class> {
let seam = self.seam;
let Some(t) = self.texs.as_slice().get(i).filter(|t| t.name.is_none()) else {
return Ok(());
};
let obj = t.obj.clone();
let name = match self.reader.peek_name(&seam, &obj) {
Ok(n) => Ok(n),
Err(c) => Err(Kept::keep(seam.meter, seam.hooks, c)?),
};
if let Some(t) = self.texs.as_mut_slice().get_mut(i) {
t.name = Some(name);
}
Ok(())
}
pub fn owner(&mut self, name: &[u8]) -> Result<Option<usize>, Class> {
if self.owners.is_some() && !self.late.is_empty() {
self.join_late()?;
}
let Some(owners) = self.owners.as_ref().map(MeteredVec::as_slice) else {
return Ok(None);
};
let texs = self.texs.as_slice();
let of = |i: usize| texs.get(i).and_then(Tex::named).unwrap_or_default();
let at = owners.partition_point(|i| of(*i) < name);
Ok(owners.get(at).copied().filter(|i| of(*i) == name))
}
fn join_late(&mut self) -> Result<(), Class> {
let internal = || Class::Run(Reason::plain("internal"));
while let Some(i) = self.late.as_slice().get(self.late_read).copied() {
#[cfg(feature = "test-counters")]
crate::testing::late_scan();
self.name(i)?;
if self.texs.as_slice().get(i).and_then(Tex::named).is_some() {
self.late_named += 1;
}
self.late_read += 1;
}
let seam = self.seam;
let meter = seam.meter;
let Some(owners) = self.owners.as_ref() else {
return Err(internal());
};
let texs = self.texs.as_slice();
let named = |i: &usize| texs.get(*i).and_then(Tex::named).is_some();
let n = owners.len() + self.late_named;
let mut joined = seam.probe(|| table::with_capacity(meter, n))?;
for i in owners.as_slice().iter().chain(self.late.as_slice()) {
if named(i) {
seam.probe(|| table::push(&mut joined, *i))?;
}
}
let name = |i: usize| texs.get(i).and_then(Tex::named).unwrap_or_default();
joined
.as_mut_slice()
.sort_unstable_by(|a, b| name(*a).cmp(name(*b)).then(a.cmp(b)));
self.owners = Some(joined);
self.late = MeteredVec::new(meter);
(self.late_read, self.late_named) = (0, 0);
Ok(())
}
pub fn texture(&mut self, i: usize) -> Result<Texture, Class> {
let seam = self.seam;
let t = self
.texs
.as_mut_slice()
.get_mut(i)
.ok_or(Class::Run(Reason::plain("internal")))?;
if t.read.is_none() {
let read = match seam.probe(|| read::texture(&t.obj)) {
Ok(t) => Ok(t),
Err(c) => Err(Kept::keep(seam.meter, seam.hooks, c)?),
};
t.read = Some(read);
}
match &t.read {
Some(Ok(t)) => Ok(t.clone()),
Some(Err(k)) => Err(k.class()),
None => Err(Class::Run(Reason::plain("internal"))),
}
}
pub fn selection(&self, i: usize, t: &Texture) -> Result<Format, Class> {
let obj = self.texs.as_slice().get(i).map(|x| &x.obj);
read::object_answer(t, obj, self.options.formats)
}
pub fn sheet_answer(&mut self, i: usize) -> Result<unityrs_texture::Mode, Class> {
let t = self.texture(i)?;
let format = self.selection(i, &t)?;
let platform = self
.texs
.as_slice()
.get(i)
.and_then(|t| t.obj.file().target_platform())
.unwrap_or(UNKNOWN_PLATFORM);
let mut blob = [0u8; 12];
Ok(t.fields(format.texture_format(), platform, &mut blob)
.image_mode()
.unwrap_or(format.mode()))
}
pub fn expand(&mut self, template: &Template, obj: &ObjectRef, vars: Vars<'_>) {
self.scratch.tail = expand(self.input, template, obj, vars, &mut self.scratch.key);
}
pub fn check_key(&mut self) -> Result<usize, KeyRule> {
let Scratch { key, full, .. } = &mut self.scratch;
check_prefixed(key, self.seam.prefix, full).map(str::len)
}
pub fn scratch_key(&self) -> &[u8] {
&self.scratch.key
}
pub fn take(&mut self, site: &Site<'_>) -> Result<Option<String>, Failure> {
if let Err(rule) = self.check_key() {
self.skip(site, unwritable(rule))?;
return Ok(None);
}
let key = std::mem::take(&mut self.scratch.key);
let taken = self.take_checked(&key, site);
self.scratch.key = key;
taken
}
pub fn take_checked(&mut self, k: &[u8], site: &Site<'_>) -> Result<Option<String>, Failure> {
let Ok(k) = std::str::from_utf8(k) else {
return Err(Failure::Run(Reason::plain("internal")));
};
let keys = &mut *self.keys;
let taken = self.seam.probe(|| keys.take(k)).map_err(Failure::from)?;
if !taken {
self.skip(site, Reason::plain("duplicate_key"))?;
return Ok(None);
}
self.hold(table::string(k.len()))?;
Ok(Some(k.to_owned()))
}
pub fn member_paths(
&mut self,
kind: TemplateKind,
obj: &ObjectRef,
vars: Vars<'_>,
) -> Result<MeteredVec<MemberPath>, Failure> {
let members = self.seam.members;
let n = members.iter().filter(|m| m.kind == kind).count();
let meter = self.seam.meter;
let mut out = self.charged(|| table::with_capacity(meter, n))?;
for m in members.iter().filter(|m| m.kind == kind) {
self.expand(&m.path, obj, vars);
let path = match check_member(&self.scratch.key) {
Ok(p) => Ok(p.len()),
Err(rule) => Err(rule),
};
let path = match path {
Ok(len) => {
self.hold(table::string(len))?;
let p = std::str::from_utf8(&self.scratch.key).unwrap_or_default();
let mut s = String::new();
s.try_reserve_exact(len)
.map_err(|_| Failure::from(table::host_memory()))?;
s.push_str(p);
Ok(s)
}
Err(rule) => {
let made = self.scratch.key.len();
let whole = made.saturating_sub(self.scratch.tail);
let key = &self.scratch.key;
let (len, _) = classify::text_len(&[key.get(..whole).unwrap_or_default()]);
self.hold(table::string(len))?;
let key = &self.scratch.key;
let (path, cut) = classify::try_text(&[key.get(..whole).unwrap_or_default()])
.map_err(|_| Failure::from(table::host_memory()))?;
let cut = cut || made > classify::CUT;
Err(Rejected { rule, path, cut })
}
};
self.charged(|| {
table::push(
&mut out,
MemberPath {
archive: m.archive,
path,
},
)
})?;
}
Ok(out)
}
}