Skip to main content

unityrs_testkit/fuzz/
scene.rs

1//! Synthetic scene/profile pairs shared by fuzz seeds and harness tests.
2use super::SceneCase;
3use crate::{
4    ngui::{self, Object, V, st, vector},
5    scene3d::{self as s, mesh as m},
6};
7
8/// All three supported version layouts, renderers, materials, and hostile links.
9/// The generated bytes are never checked into the repository.
10///
11/// # Panics
12/// If a hand-built synthetic file cannot be encoded.
13#[must_use]
14pub fn scene_cases() -> Vec<(String, SceneCase)> {
15    let mut out = Vec::new();
16    for (version, layout) in [
17        (m::MeshVersion::V2019, s::Layout::Unity2019),
18        (m::MeshVersion::V2022, s::Layout::Unity2022),
19        (m::MeshVersion::V6000, s::Layout::Unity6000),
20    ] {
21        for kind in [
22            "plain", "batch", "skin", "morph", "cycle", "dangling", "negative", "nan",
23        ] {
24            let mut objects = objects(version, kind);
25            if kind == "nan" {
26                s::set(
27                    &mut objects[1].value,
28                    "m_LocalPosition",
29                    s::xyz("Vector3f", &[f32::NAN, 0., 0.]),
30                );
31            }
32            let data = s::file(layout, &[], &objects).expect("synthetic 3D file");
33            for (policy, flags, profile) in [
34                ("default", 0, b"".as_slice()),
35                (
36                    "prefab",
37                    1,
38                    br#"{"profile_version":1,"inactive":"include_hidden"}"#.as_slice(),
39                ),
40                (
41                    "pbr",
42                    2,
43                    br#"{"profile_version":1,"static_batch":"keep_combined"}"#.as_slice(),
44                ),
45            ] {
46                for meter in [0, 1, 16, 64] {
47                    out.push((
48                        format!("{version:?}-{kind}-{policy}-m{meter}"),
49                        SceneCase {
50                            meter,
51                            flags,
52                            profile: profile.to_vec(),
53                            data: data.clone(),
54                        },
55                    ));
56                }
57            }
58        }
59    }
60    out
61}
62
63fn objects(version: m::MeshVersion, kind: &str) -> Vec<Object> {
64    let mut mesh = m::mesh(
65        7,
66        if kind == "negative" {
67            b"mesh\xff"
68        } else {
69            b"mesh"
70        },
71        &[[1., 0., 0.], [0., 1., 0.], [0., 0., 0.]],
72        &[0, 1, 2],
73        version,
74    );
75    if kind == "morph" {
76        s::set(
77            &mut mesh.value,
78            "m_Shapes",
79            m::blend_shapes(
80                vec![m::blend_vertex(1, [0.5, 0., 0.], [0.; 3], [0.; 3])],
81                vec![m::blend_frame(0, 1, false, false)],
82                vec![m::blend_channel(b"bend", 0, 0, 1)],
83                vec![100.],
84            ),
85        );
86    }
87    let skin = matches!(kind, "skin" | "morph");
88    if skin {
89        skin_arrays(&mut mesh);
90    }
91    let mut renderer = if skin {
92        s::skinned_mesh_renderer((0, 1), (0, 7), &[(0, 2)], &[25.])
93    } else {
94        s::mesh_renderer(
95            (0, 1),
96            &[(0, 8)],
97            if kind == "batch" { (0, 1) } else { (0, 0) },
98        )
99    };
100    if skin {
101        s::set(
102            &mut renderer,
103            "m_Materials",
104            s::pointers("Material", &[(0, 8)]),
105        );
106    }
107    let father = if kind == "cycle" { (0, 2) } else { (0, 0) };
108    let children = if kind == "cycle" {
109        vec![(0, 2)]
110    } else {
111        vec![]
112    };
113    let ptr = match kind {
114        "dangling" => (0, 999),
115        "negative" => (-1, 7),
116        _ => (0, 7),
117    };
118    let mut objects = vec![
119        // Deliberately place root 20 before root 1 in the object table.
120        Object::new(20, 1, s::game_object(b"first", &[(0, 21)])),
121        Object::new(21, 4, s::transform((0, 20), (0, 0), &[], false)),
122        Object::new(1, 1, s::game_object(b"mesh", &[(0, 2), (0, 5), (0, 6)])),
123        Object::new(2, 4, s::transform((0, 1), father, &children, false)),
124        Object::new(5, 33, s::mesh_filter((0, 1), ptr)),
125        Object::new(6, if skin { 137 } else { 23 }, renderer),
126        mesh,
127        s::material(
128            8,
129            b"material",
130            (0, 9),
131            &[("_Metallic", 0.5)],
132            &[("_Color", [0.2, 0.4, 0.8, 1.])],
133            &[("_MainTex", s::tex_env((0, 10), [1.; 2], [0.; 2]))],
134        ),
135        s::shader(9, b"Standard"),
136        ngui::texture(
137            10,
138            b"asymmetric",
139            ngui::format::RGBA32,
140            (2, 2),
141            vec![
142                255, 0, 0, 255, 0, 255, 0, 128, 0, 0, 255, 255, 255, 255, 0, 64,
143            ],
144        ),
145    ];
146    // Exercise an inactive root and a non-default layer as profile inputs.
147    s::set(&mut objects[0].value, "m_IsActive", V::Bool(false));
148    s::set(&mut objects[0].value, "m_Layer", V::UInt(31));
149    objects
150}
151
152// Position, normal, UV0 and the four fixed bone influences; all one stream.
153fn skin_arrays(mesh: &mut Object) {
154    let mut channels = Vec::new();
155    let mut offset = 0u8;
156    for i in 0..14 {
157        let dimension = match i {
158            0 | 1 => 3,
159            4 => 2,
160            12 | 13 => 4,
161            _ => 0,
162        };
163        channels.push(st(
164            "ChannelInfo",
165            vec![
166                ("stream", V::UInt8(0)),
167                ("offset", V::UInt8(offset)),
168                ("format", V::UInt8(if i == 13 { 10 } else { 0 })),
169                ("dimension", V::UInt8(dimension)),
170            ],
171        ));
172        offset += dimension * 4;
173    }
174    let mut data = Vec::new();
175    for position in [[1f32, 0., 0.], [0., 1., 0.], [0., 0., 0.]] {
176        for x in position
177            .into_iter()
178            .chain([0., 0., 1.])
179            .chain([0.25, 0.75])
180            .chain([1., 0., 0., 0.])
181        {
182            data.extend_from_slice(&x.to_le_bytes());
183        }
184        data.extend_from_slice(&[0; 16]);
185    }
186    data.resize(data.len().next_multiple_of(16), 0);
187    s::set(
188        &mut mesh.value,
189        "m_VertexData",
190        st(
191            "VertexData",
192            vec![
193                ("m_VertexCount", V::UInt(3)),
194                ("m_Channels", vector(channels[0].clone(), channels)),
195                ("m_DataSize", V::Bytes(data)),
196            ],
197        ),
198    );
199    let identity = m::matrix([
200        1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1.,
201    ]);
202    s::set(
203        &mut mesh.value,
204        "m_BindPose",
205        vector(identity.clone(), vec![identity]),
206    );
207}