Method prepare

native/shared/src/scene.rs:592–927

Prepare GPU resources for all visible nodes. Must be called before render(). Creates/updates vertex buffers, index buffers, and uniform bind groups. `prev_vp_matrix` is the previous frame's view-projection — used together with each node's `prev_transform` to compute `prev_mvp` for the velocity buffer (motion blur + TAA per-object reprojection).

(
        &mut self,
        device: &wgpu::Device,
        queue: &wgpu::Queue,
        vp_matrix: &[[f32; 4]; 4],
        prev_vp_matrix: &[[f32; 4]; 4],
        uniform_layout: &wgpu::BindGroupLayo

    /// with each node's `prev_transform` to compute `prev_mvp` for the velocity
    /// buffer (motion blur + TAA per-object reprojection).
    pub fn prepare(
        &mut self,
        device: &wgpu::Device,
        queue: &wgpu::Queue,
        vp_matrix: &[[f32; 4]; 4],
        prev_vp_matrix: &[[f32; 4]; 4],
        uniform_layout: &wgpu::BindGroupLayout,
    ) {
        let frustum = extract_frustum_planes(vp_matrix);

        // Phase 1: upload geometry for any freshly-added or dirty nodes,
        // assign uniform slots, and count how many nodes we'll draw.
        // Borrow splits so we can push to `pending_blas_builds` while
        // iterating `nodes` mutably.
        let hw_rt = self.hw_rt_enabled;
        let pending_blas = &mut self.pending_blas_builds;
        let pending_cards = &mut self.pending_card_captures;
        let pending_sdf = &mut self.pending_sdf_bakes;
        let next_card_slot = &mut self.next_card_slot;
        let mut visible_count: u32 = 0;
        for (handle, node) in self.nodes.iter_mut() {
            if !node.visible || node.indices.is_empty() {
                continue;
            }
            // Frustum cull against world-space AABB. Transform the local
            // bounds into world space by applying the node's transform
            // to the 8 corners; use the min/max of the result.
            if node.bounds_min[0] <= node.bounds_max[0] {
                let t = &node.transform;
                let mut wmin = [f32::MAX; 3];
                let mut wmax = [f32::MIN; 3];
                for ix in 0..2 {
                    for iy in 0..2 {
                        for iz in 0..2 {
                            let lx = if ix == 0 { node.bounds_min[0] } else { node.bounds_max[0] };
                            let ly = if iy == 0 { node.bounds_min[1] } else { node.bounds_max[1] };
                            let lz = if iz == 0 { node.bounds_min[2] } else { node.bounds_max[2] };
                            let wx = t[0][0]*lx + t[1][0]*ly + t[2][0]*lz + t[3][0];
                            let wy = t[0][1]*lx + t[1][1]*ly + t[2][1]*lz + t[3][1];
                            let wz = t[0][2]*lx + t[1][2]*ly + t[2][2]*lz + t[3][2];
                            if wx < wmin[0] { wmin[0] = wx; }
                            if wy < wmin[1] { wmin[1] = wy; }
                            if wz < wmin[2] { wmin[2] = wz; }
                            if wx > wmax[0] { wmax[0] = wx; }
                            if wy > wmax[1] { wmax[1] = wy; }
                            if wz > wmax[2] { wmax[2] = wz; }
                        }
                    }
                }
                node.in_view_frustum = !aabb_outside_frustum(&frustum, wmin, wmax);
                node.world_bounds_min = wmin;
                node.world_bounds_max = wmax;
            } else {
                // Empty or uninitialized bounds — can't cull, play safe.
                node.in_view_frustum = true;
                node.world_bounds_min = [f32::MAX; 3];
                node.world_bounds_max = [f32::MIN; 3];
            }