Skip to main content

page_codec_measure/
page_codec_measure.rs

1//! Measures the page triangle codec choice (meshlet codec against the
2//! index-sequence codec) and page sizes per DAG triangle, on meshes in the parity
3//! corpus's packed XYZ/u32 input format (two u32 counts, XYZ floats, u32 indices).
4use 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}