Refactor code to allow construction of game in binary

Author: rishflab

Cargo.toml

@@ -11,19 +11,15 @@ anyhow = "1.0"
 bytemuck = "1.3"
 failure = "0.1"
 futures = "0.3"
-winit = "0.22"
-rand = "0.7.3"
+winit = "0.24"
 shaderc = "0.6"
 serde = { version = "1", features = ["derive"], optional = true }
-gltf = { version = "0.15", default-features = false, features = ["utils"] }
 thiserror = "1.0"
 base64 = "0.12"
-glam = "0.9"
+glam = "0.12"
 log = "0.4"
 wgpu = "0.7"
-hecs = "0.2"
-legion = "0.3"
-bevy_ecs = "0.2"
+hecs = "0.3"
 image = "0.23"
 num-traits = "0.2"
 

src/app.rs

@@ -1,5 +1,4 @@
-use crate::renderer::Renderer;
-
+use crate::{renderer::Renderer, Game};
 use winit::{
     dpi::LogicalSize,
     event::{self, WindowEvent},
@@ -80,7 +79,7 @@ impl App {
         }
     }
 
-    pub fn run(mut self, event_loop: EventLoop<()>) {
+    pub fn run(mut self, event_loop: EventLoop<()>, mut game: Game<'static>) {
         let sc_desc = wgpu::SwapChainDescriptor {
             usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
             width: self.size.width,
@@ -91,8 +90,6 @@ impl App {
         };
         let mut swap_chain = self.device.create_swap_chain(&self.surface, &sc_desc);
 
-        let mut game = crate::game::Game::new();
-
         let mut renderer = Renderer::init(&sc_desc, &mut self.device, &self.queue);
 
         log::info!("Entering render loop...");

src/bin/game.rs

@@ -1,10 +1,155 @@
 extern crate erlking;
 
-use erlking::app::App;
-use winit::event_loop::EventLoop;
+use cgmath::{Deg, Quaternion, Rotation3, Vector3};
+use erlking::{
+    app::App, camera::ParallaxCamera, ActiveCamera, Game, KeyboardInput, Position, Rotation, Scale,
+    Sprite,
+};
+use glam::Vec3;
+use hecs::World;
+use std::time::Duration;
+use winit::{
+    event::{ElementState, VirtualKeyCode},
+    event_loop::EventLoop,
+};
+
+#[derive(Clone, Copy)]
+struct MoveSpeed(f32);
 
 fn main() {
     let event_loop = EventLoop::new();
-    let app = futures::executor::block_on(App::new("erlking", &event_loop));
-    app.run(event_loop);
+    let app = futures::executor::block_on(App::new("parallax-demo", &event_loop));
+    let mut parallax_demo = Game::new();
+
+    let movespeed = MoveSpeed(10.0);
+
+    let player = (
+        Position(cgmath::Vector3::new(0.0, 0.0, 20.0)),
+        Rotation(Quaternion::from_axis_angle(
+            Vector3::new(0.0, 1.0, 0.0),
+            Deg(0.0),
+        )),
+        Scale(1),
+        KeyboardInput(None),
+        Sprite("player".to_string()),
+        movespeed,
+    );
+
+    let camera = (
+        ParallaxCamera::new(
+            Vec3::new(0.0, 3.0, 0.0),
+            Vec3::new(0.0, 0.0, 1.0),
+            1.0,
+            0.1,
+            500.0,
+        ),
+        KeyboardInput(None),
+        ActiveCamera,
+        movespeed,
+    );
+
+    let apple = (
+        Position(cgmath::Vector3::new(-2.0, 0.0, 30.0)),
+        Rotation(Quaternion::from_axis_angle(
+            Vector3::new(0.0, 1.0, 0.0),
+            Deg(0.0),
+        )),
+        Scale(1),
+        Sprite("apple".to_string()),
+    );
+
+    let ashberry = (
+        Position(cgmath::Vector3::new(2.0, 0.0, 30.0)),
+        Rotation(Quaternion::from_axis_angle(
+            Vector3::new(0.0, 1.0, 0.0),
+            Deg(0.0),
+        )),
+        Scale(1),
+        Sprite("ashberry".to_string()),
+    );
+
+    let baobab = (
+        Position(cgmath::Vector3::new(3.0, 0.0, 55.0)),
+        Rotation(Quaternion::from_axis_angle(
+            Vector3::new(0.0, 1.0, 0.0),
+            Deg(0.0),
+        )),
+        Scale(1),
+        Sprite("baobab".to_string()),
+    );
+
+    let beech = (
+        Position(cgmath::Vector3::new(-3.5, 0.0, 95.0)),
+        Rotation(Quaternion::from_axis_angle(
+            Vector3::new(0.0, 1.0, 0.0),
+            Deg(0.0),
+        )),
+        Scale(1),
+        Sprite("beech".to_string()),
+    );
+    parallax_demo.spawn_entity(player);
+    parallax_demo.spawn_entity(apple);
+    parallax_demo.spawn_entity(ashberry);
+    parallax_demo.spawn_entity(baobab);
+    parallax_demo.spawn_entity(beech);
+    parallax_demo.spawn_entity(camera);
+
+    parallax_demo.add_system(&move_player);
+
+    app.run(event_loop, parallax_demo);
+}
+
+fn move_player(world: &World, dt: Duration) {
+    let mut q = world.query::<(&KeyboardInput, &mut Position, &MoveSpeed)>();
+
+    for (_, (key, pos, speed)) in q.iter() {
+        if let Some(input) = key.0 {
+            let dx = Vector3::new(speed.0 * dt.as_secs_f32(), 0.0, 0.0);
+            match input {
+                winit::event::KeyboardInput {
+                    state: ElementState::Pressed,
+                    virtual_keycode: Some(VirtualKeyCode::Left),
+                    ..
+                } => {
+                    pos.0 -= dx;
+                }
+                winit::event::KeyboardInput {
+                    state: ElementState::Pressed,
+                    virtual_keycode: Some(VirtualKeyCode::Right),
+                    ..
+                } => {
+                    pos.0 += dx;
+                }
+                _ => (),
+            }
+        }
+    }
+    let mut q = world.query::<(
+        &ActiveCamera,
+        &mut ParallaxCamera,
+        &KeyboardInput,
+        &MoveSpeed,
+    )>();
+
+    let (_, (_, cam, key, speed)) = q.iter().next().expect("active camera is preset");
+    if let Some(input) = key.0 {
+        let dx = Vec3::new(speed.0 * dt.as_secs_f32(), 0.0, 0.0);
+        match input {
+            winit::event::KeyboardInput {
+                state: ElementState::Pressed,
+                virtual_keycode: Some(VirtualKeyCode::Left),
+                ..
+            } => {
+                cam.eye -= dx;
+            }
+            winit::event::KeyboardInput {
+                state: ElementState::Pressed,
+                virtual_keycode: Some(VirtualKeyCode::Right),
+                ..
+            } => {
+                cam.eye += dx;
+            }
+            _ => (),
+        }
+    }
 }

src/camera.rs

@@ -5,13 +5,13 @@ use std::f32;
 pub const SPRITE_SCALING_FACTOR: u8 = 2;
 
 pub trait Camera {
-    fn generate_matrix(&self) -> Mat4;
+    fn generate_matrix(&self) -> CameraUniform;
 }
 
 #[derive(Clone, Copy)]
 pub struct ParallaxCamera {
     pub eye: glam::Vec3,
-    pub look_to: glam::Vec3,
+    pub look_dir: glam::Vec3,
     pub fov_y: f32,
     pub near: f32,
     pub far: f32,
@@ -21,7 +21,7 @@ impl ParallaxCamera {
     pub fn new(eye: glam::Vec3, look_to: glam::Vec3, fov_y: f32, near: f32, far: f32) -> Self {
         ParallaxCamera {
             eye,
-            look_to,
+            look_dir: look_to,
             fov_y,
             near,
             far,
@@ -36,7 +36,7 @@ impl ParallaxCamera {
         let mx_ortho =
             glam::Mat4::orthographic_lh(-w / 2.0, w / 2.0, -h / 2.0, h / 2.0, self.near, self.far);
 
-        let mx_view = look_to_lh(self.eye, self.look_to, Vec3::unit_y());
+        let mx_view = look_to_lh(self.eye, self.look_dir, Vec3::unit_y());
 
         mx_ortho * mx_view
     }
@@ -49,12 +49,14 @@ impl ParallaxCamera {
             self.far,
         );
 
-        let mx_view = look_to_lh(self.eye, self.look_to, Vec3::unit_y());
+        let mx_view = look_to_lh(self.eye, self.look_dir, Vec3::unit_y());
 
         mx_perspective * mx_view
     }
+}
 
-    pub fn camera_uniform(&self) -> CameraUniform {
+impl Camera for ParallaxCamera {
+    fn generate_matrix(&self) -> CameraUniform {
         let ortho = *self.generate_ortho().as_ref();
         let persp = *self.generate_perspective().as_ref();
         CameraUniform { ortho, persp }