Method rebuild_instance_data

native/shared/src/renderer/mod.rs:7465–7521

Ticket 007b — build any pending BLASes and refresh the TLAS + per-instance GI data. Called once per frame, before the SSGI probe passes that sample the TLAS. No-op when HW RT is off or when nothing has changed since the last rebuild. Encodes `build_acceleration_structures` into the caller's `encoder` so the builds are ordered ahead of the trace pass without a separate queue submit. Ticket 014 V4

(
        &mut self,
        scene: &crate::scene::SceneGraph,
        instance_handles: &[f64],
    )

    /// / `instance_custom_data` conventions stay consistent across
    /// HW and SW trace paths.
    fn rebuild_instance_data(
        &mut self,
        scene: &crate::scene::SceneGraph,
        instance_handles: &[f64],
    ) -> (u32, bool) {
        let instance_count = instance_handles.len() as u32;
        let mut resized = false;
        let needed_cap = instance_count.max(self.tlas_max_instances).max(64);
        if self.tlas_instance_data_buffer.is_none()
            || needed_cap > self.tlas_max_instances
        {
            let new_cap = needed_cap.next_power_of_two();
            self.tlas_instance_data_buffer = Some(self.device.create_buffer(&wgpu::BufferDescriptor {
                label: Some("tlas_instance_data"),
                size: (new_cap as u64) * std::mem::size_of::<InstanceGiDataCpu>() as u64,
                usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,
                mapped_at_creation: false,
            }));
            self.tlas_max_instances = new_cap;
            self.probe_trace_hw_bg_cache = [None, None];
            // V4 — SDF bind group also references instance_data, so
            // invalidate when the buffer is re-allocated.
            self.probe_trace_sdf_bg_cache = [None, None];
            // V14 — WSRC HW bake bg also references the TLAS +
            // instance_data buffer; invalidate on resize.
            self.wsrc_bake_hw_bg_cache = None;
            resized = true;
        }

        let mut instance_data: Vec<InstanceGiDataCpu> =
            Vec::with_capacity(instance_count as usize);
        for &h in instance_handles {
            let n = scene.nodes.get(h).unwrap();
            let e = n.material.emissive;
            let (first_slot, has_card) = match n.card_first_slot {
                Some(s) => (s as f32, 1.0_f32),
                None => (0.0, 0.0),
            };
            instance_data.push(InstanceGiDataCpu {
                albedo: n.flat_albedo,
                emissive_luma: (e[0] + e[1] + e[2]) * (1.0 / 3.0),
                normal_ws: n.flat_normal_ws,
                _pad0: 0.0,
                card_slot: [first_slot, 0.0, 0.0, has_card],
                card_aabb_min: [n.bounds_min[0], n.bounds_min[1], n.bounds_min[2], 0.0],
                card_aabb_max: [n.bounds_max[0], n.bounds_max[1], n.bounds_max[2], 0.0],
            });
        }
        if !instance_data.is_empty() {
            self.queue.write_buffer(
                self.tlas_instance_data_buffer.as_ref().unwrap(),
                0,
                bytemuck::cast_slice(&instance_data),
            );
        }
        (instance_count, resized)
    }