use std::collections::HashMap;
use crate::data::attribute::AttributeData;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SubmeshRange {
pub first_index: u32,
pub index_count: u32,
}
#[derive(Clone)]
#[non_exhaustive]
pub struct MeshData {
pub positions: Vec<[f32; 3]>,
pub normals: Vec<[f32; 3]>,
pub indices: Vec<u32>,
pub uvs: Option<Vec<[f32; 2]>>,
pub tangents: Option<Vec<[f32; 4]>>,
pub vertex_colours: Option<Vec<[f32; 4]>>,
pub attributes: HashMap<String, AttributeData>,
pub extension_attributes: Option<Vec<[f32; 4]>>,
pub submeshes: Vec<SubmeshRange>,
}
impl Default for MeshData {
fn default() -> Self {
Self {
positions: Vec::new(),
normals: Vec::new(),
indices: Vec::new(),
uvs: None,
tangents: None,
vertex_colours: None,
attributes: HashMap::new(),
extension_attributes: None,
submeshes: Vec::new(),
}
}
}
impl MeshData {
pub fn new(positions: Vec<[f32; 3]>, normals: Vec<[f32; 3]>, indices: Vec<u32>) -> Self {
Self {
positions,
normals,
indices,
..Self::default()
}
}
pub fn compute_aabb(&self) -> crate::scene::aabb::Aabb {
crate::scene::aabb::Aabb::from_positions(&self.positions)
}
pub fn sort_triangles_into_submeshes(
&mut self,
triangle_materials: &[u32],
) -> crate::error::ViewportResult<Vec<u32>> {
let tri_count = self.indices.len() / 3;
if self.indices.len() % 3 != 0 || triangle_materials.len() != tri_count {
return Err(crate::error::ViewportError::SubmeshTriangleCountMismatch {
triangles: tri_count,
material_ids: triangle_materials.len(),
});
}
let mut order: Vec<u32> = (0..tri_count as u32).collect();
order.sort_by_key(|&t| triangle_materials[t as usize]);
let old_indices = std::mem::take(&mut self.indices);
self.indices = Vec::with_capacity(old_indices.len());
for &t in &order {
let base = t as usize * 3;
self.indices.extend_from_slice(&old_indices[base..base + 3]);
}
fn permute<T: Copy>(values: &mut Vec<T>, order: &[u32], per_tri: usize) {
if values.len() != order.len() * per_tri {
return;
}
let old = std::mem::take(values);
values.reserve(old.len());
for &t in order {
let base = t as usize * per_tri;
values.extend_from_slice(&old[base..base + per_tri]);
}
}
for data in self.attributes.values_mut() {
match data {
AttributeData::Cell(v) | AttributeData::Face(v) => permute(v, &order, 1),
AttributeData::FaceColour(v) => permute(v, &order, 1),
AttributeData::Edge(v) | AttributeData::Halfedge(v) | AttributeData::Corner(v) => {
permute(v, &order, 3)
}
AttributeData::Vertex(_) | AttributeData::VertexVector(_) => {}
}
}
self.submeshes.clear();
let mut ids = Vec::new();
let mut run_start = 0usize;
for i in 0..order.len() {
let id = triangle_materials[order[i] as usize];
let next_differs = order
.get(i + 1)
.map_or(true, |&t| triangle_materials[t as usize] != id);
if next_differs {
self.submeshes.push(SubmeshRange {
first_index: run_start as u32 * 3,
index_count: (i + 1 - run_start) as u32 * 3,
});
ids.push(id);
run_start = i + 1;
}
}
Ok(ids)
}
}
pub fn lerp_attributes(a: &[f32], b: &[f32], t: f32) -> Vec<f32> {
let t = t.clamp(0.0, 1.0);
let one_minus_t = 1.0 - t;
a.iter()
.zip(b.iter())
.map(|(&av, &bv)| av * one_minus_t + bv * t)
.collect()
}