1use std::sync::Arc;
35
36use unityrs_core::limits::Meter;
37use unityrs_core::{Map, Parsed, Value};
38
39use super::{SpriteData, SpriteError};
40
41#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
43pub struct Pptr {
44 pub file_id: i64,
46 pub path_id: i64,
48}
49
50impl Pptr {
51 #[must_use]
53 pub fn is_set(&self) -> bool {
54 self.path_id != 0
55 }
56}
57
58pub type Guid = [u64; 4];
60
61#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
65pub struct AtlasKey {
66 pub guid: Guid,
68 pub id: i64,
70}
71
72#[derive(Clone, Copy, Debug, PartialEq)]
76pub struct RenderData {
77 pub texture: Pptr,
79 pub alpha_texture: Option<Pptr>,
82 pub texture_rect: [f64; 4],
84 pub settings_raw: u64,
86}
87
88const _: () = crate::send_sync::<RenderData>();
89const _: () = crate::send_sync::<Pptr>();
90const _: () = crate::send_sync::<Guid>();
91const _: () = crate::send_sync::<AtlasKey>();
92const _: () = crate::send_sync::<SpriteFields<'static>>();
93
94#[derive(Clone, Debug, PartialEq)]
97pub struct SpriteFields<'p> {
98 pub pixels_to_units: f64,
100 pub rd: RenderData,
102 pub sprite_atlas: Option<Pptr>,
104 pub atlas_tag: Option<&'p [u8]>,
108 pub render_data_key: Option<AtlasKey>,
110}
111
112impl<'p> SpriteFields<'p> {
113 pub fn read(sprite: &'p Parsed, meter: &Arc<Meter>) -> Result<Self, SpriteError> {
118 let top = |name: &[u8]| top(sprite, name, meter);
119 let pixels_to_units = top(b"m_PixelsToUnits")?
120 .and_then(Value::as_f64)
121 .ok_or(SpriteError::Malformed("m_PixelsToUnits"))?;
122 let rd = top(b"m_RD")?.ok_or(SpriteError::Malformed("m_RD"))?;
123 let rd = render_data(sprite, rd, "m_RD", meter)?;
124 let sprite_atlas = match top(b"m_SpriteAtlas")? {
125 None => None,
126 Some(v) => {
127 Some(pptr(sprite, v, meter)?.ok_or(SpriteError::Malformed("m_SpriteAtlas"))?)
128 }
129 };
130 let atlas_tag = match top(b"m_AtlasTags")? {
131 None => None,
132 Some(Value::List(items)) => {
133 for v in items {
134 meter.count_decode(1)?;
135 if v.as_bytes().is_none() {
136 return Err(SpriteError::Malformed("m_AtlasTags"));
137 }
138 }
139 items.first().and_then(Value::as_bytes)
140 }
141 Some(_) => return Err(SpriteError::Malformed("m_AtlasTags")),
142 };
143 let render_data_key = match top(b"m_RenderDataKey")? {
144 None => None,
145 Some(v) => {
146 Some(key(sprite, v, meter)?.ok_or(SpriteError::Malformed("m_RenderDataKey"))?)
147 }
148 };
149 Ok(Self {
150 pixels_to_units,
151 rd,
152 sprite_atlas,
153 atlas_tag,
154 render_data_key,
155 })
156 }
157
158 #[must_use]
161 pub fn data(&self, rd: &RenderData) -> SpriteData {
162 SpriteData {
163 texture_rect: rd.texture_rect,
164 settings_raw: rd.settings_raw,
165 pixels_to_units: self.pixels_to_units,
166 }
167 }
168}
169
170pub fn select_render_data<'a, D, I, F>(
182 sprite: &SpriteFields<'_>,
183 deref: D,
184 file_atlases: I,
185 meter: &Arc<Meter>,
186) -> Result<RenderData, SpriteError>
187where
188 D: FnOnce(Pptr) -> Option<&'a Parsed>,
189 I: IntoIterator<Item = (&'a [u8], F)>,
190 F: FnOnce() -> Option<&'a Parsed>,
191{
192 let key = sprite.render_data_key.as_ref();
193 if let Some(p) = sprite.sprite_atlas.filter(Pptr::is_set) {
194 let atlas = deref(p).ok_or(SpriteError::AtlasUnresolved)?;
195 return atlas_render_data(atlas, key, meter);
196 }
197 if let Some(tag) = sprite.atlas_tag {
198 for (name, parse) in file_atlases {
199 meter.count_decode(compared(name, tag))?;
200 if name == tag {
201 let atlas = parse().ok_or(SpriteError::AtlasUnresolved)?;
202 return atlas_render_data(atlas, key, meter);
203 }
204 }
205 }
206 Ok(sprite.rd)
207}
208
209pub fn atlas_render_data(
217 atlas: &Parsed,
218 key: Option<&AtlasKey>,
219 meter: &Arc<Meter>,
220) -> Result<RenderData, SpriteError> {
221 let map =
222 top(atlas, b"m_RenderDataMap", meter)?.ok_or(SpriteError::Malformed("m_RenderDataMap"))?;
223 let Value::List(entries) = map else {
224 return Err(SpriteError::Malformed("m_RenderDataMap"));
225 };
226 for entry in entries {
227 meter.count_decode(1)?;
228 let Value::Tuple(pair) = entry else {
229 return Err(SpriteError::Malformed("m_RenderDataMap"));
230 };
231 let (Some(k), Some(v)) = (pair.first(), pair.get(1)) else {
232 return Err(SpriteError::Malformed("m_RenderDataMap"));
233 };
234 let k = self::key(atlas, k, meter)?.ok_or(SpriteError::Malformed("m_RenderDataMap"))?;
235 if Some(&k) == key {
236 return render_data(atlas, v, "m_RenderDataMap", meter);
237 }
238 }
239 Err(SpriteError::NoAtlasData)
240}
241
242fn render_data(
243 parsed: &Parsed,
244 v: &Value,
245 what: &'static str,
246 meter: &Meter,
247) -> Result<RenderData, SpriteError> {
248 let Value::Dict(m) = v else {
249 return Err(SpriteError::Malformed(what));
250 };
251 let field = |name: &[u8]| field(parsed, m, name, meter);
252 let texture = match field(b"texture")? {
253 Some(t) => pptr(parsed, t, meter)?,
254 None => None,
255 }
256 .ok_or(SpriteError::Malformed(what))?;
257 let alpha_texture = match field(b"alphaTexture")? {
258 None => None,
259 Some(t) => Some(pptr(parsed, t, meter)?.ok_or(SpriteError::Malformed(what))?),
260 };
261 let rect = field(b"textureRect")?
262 .and_then(Value::as_dict)
263 .ok_or(SpriteError::Malformed(what))?;
264 let mut texture_rect = [0.0; 4];
265 for (out, name) in texture_rect
266 .iter_mut()
267 .zip([&b"x"[..], b"y", b"width", b"height"])
268 {
269 *out = self::field(parsed, rect, name, meter)?
270 .and_then(Value::as_f64)
271 .ok_or(SpriteError::Malformed(what))?;
272 }
273 let settings_raw = field(b"settingsRaw")?
274 .and_then(Value::as_u64)
275 .ok_or(SpriteError::Malformed(what))?;
276 Ok(RenderData {
277 texture,
278 alpha_texture,
279 texture_rect,
280 settings_raw,
281 })
282}
283
284fn pptr(parsed: &Parsed, v: &Value, meter: &Meter) -> Result<Option<Pptr>, SpriteError> {
286 let Some(m) = v.as_dict() else {
287 return Ok(None);
288 };
289 let id =
290 |name: &[u8]| Ok::<_, SpriteError>(field(parsed, m, name, meter)?.and_then(Value::as_i64));
291 let (Some(file_id), Some(path_id)) = (id(b"m_FileID")?, id(b"m_PathID")?) else {
292 return Ok(None);
293 };
294 Ok(Some(Pptr { file_id, path_id }))
295}
296
297fn key(parsed: &Parsed, v: &Value, meter: &Meter) -> Result<Option<AtlasKey>, SpriteError> {
299 let Value::Tuple(pair) = v else {
300 return Ok(None);
301 };
302 let (Some(guid), Some(id)) = (
303 pair.first().and_then(Value::as_dict),
304 pair.get(1).and_then(Value::as_i64),
305 ) else {
306 return Ok(None);
307 };
308 let mut words = [0_u64; 4];
309 for (w, name) in words
310 .iter_mut()
311 .zip([&b"data[0]"[..], b"data[1]", b"data[2]", b"data[3]"])
312 {
313 let Some(word) = field(parsed, guid, name, meter)?.and_then(Value::as_u64) else {
314 return Ok(None);
315 };
316 *w = word;
317 }
318 Ok(Some(AtlasKey { guid: words, id }))
319}
320
321fn compared(a: &[u8], b: &[u8]) -> u64 {
325 1 + if a.len() == b.len() {
326 a.len() as u64
327 } else {
328 0
329 }
330}
331
332fn field<'a>(
336 parsed: &'a Parsed,
337 map: &'a Map,
338 name: &[u8],
339 meter: &Meter,
340) -> Result<Option<&'a Value>, SpriteError> {
341 for (n, v) in parsed.entries(map) {
342 meter.count_decode(compared(n, name))?;
343 if n == name {
344 return Ok(Some(v));
345 }
346 }
347 Ok(None)
348}
349
350fn top<'a>(
352 parsed: &'a Parsed,
353 name: &[u8],
354 meter: &Meter,
355) -> Result<Option<&'a Value>, SpriteError> {
356 match parsed.value() {
357 Value::Dict(m) => field(parsed, m, name, meter),
358 _ => Ok(None),
359 }
360}