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

@@ -2,7 +2,8 @@
 //!
 //! # Loading GLTF files
 //!
-//! Loading GLTF files is accomplished through [`Stage::load_gltf_document_from_path`]
+//! Loading GLTF files is accomplished through
+//! [`Stage::load_gltf_document_from_path`]
 //! and [`Stage::load_gltf_document_from_bytes`].
 use std::{collections::HashMap, sync::Arc};
 
@@ -458,8 +459,8 @@ impl GltfPrimitive {
         // https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#morph-targets
         //
         // TODO: Generate morph target normals and tangents if absent.
-        // Although the spec says we have to generate normals or tangents if not specified,
-        // we are explicitly *not* doing that here.
+        // Although the spec says we have to generate normals or tangents if not
+        // specified, we are explicitly *not* doing that here.
         let morph_targets: Vec<Vec<MorphTarget>> = reader
             .read_morph_targets()
             .map(|(may_ps, may_ns, may_ts)| {
@@ -1236,29 +1237,56 @@ 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()
     }
 
     /// Returns the bounding volume of this document, if possible.
     ///
-    /// This function will return `None` if this document does not contain meshes.
+    /// This function will return `None` if this document does not contain
+    /// meshes.
     pub fn bounding_volume(&self) -> Option<Aabb> {
         let mut aabbs = vec![];
         for node in self.nodes.iter() {
@@ -1512,8 +1540,8 @@ mod test {
         //     .get(0)
         //     .unwrap()
         //     .clone()
-        //     .into_animator(doc.nodes.iter().map(|n| (n.index, n.transform.clone())));
-        // animator.progress(0.0).unwrap();
+        //     .into_animator(doc.nodes.iter().map(|n| (n.index,
+        // n.transform.clone()))); animator.progress(0.0).unwrap();
         // let frame = ctx.get_next_frame().unwrap();
         // stage.render(&frame.view());
         // let img = frame.read_image().unwrap();

crates/renderling/src/gltf/anime.rs

@@ -746,7 +746,10 @@ impl Animator {
                     }
                     TweenProperty::MorphTargetWeights(new_weights) => {
                         if node.morph_weights.array().is_empty() {
-                            log::error!("animation is applied to morph targets but node {node_index} is missing weights");
+                            log::error!(
+                                "animation is applied to morph targets but node {node_index} is \
+                                 missing weights"
+                            );
                         } else {
                             for (i, w) in new_weights.into_iter().enumerate() {
                                 node.morph_weights.set_item(i, w);
@@ -785,7 +788,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());

crates/renderling/src/linkage/light_tiling_compute_tile_min_and_max_depth_multisampled.rs

@@ -6,7 +6,10 @@ mod target {
     pub const ENTRY_POINT: &str =
         "light::shader::light_tiling_compute_tile_min_and_max_depth_multisampled";
     pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> {
-        wgpu :: include_spirv ! ("../../shaders/light-shader-light_tiling_compute_tile_min_and_max_depth_multisampled.spv")
+        wgpu::include_spirv!(
+            "../../shaders/light-shader-light_tiling_compute_tile_min_and_max_depth_multisampled.\
+             spv"
+        )
     }
     pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage {
         log::debug!(
@@ -24,7 +27,10 @@ mod target {
     pub const ENTRY_POINT: &str =
         "lightshaderlight_tiling_compute_tile_min_and_max_depth_multisampled";
     pub fn descriptor() -> wgpu::ShaderModuleDescriptor<'static> {
-        wgpu :: include_wgsl ! ("../../shaders/light-shader-light_tiling_compute_tile_min_and_max_depth_multisampled.wgsl")
+        wgpu::include_wgsl!(
+            "../../shaders/light-shader-light_tiling_compute_tile_min_and_max_depth_multisampled.\
+             wgsl"
+        )
     }
     pub fn linkage(device: &wgpu::Device) -> super::ShaderLinkage {
         log::debug!(