use std::sync::Arc;
use unityrs_core::limits::Meter;
use unityrs_core::{Map, Parsed, Value};
use super::{SpriteData, SpriteError};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct Pptr {
pub file_id: i64,
pub path_id: i64,
}
impl Pptr {
#[must_use]
pub fn is_set(&self) -> bool {
self.path_id != 0
}
}
pub type Guid = [u64; 4];
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct AtlasKey {
pub guid: Guid,
pub id: i64,
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct RenderData {
pub texture: Pptr,
pub alpha_texture: Option<Pptr>,
pub texture_rect: [f64; 4],
pub settings_raw: u64,
}
const _: () = crate::send_sync::<RenderData>();
const _: () = crate::send_sync::<Pptr>();
const _: () = crate::send_sync::<Guid>();
const _: () = crate::send_sync::<AtlasKey>();
const _: () = crate::send_sync::<SpriteFields<'static>>();
#[derive(Clone, Debug, PartialEq)]
pub struct SpriteFields<'p> {
pub pixels_to_units: f64,
pub rd: RenderData,
pub sprite_atlas: Option<Pptr>,
pub atlas_tag: Option<&'p [u8]>,
pub render_data_key: Option<AtlasKey>,
}
impl<'p> SpriteFields<'p> {
pub fn read(sprite: &'p Parsed, meter: &Arc<Meter>) -> Result<Self, SpriteError> {
let top = |name: &[u8]| top(sprite, name, meter);
let pixels_to_units = top(b"m_PixelsToUnits")?
.and_then(Value::as_f64)
.ok_or(SpriteError::Malformed("m_PixelsToUnits"))?;
let rd = top(b"m_RD")?.ok_or(SpriteError::Malformed("m_RD"))?;
let rd = render_data(sprite, rd, "m_RD", meter)?;
let sprite_atlas = match top(b"m_SpriteAtlas")? {
None => None,
Some(v) => {
Some(pptr(sprite, v, meter)?.ok_or(SpriteError::Malformed("m_SpriteAtlas"))?)
}
};
let atlas_tag = match top(b"m_AtlasTags")? {
None => None,
Some(Value::List(items)) => {
for v in items {
meter.count_decode(1)?;
if v.as_bytes().is_none() {
return Err(SpriteError::Malformed("m_AtlasTags"));
}
}
items.first().and_then(Value::as_bytes)
}
Some(_) => return Err(SpriteError::Malformed("m_AtlasTags")),
};
let render_data_key = match top(b"m_RenderDataKey")? {
None => None,
Some(v) => {
Some(key(sprite, v, meter)?.ok_or(SpriteError::Malformed("m_RenderDataKey"))?)
}
};
Ok(Self {
pixels_to_units,
rd,
sprite_atlas,
atlas_tag,
render_data_key,
})
}
#[must_use]
pub fn data(&self, rd: &RenderData) -> SpriteData {
SpriteData {
texture_rect: rd.texture_rect,
settings_raw: rd.settings_raw,
pixels_to_units: self.pixels_to_units,
}
}
}
pub fn select_render_data<'a, D, I, F>(
sprite: &SpriteFields<'_>,
deref: D,
file_atlases: I,
meter: &Arc<Meter>,
) -> Result<RenderData, SpriteError>
where
D: FnOnce(Pptr) -> Option<&'a Parsed>,
I: IntoIterator<Item = (&'a [u8], F)>,
F: FnOnce() -> Option<&'a Parsed>,
{
let key = sprite.render_data_key.as_ref();
if let Some(p) = sprite.sprite_atlas.filter(Pptr::is_set) {
let atlas = deref(p).ok_or(SpriteError::AtlasUnresolved)?;
return atlas_render_data(atlas, key, meter);
}
if let Some(tag) = sprite.atlas_tag {
for (name, parse) in file_atlases {
meter.count_decode(compared(name, tag))?;
if name == tag {
let atlas = parse().ok_or(SpriteError::AtlasUnresolved)?;
return atlas_render_data(atlas, key, meter);
}
}
}
Ok(sprite.rd)
}
pub fn atlas_render_data(
atlas: &Parsed,
key: Option<&AtlasKey>,
meter: &Arc<Meter>,
) -> Result<RenderData, SpriteError> {
let map =
top(atlas, b"m_RenderDataMap", meter)?.ok_or(SpriteError::Malformed("m_RenderDataMap"))?;
let Value::List(entries) = map else {
return Err(SpriteError::Malformed("m_RenderDataMap"));
};
for entry in entries {
meter.count_decode(1)?;
let Value::Tuple(pair) = entry else {
return Err(SpriteError::Malformed("m_RenderDataMap"));
};
let (Some(k), Some(v)) = (pair.first(), pair.get(1)) else {
return Err(SpriteError::Malformed("m_RenderDataMap"));
};
let k = self::key(atlas, k, meter)?.ok_or(SpriteError::Malformed("m_RenderDataMap"))?;
if Some(&k) == key {
return render_data(atlas, v, "m_RenderDataMap", meter);
}
}
Err(SpriteError::NoAtlasData)
}
fn render_data(
parsed: &Parsed,
v: &Value,
what: &'static str,
meter: &Meter,
) -> Result<RenderData, SpriteError> {
let Value::Dict(m) = v else {
return Err(SpriteError::Malformed(what));
};
let field = |name: &[u8]| field(parsed, m, name, meter);
let texture = match field(b"texture")? {
Some(t) => pptr(parsed, t, meter)?,
None => None,
}
.ok_or(SpriteError::Malformed(what))?;
let alpha_texture = match field(b"alphaTexture")? {
None => None,
Some(t) => Some(pptr(parsed, t, meter)?.ok_or(SpriteError::Malformed(what))?),
};
let rect = field(b"textureRect")?
.and_then(Value::as_dict)
.ok_or(SpriteError::Malformed(what))?;
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 = self::field(parsed, rect, name, meter)?
.and_then(Value::as_f64)
.ok_or(SpriteError::Malformed(what))?;
}
let settings_raw = field(b"settingsRaw")?
.and_then(Value::as_u64)
.ok_or(SpriteError::Malformed(what))?;
Ok(RenderData {
texture,
alpha_texture,
texture_rect,
settings_raw,
})
}
fn pptr(parsed: &Parsed, v: &Value, meter: &Meter) -> Result<Option<Pptr>, SpriteError> {
let Some(m) = v.as_dict() else {
return Ok(None);
};
let id =
|name: &[u8]| Ok::<_, SpriteError>(field(parsed, m, name, meter)?.and_then(Value::as_i64));
let (Some(file_id), Some(path_id)) = (id(b"m_FileID")?, id(b"m_PathID")?) else {
return Ok(None);
};
Ok(Some(Pptr { file_id, path_id }))
}
fn key(parsed: &Parsed, v: &Value, meter: &Meter) -> Result<Option<AtlasKey>, SpriteError> {
let Value::Tuple(pair) = v else {
return Ok(None);
};
let (Some(guid), Some(id)) = (
pair.first().and_then(Value::as_dict),
pair.get(1).and_then(Value::as_i64),
) else {
return Ok(None);
};
let mut words = [0_u64; 4];
for (w, name) in words
.iter_mut()
.zip([&b"data[0]"[..], b"data[1]", b"data[2]", b"data[3]"])
{
let Some(word) = field(parsed, guid, name, meter)?.and_then(Value::as_u64) else {
return Ok(None);
};
*w = word;
}
Ok(Some(AtlasKey { guid: words, id }))
}
fn compared(a: &[u8], b: &[u8]) -> u64 {
1 + if a.len() == b.len() {
a.len() as u64
} else {
0
}
}
fn field<'a>(
parsed: &'a Parsed,
map: &'a Map,
name: &[u8],
meter: &Meter,
) -> Result<Option<&'a Value>, SpriteError> {
for (n, v) in parsed.entries(map) {
meter.count_decode(compared(n, name))?;
if n == name {
return Ok(Some(v));
}
}
Ok(None)
}
fn top<'a>(
parsed: &'a Parsed,
name: &[u8],
meter: &Meter,
) -> Result<Option<&'a Value>, SpriteError> {
match parsed.value() {
Value::Dict(m) => field(parsed, m, name, meter),
_ => Ok(None),
}
}