1use crate::ngui::{BuildError, Object, V, nodes, pair, pptr, st, vector, write};
7use crate::serialized::{ExternalSpec, ObjectSpec, SerializedSpec, TypeSpec};
8use crate::writer::ByteWriter;
9
10#[derive(Clone, Copy, Debug)]
13pub enum Layout {
14 Unity51,
15 Unity55,
16 Unity2019,
17 Unity20221,
18 Unity2022,
19 Unity6000,
20}
21impl Layout {
22 #[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#[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#[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#[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#[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#[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#[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#[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#[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#[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}
226pub 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
266pub 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}