Function build_lod_sets

perro_source/render_stack/perro_meshlets/src/lib.rs:160–246

(
    vertices: &[LodVertex],
    indices: &[u32],
    surface_ranges: &[LodSurfaceRange],
    target_ratios: &[f32],
)

        cmax[1] = cmax[1].max(cy);
        cmax[2] = cmax[2].max(cz);
    }

    let span = [
        (cmax[0] - cmin[0]).max(1.0e-6),
        (cmax[1] - cmin[1]).max(1.0e-6),
        (cmax[2] - cmin[2]).max(1.0e-6),
    ];

    let mut keyed = Vec::with_capacity(tri_count);
    for tri_i in 0..tri_count {
        let base = tri_i * 3;
        let Some(a) = positions.get(indices[base] as usize) else {
            return Ok(MeshletPack {
                packed_indices: indices.to_vec(),
                meshlets: Vec::new(),
            });
        };
        let Some(b) = positions.get(indices[base + 1] as usize) else {
            return Ok(MeshletPack {
                packed_indices: indices.to_vec(),
                meshlets: Vec::new(),
            });
        };
        let Some(c) = positions.get(indices[base + 2] as usize) else {
            return Ok(MeshletPack {
                packed_indices: indices.to_vec(),
                meshlets: Vec::new(),
            });
        };
        let nx = (((a[0] + b[0] + c[0]) * (1.0 / 3.0) - cmin[0]) / span[0]).clamp(0.0, 1.0);
        let ny = (((a[1] + b[1] + c[1]) * (1.0 / 3.0) - cmin[1]) / span[1]).clamp(0.0, 1.0);
        let nz = (((a[2] + b[2] + c[2]) * (1.0 / 3.0) - cmin[2]) / span[2]).clamp(0.0, 1.0);
        keyed.push((morton3(nx, ny, nz), tri_i as u32));
    }
    keyed.sort_unstable_by_key(|item| item.0);

    let mut packed_indices = Vec::with_capacity(indices.len());
    for (_, tri) in keyed {
        let base = tri as usize * 3;
        packed_indices.push(indices[base]);
        packed_indices.push(indices[base + 1]);
        packed_indices.push(indices[base + 2]);
    }
    if tri_len < indices.len() {
        packed_indices.extend_from_slice(&indices[tri_len..]);
    }

    let packed_tri_len = (packed_indices.len() / 3) * 3;
    let mut meshlets = Vec::with_capacity(packed_tri_len.div_ceil(chunk));
    let mut start = 0usize;
    while start < packed_tri_len {
        let end = start.saturating_add(chunk).min(packed_tri_len);
        if let Some((center, radius)) = meshlet_bounds(positions, &packed_indices[start..end]) {
            let (index_start, index_count) = checked_meshlet_index_range(start, end)?;
            meshlets.push(MeshletBounds {
                index_start,
                index_count,
                center,