Skip to main content

unityrs_testkit/scene3d/
graph.rs

1// Ported from UnityPy 1.25.2 (MIT): UnityPy/classes/generated.py's GameObject, Transform, RectTransform, MeshFilter, MeshRenderer, SkinnedMeshRenderer and LODGroup field lists. See THIRD_PARTY_LICENSES.
2//! Synthetic 3D graph facts on hand-built trees. These deliberately small
3//! embedded trees describe only fields used by the scene graph, with no
4//! TPK input. They are not complete `Editor` or stripped-file layouts.
5//! Geometry and Material writers belong to the mesh/material work.
6use crate::ngui::{BuildError, Object, V, nodes, pair, pptr, st, vector, write};
7use crate::serialized::{ExternalSpec, ObjectSpec, SerializedSpec, TypeSpec};
8use crate::writer::ByteWriter;
9
10/// Engine versions exercised by scene tests. Graph fields have the same
11/// shape in these versions; the file's version identifies each case.
12#[derive(Clone, Copy, Debug)]
13pub enum Layout {
14    Unity51,
15    Unity55,
16    Unity2019,
17    Unity20221,
18    Unity2022,
19    Unity6000,
20}
21impl Layout {
22    /// The synthetic file's engine version.
23    #[must_use]
24    pub const fn version(self) -> &'static [u8] {
25        match self {
26            Self::Unity51 => b"5.1.0f1",
27            Self::Unity55 => b"5.5.0f1",
28            Self::Unity20221 => b"2022.1.0f1",
29            Self::Unity2019 => b"2019.4.0f1",
30            Self::Unity2022 => b"2022.3.0f1",
31            Self::Unity6000 => b"6000.0.0f1",
32        }
33    }
34}
35/// A `GameObject`'s dict facts, with modern `ComponentPairs`.
36#[must_use]
37pub fn game_object(name: &[u8], components: &[(i32, i64)]) -> V {
38    st(
39        "GameObject",
40        vec![
41            ("m_Name", V::Str(name.to_vec())),
42            ("m_IsActive", V::Bool(true)),
43            ("m_Layer", V::UInt(0)),
44            ("m_Tag", V::UInt(0)),
45            (
46                "m_Component",
47                vector(
48                    component_pair((0, 0)),
49                    components.iter().map(|p| component_pair(*p)).collect(),
50                ),
51            ),
52        ],
53    )
54}
55fn component_pair(ptr: (i32, i64)) -> V {
56    st("ComponentPair", vec![("component", pptr("Component", ptr))])
57}
58/// The legacy 5.4 (class id, `PPtr`) component representation (Tier B).
59#[must_use]
60pub fn legacy_game_object(name: &[u8], components: &[(i32, (i32, i64))]) -> V {
61    let mut go = game_object(name, &[]);
62    set(
63        &mut go,
64        "m_Component",
65        vector(
66            pair(V::Int(0), pptr("Component", (0, 0))),
67            components
68                .iter()
69                .map(|(id, ptr)| pair(V::Int(*id), pptr("Component", *ptr)))
70                .collect(),
71        ),
72    );
73    go
74}
75/// A vector3 or quaternion.
76#[must_use]
77pub fn xyz(ty: &str, values: &[f32]) -> V {
78    st(
79        ty,
80        ["x", "y", "z", "w"]
81            .iter()
82            .zip(values)
83            .map(|(n, x)| (*n, V::Float(*x)))
84            .collect(),
85    )
86}
87/// Identity local TRS, with caller-chosen hierarchy links. Change fields
88/// with `ngui::set_field` for non-identity or hostile cases.
89#[must_use]
90pub fn transform(
91    game_object: (i32, i64),
92    father: (i32, i64),
93    children: &[(i32, i64)],
94    rect: bool,
95) -> V {
96    let mut value = st(
97        if rect { "RectTransform" } else { "Transform" },
98        vec![
99            ("m_GameObject", pptr("GameObject", game_object)),
100            ("m_LocalPosition", xyz("Vector3f", &[0., 0., 0.])),
101            ("m_LocalRotation", xyz("Quaternionf", &[0., 0., 0., 1.])),
102            ("m_LocalScale", xyz("Vector3f", &[1., 1., 1.])),
103            ("m_Children", pointers("Transform", children)),
104            ("m_Father", pptr("Transform", father)),
105        ],
106    );
107    if rect {
108        set(&mut value, "m_AnchorMin", xyz("Vector2f", &[0., 0.]));
109        set(&mut value, "m_AnchorMax", xyz("Vector2f", &[1., 1.]));
110        set(&mut value, "m_AnchoredPosition", xyz("Vector2f", &[0., 0.]));
111        set(&mut value, "m_SizeDelta", xyz("Vector2f", &[100., 100.]));
112        set(&mut value, "m_Pivot", xyz("Vector2f", &[0.5, 0.5]));
113    }
114    value
115}
116/// An ordered pointer array, including nulls.
117#[must_use]
118pub fn pointers(ty: &str, items: &[(i32, i64)]) -> V {
119    vector(
120        pptr(ty, (0, 0)),
121        items.iter().map(|p| pptr(ty, *p)).collect(),
122    )
123}
124/// `MeshFilter` facts.
125#[must_use]
126pub fn mesh_filter(go: (i32, i64), mesh: (i32, i64)) -> V {
127    st(
128        "MeshFilter",
129        vec![
130            ("m_GameObject", pptr("GameObject", go)),
131            ("m_Mesh", pptr("Mesh", mesh)),
132        ],
133    )
134}
135/// Renderer facts, including a static batch and the legacy subset list.
136#[must_use]
137pub fn mesh_renderer(go: (i32, i64), materials: &[(i32, i64)], static_batch: (u16, u16)) -> V {
138    st(
139        "MeshRenderer",
140        vec![
141            ("m_GameObject", pptr("GameObject", go)),
142            ("m_Enabled", V::Bool(true)),
143            ("m_Materials", pointers("Material", materials)),
144            (
145                "m_StaticBatchInfo",
146                st(
147                    "StaticBatchInfo",
148                    vec![
149                        ("firstSubMesh", V::UInt(u32::from(static_batch.0))),
150                        ("subMeshCount", V::UInt(u32::from(static_batch.1))),
151                    ],
152                ),
153            ),
154            ("m_SubsetIndices", vector(V::UInt(0), vec![])),
155            ("m_StaticBatchRoot", pptr("Transform", (0, 0))),
156        ],
157    )
158}
159/// Skin references and blend weights, reusing renderer facts.
160#[must_use]
161pub fn skinned_mesh_renderer(
162    go: (i32, i64),
163    mesh: (i32, i64),
164    bones: &[(i32, i64)],
165    weights: &[f32],
166) -> V {
167    let V::Struct(_, fields) = mesh_renderer(go, &[], (0, 0)) else {
168        return st("SkinnedMeshRenderer", vec![]);
169    };
170    let mut v = V::Struct("SkinnedMeshRenderer".into(), fields);
171    for (name, value) in [
172        ("m_Mesh", pptr("Mesh", mesh)),
173        ("m_Bones", pointers("Transform", bones)),
174        (
175            "m_RootBone",
176            pptr("Transform", bones.first().copied().unwrap_or((0, 0))),
177        ),
178        (
179            "m_BlendShapeWeights",
180            vector(V::Float(0.), weights.iter().map(|x| V::Float(*x)).collect()),
181        ),
182    ] {
183        set(&mut v, name, value);
184    }
185    v
186}
187/// One LOD and an `LODGroup` with those levels in order.
188#[must_use]
189pub fn lod_group(go: (i32, i64), levels: &[(f32, Vec<(i32, i64)>)]) -> V {
190    let level = |height, renderers: &[(i32, i64)]| {
191        st(
192            "LOD",
193            vec![
194                ("screenRelativeHeight", V::Float(height)),
195                ("fadeTransitionWidth", V::Float(0.1)),
196                (
197                    "renderers",
198                    vector(
199                        st("LODRenderer", vec![("renderer", pptr("Renderer", (0, 0)))]),
200                        renderers
201                            .iter()
202                            .map(|p| st("LODRenderer", vec![("renderer", pptr("Renderer", *p))]))
203                            .collect(),
204                    ),
205                ),
206            ],
207        )
208    };
209    st(
210        "LODGroup",
211        vec![
212            ("m_GameObject", pptr("GameObject", go)),
213            ("m_Enabled", V::Bool(true)),
214            ("m_LocalReferencePoint", xyz("Vector3f", &[0., 0., 0.])),
215            ("m_Size", V::Float(2.)),
216            (
217                "m_LODs",
218                vector(
219                    level(0., &[]),
220                    levels.iter().map(|(h, r)| level(*h, r)).collect(),
221                ),
222            ),
223        ],
224    )
225}
226/// A file with independently typed objects, preserving caller table order.
227/// All trees are hand-built from these values; no external schema is read.
228pub fn file(layout: Layout, externals: &[&str], objects: &[Object]) -> Result<Vec<u8>, BuildError> {
229    let mut types = Vec::new();
230    let mut rows = Vec::new();
231    for (i, obj) in objects.iter().enumerate() {
232        types.push(TypeSpec {
233            class_id: obj.class_id,
234            nodes: nodes(0, "Base", &obj.value)?,
235            ..TypeSpec::default()
236        });
237        let mut writer = ByteWriter::le();
238        write(&mut writer, &obj.value)?;
239        let mut data = writer.into_inner();
240        if let Some(cut) = obj.cut {
241            data.truncate(cut);
242        }
243        data.resize(data.len() + obj.trailing, 0);
244        rows.push(ObjectSpec {
245            path_id: obj.path_id,
246            type_id: i32::try_from(i).map_err(|_| BuildError::TooManyObjects(objects.len()))?,
247            data,
248            ..ObjectSpec::default()
249        });
250    }
251    Ok(crate::serialized::build(&SerializedSpec {
252        unity_version: layout.version().to_vec(),
253        types,
254        objects: rows,
255        externals: externals
256            .iter()
257            .map(|s| ExternalSpec {
258                path: s.as_bytes().to_vec(),
259                ..ExternalSpec::default()
260            })
261            .collect(),
262        ..SerializedSpec::default()
263    }))
264}
265
266/// Set or append a dict field in a synthetic struct.
267pub fn set(value: &mut V, name: &str, replacement: V) {
268    if let V::Struct(_, fields) = value {
269        if let Some((_, v)) = fields.iter_mut().find(|(n, _)| n == name) {
270            *v = replacement;
271        } else {
272            fields.push((name.to_owned(), replacement));
273        }
274    }
275}