Rename nodes_in_scene to root_nodes_in_scene, add recursive_nodes_in_scene

Split the scene node query API into two explicit methods:

- root_nodes_in_scene: returns only the top-level nodes directly
  referenced by the scene (the original behavior)
- recursive_nodes_in_scene: returns all nodes including descendants
  in depth-first order

This fixes a bug where animations targeting child (parented) nodes
were silently skipped because only root nodes were collected.

Update call sites:
- Animator test now uses recursive_nodes_in_scene for correctness
- Example crate simplified by removing manual get_children helper

Co-authored-by: Andreas Streichardt <andreas@mop.koeln>

Author: schell

crates/example/src/lib.rs

@@ -286,29 +286,8 @@ impl App {
 
         let scene = doc.default_scene.unwrap_or(0);
         log::info!("Displaying scene {scene}");
-        fn get_children(doc: &GltfDocument, n: usize) -> Vec<usize> {
-            let mut children = vec![];
-            if let Some(parent) = doc.nodes.get(n) {
-                children.extend(parent.children.iter().copied());
-                let descendants = parent
-                    .children
-                    .iter()
-                    .copied()
-                    .flat_map(|n| get_children(doc, n));
-                children.extend(descendants);
-            }
-            children
-        }
 
-        let nodes = doc.nodes_in_scene(scene).flat_map(|n| {
-            let mut all_nodes = vec![n];
-            for child_index in get_children(&doc, n.index) {
-                if let Some(child_node) = doc.nodes.get(child_index) {
-                    all_nodes.push(child_node);
-                }
-            }
-            all_nodes
-        });
+        let nodes = doc.recursive_nodes_in_scene(scene);
         log::trace!("  nodes:");
         for node in nodes {
             let tfrm = Mat4::from(node.global_transform());

crates/renderling/src/gltf.rs

@@ -1237,21 +1237,47 @@ where
         self.primitives.iter().flat_map(|(_, rs)| rs.iter())
     }
 
-    fn nodes_in_scene_recursive<'a>(&'a self, node_index: usize, nodes: &mut Vec<&'a GltfNode>) {
+    fn collect_nodes_recursive<'a>(&'a self, node_index: usize, nodes: &mut Vec<&'a GltfNode>) {
         if let Some(node) = self.nodes.get(node_index) {
             nodes.push(node);
             for child_index in node.children.iter() {
-                self.nodes_in_scene_recursive(*child_index, nodes);
+                self.collect_nodes_recursive(*child_index, nodes);
             }
         }
     }
 
-    pub fn nodes_in_scene(&self, scene_index: usize) -> impl Iterator<Item = &GltfNode> {
+    /// Returns the root (top-level) nodes in the given scene.
+    ///
+    /// This roughly follows [`gltf::Scene::nodes`](https://docs.rs/gltf/latest/gltf/scene/struct.Scene.html#method.nodes),
+    /// returning only the nodes directly referenced by the scene — not
+    /// their children.
+    ///
+    /// Use [`recursive_nodes_in_scene`](Self::recursive_nodes_in_scene)
+    /// if you need all nodes (including descendants).
+    pub fn root_nodes_in_scene(&self, scene_index: usize) -> impl Iterator<Item = &GltfNode> {
+        let scene = self.scenes.get(scene_index);
+        let mut nodes = vec![];
+        if let Some(indices) = scene {
+            for node_index in indices {
+                if let Some(node) = self.nodes.get(*node_index) {
+                    nodes.push(node);
+                }
+            }
+        }
+        nodes.into_iter()
+    }
+
+    /// Returns all nodes in the given scene, recursively including
+    /// children.
+    ///
+    /// Root nodes are visited first, followed by their descendants in
+    /// depth-first order.
+    pub fn recursive_nodes_in_scene(&self, scene_index: usize) -> impl Iterator<Item = &GltfNode> {
         let scene = self.scenes.get(scene_index);
         let mut nodes = vec![];
         if let Some(indices) = scene {
             for node_index in indices {
-                self.nodes_in_scene_recursive(*node_index, &mut nodes);
+                self.collect_nodes_recursive(*node_index, &mut nodes);
             }
         }
         nodes.into_iter()

crates/renderling/src/gltf/anime.rs

@@ -787,7 +787,7 @@ mod test {
             .unwrap();
 
         let nodes = doc
-            .nodes_in_scene(doc.default_scene.unwrap_or_default())
+            .recursive_nodes_in_scene(doc.default_scene.unwrap_or_default())
             .collect::<Vec<_>>();
 
         let mut animator = Animator::new(nodes, doc.animations.first().unwrap().clone());