Skip to main content

unityrs_export/shader/
blob.rs

1// Ported from UnityPy 1.25.2 (MIT): UnityPy/export/ShaderConverter.py. See THIRD_PARTY_LICENSES.
2// Ported from AssetStudio v0.16.47 (MIT): AssetStudioUtility/ShaderConverter.cs, ShaderSubProgramEntry's segmented table layout. See THIRD_PARTY_LICENSES.
3//! Shader tables and subprograms: export/ShaderConverter.py:543-689.
4use super::{Error, output::Output};
5use std::{ops::Range, sync::Arc};
6use unityrs_core::budget::DecodeBuf;
7use unityrs_core::{
8    limits::{Meter, MeteredVec},
9    stream::Endian,
10    stream::Reader,
11};
12
13#[derive(Debug)]
14pub struct Program<'a> {
15    subs: MeteredVec<SubProgram>,
16    data: Data<'a>,
17    selected: Option<MeteredVec<usize>>,
18    capacity: usize,
19}
20#[derive(Debug)]
21struct SubProgram {
22    kind: i32,
23    keywords: MeteredVec<Range<usize>>,
24    local: MeteredVec<Range<usize>>,
25    code: Range<usize>,
26    segment: usize,
27}
28fn int(r: &mut Reader<'_>, meter: &Meter) -> Result<i32, Error> {
29    meter.count_decode(4)?;
30    r.read_i32().map_err(|_| Error::Struct)
31}
32fn keywords(
33    r: &mut Reader<'_>,
34    meter: &Arc<Meter>,
35    collect: bool,
36    strict: bool,
37) -> Result<MeteredVec<Range<usize>>, Error> {
38    let count = int(r, meter)?;
39    if strict && count < 0 {
40        return Err(Error::Struct);
41    }
42    let mut words = MeteredVec::new(meter);
43    // Each item requires a real four-byte length. Never reserve the count.
44    if i128::from(count.max(0)) * 4 > r.data().len() as i128 - r.position() {
45        return Err(Error::Struct);
46    }
47    for _ in 0..count {
48        let len = int(r, meter)?;
49        if strict && (len < 0 || i128::from(len) > r.data().len() as i128 - r.position()) {
50            return Err(Error::Struct);
51        }
52        let word = if len > 0 && i128::from(len) <= r.data().len() as i128 - r.position() {
53            let word = r.read_range(i64::from(len)).map_err(|_| Error::Struct)?;
54            meter.count_decode(word.len() as u64)?;
55            r.align(4).map_err(|_| Error::Struct)?;
56            word
57        } else {
58            0..0
59        };
60        if collect {
61            words.push(word)?;
62        }
63    }
64    Ok(words)
65}
66impl<'a> Program<'a> {
67    /// The table in segment zero indexes independently compressed segments.
68    pub(super) fn modern(
69        segments: MeteredVec<DecodeBuf>,
70        version: (u32, u32),
71        form: super::View<'_>,
72        platforms: super::view::Seq<'_>,
73        platform_index: usize,
74        meter: &Arc<Meter>,
75    ) -> Result<Program<'static>, Error> {
76        let data = Data::Segments(segments);
77        let mut table = Reader::new(data.bytes(), Endian::Little);
78        let count = int(&mut table, meter)?;
79        let capacity = usize::try_from(count).map_err(|_| Error::LayoutIndex)?;
80        let stride = if version >= (2019, 3) { 12 } else { 8 };
81        if 4 + capacity as i128 * stride > data.bytes().len() as i128 {
82            return Err(Error::LayoutIndex);
83        }
84        let selection =
85            super::layout::Selection::collect(form, platforms, platform_index, capacity)?;
86        let mut subs = MeteredVec::new(meter);
87        for (indices, code) in [(&selection.code, true), (&selection.parameters, false)] {
88            for index in indices.as_slice() {
89                meter.count_decode(1)?;
90                if *index >= capacity {
91                    return Err(Error::LayoutIndex);
92                }
93                table
94                    .set_position(4 + *index as i128 * stride)
95                    .map_err(|_| Error::LayoutIndex)?;
96                let start =
97                    usize::try_from(int(&mut table, meter)?).map_err(|_| Error::LayoutIndex)?;
98                let length =
99                    usize::try_from(int(&mut table, meter)?).map_err(|_| Error::LayoutIndex)?;
100                let segment = if stride == 12 {
101                    usize::try_from(int(&mut table, meter)?).map_err(|_| Error::LayoutIndex)?
102                } else {
103                    0
104                };
105                let bytes = data.segment(segment)?;
106                // Offset-only tables use zero length; keep the segment bound.
107                let end = if length == 0 {
108                    bytes.len()
109                } else {
110                    start.checked_add(length).ok_or(Error::LayoutIndex)?
111                };
112                if start >= bytes.len() || end > bytes.len() {
113                    return Err(Error::LayoutIndex);
114                }
115                if code {
116                    let mut r =
117                        Reader::new(bytes.get(..end).ok_or(Error::LayoutIndex)?, Endian::Little);
118                    r.set_position(start as i128)
119                        .map_err(|_| Error::LayoutIndex)?;
120                    let mut sub = read_sub(&mut r, meter, true, true).map_err(|e| match e {
121                        Error::Struct => Error::LayoutIndex,
122                        other => other,
123                    })?;
124                    sub.segment = segment;
125                    subs.push(sub)?;
126                }
127            }
128        }
129        Ok(Program {
130            subs,
131            data,
132            selected: Some(selection.code),
133            capacity,
134        })
135    }
136    pub(super) fn legacy(data: DecodeBuf, meter: &Arc<Meter>) -> Result<Program<'static>, Error> {
137        let data = Data::Decoded(data);
138        let mut r = Reader::new(data.bytes(), Endian::Big);
139        let count = int(&mut r, meter)?;
140        if count < 0 || 4 + i128::from(count) * 8 > data.bytes().len() as i128 {
141            return Err(Error::Struct);
142        }
143        let mut subs = MeteredVec::new(meter);
144        for i in 0..count {
145            r.set_position(4 + i128::from(i) * 8)
146                .map_err(|_| Error::Struct)?;
147            let offset = int(&mut r, meter)?;
148            if usize::try_from(offset).map_or(true, |offset| offset >= data.bytes().len()) {
149                return Err(Error::Struct);
150            }
151            r.set_position(i128::from(offset))
152                .map_err(|_| Error::Struct)?;
153            subs.push(read_sub(&mut r, meter, true, true)?)?;
154        }
155        Ok(Program {
156            subs,
157            data,
158            selected: None,
159            capacity: usize::try_from(count).map_err(|_| Error::Struct)?,
160        })
161    }
162    /// Number of parsed table entries available to render.
163    #[must_use]
164    pub fn subprogram_count(&self) -> usize {
165        self.subs.len()
166    }
167    /// Parse a little-endian platform blob. Tables grow only after valid reads.
168    pub fn parse(blob: &'a [u8], version: (u32, u32), meter: &Arc<Meter>) -> Result<Self, Error> {
169        Self::parse_data(Data::Borrowed(blob), version, meter)
170    }
171    pub(super) fn decoded(
172        blob: DecodeBuf,
173        version: (u32, u32),
174        meter: &Arc<Meter>,
175    ) -> Result<Program<'static>, Error> {
176        Program::parse_data(Data::Decoded(blob), version, meter)
177    }
178    fn parse_data(data: Data<'a>, version: (u32, u32), meter: &Arc<Meter>) -> Result<Self, Error> {
179        let blob = data.bytes();
180        let mut r = Reader::new(blob, Endian::Little);
181        let count = int(&mut r, meter)?;
182        let entry = if version >= (2019, 3) { 12 } else { 8 };
183        if count > 0 && 4 + (i128::from(count) - 1) * entry + 4 > blob.len() as i128 {
184            // Validate without allocating. Earlier subprogram errors must
185            // win over a later missing table entry, as in the reference.
186            for i in 0..count {
187                r.set_position(4 + i128::from(i) * entry)
188                    .map_err(|_| Error::Struct)?;
189                let offset = int(&mut r, meter)?;
190                r.set_position(i128::from(offset))
191                    .map_err(|_| Error::Struct)?;
192                read_sub(&mut r, meter, false, false)?;
193            }
194            return Err(Error::Struct);
195        }
196        let mut subs = MeteredVec::new(meter);
197        for i in 0..count {
198            r.set_position(4 + i128::from(i) * entry)
199                .map_err(|_| Error::Struct)?;
200            let offset = int(&mut r, meter)?;
201            r.set_position(i128::from(offset))
202                .map_err(|_| Error::Struct)?;
203            subs.push(read_sub(&mut r, meter, true, false)?)?;
204        }
205        Ok(Self {
206            subs,
207            data,
208            selected: None,
209            capacity: usize::try_from(count.max(0)).map_err(|_| Error::Struct)?,
210        })
211    }
212    /// Render one table entry with UnityPy's raises and signed list indices.
213    pub fn export(&self, index: i64, meter: &Arc<Meter>) -> Result<MeteredVec<u8>, Error> {
214        let mut out = Output::new(meter);
215        out.code_fallback = false;
216        self.write(index, &mut out)?;
217        Ok(out.bytes)
218    }
219    pub(super) fn write(&self, index: i64, out: &mut Output<'_>) -> Result<(), Error> {
220        let index = if index < 0 {
221            self.capacity as i128 + i128::from(index)
222        } else {
223            i128::from(index)
224        };
225        let index = usize::try_from(index).map_err(|_| Error::Index)?;
226        let index = if let Some(selected) = &self.selected {
227            out.work(u64::from(selected.len().max(1).ilog2()) + 1)?;
228            selected
229                .as_slice()
230                .binary_search(&index)
231                .map_err(|_| Error::Index)?
232        } else {
233            index
234        };
235        let sub = Some(index)
236            .and_then(|i| self.subs.as_slice().get(i))
237            .ok_or(Error::Index)?;
238        for (label, words) in [
239            ("Keywords { ", &sub.keywords),
240            ("Local Keywords { ", &sub.local),
241        ] {
242            if !words.is_empty() {
243                out.text(label)?;
244                for word in words.as_slice() {
245                    out.text("\"")?;
246                    out.text(
247                        self.data
248                            .segment(sub.segment)?
249                            .get(word.clone())
250                            .ok_or(Error::Index)?,
251                    )?;
252                    out.text("\" ")?;
253                }
254                out.text("}\n")?;
255            }
256        }
257        out.text("\"")?;
258        let code = self
259            .data
260            .segment(sub.segment)?
261            .get(sub.code.clone())
262            .ok_or(Error::Index)?;
263        if !code.is_empty() {
264            match sub.kind {
265                1..=8 | 26..=30 => utf8(code, sub.kind, out)?,
266                9..=22 => out.text("// shader disassembly not supported on DXBC")?,
267                23 | 24 => {
268                    // Fixed reads, NUL search and entry-name decoding, including failures.
269                    out.work((code.len() as u64).saturating_mul(2))?;
270                    match metal_source(code) {
271                        Ok(source) => utf8(source, sub.kind, out)?,
272                        Err(Error::Struct | Error::Unterminated) if out.code_fallback => {
273                            unsupported(sub.kind, out)?;
274                        }
275                        Err(error) => return Err(error),
276                    }
277                }
278                25 => {}
279                n => unsupported(n, out)?,
280            }
281        }
282        out.text("\"")
283    }
284}
285fn metal_source(code: &[u8]) -> Result<&[u8], Error> {
286    let mut r = Reader::new(code, Endian::Little);
287    let tag = r.read_u32().map_err(|_| Error::Struct)?;
288    if tag == 0xf00d_cafe {
289        let offset = r.read_i32().map_err(|_| Error::Struct)?;
290        r.set_position(i128::from(offset))
291            .map_err(|_| Error::Struct)?;
292    }
293    r.read_string_to_null().map_err(|_| Error::Unterminated)?;
294    let remaining = code.len() as i128 - r.position();
295    let remaining = i64::try_from(remaining).map_err(|_| Error::Struct)?;
296    r.read(remaining).map_err(|_| Error::Struct)
297}
298
299fn unsupported(kind: i32, out: &mut Output<'_>) -> Result<(), Error> {
300    out.text("//shader disassembly not supported on ")?;
301    out.int(i128::from(kind))
302}
303
304fn utf8(code: &[u8], kind: i32, out: &mut Output<'_>) -> Result<(), Error> {
305    out.work(code.len() as u64)?;
306    if std::str::from_utf8(code).is_err() {
307        return if out.code_fallback {
308            unsupported(kind, out)
309        } else {
310            Err(out.utf8_error(code))
311        };
312    }
313    out.text(code)
314}
315
316#[derive(Debug)]
317enum Data<'a> {
318    Borrowed(&'a [u8]),
319    Decoded(DecodeBuf),
320    Segments(MeteredVec<DecodeBuf>),
321}
322impl Data<'_> {
323    fn segment(&self, i: usize) -> Result<&[u8], Error> {
324        match self {
325            Self::Segments(b) => b
326                .as_slice()
327                .get(i)
328                .map(DecodeBuf::as_slice)
329                .ok_or(Error::LayoutIndex),
330            _ if i == 0 => Ok(self.bytes()),
331            _ => Err(Error::LayoutIndex),
332        }
333    }
334    fn bytes(&self) -> &[u8] {
335        match self {
336            Self::Borrowed(b) => b,
337            Self::Decoded(b) => b.as_slice(),
338            Self::Segments(b) => b.as_slice().first().map_or(&[], DecodeBuf::as_slice),
339        }
340    }
341}
342
343fn read_sub(
344    r: &mut Reader<'_>,
345    meter: &Arc<Meter>,
346    collect: bool,
347    strict: bool,
348) -> Result<SubProgram, Error> {
349    let version = int(r, meter)?;
350    let kind = int(r, meter)?;
351    if !(0..=31).contains(&kind) {
352        return Err(Error::ProgramType(kind));
353    }
354    r.set_position(r.position() + 12 + if version >= 201_608_170 { 4 } else { 0 })
355        .map_err(|_| Error::Struct)?;
356    let words = keywords(r, meter, collect, strict)?;
357    let local = if (201_806_140..202_012_090).contains(&version) {
358        keywords(r, meter, collect, strict)?
359    } else {
360        MeteredVec::new(meter)
361    };
362    let len = int(r, meter)?;
363    if strict && (len < 0 || i128::from(len) > r.data().len() as i128 - r.position()) {
364        return Err(Error::Struct);
365    }
366    let code = r.read_range(i64::from(len)).map_err(|_| Error::Struct)?;
367    meter.count_decode(code.len() as u64)?;
368    r.align(4).map_err(|_| Error::Struct)?;
369    Ok(SubProgram {
370        kind,
371        keywords: words,
372        local,
373        code,
374        segment: 0,
375    })
376}