Add Planets demo

src/main.rs

@@ -376,29 +376,114 @@ fn load_model() -> MeshData {
     MeshData { vertices, indices }
 }
 
+trait WorldState {
+    fn update(&mut self);
+    fn render(&self) -> Vec<MeshInstance>;
+}
+
+struct Grid {
+    meshes: Vec<MeshInstance>,
+}
+
+impl Grid {
+    fn new(ren: &mut Renderer) -> Self {
+        let mesh_data = load_model();
+        let mesh = ren.mesh_pool.allocate(&ren.device, &mesh_data);
+        let mut meshes = Vec::new();
+        for x in -5..5 {
+            for y in -5..5 {
+                let translation = glam::Vec3::new(x as f32, 0.0, y as f32) * 3.0;
+                let transform = glam::Mat4::from_translation(translation);
+                meshes.push(MeshInstance {
+                    handle: mesh,
+                    transform,
+                });
+            }
+        }
+
+        Self { meshes }
+    }
+}
+
+impl WorldState for Grid {
+    fn update(&mut self) {}
+
+    fn render(&self) -> Vec<MeshInstance> {
+        self.meshes.clone()
+    }
+}
+
+struct Planet {
+    speed: f32,
+    offset: f32,
+    radius: f32,
+    size: f32,
+}
+
+struct Planets {
+    start: std::time::Instant,
+    planets: Vec<Planet>,
+    mesh: MeshHandle,
+}
+
+impl Planets {
+    fn new(ren: &mut Renderer) -> Self {
+        let start = std::time::Instant::now();
+        let mesh_data = load_model();
+        let mesh = ren.mesh_pool.allocate(&ren.device, &mesh_data);
+
+        let mut planets = Vec::new();
+        for i in 0..10 {
+            let i = i as f32;
+            planets.push(Planet {
+                speed: 1.618 * 1.5 / i,
+                offset: 0.0,
+                radius: i * 2.0,
+                size: 0.5,
+            });
+        }
+
+        Self {
+            start,
+            planets,
+            mesh,
+        }
+    }
+}
+
+impl WorldState for Planets {
+    fn update(&mut self) {}
+
+    fn render(&self) -> Vec<MeshInstance> {
+        let elapsed = self.start.elapsed().as_secs_f32();
+
+        let mut meshes = Vec::new();
+        for planet in self.planets.iter() {
+            let translation = glam::Vec3::new(0.0, 0.0, planet.radius);
+            let translation = glam::Mat4::from_translation(translation);
+            let theta = planet.speed * elapsed + planet.offset;
+            let rotation = glam::Mat4::from_rotation_y(theta);
+            meshes.push(MeshInstance {
+                handle: self.mesh,
+                transform: rotation * translation,
+            });
+        }
+
+        meshes
+    }
+}
+
 fn main() {
-    let mesh_data = load_model();
     let event_loop = EventLoop::new();
     let window = WindowBuilder::new().build(&event_loop).unwrap();
     let mut camera = Flycam::new(10.0, 0.002);
     let mut is_grabbed = false;
     let mut ren = pollster::block_on(Renderer::new(&window));
-
-    let mesh = ren.mesh_pool.allocate(&ren.device, &mesh_data);
-    let mut commands = Vec::new();
-    for x in -5..5 {
-        for y in -5..5 {
-            let translation = glam::Vec3::new(x as f32, 0.0, y as f32) * 3.0;
-            let transform = glam::Mat4::from_translation(translation);
-            commands.push(MeshInstance {
-                handle: mesh,
-                transform,
-            });
-        }
-    }
+    let mut state: Box<dyn WorldState> = Box::new(Planets::new(&mut ren));
+    // let mut state: Box<dyn WorldState> = Box::new(Grid::new(&mut ren));
 
     event_loop.run(move |event, _, control_flow| match event {
-        Event::RedrawRequested(_) => match ren.render(&camera, &commands) {
+        Event::RedrawRequested(_) => match ren.render(&camera, &state.render()) {
             Ok(_) => {}
             Err(wgpu::SurfaceError::Lost) => ren.resize(ren.size),
             Err(wgpu::SurfaceError::OutOfMemory) => *control_flow = ControlFlow::Exit,
@@ -406,6 +491,7 @@ fn main() {
         },
         Event::MainEventsCleared => {
             camera.update();
+            state.update();
             window.request_redraw();
         }
         Event::DeviceEvent { ref event, .. } => match event {