1use meshoptimizer_rs::{clusterlod::page::*, clusterlod::*, codec, Workspace};
5use std::fs;
6
7const CLUSTERS_PER_PAGE: usize = 64;
8
9fn u32_at(b: &[u8], at: usize) -> u32 {
10 u32::from_le_bytes(b[at..at + 4].try_into().unwrap())
11}
12
13fn main() {
14 println!("mesh,grid_exponent,dag_triangles,clusters,pages,meshlet_bytes,index_sequence_bytes,memory_bytes,disk_bytes,memory_b_per_triangle,disk_b_per_triangle");
15 for path in std::env::args().skip(1) {
16 let b = fs::read(&path).unwrap();
17 let nv = u32_at(&b, 0) as usize;
18 let ni = u32_at(&b, 4) as usize;
19 let mut positions: Vec<[f32; 3]> = (0..nv)
20 .map(|i| core::array::from_fn(|k| f32::from_bits(u32_at(&b, 8 + i * 12 + k * 4))))
21 .collect();
22 let indices: Vec<_> = (0..ni).map(|i| u32_at(&b, 8 + nv * 12 + i * 4)).collect();
23 drop(b);
24 let (mut min, mut max) = ([f32::MAX; 3], [f32::MIN; 3]);
25 for p in &positions {
26 for ((lo, hi), &x) in min.iter_mut().zip(&mut max).zip(p) {
27 *lo = lo.min(x);
28 *hi = hi.max(x);
29 }
30 }
31 let grid = QuantGrid::from_bounds(min, max, 16).unwrap();
32 grid.snap_positions(&mut positions).unwrap();
33 let mut source = vec![0; ni * 8];
34 let mut vp = vec![[0.; 3]; ni * 8];
35 let mut ix = vec![0; ni * 8];
36 let mut cl = vec![FlatDagCluster::default(); ni / 3];
37 let mut gr = vec![FlatDagGroup::default(); ni / 3];
38 let mut nodes = vec![Node::default(); ni / 3 + 128];
39 let mut ws = Workspace::default();
40 let counts = build_dag_into(
41 default_config(128).unwrap(),
42 Mesh {
43 indices: &indices,
44 positions: &mut positions,
45 attributes: None,
46 vertex_lock: None,
47 attribute_weights: &[],
48 attribute_protect_mask: 0,
49 },
50 8,
51 DagBuffers {
52 vertex_source: &mut source,
53 vertex_positions: &mut vp,
54 indices: &mut ix,
55 clusters: &mut cl,
56 groups: &mut gr,
57 nodes: &mut nodes,
58 },
59 &mut ws,
60 )
61 .unwrap();
62 drop(source);
63 drop(nodes);
64 let (mut meshlet, mut sequence, mut memory, mut disk, mut pages) = (0, 0, 0, 0, 0);
65 let mut locals = Vec::new();
66 for c in &cl[..counts.clusters] {
67 let tri = &ix[c.first_index as usize..][..c.index_count as usize];
68 let (mut local, mut ids, mut pos) = (Vec::new(), Vec::new(), Vec::new());
69 for &v in tri {
70 let k = ids.iter().position(|&x| x == v).unwrap_or_else(|| {
71 ids.push(v);
72 pos.push(vp[v as usize]);
73 ids.len() - 1
74 });
75 local.push(k as u32);
76 }
77 locals.push((c.group, c.refined, pos, local));
78 }
79 for chunk in locals.chunks(CLUSTERS_PER_PAGE) {
80 let clusters: Vec<_> = chunk
81 .iter()
82 .map(|(g, r, p, i)| PageCluster::new(*g, *r, p, i))
83 .collect();
84 let page = encode_page(grid, &clusters, 0, &mut ws).unwrap();
85 let view = PageView::new(&page, grid).unwrap();
86 for c in 0..view.cluster_count() {
87 let mut t = [[0u8; 3]; 256];
88 let n = view.decode_triangles(c, &mut t).unwrap();
89 let nv = view.cluster(c).unwrap().vertex_count;
90 let refs: Vec<u32> = (0..nv).collect();
91 let flat: Vec<u8> = t[..n].iter().flatten().copied().collect();
92 meshlet += codec::encode_meshlet(&refs, &flat, &mut ws).unwrap().len();
93 let wide: Vec<u32> = flat.iter().map(|&i| u32::from(i)).collect();
94 sequence += codec::encode_index_sequence(
95 &wide,
96 codec::IndexEncoding::new(1).unwrap(),
97 &mut ws,
98 )
99 .unwrap()
100 .len();
101 }
102 memory += page.len() * 4;
103 disk += encode_disk_page(&page, grid, DiskCodec::Compressed, &mut ws)
104 .unwrap()
105 .len();
106 pages += 1;
107 }
108 let triangles = counts.indices / 3;
109 println!(
110 "{path},{},{triangles},{},{pages},{meshlet},{sequence},{memory},{disk},{:.3},{:.3}",
111 grid.exponent(),
112 counts.clusters,
113 memory as f64 / triangles as f64,
114 disk as f64 / triangles as f64,
115 );
116 }
117}