1mod 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#[derive(Clone, Copy, Debug, PartialEq, Eq)]
101pub enum Unsupported {
102 BigEndian53Blob,
103 BigEndian54Blob,
104 GpuProgramIndex,
105}
106impl Error {
107 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}
133pub 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}
168pub 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}
182pub 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
192pub 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 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 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 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 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 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}
398pub 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
412fn 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}