use super::SceneCase;
use crate::{
ngui::{self, Object, V, st, vector},
scene3d::{self as s, mesh as m},
};
#[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![
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,
],
),
];
s::set(&mut objects[0].value, "m_IsActive", V::Bool(false));
s::set(&mut objects[0].value, "m_Layer", V::UInt(31));
objects
}
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]),
);
}