Function bloom_scene_attach_model

native/watchos/src/lib.rs:881–952

(node_handle: f64, model_handle: f64, mesh_idx: f64)

/// hierarchy — it picks which mesh to instantiate into `node_handle`.
#[no_mangle]
pub extern "C" fn bloom_scene_attach_model(node_handle: f64, model_handle: f64, mesh_idx: f64) {
    let Some(model) = models::get(model_handle as u32) else { return; };
    let root = node_handle as u32;

    // If the model has a scene graph with non-trivial hierarchy (>1 node or a
    // transform on the root), walk it. Otherwise fall back to single-mesh
    // mode so mesh_idx still picks which mesh to attach.
    let single_mesh = model.nodes.len() <= 1
        && model.scene_roots.len() <= 1
        && model.nodes.first().map(|n| n.matrix.is_none()
            && n.translation == [0.0; 3]
            && n.rotation == [0.0, 0.0, 0.0, 1.0]
            && n.scale == [1.0; 3]).unwrap_or(true);

    if single_mesh {
        let mesh_i = mesh_idx as usize;
        let Some(mesh) = model.meshes.get(mesh_i) else { return; };
        attach_mesh(root, mesh);
        return;
    }

    // Scene-hierarchy path: one bloom scene node per glTF node. The attach
    // target `root` itself doesn't gain geometry — it's the hierarchy's
    // anchor. Children materialize via scene::create + scene::set_parent.
    // We build a gltf_node_idx → bloom_handle map during the walk, then
    // resolve skin joint references once everyone's in place.
    let mut gltf_to_bloom: std::collections::HashMap<usize, u32> = std::collections::HashMap::new();
    let mut skinned_nodes: Vec<(u32, usize)> = Vec::new();  // (bloom_handle, gltf_node_idx)
    for scene_root in &model.scene_roots {
        spawn_node_subtree(&model, *scene_root, root, &mut gltf_to_bloom, &mut skinned_nodes);
    }
    // Second pass: attach skin data to each skinned mesh-node. Joints are
    // resolved to the bloom handles we just created.
    for (bloom_handle, gltf_idx) in skinned_nodes {
        let gltf_node = &model.nodes[gltf_idx];
        let Some(skin_idx) = gltf_node.skin else { continue };
        let Some(skin) = model.skins.get(skin_idx) else { continue };
        let Some(mesh_idx) = gltf_node.mesh else { continue };
        let Some(mesh) = model.meshes.get(mesh_idx) else { continue };
        let Some(prim) = mesh.primitives.first() else { continue };

        let joint_handles: Vec<u32> = skin.joints.iter()
            .map(|&gi| *gltf_to_bloom.get(&gi).unwrap_or(&0))
            .collect();
        scene::set_skin(bloom_handle,
            joint_handles,
            skin.inverse_bind_matrices.clone(),
            prim.joint_indices.clone(),
            prim.weights.clone(),
        );

        // Animation tracks — resolve channel targets to bloom handles.
        // Auto-select animation 0 for now (typically the idle/survey clip).
        // Follow-up: bloom_update_model_animation to switch between them.
        if let Some(anim) = model.animations.first() {
            let mut tracks: Vec<scene::AnimTrack> = Vec::new();
            for ch in &anim.channels {
                let Some(&bone_h) = gltf_to_bloom.get(&ch.target_node) else { continue };