Function walk_node

tools/bloom-reference/src/main.rs:536–648

(
    node: &gltf::Node,
    parent_transform: Mat4,
    buffers: &[gltf::buffer::Data],
    materials: &[Material],
    default_material_index: u32,
    triangles: &mut Vec<Triangle>,
    bbox_min: &

}

fn walk_node(
    node: &gltf::Node,
    parent_transform: Mat4,
    buffers: &[gltf::buffer::Data],
    materials: &[Material],
    default_material_index: u32,
    triangles: &mut Vec<Triangle>,
    bbox_min: &mut Vec3,
    bbox_max: &mut Vec3,
) {
    let local = Mat4::from_cols_array_2d(&node.transform().matrix());
    let world = parent_transform * local;
    let world_normal = world.inverse().transpose();

    if let Some(mesh) = node.mesh() {
        for primitive in mesh.primitives() {
            let reader = primitive.reader(|buffer| Some(&buffers[buffer.index()]));

            let positions: Vec<[f32; 3]> = match reader.read_positions() {
                Some(iter) => iter.collect(),
                None => continue,
            };
            let normals: Vec<[f32; 3]> = reader
                .read_normals()
                .map(|iter| iter.collect())
                .unwrap_or_else(|| vec![[0.0, 1.0, 0.0]; positions.len()]);
            let texcoords: Vec<[f32; 2]> = reader
                .read_tex_coords(0)
                .map(|iter| iter.into_f32().collect())
                .unwrap_or_else(|| vec![[0.0, 0.0]; positions.len()]);
            // glTF tangents: Vec4 (xyz = tangent, w = ±1 bitangent sign).
            // Required for normal mapping; we zero them out for meshes
            // without tangents, and the shader falls back to geometric
            // normals when the length is zero.
            let tangents: Vec<[f32; 4]> = reader
                .read_tangents()
                .map(|iter| iter.collect())
                .unwrap_or_else(|| vec![[0.0, 0.0, 0.0, 0.0]; positions.len()]);
            let indices: Vec<u32> = match reader.read_indices() {
                Some(i) => i.into_u32().collect(),
                None => (0..positions.len() as u32).collect(),
            };

            let material_index = primitive
                .material()
                .index()
                .map(|i| i as u32)
                .unwrap_or(default_material_index);
            if material_index as usize >= materials.len() {
                continue;
            }

            for tri in indices.chunks_exact(3) {
                let (i0, i1, i2) = (tri[0] as usize, tri[1] as usize, tri[2] as usize);
                if i0.max(i1).max(i2) >= positions.len() {
                    continue;
                }