Function best_collapse

perro_source/render_stack/perro_meshlets/src/lib.rs:378–422

(
    vertices: &[LodVertex],
    triangles: &[[u32; 3]],
    quadrics: &[[f64; 10]],
    edges: &[EdgeCandidate],
    adjacency: &[Vec<usize>],
    tri_normals: &[Option<[f32; 3]>],
)

        return ratios.iter().map(|_| Vec::new()).collect();
    };
    let min_vertex = min_index as usize;
    let max_vertex = max_index as usize;
    if max_vertex < vertices.len()
        && (min_vertex > 0 || max_vertex.saturating_add(1) < vertices.len())
    {
        let local_indices = surface_indices
            .iter()
            .map(|index| index - min_index)
            .collect::<Vec<_>>();
        let mut lods =
            build_surface_lods_dense(&vertices[min_vertex..=max_vertex], &local_indices, ratios);
        for lod in &mut lods {
            for index in lod {
                *index += min_index;
            }
        }
        return lods;
    }
    build_surface_lods_dense(vertices, surface_indices, ratios)
}

fn build_surface_lods_dense(
    vertices: &[LodVertex],
    surface_indices: &[u32],
    ratios: &[f32],
) -> Vec<Vec<u32>> {
    let original_tri_count = surface_indices.len() / 3;
    if original_tri_count == 0 {
        return ratios.iter().map(|_| Vec::new()).collect();
    }
    let source = &surface_indices[..original_tri_count * 3];
    if (PARALLEL_LOD_RATIO_TRI_THRESHOLD..=PARALLEL_LOD_RATIO_TRI_MAX).contains(&original_tri_count)
        && ratios.len() > 1
    {
        return ratios
            .par_iter()
            .map(|&ratio| {
                let target = ((original_tri_count as f32) * ratio).ceil() as usize;
                simplify_surface(vertices, source, target.clamp(1, original_tri_count))
            })
            .collect();
    }

    let mut current = source.to_vec();
    let mut lods = Vec::with_capacity(ratios.len());
    for &ratio in ratios {
        let target = ((original_tri_count as f32) * ratio).ceil() as usize;
        let target = target.clamp(1, original_tri_count);