Move scene data into Scene

src/commands.rs

@@ -74,7 +74,7 @@ pub struct CommandSet {
 }
 
 impl CommandSet {
-    pub fn build(instances: &Vec<MeshInstance>) -> Self {
+    pub fn build(instances: &[MeshInstance]) -> Self {
         let mut sorted_meshes = HashMap::<(usize, usize), Vec<MeshInstance>>::new();
         for instance in instances.iter() {
             let group_id = instance.mesh.group_id;

src/main.rs

@@ -151,8 +151,8 @@ fn main() {
     let mut camera = Flycam::new(10.0, 0.002);
     let mut is_grabbed = false;
     let mut ren = pollster::block_on(make_window_renderer(&window));
-    let mut state: Box<dyn WorldState> = Box::new(Planets::new(&mut ren));
+    // let mut state: Box<dyn WorldState> = Box::new(Planets::new(&mut ren));
-    // let mut state: Box<dyn WorldState> = Box::new(Grid::new(&mut ren));
+    let mut state: Box<dyn WorldState> = Box::new(Grid::new(&mut ren));
 
     let lights = vec![
         PointLight {
@@ -174,11 +174,14 @@ fn main() {
     ];
 
     event_loop.run(move |event, _, control_flow| match event {
-        Event::RedrawRequested(_) => match ren.render(&camera, &state.render(), &lights) {
+        Event::RedrawRequested(_) => {
-            Ok(_) => {}
+            let scene = Scene { meshes: &state.render(), point_lights: &lights };
-            Err(wgpu::SurfaceError::Lost) => ren.resize(ren.size),
+            match ren.render(&camera, &scene) {
-            Err(wgpu::SurfaceError::OutOfMemory) => *control_flow = ControlFlow::Exit,
+                Ok(_) => {}
-            Err(e) => println!("error: {:?}", e),
+                Err(wgpu::SurfaceError::Lost) => ren.resize(ren.size),
+                Err(wgpu::SurfaceError::OutOfMemory) => *control_flow = ControlFlow::Exit,
+                Err(e) => println!("error: {:?}", e),
+            };
         },
         Event::MainEventsCleared => {
             camera.update();

src/renderer.rs

@@ -2,7 +2,7 @@ use super::camera::Camera;
 use super::commands::{Command, CommandSet};
 use super::mesh::Vertex;
 use super::pool::{MaterialPool, MeshGroup, MeshPool, TexturePool};
-use super::scene::{MeshInstance, PointLight};
+use super::scene::{Scene, PointLight};
 use wgpu::util::DeviceExt;
 
 pub struct Renderer {
@@ -246,8 +246,7 @@ impl Renderer {
     pub fn render(
         &mut self,
         camera: &impl Camera,
-        meshes: &Vec<MeshInstance>,
+        scene: &Scene,
-        point_lights: &Vec<PointLight>,
     ) -> Result<(), wgpu::SurfaceError> {
         self.camera_uniform.update(camera);
         self.queue.write_buffer(
@@ -256,6 +255,7 @@ impl Renderer {
             bytemuck::cast_slice(&[self.camera_uniform]),
         );
 
+        let Scene { meshes, point_lights } = scene;
         let mesh_commands = CommandSet::build(meshes);
 
         // TODO persistent staging buffer (write_buffer creates a new one per call)

src/scene.rs

@@ -12,3 +12,9 @@ pub struct PointLight {
     pub center: glam::Vec3A,
     pub intensity: glam::Vec3A,
 }
+
+#[derive(Copy, Clone, PartialEq)]
+pub struct Scene<'a> {
+    pub meshes: &'a [MeshInstance],
+    pub point_lights: &'a [PointLight],
+}