unityrs-testkit 1.1.0

Synthetic Unity files built in code, for unityrs's own tests and the CLI's test hooks; not a stable API. Never game data.
Documentation
//! Synthetic scene/profile pairs shared by fuzz seeds and harness tests.
use super::SceneCase;
use crate::{
    ngui::{self, Object, V, st, vector},
    scene3d::{self as s, mesh as m},
};

/// All three supported version layouts, renderers, materials, and hostile links.
/// The generated bytes are never checked into the repository.
///
/// # Panics
/// If a hand-built synthetic file cannot be encoded.
#[must_use]
pub fn scene_cases() -> Vec<(String, SceneCase)> {
    let mut out = Vec::new();
    for (version, layout) in [
        (m::MeshVersion::V2019, s::Layout::Unity2019),
        (m::MeshVersion::V2022, s::Layout::Unity2022),
        (m::MeshVersion::V6000, s::Layout::Unity6000),
    ] {
        for kind in [
            "plain", "batch", "skin", "morph", "cycle", "dangling", "negative", "nan",
        ] {
            let mut objects = objects(version, kind);
            if kind == "nan" {
                s::set(
                    &mut objects[1].value,
                    "m_LocalPosition",
                    s::xyz("Vector3f", &[f32::NAN, 0., 0.]),
                );
            }
            let data = s::file(layout, &[], &objects).expect("synthetic 3D file");
            for (policy, flags, profile) in [
                ("default", 0, b"".as_slice()),
                (
                    "prefab",
                    1,
                    br#"{"profile_version":1,"inactive":"include_hidden"}"#.as_slice(),
                ),
                (
                    "pbr",
                    2,
                    br#"{"profile_version":1,"static_batch":"keep_combined"}"#.as_slice(),
                ),
            ] {
                for meter in [0, 1, 16, 64] {
                    out.push((
                        format!("{version:?}-{kind}-{policy}-m{meter}"),
                        SceneCase {
                            meter,
                            flags,
                            profile: profile.to_vec(),
                            data: data.clone(),
                        },
                    ));
                }
            }
        }
    }
    out
}

fn objects(version: m::MeshVersion, kind: &str) -> Vec<Object> {
    let mut mesh = m::mesh(
        7,
        if kind == "negative" {
            b"mesh\xff"
        } else {
            b"mesh"
        },
        &[[1., 0., 0.], [0., 1., 0.], [0., 0., 0.]],
        &[0, 1, 2],
        version,
    );
    if kind == "morph" {
        s::set(
            &mut mesh.value,
            "m_Shapes",
            m::blend_shapes(
                vec![m::blend_vertex(1, [0.5, 0., 0.], [0.; 3], [0.; 3])],
                vec![m::blend_frame(0, 1, false, false)],
                vec![m::blend_channel(b"bend", 0, 0, 1)],
                vec![100.],
            ),
        );
    }
    let skin = matches!(kind, "skin" | "morph");
    if skin {
        skin_arrays(&mut mesh);
    }
    let mut renderer = if skin {
        s::skinned_mesh_renderer((0, 1), (0, 7), &[(0, 2)], &[25.])
    } else {
        s::mesh_renderer(
            (0, 1),
            &[(0, 8)],
            if kind == "batch" { (0, 1) } else { (0, 0) },
        )
    };
    if skin {
        s::set(
            &mut renderer,
            "m_Materials",
            s::pointers("Material", &[(0, 8)]),
        );
    }
    let father = if kind == "cycle" { (0, 2) } else { (0, 0) };
    let children = if kind == "cycle" {
        vec![(0, 2)]
    } else {
        vec![]
    };
    let ptr = match kind {
        "dangling" => (0, 999),
        "negative" => (-1, 7),
        _ => (0, 7),
    };
    let mut objects = vec![
        // Deliberately place root 20 before root 1 in the object table.
        Object::new(20, 1, s::game_object(b"first", &[(0, 21)])),
        Object::new(21, 4, s::transform((0, 20), (0, 0), &[], false)),
        Object::new(1, 1, s::game_object(b"mesh", &[(0, 2), (0, 5), (0, 6)])),
        Object::new(2, 4, s::transform((0, 1), father, &children, false)),
        Object::new(5, 33, s::mesh_filter((0, 1), ptr)),
        Object::new(6, if skin { 137 } else { 23 }, renderer),
        mesh,
        s::material(
            8,
            b"material",
            (0, 9),
            &[("_Metallic", 0.5)],
            &[("_Color", [0.2, 0.4, 0.8, 1.])],
            &[("_MainTex", s::tex_env((0, 10), [1.; 2], [0.; 2]))],
        ),
        s::shader(9, b"Standard"),
        ngui::texture(
            10,
            b"asymmetric",
            ngui::format::RGBA32,
            (2, 2),
            vec![
                255, 0, 0, 255, 0, 255, 0, 128, 0, 0, 255, 255, 255, 255, 0, 64,
            ],
        ),
    ];
    // Exercise an inactive root and a non-default layer as profile inputs.
    s::set(&mut objects[0].value, "m_IsActive", V::Bool(false));
    s::set(&mut objects[0].value, "m_Layer", V::UInt(31));
    objects
}

// Position, normal, UV0 and the four fixed bone influences; all one stream.
fn skin_arrays(mesh: &mut Object) {
    let mut channels = Vec::new();
    let mut offset = 0u8;
    for i in 0..14 {
        let dimension = match i {
            0 | 1 => 3,
            4 => 2,
            12 | 13 => 4,
            _ => 0,
        };
        channels.push(st(
            "ChannelInfo",
            vec![
                ("stream", V::UInt8(0)),
                ("offset", V::UInt8(offset)),
                ("format", V::UInt8(if i == 13 { 10 } else { 0 })),
                ("dimension", V::UInt8(dimension)),
            ],
        ));
        offset += dimension * 4;
    }
    let mut data = Vec::new();
    for position in [[1f32, 0., 0.], [0., 1., 0.], [0., 0., 0.]] {
        for x in position
            .into_iter()
            .chain([0., 0., 1.])
            .chain([0.25, 0.75])
            .chain([1., 0., 0., 0.])
        {
            data.extend_from_slice(&x.to_le_bytes());
        }
        data.extend_from_slice(&[0; 16]);
    }
    data.resize(data.len().next_multiple_of(16), 0);
    s::set(
        &mut mesh.value,
        "m_VertexData",
        st(
            "VertexData",
            vec![
                ("m_VertexCount", V::UInt(3)),
                ("m_Channels", vector(channels[0].clone(), channels)),
                ("m_DataSize", V::Bytes(data)),
            ],
        ),
    );
    let identity = m::matrix([
        1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1.,
    ]);
    s::set(
        &mut mesh.value,
        "m_BindPose",
        vector(identity.clone(), vec![identity]),
    );
}