use super::{BufferGeometry, GeometryGroup};
use crate::materials::Material;
use std::collections::HashMap;
use std::sync::Arc;
#[derive(Debug, Clone)]
pub struct Mesh {
pub geometry: Arc<BufferGeometry>,
pub material: Arc<Material>,
pub materials: Vec<Arc<Material>>,
pub morph_influences: Vec<f32>,
pub morph_target_dictionary: HashMap<String, usize>,
}
#[derive(Debug, Clone, Copy)]
pub struct MeshDraw<'a> {
pub start: u32,
pub end: u32,
pub material: &'a Arc<Material>,
pub material_index: u32,
}
impl MeshDraw<'_> {
pub fn count(&self) -> u32 {
self.end - self.start
}
}
impl Mesh {
pub fn new(geometry: BufferGeometry, material: Material) -> Self {
Self::from_arc(Arc::new(geometry), Arc::new(material))
}
pub fn from_arc(geometry: Arc<BufferGeometry>, material: Arc<Material>) -> Self {
let mut mesh = Self {
geometry,
material,
materials: Vec::new(),
morph_influences: Vec::new(),
morph_target_dictionary: HashMap::new(),
};
mesh.update_morph_targets();
mesh
}
pub fn with_materials(geometry: Arc<BufferGeometry>, materials: Vec<Arc<Material>>) -> Self {
let first = materials
.first()
.cloned()
.unwrap_or_else(|| Arc::new(Material::Basic(Default::default())));
let mut mesh = Self::from_arc(geometry, first);
mesh.materials = materials;
mesh
}
pub fn is_multi_material(&self) -> bool {
!self.materials.is_empty()
}
pub fn update_morph_targets(&mut self) {
let (influences, dictionary) = morph_target_defaults(&self.geometry);
if let Some(influences) = influences {
self.morph_influences = influences;
self.morph_target_dictionary = dictionary;
}
}
pub fn draws(&self) -> Vec<MeshDraw<'_>> {
mesh_draws(&self.geometry, &self.material, &self.materials)
}
pub fn posed_geometry(&self) -> Arc<BufferGeometry> {
super::skinning::posed_geometry(&self.geometry, &self.morph_influences, None)
}
}
pub(crate) fn morph_target_defaults(
geometry: &BufferGeometry,
) -> (Option<Vec<f32>>, HashMap<String, usize>) {
let first = ["position", "normal", "color"]
.iter()
.find_map(|k| geometry.morph_attributes.get(*k))
.or_else(|| geometry.morph_attributes.values().next());
let Some(targets) = first else {
return (None, HashMap::new());
};
let mut dictionary = HashMap::new();
for m in 0..targets.len() {
let name = geometry
.morph_target_names
.get(m)
.filter(|n| !n.is_empty())
.cloned()
.unwrap_or_else(|| m.to_string());
dictionary.insert(name, m);
}
(Some(vec![0.0; targets.len()]), dictionary)
}
pub fn mesh_draws<'a>(
geometry: &BufferGeometry,
material: &'a Arc<Material>,
materials: &'a [Arc<Material>],
) -> Vec<MeshDraw<'a>> {
if materials.is_empty() {
return geometry
.draw_span(None)
.map(|(start, end)| MeshDraw {
start,
end,
material,
material_index: 0,
})
.into_iter()
.collect();
}
geometry
.groups
.iter()
.filter_map(|g: &GeometryGroup| {
let material = materials.get(g.material_index as usize)?;
let (start, end) = geometry.draw_span(Some(g))?;
Some(MeshDraw {
start,
end,
material,
material_index: g.material_index,
})
})
.collect()
}