Skip to main content

unityrs_texture/write/
object.rs

1// Ported from UnityPy 1.25.2 (MIT): classes/legacy_patch/Texture2D.py. See LICENSE-UNITYPY.
2//! Texture field edits (`classes/legacy_patch/Texture2D.py:14-60`) installed
3//! through B1 only after the entire mip chain and object serialization succeed.
4use super::{Options, Source, WriteError, image_to_texture2d};
5use unityrs_core::walk::WriteRules;
6use unityrs_core::{Bytes, ObjectRef, Parsed, RawStr, Value};
7
8fn field<'a>(parsed: &'a Parsed, name: &[u8]) -> Option<&'a Value> {
9    parsed.get(&[name])
10}
11fn integer(parsed: &Parsed, name: &[u8]) -> Result<i32, WriteError> {
12    match field(parsed, name) {
13        Some(Value::Int(n)) => {
14            i32::try_from(*n).map_err(|_| WriteError::Invalid("integer field range"))
15        }
16        _ => Err(WriteError::Invalid("integer field")),
17    }
18}
19fn set(parsed: &mut Parsed, path: &[&[u8]], value: Value) -> Result<(), WriteError> {
20    if !parsed.replace_scalar(path, value)? {
21        return Err(WriteError::Invalid("missing texture field"));
22    }
23    Ok(())
24}
25
26/// Update and re-save a `Texture2D`, propagating changed state to its parents.
27/// `None` or target zero defaults to `m_TextureFormat`. Absent optional mip,
28/// stream and platform fields stay absent, and platform blobs stay unchanged.
29/// Failure preserves the object's previous installed bytes and changed state.
30/// Like UnityPy's ObjectReader, subsequent reads still see the original data.
31/// The returned bytes are the exact updated object serialization.
32pub fn set_image(
33    object: &ObjectRef,
34    source: &Source<'_>,
35    target: Option<i32>,
36    mipmap_count: i32,
37) -> Result<Bytes, WriteError> {
38    if object.class_id() != 28 {
39        return Err(WriteError::Invalid("object is not Texture2D"));
40    }
41    let meter = object.file().meter();
42    let mut parsed = object.parse_as_dict(true)?;
43    let format = match target {
44        Some(n) if n != 0 => n,
45        _ => integer(&parsed, b"m_TextureFormat")?,
46    };
47    let blob = match field(&parsed, b"m_PlatformBlob") {
48        Some(Value::Bytes(b) | Value::Prims(unityrs_core::PrimArray::U8(b))) => Some(b.clone()),
49        None => None,
50        _ => return Err(WriteError::Invalid("platform blob")),
51    };
52    let encoded = image_to_texture2d(
53        source,
54        Options {
55            format,
56            platform: object.file().target_platform().unwrap_or(0),
57            platform_blob: blob.as_deref(),
58            flip: true,
59            mipmap_count,
60        },
61        meter,
62    )?;
63    set(
64        &mut parsed,
65        &[b"m_Width"],
66        Value::Int(i64::from(source.width())),
67    )?;
68    set(
69        &mut parsed,
70        &[b"m_Height"],
71        Value::Int(i64::from(source.height())),
72    )?;
73    for (name, value) in [
74        (
75            b"m_MipMap".as_slice(),
76            Value::Bool(encoded.mipmap_count > 1),
77        ),
78        (
79            b"m_MipCount".as_slice(),
80            Value::Int(i64::from(encoded.mipmap_count)),
81        ),
82    ] {
83        if field(&parsed, name).is_some() {
84            set(&mut parsed, &[name], value)?;
85        }
86    }
87    set(
88        &mut parsed,
89        &[b"m_CompleteImageSize"],
90        Value::Int(
91            i64::try_from(encoded.data.len())
92                .map_err(|_| WriteError::Invalid("complete image size"))?,
93        ),
94    )?;
95    set(
96        &mut parsed,
97        &[b"m_TextureFormat"],
98        Value::Int(i64::from(encoded.format)),
99    )?;
100    set(&mut parsed, &[b"image data"], Value::Bytes(encoded.data))?;
101    if field(&parsed, b"m_StreamData").is_some() {
102        set(
103            &mut parsed,
104            &[b"m_StreamData", b"path"],
105            Value::Str(RawStr::from_static(b"")),
106        )?;
107        set(&mut parsed, &[b"m_StreamData", b"offset"], Value::Int(0))?;
108        set(&mut parsed, &[b"m_StreamData", b"size"], Value::Int(0))?;
109    }
110    Ok(object.save_typetree(&parsed, None, WriteRules::UnityPy)?)
111}