1use crate::pyjson::{self, Options, Sink};
15use std::sync::Arc;
16use unityrs_core::limits::{ChargeError, Meter, MeteredVec};
17use unityrs_core::typetree::TreeError;
18use unityrs_core::walk::{ParseError, ReadDetail};
19use unityrs_core::{ObjectRef, Parsed, PrimArray, Value, env::Environment};
20
21#[derive(Clone, Copy, Debug, PartialEq, Eq)]
23pub enum Fallback {
24 NoTypeTree,
25 ReadFailed,
26 JsonUnwritable,
27}
28#[derive(Debug)]
30pub struct Export<'a> {
31 pub extension: &'a str,
32 pub bytes: MeteredVec<u8>,
33 pub fallback: Option<Fallback>,
34}
35#[derive(Debug, thiserror::Error)]
36pub enum Error {
37 #[error("no simple exporter for class {0}")]
38 UnsupportedClass(i32),
39 #[error("missing or invalid export field {0}")]
40 Field(&'static str),
41 #[error("typetree read {actual} bytes, expected {expected}")]
42 CheckRead { expected: u32, actual: i64 },
43 #[error(transparent)]
44 Parse(#[from] ParseError),
45 #[error(transparent)]
46 Core(#[from] unityrs_core::Error),
47 #[error(transparent)]
48 Charge(#[from] ChargeError),
49 #[error(transparent)]
50 Json(#[from] pyjson::WriteError),
51}
52#[must_use]
55pub const fn supports(class_id: i32) -> bool {
56 matches!(class_id, 49 | 128 | 114 | 329)
57}
58pub fn export<'a>(
68 obj: &ObjectRef,
69 env: &Environment,
70 extension: &'a str,
71 meter: &Arc<Meter>,
72) -> Result<Option<Export<'a>>, Error> {
73 if !supports(obj.class_id()) {
74 return Err(Error::UnsupportedClass(obj.class_id()));
75 }
76 let parsed = read(obj, env);
77 let parsed = match parsed {
78 Ok(parsed) => parsed,
79 Err(e) if obj.class_id() == 114 && read_failed(&e) => {
80 let why = if matches!(e, Error::Parse(ParseError::NoTypeTree { .. })) {
81 Fallback::NoTypeTree
82 } else {
83 Fallback::ReadFailed
84 };
85 return raw(obj, why, meter).map(Some);
86 }
87 Err(e) => return Err(e),
88 };
89 let (extension, bytes) = match obj.class_id() {
90 49 => {
91 let Value::Str(script) = attr(&parsed, b"m_Script")? else {
92 return Err(Error::Field("m_Script"));
93 };
94 (
95 if extension.is_empty() {
96 ".txt"
97 } else {
98 extension
99 },
100 copy(script.as_bytes(), meter)?,
101 )
102 }
103 128 => {
104 let data = attr(&parsed, b"m_FontData")?;
105 let bytes = font(data, meter)?;
106 if bytes.is_empty() {
107 return Ok(None);
108 }
109 let extension = if matches!(data, Value::Bytes(b) if b.starts_with(b"OTTO")) {
112 ".otf"
113 } else {
114 ".ttf"
115 };
116 (extension, bytes)
117 }
118 114 => match json(&parsed, meter) {
119 Ok(bytes) => (".json", bytes),
120 Err(Error::Json(pyjson::WriteError::Unwritable(_))) => {
121 return raw(obj, Fallback::JsonUnwritable, meter).map(Some);
122 }
123 Err(e) => return Err(e),
124 },
125 329 => {
126 let resource = attr(&parsed, b"m_ExternalResources")?;
127 let map = resource
128 .as_dict()
129 .ok_or(Error::Field("m_ExternalResources"))?;
130 let get = |name| {
131 parsed
132 .attr(map, name)
133 .ok_or(Error::Field("StreamedResource"))
134 };
135 let Value::Str(path) = get(b"m_Source")? else {
136 return Err(Error::Field("m_Source"));
137 };
138 let offset = get(b"m_Offset")?.as_u64().ok_or(Error::Field("m_Offset"))?;
139 let size = get(b"m_Size")?.as_u64().ok_or(Error::Field("m_Size"))?;
140 let data = env.resource(obj.file(), path, offset, size)?;
141 (
142 if extension.is_empty() {
143 ".video"
144 } else {
145 extension
146 },
147 copy(&data, meter)?,
148 )
149 }
150 id => return Err(Error::UnsupportedClass(id)),
151 };
152 Ok(Some(Export {
153 extension,
154 bytes,
155 fallback: None,
156 }))
157}
158pub(crate) fn read(obj: &ObjectRef, env: &Environment) -> Result<Parsed, Error> {
159 let Some(tree) = env.object_tree(obj, None)? else {
160 return Err(ParseError::NoTypeTree {
161 class_id: obj.class_id(),
162 why: obj.why_no_tree(),
163 }
164 .into());
165 };
166 let parsed = obj.read_typetree(Some(&tree.tree), false)?;
167 let expected = obj.info().byte_size;
170 if parsed.bytes_read != i64::from(expected) {
171 return Err(Error::CheckRead {
172 expected,
173 actual: parsed.bytes_read,
174 });
175 }
176 Ok(parsed)
177}
178pub(crate) fn read_failed(error: &Error) -> bool {
179 match error {
180 Error::CheckRead { .. } => true,
181 Error::Parse(p) => semantic(p),
182 _ => false,
183 }
184}
185fn semantic(error: &ParseError) -> bool {
188 enum Fault<'a> {
189 Parse(&'a ParseError),
190 Tree(&'a TreeError),
191 Deref(&'a unityrs_core::env::DerefError),
192 Core(&'a unityrs_core::Error),
193 }
194 let mut fault = Fault::Parse(error);
195 loop {
196 fault = match fault {
197 Fault::Parse(p) => match p {
198 ParseError::NoTypeTree { .. } | ParseError::CheckRead { .. } => return true,
199 ParseError::Read(r) => match &r.detail {
200 ReadDetail::Tree(t) => Fault::Tree(t),
201 ReadDetail::Limit(_) | ReadDetail::Charge(_) => return false,
202 _ => return true,
203 },
204 ParseError::Tree(t) => Fault::Tree(t),
205 ParseError::Provider(p) => {
206 return p.limit.is_none() && p.memory.is_none() && p.allocator.is_none();
207 }
208 ParseError::Deref(d) => Fault::Deref(d),
209 _ => return false,
210 },
211 Fault::Tree(t) => {
212 return matches!(t, TreeError::Empty | TreeError::LevelUnderflow { .. });
213 }
214 Fault::Deref(d) => match d {
215 unityrs_core::env::DerefError::Load(e) => Fault::Core(e),
216 _ => return true,
217 },
218 Fault::Core(e) => match e {
219 unityrs_core::Error::Tree(t) => Fault::Tree(t),
220 unityrs_core::Error::AssetBundle(p) => Fault::Parse(p),
221 unityrs_core::Error::Entry { source, .. } => Fault::Core(source),
222 unityrs_core::Error::Deref(d) => Fault::Deref(d),
223 unityrs_core::Error::Limit(_)
224 | unityrs_core::Error::Budget(_)
225 | unityrs_core::Error::Allocator(_) => return false,
226 unityrs_core::Error::Detect(d) => {
227 return matches!(
228 d,
229 unityrs_core::detect::DetectError::Unterminated
230 | unityrs_core::detect::DetectError::Gzip(_)
231 | unityrs_core::detect::DetectError::GzipCrc { .. }
232 );
233 }
234 unityrs_core::Error::Io(e) => return e.0.kind() != std::io::ErrorKind::OutOfMemory,
235 _ => return true,
236 },
237 };
238 }
239}
240pub(crate) fn attr<'a>(parsed: &'a Parsed, key: &[u8]) -> Result<&'a Value, Error> {
241 parsed
242 .value()
243 .as_dict()
244 .and_then(|m| parsed.attr(m, key))
245 .ok_or(Error::Field("object attribute"))
246}
247fn copy(bytes: &[u8], meter: &Arc<Meter>) -> Result<MeteredVec<u8>, Error> {
248 meter.count_decode(bytes.len() as u64)?;
249 let mut out = MeteredVec::with_capacity(meter, bytes.len())?;
250 out.extend_from_slice(bytes)?;
251 Ok(out)
252}
253fn raw(obj: &ObjectRef, why: Fallback, meter: &Arc<Meter>) -> Result<Export<'static>, Error> {
254 let bytes = copy(&obj.raw_data()?, meter)?;
255 Ok(Export {
256 extension: ".bin",
257 bytes,
258 fallback: Some(why),
259 })
260}
261fn font(data: &Value, meter: &Arc<Meter>) -> Result<MeteredVec<u8>, Error> {
262 macro_rules! bytes {
263 ($items:expr) => {
264 font_iter($items.iter().map(|&x| u8::try_from(x).ok()), meter)
265 };
266 }
267 match data {
268 Value::Bytes(bytes) | Value::Prims(PrimArray::U8(bytes)) => copy(bytes, meter),
269 Value::Prims(p) => match p {
270 PrimArray::Bool(v) => font_iter(v.iter().map(|&x| Some(u8::from(x))), meter),
271 PrimArray::I8(v) => bytes!(v),
272 PrimArray::U16(v) => bytes!(v),
273 PrimArray::I16(v) => bytes!(v),
274 PrimArray::U32(v) => bytes!(v),
275 PrimArray::I32(v) => bytes!(v),
276 PrimArray::U64(v) => bytes!(v),
277 PrimArray::I64(v) => bytes!(v),
278 _ => Err(Error::Field("m_FontData integer")),
279 },
280 Value::List(items) => font_values(items, meter),
281 Value::Tuple(items) => font_values(items, meter),
282 _ => Err(Error::Field("m_FontData")),
283 }
284}
285fn font_values(items: &[Value], meter: &Arc<Meter>) -> Result<MeteredVec<u8>, Error> {
286 font_iter(
287 items.iter().map(|v| {
288 v.as_u64()
289 .and_then(|n| u8::try_from(n).ok())
290 .or_else(|| v.as_bool().map(u8::from))
291 }),
292 meter,
293 )
294}
295fn font_iter(
296 items: impl ExactSizeIterator<Item = Option<u8>>,
297 meter: &Arc<Meter>,
298) -> Result<MeteredVec<u8>, Error> {
299 let mut out = MeteredVec::with_capacity(meter, items.len())?;
300 meter.count_decode(items.len() as u64)?;
301 for item in items {
302 out.push(item.ok_or(Error::Field("m_FontData byte"))?)?;
303 }
304 Ok(out)
305}
306struct WorkCount<'a> {
308 len: u64,
309 meter: &'a Meter,
310 error: Option<ChargeError>,
311}
312impl Sink for WorkCount<'_> {
313 fn put(&mut self, bytes: &[u8]) {
314 if self.error.is_none() {
315 let n = bytes.len() as u64;
316 match self.meter.count_decode(n) {
317 Ok(()) => self.len += n,
318 Err(e) => self.error = Some(e),
319 }
320 }
321 }
322 fn check(&self) -> Result<(), ChargeError> {
323 self.error.clone().map_or(Ok(()), Err)
324 }
325}
326struct Buffer {
327 bytes: MeteredVec<u8>,
328 error: Option<ChargeError>,
329}
330impl Sink for Buffer {
331 fn put(&mut self, bytes: &[u8]) {
332 if self.error.is_none() {
333 self.error = self.bytes.extend_from_slice(bytes).err();
334 }
335 }
336 fn check(&self) -> Result<(), ChargeError> {
337 self.error.clone().map_or(Ok(()), Err)
338 }
339}
340pub(crate) fn json(parsed: &Parsed, meter: &Arc<Meter>) -> Result<MeteredVec<u8>, Error> {
341 let write = |sink: &mut Buffer| {
342 pyjson::value_with(
343 parsed,
344 parsed.value(),
345 0,
346 Options::MONO_BEHAVIOUR,
347 sink,
348 meter,
349 )
350 };
351 let mut count = WorkCount {
352 len: 0,
353 meter,
354 error: None,
355 };
356 pyjson::value_with(
357 parsed,
358 parsed.value(),
359 0,
360 Options::MONO_BEHAVIOUR,
361 &mut count,
362 meter,
363 )?;
364 let len = usize::try_from(count.len).map_err(|_| Error::Field("JSON length"))?;
365 let mut out = Buffer {
366 bytes: MeteredVec::with_capacity(meter, len)?,
367 error: None,
368 };
369 write(&mut out)?;
370 if let Some(error) = out.error {
371 return Err(error.into());
372 }
373 Ok(out.bytes)
374}