Skip to main content

unityrs_export/shader/
mod.rs

1// Ported from UnityPy 1.25.2 (MIT): UnityPy/export/ShaderConverter.py, UnityPy/classes/legacy_patch/Shader.py. See THIRD_PARTY_LICENSES.
2//! Tier A Shader export and Tier C no-blob, Int, code and player/parameter corrections.
3//! Malformed legacy blobs and unfillable replacements have named Tier U refusals.
4//! Entry point: export/ShaderConverter.py:41-89;
5//! classes/legacy_patch/Shader.py:4-7.
6mod blob;
7#[cfg(test)]
8mod bytes_tests;
9mod convert;
10mod direct;
11pub use direct::direct_stage;
12mod layout;
13mod legacy;
14mod output;
15mod sort;
16mod view;
17pub use blob::Program;
18use output::Output;
19use std::sync::Arc;
20use unityrs_core::{
21    Bytes, ObjectRef, Parsed, PrimArray, Value,
22    budget::DecodeBuf,
23    codec::{Codec, Lz4, decode_block},
24    env::Environment,
25    error::LimitKind,
26    limits::{ChargeError, Meter, MeteredVec},
27    walk::ParseError,
28};
29use view::View;
30
31pub const HEADER: &str = "//////////////////////////////////////////\n//\n// NOTE: This is *not* a valid shader file\n//\n///////////////////////////////////////////\n";
32#[derive(Debug, thiserror::Error)]
33pub enum Error {
34    #[error("no Shader exporter for class {0}")]
35    UnsupportedClass(i32),
36    #[error("unsupported Shader layout: {0}")]
37    Refusal(&'static str),
38    #[error("unsupported Shader layout (Tier U): {0:?}")]
39    Unsupported(Unsupported),
40    #[error("invalid Shader code or parameter blob index")]
41    LayoutIndex,
42    #[error("missing or invalid Shader field {0}")]
43    Field(&'static str),
44    #[error("{0}")]
45    PythonType(&'static str),
46    #[error("unsupported operand type(s) for +: '{left}' and '{right}'")]
47    AddType {
48        left: &'static str,
49        right: &'static str,
50    },
51    #[error("can only concatenate {container} (not \"{other}\") to {container}")]
52    ConcatType {
53        container: &'static str,
54        other: &'static str,
55    },
56    #[error("'{0}' object cannot be interpreted as an integer")]
57    IntegerType(&'static str),
58    #[error("'UnknownObject' object has no attribute '{0}'")]
59    Attribute(&'static str),
60    #[error("{0}")]
61    PropertyType(i64),
62    #[error("{0} is not a valid ShaderGpuProgramType")]
63    ProgramType(i32),
64    #[error("")]
65    NotImplemented,
66    #[error("fixed-width field outside Shader blob")]
67    Struct,
68    #[error("Input source data size too small")]
69    Lz4Prefix,
70    #[error("Invalid size: 0x{0}")]
71    Lz4HeaderSize(u32),
72    #[error("Decompressor wrote {actual} bytes, but {expected} bytes expected from header")]
73    Lz4HeaderLength { actual: usize, expected: u32 },
74    #[error("signed integer is greater than maximum or less than minimum")]
75    Lz4Size,
76    #[error("list index out of range")]
77    Index,
78    #[error("String not terminated")]
79    Unterminated,
80    #[error("invalid UTF-8 in Shader code")]
81    Utf8,
82    #[error("invalid UTF-8 in Shader code")]
83    Utf8Bytes(Bytes),
84    #[error("string argument without an encoding")]
85    StringBytes,
86    #[error("cannot convert 'NoneType' object to bytes")]
87    NoneBytes,
88    #[error("bytes must be in range(0, 256)")]
89    ByteRange,
90    #[error("typetree read {actual} bytes, expected {expected}")]
91    CheckRead { expected: u32, actual: i64 },
92    #[error(transparent)]
93    Parse(#[from] ParseError),
94    #[error(transparent)]
95    Core(#[from] unityrs_core::Error),
96    #[error(transparent)]
97    Charge(#[from] ChargeError),
98}
99/// Legacy layouts without an established sample/reference contract.
100#[derive(Clone, Copy, Debug, PartialEq, Eq)]
101pub enum Unsupported {
102    BigEndian53Blob,
103    BigEndian54Blob,
104    GpuProgramIndex,
105}
106impl Error {
107    /// The Python exception represented by a reference failure.
108    pub fn exception(&self) -> Option<&'static str> {
109        Some(match self {
110            Self::PropertyType(_)
111            | Self::ProgramType(_)
112            | Self::Lz4Prefix
113            | Self::Lz4HeaderSize(_)
114            | Self::ByteRange => "ValueError",
115            Self::Lz4HeaderLength { .. } => "LZ4BlockError",
116            Self::Lz4Size => "OverflowError",
117            Self::NotImplemented => "NotImplementedError",
118            Self::Struct => "error",
119            Self::Index => "IndexError",
120            Self::Unterminated => "Exception",
121            Self::Utf8 | Self::Utf8Bytes(_) => "UnicodeDecodeError",
122            Self::StringBytes
123            | Self::NoneBytes
124            | Self::PythonType(_)
125            | Self::AddType { .. }
126            | Self::ConcatType { .. }
127            | Self::IntegerType(_) => "TypeError",
128            Self::Attribute(_) => "AttributeError",
129            _ => return None,
130        })
131    }
132}
133/// Export one Shader into a fallibly grown buffer charged to `meter`.
134/// The object's typetree reads retain the source meter, as E1's do.
135pub fn export(
136    obj: &ObjectRef,
137    env: &Environment,
138    meter: &Arc<Meter>,
139) -> Result<MeteredVec<u8>, Error> {
140    if obj.class_id() != 48 {
141        return Err(Error::UnsupportedClass(obj.class_id()));
142    }
143    let tree = env.object_tree(obj, None)?.ok_or(ParseError::NoTypeTree {
144        class_id: 48,
145        why: obj.why_no_tree(),
146    })?;
147    let parsed = obj.read_typetree(Some(&tree.tree), false)?;
148    if parsed.bytes_read != i64::from(obj.info().byte_size) {
149        return Err(Error::CheckRead {
150            expected: obj.info().byte_size,
151            actual: parsed.bytes_read,
152        });
153    }
154    let version = obj
155        .file()
156        .version()
157        .ok_or(Error::Field("version"))?
158        .version
159        .as_tuple()
160        .map_err(|_| Error::Field("version"))?;
161    export_with_cap(
162        &parsed,
163        (u32::from(version.0), u32::from(version.1)),
164        meter,
165        obj.file().context().limits.max_block_output,
166    )
167}
168/// Convert an already read tree. Useful for callers with a supplied typetree,
169/// and for bounded fuzzing of arbitrary field shapes.
170pub fn export_parsed(
171    parsed: &Parsed,
172    version: (u32, u32),
173    meter: &Arc<Meter>,
174) -> Result<MeteredVec<u8>, Error> {
175    export_with_cap(
176        parsed,
177        version,
178        meter,
179        unityrs_core::limits::Limits::default().max_block_output,
180    )
181}
182/// Convert current fields using the owning file's decompression bound.
183pub fn export_with_cap(
184    parsed: &Parsed,
185    version: (u32, u32),
186    meter: &Arc<Meter>,
187    max_block_output: u64,
188) -> Result<MeteredVec<u8>, Error> {
189    export_impl(parsed, version, meter, max_block_output, true)
190}
191
192/// Binding adapter: retain UnityPy's Int-property and sub-program code raises using
193/// the same metered conversion and error ordering as the native exporter.
194pub fn export_with_cap_unitypy_properties(
195    parsed: &Parsed,
196    version: (u32, u32),
197    meter: &Arc<Meter>,
198    max_block_output: u64,
199) -> Result<MeteredVec<u8>, Error> {
200    export_impl(parsed, version, meter, max_block_output, false)
201}
202
203fn export_impl(
204    parsed: &Parsed,
205    version: (u32, u32),
206    meter: &Arc<Meter>,
207    max_block_output: u64,
208    native_corrections: bool,
209) -> Result<MeteredVec<u8>, Error> {
210    let root = View {
211        parsed,
212        value: parsed.value(),
213        meter,
214        is_none: false,
215    };
216    if let Some(old) = root.optional("m_SubProgramBlob")?
217        && !old.empty()
218    {
219        return legacy::export(root, version, meter, max_block_output, native_corrections);
220    }
221    let mut out = Output::new(meter);
222    out.int_properties = native_corrections;
223    out.code_fallback = native_corrections;
224    out.text(HEADER)?;
225    if let Some(blob) = root.optional("compressedBlob")?
226        && !blob.empty()
227    {
228        let platforms = root.field("platforms")?.seq()?;
229        let bytes = bytes(blob.value, meter)?;
230        let mut programs = MeteredVec::new(meter);
231        let modern = root
232            .optional("m_ParsedForm")?
233            .map(layout::modern)
234            .transpose()?
235            .unwrap_or(false);
236        // UnityPy's short-circuit guards precede get_entry and offsets:
237        // export/ShaderConverter.py:70-87 (get_entry: export/ShaderConverter.py:64-68).
238        for i in 0..platforms.len() {
239            meter.count_decode(1)?;
240            let compressed = root.field("compressedLengths")?.seq()?;
241            if i >= compressed.len() {
242                break;
243            }
244            let decompressed = root.field("decompressedLengths")?.seq()?;
245            if i >= decompressed.len() {
246                break;
247            }
248            let count = if modern {
249                compressed.segment_count(i)?
250            } else {
251                1
252            };
253            let mut segments = MeteredVec::new(meter);
254            let offsets = root.field("offsets")?.seq()?;
255            if modern
256                && (count == 0
257                    || count != decompressed.segment_count(i)?
258                    || count != offsets.segment_count(i)?)
259            {
260                return Err(Error::LayoutIndex);
261            }
262            for segment in 0..count {
263                meter.count_decode(1)?;
264                let length = if modern {
265                    compressed.segment(i, segment)?
266                } else {
267                    compressed.entry(i)?
268                };
269                let size = if modern {
270                    decompressed.segment(i, segment)?
271                } else {
272                    decompressed.entry(i)?
273                };
274                let offset = if modern {
275                    offsets.segment(i, segment)?
276                } else {
277                    offsets.entry(i)?
278                };
279                let range = offset.slice(length, bytes.len())?;
280                let buf = decode(bytes.slice(range), size, meter, max_block_output)?;
281                if modern {
282                    segments.push(buf)?;
283                } else {
284                    programs.push(Program::decoded(buf, version, meter)?)?;
285                }
286            }
287            if modern {
288                programs.push(Program::modern(
289                    segments,
290                    version,
291                    root.field("m_ParsedForm")?,
292                    platforms,
293                    i,
294                    meter,
295                )?)?;
296            }
297        }
298        convert::shader(
299            root.field("m_ParsedForm")?,
300            platforms,
301            programs.as_slice(),
302            &mut out,
303            meter,
304        )?;
305    } else {
306        no_blob(root, version, &mut out, meter)?;
307    }
308    Ok(out.bytes)
309}
310
311fn no_blob(
312    root: View<'_>,
313    version: (u32, u32),
314    out: &mut Output<'_>,
315    meter: &Arc<Meter>,
316) -> Result<(), Error> {
317    if version >= (5, 5) {
318        // Tier C: 5.5+ ignores any retained script. Convert the parsed form
319        // exactly as a blob with no platforms would, without reading metadata
320        // for nonexistent programs or constructing platform/program buffers.
321        let platforms = Value::List(Vec::new());
322        convert::shader(
323            root.field("m_ParsedForm")?,
324            view::Seq::new(&platforms)?,
325            &[],
326            out,
327            meter,
328        )?;
329    } else if let Some(script) = root.optional("m_Script")? {
330        // Tier C: legacy strings are already UTF-8; bytes(str) is UnityPy's
331        // missing-encoding error, not a reason to discard a valid script.
332        let converted;
333        let script = if let Value::Str(s) = script.value {
334            s.as_bytes()
335        } else {
336            converted = bytes(script.value, meter)?;
337            converted.as_ref()
338        };
339        meter.count_decode(script.len() as u64)?;
340        std::str::from_utf8(script).map_err(|_| utf8_error(script, meter))?;
341        out.text(script)?;
342    } else {
343        return Err(Error::NoneBytes);
344    }
345    Ok(())
346}
347
348fn utf8_error(data: &[u8], meter: &Arc<Meter>) -> Error {
349    let copy = DecodeBuf::new(meter, 0, u64::MAX, LimitKind::InputMemory).and_then(|mut bytes| {
350        meter.count_decode(data.len() as u64)?;
351        bytes.extend_from_slice(data)?;
352        bytes.into_bytes()
353    });
354    match copy {
355        Ok(bytes) => Error::Utf8Bytes(bytes),
356        Err(error) => Error::Charge(error),
357    }
358}
359
360fn decode(
361    mut input: Bytes,
362    size: view::Entry<'_>,
363    meter: &Arc<Meter>,
364    max_block_output: u64,
365) -> Result<DecodeBuf, Error> {
366    let size = size.integer(view::ArrayUse::Decompressed)?;
367    // python-lz4's negative-size mode reads a stored LE size prefix.
368    // The core codec takes the resulting nonnegative maximum.
369    i32::try_from(size).map_err(|_| Error::Lz4Size)?;
370    let prefixed = size < 0;
371    let size = if prefixed {
372        let prefix: [u8; 4] = input
373            .get(..4)
374            .ok_or(Error::Lz4Prefix)?
375            .try_into()
376            .map_err(|_| Error::Lz4Prefix)?;
377        let size = u32::from_le_bytes(prefix);
378        if size > i32::MAX.unsigned_abs() {
379            return Err(Error::Lz4HeaderSize(size));
380        }
381        input = input.slice(4..);
382        size
383    } else {
384        u32::try_from(size).map_err(|_| Error::Lz4Size)?
385    };
386    // Both LZ4 passes may scan the complete input, even on failure.
387    meter.count_decode((input.len() as u64).saturating_mul(2))?;
388    let mut buf = DecodeBuf::new(meter, 0, max_block_output, LimitKind::BlockOutput)?;
389    decode_block(Codec::Lz4, &Lz4, &input, size, &mut buf, max_block_output)?;
390    if prefixed && buf.len() as u64 != u64::from(size) {
391        return Err(Error::Lz4HeaderLength {
392            actual: buf.len(),
393            expected: size,
394        });
395    }
396    Ok(buf)
397}
398/// Validate a platform's table and every subprogram without producing text.
399pub fn validate_blob(blob: &[u8], version: (u32, u32), meter: &Arc<Meter>) -> Result<(), Error> {
400    Program::parse(blob, version, meter).map(|_| ())
401}
402fn bytes(v: &Value, meter: &Arc<Meter>) -> Result<Bytes, Error> {
403    match v {
404        Value::Bytes(b) | Value::Prims(PrimArray::U8(b)) => Ok(b.clone()),
405        Value::Str(_) => Err(Error::StringBytes),
406        Value::List(items) => byte_values(items, meter),
407        Value::Tuple(items) => byte_values(items, meter),
408        _ => Err(Error::Field("byte array")),
409    }
410}
411
412// export/ShaderConverter.py:41-55 uses Python bytes(), including when a
413// caller edits an already read class from a packed U8 array to a list.
414fn byte_values(items: &[Value], meter: &Arc<Meter>) -> Result<Bytes, Error> {
415    struct Owner {
416        bytes: MeteredVec<u8>,
417        _owner: unityrs_core::limits::Charge,
418    }
419    impl AsRef<[u8]> for Owner {
420        fn as_ref(&self) -> &[u8] {
421            self.bytes.as_slice()
422        }
423    }
424    meter.count_decode(items.len() as u64)?;
425    let mut bytes = MeteredVec::with_capacity(meter, items.len())?;
426    for item in items {
427        let byte = match item {
428            Value::Int(n) => u8::try_from(*n).map_err(|_| Error::ByteRange)?,
429            Value::UInt(n) => u8::try_from(*n).map_err(|_| Error::ByteRange)?,
430            Value::Bool(n) => u8::from(*n),
431            Value::F32(_) | Value::F64(_) => return Err(Error::IntegerType("float")),
432            Value::Str(_) => return Err(Error::IntegerType("str")),
433            Value::Bytes(_) => return Err(Error::IntegerType("bytes")),
434            Value::List(_) | Value::Prims(_) => return Err(Error::IntegerType("list")),
435            Value::Tuple(_) => return Err(Error::IntegerType("tuple")),
436            Value::Dict(_) => return Err(Error::IntegerType("dict")),
437        };
438        bytes.push(byte)?;
439    }
440    let owner = meter.charge(128)?;
441    Ok(Bytes::from_owner(Owner {
442        bytes,
443        _owner: owner,
444    }))
445}
446fn compressed_range(len: usize, offset: i128, size: i128) -> std::ops::Range<usize> {
447    let norm = |n: i128| {
448        usize::try_from(if n < 0 {
449            (len as i128 + n).max(0)
450        } else {
451            n.min(len as i128)
452        })
453        .unwrap_or(0)
454    };
455    let start = norm(offset);
456    let end = norm(offset + size).max(start);
457    start..end
458}