summaryrefslogtreecommitdiff
path: root/import/src/prefab.rs
diff options
context:
space:
mode:
Diffstat (limited to 'import/src/prefab.rs')
-rw-r--r--import/src/prefab.rs442
1 files changed, 442 insertions, 0 deletions
diff --git a/import/src/prefab.rs b/import/src/prefab.rs
new file mode 100644
index 0000000..62690f7
--- /dev/null
+++ b/import/src/prefab.rs
@@ -0,0 +1,442 @@
+/*
+ wearechat - generic multiplayer game with voip
+ Copyright (C) 2025 metamuffin
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, version 3 of the License only.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see <https://www.gnu.org/licenses/>.
+*/
+use crate::{
+ Args, TextureCache, animation::import_animation, mesh::import_mesh, physics::import_physics,
+ transform_to_affine, vrm::extract_vrm_data,
+};
+use anyhow::{Context, Result, anyhow};
+use glam::{Affine3A, Vec3, Vec3A, vec3a};
+use gltf::{Gltf, Node, import_buffers, scene::Transform};
+use log::{debug, info};
+use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
+use serde::Deserialize;
+use serde_json::Value;
+use std::{
+ borrow::Cow,
+ collections::BTreeMap,
+ fs::{File, read_to_string},
+ io::Read,
+ path::Path,
+ sync::Mutex,
+};
+use weareshared::{
+ packets::Resource,
+ resources::{
+ ArmaturePart, AvatarInfoPart, EnvironmentPart, Image, LightPart, ParticlesPart, Prefab,
+ },
+ store::ResourceStore,
+};
+
+pub fn import_prefab(
+ store: &ResourceStore,
+ texture_cache: &TextureCache,
+ scenepath: &Path,
+ args: &Args,
+) -> Result<Resource<Prefab>> {
+ let path_base = scenepath.parent().unwrap();
+ let mut gltf =
+ Gltf::from_reader_without_validation(File::open(scenepath)?).context("gltf parsing")?;
+ let blob = gltf.blob.take();
+ let buffers = import_buffers(&gltf, Some(path_base), blob).context("importing buffers")?;
+
+ let root = gltf.default_scene().ok_or(anyhow!("no default scene"))?;
+
+ // gltf.as_json().asset.copyright
+ // eprintln!("{:?}", gltf.extensions_used());
+ // eprintln!("{:?}", gltf.extensions());
+ // eprintln!("{:?}", root.extensions());
+ // eprintln!("{:?}", root.extras());
+
+ let mut nodes = Vec::new();
+ fn traverse<'a>(out: &mut Vec<(Affine3A, Node<'a>)>, node: Node<'a>, trans: Affine3A) {
+ let trans = trans * transform_to_affine(node.transform());
+ for c in node.children() {
+ traverse(out, c, trans);
+ }
+ out.push((trans, node));
+ }
+
+ let mut root_affine = Affine3A::IDENTITY;
+ root_affine.matrix3 *= args.scale.unwrap_or(1.);
+ root_affine.translation *= args.scale.unwrap_or(1.);
+
+ for node in root.nodes() {
+ traverse(&mut nodes, node, root_affine);
+ }
+
+ let vrm = extract_vrm_data(&gltf)?;
+
+ let mut skin_index_to_arm_index = BTreeMap::new();
+ let mut joint_index_to_arm_index = BTreeMap::new();
+ let joint_name_to_arm_index: BTreeMap<String, usize>;
+ let armature = {
+ let mut name = Vec::new();
+ let mut parent_pre_map = Vec::new();
+ let mut transform = Vec::new();
+ let mut inverse_bind_transform = Vec::new();
+
+ for skin in gltf.skins() {
+ let mut inverse_bind_mat = skin
+ .reader(|buf| Some(&buffers[buf.index()]))
+ .read_inverse_bind_matrices();
+ for (j_ind, j) in skin.joints().enumerate() {
+ let ibm = inverse_bind_mat.as_mut().map(|x| x.next().unwrap());
+ let a_ind = match joint_index_to_arm_index.get(&j.index()) {
+ Some(i) => *i,
+ None => {
+ let a_ind = name.len();
+ // name.push(j.name().unwrap_or("").to_string());
+ name.push(format!("bone{}", a_ind));
+ transform.push(transform_to_affine(j.transform()));
+ parent_pre_map.push(
+ gltf.nodes()
+ .find(|n| n.children().any(|c| c.index() == j.index()))
+ .map(|n| n.index()),
+ );
+ inverse_bind_transform.push(
+ ibm.map(|a| transform_to_affine(Transform::Matrix { matrix: a }))
+ .unwrap_or(Affine3A::IDENTITY),
+ );
+
+ joint_index_to_arm_index.insert(j.index(), a_ind);
+ a_ind
+ }
+ };
+ skin_index_to_arm_index.insert((skin.index(), j_ind as u16), a_ind as u32);
+ }
+ }
+
+ let parent = parent_pre_map
+ .into_iter()
+ .enumerate()
+ .map(|(i, p)| {
+ p.and_then(|i| joint_index_to_arm_index.get(&i).copied())
+ .unwrap_or(i) as u16
+ })
+ .collect::<Vec<_>>();
+
+ for (node, bname) in &vrm.bone_node_names {
+ let ind = joint_index_to_arm_index[node];
+ name[ind] = bname.to_owned();
+ }
+
+ joint_name_to_arm_index = name
+ .iter()
+ .cloned()
+ .enumerate()
+ .map(|(a, b)| (b, a))
+ .collect();
+
+ ArmaturePart {
+ name: Some(name),
+ parent: Some(parent),
+ transform: Some(transform),
+ inverse_bind_transform: Some(inverse_bind_transform),
+ }
+ };
+
+ let head_bones = {
+ let pa = armature.parent.clone().unwrap_or_default();
+ let na = armature.name.clone().unwrap_or_default();
+ (0..pa.len())
+ .filter(|&(mut i)| {
+ let mut f = false;
+ while pa[i] as usize != i {
+ f |= na[i] == "head";
+ i = pa[i] as usize;
+ }
+ f
+ })
+ .map(|e| e as u32)
+ .collect::<Vec<_>>()
+ };
+
+ let prefab = Mutex::new(Prefab::default());
+ let node_to_meshes = Mutex::new(BTreeMap::<usize, Vec<usize>>::new());
+
+ nodes
+ .par_iter()
+ .map(|(trans, node)| {
+ // if node.name().unwrap_or_default() == "particles" {
+ // eprintln!("{:?}", node.transform());
+ // eprintln!("{:?}", node.extensions());
+ // eprintln!("{:?}", node.extras());
+ // }
+ let name = node.name().unwrap_or_default();
+ let extras: Value = node
+ .extras()
+ .to_owned()
+ .map(|v| serde_json::from_str(v.get()).unwrap())
+ .unwrap_or(Value::Object(Default::default()));
+
+ if !name.ends_with("-collider") {
+ if let Some(mesh) = node.mesh() {
+ let meshes = import_mesh(
+ mesh,
+ *trans,
+ &buffers,
+ &store,
+ path_base,
+ node,
+ &args,
+ &texture_cache,
+ &skin_index_to_arm_index,
+ &vrm,
+ &head_bones,
+ )?;
+ for (node, trans, mesh) in meshes {
+ let mut k = prefab.lock().unwrap();
+ let i = k.mesh.len();
+ k.mesh.push((trans, mesh));
+ node_to_meshes
+ .lock()
+ .unwrap()
+ .entry(node)
+ .or_default()
+ .push(i)
+ }
+ }
+ }
+ if extras.get("particles") == Some(&Value::Bool(true)) && !args.no_particles {
+ #[derive(Deserialize)]
+ struct ParticlesAttr {
+ density: Option<f32>,
+ lifetime: Option<f32>,
+ lifetime_spread: Option<f32>,
+ velocity: Option<Vec3A>,
+ velocity_spread: Option<Vec3A>,
+ }
+ // let sprite = extras
+ // .get("sprite")
+ // .ok_or(anyhow!("particle volume is missing sprite"))?;
+
+ let attr: ParticlesAttr =
+ serde_json::from_value(extras).context("particles attributes")?;
+
+ info!("adding particles part");
+
+ let part = store.set(&ParticlesPart {
+ sprite: None,
+ density: attr.density,
+ lifetime: attr.lifetime,
+ lifetime_spread: attr.lifetime_spread,
+ velocity: attr.velocity,
+ velocity_spread: attr.velocity_spread,
+ })?;
+
+ prefab
+ .lock()
+ .unwrap()
+ .particles
+ .push((transform_to_affine(node.transform()), part));
+ }
+
+ if let Some(light) = node.light() {
+ let name = node.name().map(|e| e.to_owned());
+ if let Some(name) = &name {
+ info!("adding light {name:?}");
+ } else {
+ info!("adding light");
+ }
+ let emission = Some(Vec3A::from_array(light.color()) * light.intensity());
+ if let Some(e) = emission {
+ debug!("emission is {e}");
+ }
+ let (position, _, _) = node.transform().decomposed();
+ let part = store.set(&LightPart {
+ emission,
+ name,
+ radius: None,
+ })?;
+ prefab
+ .lock()
+ .unwrap()
+ .light
+ .push((Vec3A::from_array(position), part));
+ }
+ {
+ let collider = import_physics(&gltf, *trans, node, &store, &buffers)?;
+ prefab.lock().unwrap().collision.extend(collider);
+ }
+
+ Ok::<_, anyhow::Error>(())
+ })
+ .reduce(
+ || Ok(()),
+ |a, b| match (a, b) {
+ (Ok(()), Ok(())) => Ok(()),
+ (Ok(()), a) => a,
+ (a, _) => a,
+ },
+ )?;
+
+ let mut prefab = prefab.into_inner().unwrap();
+ let node_to_meshes = node_to_meshes.into_inner().unwrap();
+
+ if let Some(apath) = args.animation.clone() {
+ let path_base = apath.parent().unwrap();
+ let mut gltf =
+ Gltf::from_reader_without_validation(File::open(&apath)?).context("gltf parsing")?;
+ let blob = gltf.blob.take();
+ let buffers = import_buffers(&gltf, Some(path_base), blob).context("importing buffers")?;
+
+ let anim_name_map = if let Some(ref map_path) = args.animation_bone_map {
+ let mut map = BTreeMap::new();
+ for l in read_to_string(map_path)?.lines() {
+ if !l.trim().is_empty() && !l.starts_with(";") {
+ let (a, b) = l.split_once("=").unwrap();
+ map.insert(a.to_string(), b.to_string());
+ }
+ }
+ Some(map)
+ } else {
+ None
+ };
+
+ let mut anim_joint_index_to_arm_index = BTreeMap::new();
+ let mut joint_index_to_ibm = BTreeMap::new();
+ for n in gltf.nodes() {
+ if let Some(name) = n.name() {
+ let Some(vrm_name) = (if let Some(map) = &anim_name_map {
+ map.get(name).cloned()
+ } else {
+ Some(name.to_string())
+ }) else {
+ continue;
+ };
+ let anim_node_index = n.index();
+ if let Some(scene_arm_index) = joint_name_to_arm_index.get(&vrm_name) {
+ debug!(
+ "mapping {name:?} (node={}) -> {vrm_name:?} (bone={})",
+ anim_node_index, scene_arm_index
+ );
+ anim_joint_index_to_arm_index.insert(anim_node_index, *scene_arm_index);
+ }
+ }
+ }
+ if args.animation_apply_ibm {
+ for s in gltf.skins() {
+ let reader = s.reader(|buf| Some(&buffers[buf.index()]));
+ if let Some(ibms) = reader.read_inverse_bind_matrices() {
+ for (jn, ibm) in s.joints().zip(ibms) {
+ joint_index_to_ibm.insert(
+ jn.index(),
+ transform_to_affine(Transform::Matrix { matrix: ibm }),
+ );
+ }
+ }
+ }
+ debug!("{} joint IBMs found", joint_index_to_ibm.len());
+ }
+ let transform = args
+ .animation_rotation_y
+ .map(Affine3A::from_rotation_y)
+ .unwrap_or_default()
+ * args
+ .animation_scale
+ .map(Vec3::splat)
+ .map(Affine3A::from_scale)
+ .unwrap_or_default();
+ for a in gltf.animations() {
+ prefab.animation.push(import_animation(
+ a,
+ &store,
+ transform,
+ &joint_index_to_ibm,
+ &anim_joint_index_to_arm_index,
+ &BTreeMap::new(),
+ &buffers,
+ )?);
+ }
+ }
+
+ for a in gltf.animations() {
+ if !args.no_animations {
+ prefab.animation.push(import_animation(
+ a,
+ &store,
+ Affine3A::IDENTITY,
+ &BTreeMap::new(),
+ &joint_index_to_arm_index,
+ &node_to_meshes,
+ &buffers,
+ )?);
+ };
+ }
+
+ if vrm.camera_mount.is_some()
+ || vrm.camera_mount_offset.is_some()
+ || !vrm.bone_node_names.is_empty()
+ {
+ info!("avatar info enabled");
+ prefab.avatar_info = Some(
+ store.set(&AvatarInfoPart {
+ armature: Some(0), // TODO
+ camera_mount: vrm
+ .camera_mount
+ .map(|e| joint_index_to_arm_index[&e] as u32),
+ camera_mount_offset: vrm.camera_mount_offset,
+ ..Default::default()
+ })?,
+ );
+ }
+
+ prefab.armature = if armature.parent.as_ref().is_some_and(|a| !a.is_empty()) {
+ vec![store.set(&armature)?]
+ } else {
+ vec![]
+ };
+
+ let skybox = if let Some(skybox) = &args.skybox {
+ let mut buf = Vec::new();
+ File::open(skybox)?.read_to_end(&mut buf)?;
+ Some(store.set(&Image(Cow::Owned(buf)))?)
+ } else {
+ None
+ };
+ let sun = if args.with_default_sun {
+ Some((
+ vec3a(1., -5., 1.).normalize(),
+ vec3a(1., 1., 1.).normalize() * 100_000.,
+ ))
+ } else {
+ None
+ };
+ prefab.environment = if skybox.is_some() || sun.is_some() {
+ Some(store.set(&EnvironmentPart { skybox, sun })?)
+ } else {
+ None
+ };
+
+ prefab.name = args.name.clone().or(gltf
+ .default_scene()
+ .and_then(|n| n.name())
+ .map(|n| n.to_owned()));
+
+ if args.debug_light {
+ prefab.light.push((
+ vec3a(5., 5., 5.),
+ store.set(&LightPart {
+ name: Some("debug light".to_owned()),
+ emission: Some(vec3a(10., 5., 15.)),
+ radius: Some(0.3),
+ })?,
+ ));
+ }
+
+ Ok(store.set(&prefab)?)
+}
generated by cgit v1.2.3-70-g09d2 (git 2.51.0) at 2025-10-07 23:32:20 +0000