Method render

perro_source/render_stack/perro_graphics/src/gpu.rs:973–2138

(&mut self, frame: RenderFrame<'_>)

        let mut caches = AHashMap::new();
        let bg = CacheProbe {
            resolution: [3840, 2160],
            mesh_count: 34,
            transforms: vec![glam::Mat4::IDENTITY.to_cols_array_2d(); 34],
            pipe: "raw-bg",
            vertex_hook: false,
            alpha_mode: 0,
            pixels: [20, 40, 80, 255],
        };
        let logo = CacheProbe {
            resolution: [2464, 464],
            mesh_count: 1,
            transforms: vec![glam::Mat4::from_scale(glam::Vec3::splat(0.88)).to_cols_array_2d()],
            pipe: "std-logo",
            vertex_hook: true,
            alpha_mode: 0,
            pixels: [240, 80, 120, 255],
        };
        camera_stream_cache_entry(&mut caches, first, || bg.clone());
        camera_stream_cache_entry(&mut caches, second, || logo.clone());

        // Hide/show A, reload its material + shader, then switch its alpha
        // mode. B must retain its exact cache throughout.
        caches.remove(&first);
        assert_eq!(caches.get(&second).map(Box::as_ref), Some(&logo));
        let reentered = camera_stream_cache_entry(&mut caches, first, || bg.clone());
        reentered.pipe = "raw-bg-reloaded";
        reentered.vertex_hook = true;
        reentered.alpha_mode = 2;
        reentered.pixels = [30, 60, 100, 255];

        assert_eq!(caches.get(&second).map(Box::as_ref), Some(&logo));
        let reentered = caches.get(&first).expect("bg cache should reenter");
        assert_eq!(reentered.mesh_count, bg.mesh_count);
        assert_eq!(reentered.transforms, bg.transforms);
        assert_eq!(caches.len(), 2);
    }

    #[test]
    fn thousand_stream_slots_allocate_only_used_spatial_columns() {
        let nodes: Vec<_> = (0..1_000)
            .map(|index| NodeID::from_parts(index + 1, 0))
            .collect();
        let mut two_d = AHashMap::new();
        let mut three_d = AHashMap::new();

        for node in nodes.iter().step_by(100) {
            camera_stream_cache_entry(&mut two_d, *node, || "2d");
        }
        for node in nodes.iter().skip(50).step_by(200) {
            camera_stream_cache_entry(&mut three_d, *node, || "3d");
        }

        assert_eq!(nodes.len(), 1_000);
        assert_eq!(two_d.len(), 10);
        assert_eq!(three_d.len(), 5);
    }
}