use std::sync::Arc;
use unityrs_core::limits::Meter;
use unityrs_core::typetree::{NodeId, NodeList};
use unityrs_core::walk::write::cleans_to;
use unityrs_core::{Map, Parsed, Value};
use super::super::classify::{self, Class, Reason};
use super::super::read;
struct Layout {
ty: &'static [u8],
prefix: bool,
required: &'static [&'static [u8]],
slots: Option<&'static [&'static [u8]]>,
setterless: &'static [&'static [u8]],
}
const SPRITE: Layout = Layout {
ty: b"Sprite",
prefix: false,
required: &[
b"m_Extrude",
b"m_Name",
b"m_Offset",
b"m_PixelsToUnits",
b"m_RD",
b"m_Rect",
],
slots: None,
setterless: &read::SETTERLESS,
};
const PPTR: Layout = Layout {
ty: b"PPtr<",
prefix: true,
required: &[b"m_FileID", b"m_PathID"],
slots: Some(&[b"m_FileID", b"m_PathID", b"assetsfile"]),
setterless: &[],
};
const RENDER_DATA: Layout = Layout {
ty: b"SpriteRenderData",
prefix: false,
required: &[
b"settingsRaw",
b"texture",
b"textureRect",
b"textureRectOffset",
],
slots: Some(&[
b"settingsRaw",
b"texture",
b"textureRect",
b"textureRectOffset",
b"alphaTexture",
b"atlasRectOffset",
b"downscaleMultiplier",
b"indices",
b"m_Bindpose",
b"m_IndexBuffer",
b"m_SourceSkin",
b"m_SubMeshes",
b"m_VertexData",
b"secondaryTextures",
b"uvTransform",
b"vertices",
]),
setterless: &[],
};
const ATLAS_DATA: Layout = Layout {
ty: b"SpriteAtlasData",
prefix: false,
required: &[
b"alphaTexture",
b"downscaleMultiplier",
b"settingsRaw",
b"texture",
b"textureRect",
b"textureRectOffset",
b"uvTransform",
],
slots: Some(&[
b"alphaTexture",
b"downscaleMultiplier",
b"settingsRaw",
b"texture",
b"textureRect",
b"textureRectOffset",
b"uvTransform",
b"atlasRectOffset",
b"secondaryTextures",
]),
setterless: &[],
};
const GUID_WORDS: [&[u8]; 4] = [b"data_0_", b"data_1_", b"data_2_", b"data_3_"];
const GUID: Layout = Layout {
ty: b"GUID",
prefix: false,
required: &GUID_WORDS,
slots: Some(&GUID_WORDS),
setterless: &[],
};
const UNATTACHED: [&Layout; 4] = [&PPTR, &GUID, &RENDER_DATA, &ATLAS_DATA];
pub(super) fn render() -> Class {
Class::Skip(Reason::decode_error("render"))
}
fn work(meter: &Meter, n: usize) -> Result<(), Class> {
meter
.count_decode(u64::try_from(n).unwrap_or(u64::MAX))
.map_err(|e| classify::charge(&e))
}
fn node<'a>(parsed: &'a Parsed, map: &Map) -> Option<(&'a NodeList, NodeId)> {
let list = usize::try_from(map.list())
.ok()
.and_then(|i| parsed.lists().get(i))?;
let first = map.entries().first()?.0;
let n = NodeId(first.0.checked_sub(1)?);
(list.children(n).first() == Some(&first)).then_some((&**list, n))
}
fn constructs(parsed: &Parsed, map: &Map, layout: &Layout, meter: &Meter) -> Result<bool, Class> {
let Some((list, n)) = node(parsed, map) else {
return Ok(false);
};
let ty = list.type_name(n);
let typed = if layout.prefix {
ty.starts_with(layout.ty)
} else {
ty == layout.ty
};
if !typed {
return Ok(false);
}
let kids = list.children(n);
let names =
layout.required.len() + layout.slots.map_or(0, <[_]>::len) + layout.setterless.len();
work(meter, kids.len().saturating_mul(names))?;
let cleaned = |k: &NodeId, name: &[u8]| cleans_to(list.name(*k), name);
let has = layout
.required
.iter()
.all(|r| kids.iter().any(|k| cleaned(k, r)));
let fits = layout
.slots
.is_none_or(|s| kids.iter().all(|k| s.iter().any(|x| cleaned(k, x))));
let sets = !kids
.iter()
.any(|k| layout.setterless.iter().any(|x| cleaned(k, x)));
Ok(has && fits && sets)
}
pub(super) fn attaches(parsed: &Parsed, meter: &Meter) -> Result<bool, Class> {
let Value::Dict(root) = parsed.value() else {
return Ok(false);
};
work(meter, root.len())?;
if read::shadowed(parsed, root) {
return Ok(false);
}
for layout in UNATTACHED {
if constructs(parsed, root, layout, meter)? {
return Ok(false);
}
}
Ok(true)
}
fn attr<'a>(
parsed: &'a Parsed,
map: &'a Map,
name: &[u8],
meter: &Meter,
) -> Result<Option<&'a Value>, Class> {
work(meter, map.len().saturating_add(1))?;
Ok(parsed.attr(map, name))
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(super) enum Num {
Int(i128),
Float(u64),
}
impl Num {
#[must_use]
pub fn of(v: &Value) -> Option<Self> {
match v {
Value::Int(i) => Some(Self::Int(i128::from(*i))),
Value::UInt(u) => Some(Self::Int(i128::from(*u))),
Value::Bool(b) => Some(Self::Int(i128::from(*b))),
Value::F32(_) | Value::F64(_) => v.as_f64().and_then(Self::float),
_ => None,
}
}
fn float(x: f64) -> Option<Self> {
if x.is_nan() {
return None;
}
if x.fract() == 0.0 && x.abs() < 2f64.powi(100) {
#[allow(clippy::cast_possible_truncation)]
return Some(Self::Int(x as i128));
}
Some(Self::Float(x.to_bits()))
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum Ptr {
Ids(Ids),
Other(bool),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) struct Ids {
pub file_id: i128,
pub path_id: i128,
}
impl Ptr {
#[must_use]
pub fn is_set(self) -> bool {
match self {
Self::Ids(i) => i.path_id != 0,
Self::Other(t) => t,
}
}
#[must_use]
pub fn ids(self) -> Option<Ids> {
match self {
Self::Ids(i) => Some(i),
Self::Other(_) => None,
}
}
}
fn pointer(parsed: &Parsed, v: &Value, meter: &Meter) -> Result<Ptr, Class> {
if let Value::Dict(m) = v
&& constructs(parsed, m, &PPTR, meter)?
{
let id = |name: &[u8]| -> Result<i128, Class> {
attr(parsed, m, name, meter)?
.and_then(read::integer)
.ok_or_else(read::shape)
};
let file_id = id(b"m_FileID")?;
let path_id = id(b"m_PathID")?;
return Ok(Ptr::Ids(Ids { file_id, path_id }));
}
Ok(Ptr::Other(truthy(parsed, v, meter)?))
}
fn truthy(parsed: &Parsed, v: &Value, meter: &Meter) -> Result<bool, Class> {
Ok(match v {
Value::Bool(b) => *b,
Value::Int(i) => *i != 0,
Value::UInt(u) => *u != 0,
Value::F32(_) | Value::F64(_) => v.as_f64() != Some(0.0),
Value::Str(s) => !s.as_bytes().is_empty(),
Value::Bytes(b) => !b.is_empty(),
Value::Prims(p) => !p.is_empty(),
Value::List(l) => !l.is_empty(),
Value::Tuple(t) => !t.is_empty(),
Value::Dict(m) => {
if constructs(parsed, m, &PPTR, meter)? {
let path = attr(parsed, m, b"m_PathID", meter)?;
!matches!(path.and_then(Num::of), Some(Num::Int(0)))
} else {
true
}
}
})
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(super) struct Key {
guid: [Num; 4],
id: Num,
}
pub(super) fn key(parsed: &Parsed, v: &Value, meter: &Meter) -> Result<Option<Key>, Class> {
work(meter, 1)?;
let Value::Tuple(pair) = v else {
return Ok(None);
};
let [Value::Dict(guid), id] = &pair[..] else {
return Ok(None);
};
let Some(id) = Num::of(id) else {
return Ok(None);
};
if !constructs(parsed, guid, &GUID, meter)? {
return Ok(None);
}
let mut words = [Num::Int(0); 4];
for (w, name) in words.iter_mut().zip(GUID_WORDS) {
let Some(n) = attr(parsed, guid, name, meter)?.and_then(Num::of) else {
return Ok(None);
};
*w = n;
}
Ok(Some(Key { guid: words, id }))
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum Tag<'p> {
None,
Name(&'p [u8]),
NoMatch,
Raises,
}
fn first_char(s: &[u8]) -> &[u8] {
let n = s.utf8_chunks().next().map_or(0, |c| {
c.valid()
.chars()
.next()
.map_or(usize::from(!c.invalid().is_empty()), char::len_utf8)
});
s.get(..n).unwrap_or_default()
}
fn tag<'p>(parsed: &Parsed, v: Option<&'p Value>, meter: &Meter) -> Result<Tag<'p>, Class> {
let Some(v) = v else {
return Ok(Tag::None);
};
if !truthy(parsed, v, meter)? {
return Ok(Tag::None);
}
Ok(match v {
Value::List(items) => first_of(items),
Value::Tuple(items) => first_of(items),
Value::Str(s) => Tag::Name(first_char(s.as_bytes())),
Value::Prims(_) | Value::Bytes(_) => Tag::NoMatch,
_ => Tag::Raises,
})
}
fn first_of(items: &[Value]) -> Tag<'_> {
match items.first() {
Some(Value::Str(s)) => Tag::Name(s.as_bytes()),
_ => Tag::NoMatch,
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum Alpha {
None,
Missing,
Set(Ptr),
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub(super) struct RenderData {
pub texture: Ptr,
pub alpha: Alpha,
pub texture_rect: [f64; 4],
pub settings_raw: u64,
}
pub(super) struct SpriteRead<'p> {
pub ppu: f64,
pub rd: RenderData,
pub atlas: Option<Ptr>,
pub tag: Tag<'p>,
pub key: Option<Key>,
}
pub(super) fn sprite<'p>(parsed: &'p Parsed, meter: &Arc<Meter>) -> Result<SpriteRead<'p>, Class> {
let Value::Dict(root) = parsed.value() else {
return Err(read::shape());
};
work(meter, root.len())?;
if read::shadowed(parsed, root) || !constructs(parsed, root, &SPRITE, meter)? {
return Err(read::shape());
}
let ppu = attr(parsed, root, b"m_PixelsToUnits", meter)?
.and_then(Value::as_f64)
.ok_or_else(read::shape)?;
let rd = match attr(parsed, root, b"m_RD", meter)? {
Some(Value::Dict(m)) => {
let constructed = constructs(parsed, m, &RENDER_DATA, meter)?;
render_data(parsed, m, constructed, meter)?
}
_ => return Err(read::shape()),
};
let atlas = match attr(parsed, root, b"m_SpriteAtlas", meter)? {
Some(v) => Some(pointer(parsed, v, meter)?),
None => None,
};
let tag = tag(parsed, attr(parsed, root, b"m_AtlasTags", meter)?, meter)?;
let key = match attr(parsed, root, b"m_RenderDataKey", meter)? {
Some(v) => key(parsed, v, meter)?,
None => None,
};
Ok(SpriteRead {
ppu,
rd,
atlas,
tag,
key,
})
}
pub(super) enum Item<'p> {
Entry(Option<Key>, &'p Value),
Other,
}
#[derive(Debug, PartialEq)]
enum Unpacked<'v> {
Pair(&'v Value, &'v Value),
Opaque,
}
fn unpack(v: &Value) -> Option<Unpacked<'_>> {
match v {
Value::Tuple(t) => match &t[..] {
[k, v] => Some(Unpacked::Pair(k, v)),
_ => None,
},
Value::List(l) => match &l[..] {
[k, v] => Some(Unpacked::Pair(k, v)),
_ => None,
},
Value::Prims(p) => (p.len() == 2).then_some(Unpacked::Opaque),
Value::Bytes(b) => (b.len() == 2).then_some(Unpacked::Opaque),
Value::Str(s) => {
let one = first_char(s.as_bytes()).len();
let rest = s.as_bytes().get(one..).unwrap_or_default();
(one > 0 && !rest.is_empty() && first_char(rest).len() == rest.len())
.then_some(Unpacked::Opaque)
}
_ => None,
}
}
pub(super) fn walk<'p>(
atlas: &'p Parsed,
meter: &Meter,
mut visit: impl FnMut(Item<'p>) -> Result<bool, Class>,
) -> Result<Option<Class>, Class> {
let Value::Dict(root) = atlas.value() else {
return Ok(Some(render()));
};
let Some(map) = attr(atlas, root, b"m_RenderDataMap", meter)? else {
return Ok(Some(render()));
};
let items: &[Value] = match map {
Value::List(items) => items,
Value::Tuple(items) => items,
Value::Str(s) if s.as_bytes().is_empty() => &[],
Value::Bytes(b) if b.is_empty() => &[],
Value::Prims(p) if p.is_empty() => &[],
_ => return Ok(Some(render())),
};
for item in items {
work(meter, 1)?;
let item = match unpack(item) {
None => return Ok(Some(render())),
Some(Unpacked::Opaque) => Item::Other,
Some(Unpacked::Pair(k, v)) => Item::Entry(key(atlas, k, meter)?, v),
};
if !visit(item)? {
break;
}
}
Ok(None)
}
pub(super) fn atlas_data(atlas: &Parsed, v: &Value, meter: &Meter) -> Result<RenderData, Class> {
let Value::Dict(m) = v else {
return Err(render());
};
if !constructs(atlas, m, &ATLAS_DATA, meter)? {
return Err(render());
}
render_data(atlas, m, true, meter)
}
fn render_data(
parsed: &Parsed,
m: &Map,
constructed: bool,
meter: &Meter,
) -> Result<RenderData, Class> {
let texture = match attr(parsed, m, b"texture", meter)? {
Some(t) => pointer(parsed, t, meter)?,
None => return Err(read::shape()),
};
let alpha = match attr(parsed, m, b"alphaTexture", meter)? {
Some(t) => Alpha::Set(pointer(parsed, t, meter)?),
None if constructed => Alpha::None,
None => Alpha::Missing,
};
let Some(Value::Dict(rect)) = attr(parsed, m, b"textureRect", meter)? else {
return Err(read::shape());
};
let mut texture_rect = [0.0; 4];
for (out, name) in texture_rect
.iter_mut()
.zip([&b"x"[..], b"y", b"width", b"height"])
{
*out = attr(parsed, rect, name, meter)?
.and_then(Value::as_f64)
.ok_or_else(read::shape)?;
}
let settings_raw = attr(parsed, m, b"settingsRaw", meter)?
.and_then(Value::as_u64)
.ok_or_else(read::shape)?;
Ok(RenderData {
texture,
alpha,
texture_rect,
settings_raw,
})
}
#[cfg(test)]
mod tests;