Skip to main content

unityrs_export/
simple.rs

1// Ported from UnityPy 1.25.2 (MIT): UnityPy/tools/extractor.py. See THIRD_PARTY_LICENSES.
2//! Single-object payloads, ready for a caller's file sink. `TextAsset` and Font
3//! follow tools/extractor.py:165-187; MonoBehaviour follows
4//! tools/extractor.py:210-224, including its semantic `.bin` fallback.
5//! `VideoClip` is Tier X: UnityPy's dispatch has no `VideoClip` entry
6//! (tools/extractor.py:307-319). Its `StreamedResource` fields are format facts,
7//! read through the core's resource resolver, with no transcoding.
8//!
9//! The object/tree/resource reads charge the source file's meter. Every
10//! payload and JSON traversal stack charges `meter` before fallible growth;
11//! the returned payload owns its charge. Budget/allocator/limit failures
12//! propagate, never becoming a successful raw fallback. No filesystem naming
13//! or extraction loop lives here (the extractor is separate work).
14use 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/// Why a MonoBehaviour is emitted as raw `.bin` instead of `.json`.
22#[derive(Clone, Copy, Debug, PartialEq, Eq)]
23pub enum Fallback {
24    NoTypeTree,
25    ReadFailed,
26    JsonUnwritable,
27}
28/// One file's bytes and suffix. An empty Font produces no file (`None`).
29#[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/// The simple-export dispatch, keyed by Unity class id. This does not widen
53/// the batch engine's output kinds or the CLI's commands.
54#[must_use]
55pub const fn supports(class_id: i32) -> bool {
56    matches!(class_id, 49 | 128 | 114 | 329)
57}
58/// Export an object. `extension` is the suffix already split from the
59/// destination, including its dot. `TextAsset` keeps it, defaulting an empty
60/// suffix to `.txt`; Font uses `.otf`/`.ttf`, MonoBehaviour `.json`/`.bin`.
61/// `VideoClip` keeps the supplied suffix, defaulting to `.video`.
62///
63/// MonoBehaviour encodes `json.dumps(tree, indent=4, ensure_ascii=False)`
64/// using UTF-8 surrogateescape, exactly as tools/extractor.py:215-223 does.
65/// A missing or unreadable tree, or a bytes value JSON cannot write, falls
66/// back to the object's raw bytes; [`Export::fallback`] says why.
67pub 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            // UnityPy tools/extractor.py:178-187 compares the slice with
110            // b"OTTO": only TypelessData (bytes), never a list, can match.
111            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    // UnityPy helpers/TypeTreeHelper.py:155-156 raises on this mismatch.
168    // Check locally to avoid core's infallible, uncharged Arc<Parsed> error.
169    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}
185// Traverse wrappers without recursion or allocating diagnostics. Semantic
186// exceptions match Python's catch-all; resource refusals retain provenance.
187fn 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}
306// Charge every counting write, even when a later value is unwritable.
307struct 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}