send entities data to render thread

Author: silverweed

assets/textures/yv.png

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+APP=ecs
+
+declare -r F=/usr/local/src/FlameGraph
+set -x
+./$APP $@ &>/dev/null&
+sudo perf record -F 80 -a -g -p $! -- sleep 60
+sudo perf script > /tmp/out.perf
+$F/stackcollapse-perf.pl /tmp/out.perf > /tmp/out.folded
+$F/flamegraph.pl /tmp/out.folded > /tmp/out.svg
+firefox /tmp/out.svg&
+pkill $APP

flamegraph.sh

@@ -1,11 +1,13 @@
 use std::vec::Vec;
 
-#[derive(Default, Copy, Clone, Debug, PartialEq)]
+#[derive(Default, Copy, Clone, Debug, PartialEq, Hash)]
 pub struct Generational_Index {
     pub index: usize,
     pub gen: u64,
 }
 
+impl Eq for Generational_Index {}
+
 /// Generational_Allocator provides an interface to allocate/deallocate
 /// Generational Indices and check if an index is valid.
 /// The allocator is given an initial size and grows automatically when
@@ -45,7 +47,7 @@ impl Generational_Allocator {
 
     pub fn allocate(&mut self) -> Generational_Index {
         let i = self.first_free_slot();
-	let cur_size = self.gens.len();
+        let cur_size = self.gens.len();
         if i == cur_size {
             // Grow the vectors
             let new_size = cur_size * 2;

src/alloc/generational_allocator.rs

@@ -6,10 +6,14 @@ use super::input;
 use super::time;
 use crate::audio;
 use crate::cfg;
+use crate::ecs::components::gfx::C_Camera2D;
+use crate::ecs::components::transform::C_Transform2D;
+use crate::ecs::entity_manager::Entity;
 use crate::fs;
 use crate::game::gameplay_system;
 use crate::gfx;
 use crate::resources;
+use std::collections::HashMap;
 use std::convert::TryFrom;
 use std::sync::mpsc;
 use std::thread::JoinHandle;
@@ -55,13 +59,14 @@ pub struct App<'r> {
     env: Env_Info,
 
     config: cfg::Config,
-    ui_req_tx: Option<std::sync::mpsc::Sender<gfx::ui::UI_Request>>,
+    ui_req_tx: Option<mpsc::Sender<gfx::ui::UI_Request>>,
 
     // Resources
     audio_resources: resources::audio::Audio_Resources<'r>,
 
     // Engine Systems
     render_thread: Option<JoinHandle<()>>,
+    render_thread_quit: Option<mpsc::Sender<()>>,
     input_actions_rx: Option<mpsc::Receiver<input::Action_List>>,
     audio_system: audio::system::Audio_System,
     gameplay_system: gameplay_system::Gameplay_System,
@@ -80,6 +85,7 @@ impl<'r> App<'r> {
             ui_req_tx: None,
             audio_resources: resources::audio::Audio_Resources::new(sound_loader),
             render_thread: None,
+            render_thread_quit: None,
             input_actions_rx: None,
             audio_system: audio::system::Audio_System::new(10),
             gameplay_system: gameplay_system::Gameplay_System::new(),
@@ -99,8 +105,6 @@ impl<'r> App<'r> {
     }
 
     fn init_all_systems(&mut self) -> Maybe_Error {
-        self.gameplay_system.init(&self.config)?;
-
         let config_watcher = Box::new(cfg::sync::Config_Watch_Handler::new(&self.config));
         fs::file_watcher::start_file_watch(
             self.env.get_cfg_root().to_path_buf(),
@@ -110,25 +114,39 @@ impl<'r> App<'r> {
         Ok(())
     }
 
-    fn start_render_thread(&mut self) {
+    fn start_render_thread(
+        &mut self,
+        entity_transform_rx: mpsc::Receiver<(Entity, C_Transform2D)>,
+        camera_transform_rx: mpsc::Receiver<C_Camera2D>,
+    ) {
         let (input_tx, input_rx) = mpsc::channel();
         self.input_actions_rx = Some(input_rx);
 
         let (ui_tx, ui_rx) = mpsc::channel();
         self.ui_req_tx = Some(ui_tx);
 
+        let (quit_tx, quit_rx) = mpsc::channel();
+        self.render_thread_quit = Some(quit_tx);
+
         self.render_thread = Some(gfx::render_system::start_render_thread(
             self.env.clone(),
             input_tx,
             ui_rx,
+            entity_transform_rx,
+            camera_transform_rx,
+            quit_rx,
             gfx::render_system::Render_System_Config {
                 clear_color: colors::rgb(48, 10, 36),
             },
         ));
     }
 
     pub fn run(&mut self) -> Maybe_Error {
-        self.start_render_thread();
+        let (et_tx, et_rx) = mpsc::channel();
+        let (cam_tx, cam_rx) = mpsc::channel();
+        self.gameplay_system.init(&self.config, et_tx, cam_tx)?; // @Temporary workaround
+        self.start_render_thread(et_rx, cam_rx);
+
         self.start_game_loop()?;
         Ok(())
     }
@@ -193,6 +211,17 @@ impl<'r> App<'r> {
             }
         }
 
+        self.render_thread_quit
+            .as_mut()
+            .unwrap()
+            .send(())
+            .expect("[ ERR ] Failed to send quit message to render thread!");
+        self.render_thread
+            .take()
+            .unwrap()
+            .join()
+            .expect("[ ERR ] Failed to join render thread!");
+
         Ok(())
     }
 

src/core/app.rs

@@ -10,3 +10,8 @@ pub type Vec2i = Vector2<i32>;
 pub fn to_framework_vec(v: Vec2f) -> sfml::system::Vector2f {
     sfml::system::Vector2f::new(v.x, v.y)
 }
+
+#[cfg(feature = "use-sfml")]
+pub fn from_framework_vec(v: sfml::system::Vector2f) -> Vec2f {
+    Vec2f::new(v.x, v.y)
+}

src/core/common/vector.rs

@@ -1,3 +1,4 @@
+use super::transform::C_Transform2D;
 use crate::core::common::rect::Rect;
 use crate::resources;
 use typename::TypeName;
@@ -23,3 +24,8 @@ pub struct C_Animated_Sprite {
     pub frame_time: f32,
     pub frame_time_elapsed: f32,
 }
+
+#[derive(Copy, Clone, Debug, TypeName, Default)]
+pub struct C_Camera2D {
+    pub transform: C_Transform2D,
+}

src/ecs/components/gfx.rs

@@ -1,5 +1,5 @@
 use crate::core::common::vector::Vec2f;
-use cgmath::Rad;
+use cgmath::{Matrix3, Rad};
 use std::convert::Into;
 use typename::TypeName;
 
@@ -8,6 +8,7 @@ pub struct C_Transform2D {
     position: Vec2f,
     rotation: Rad<f32>,
     scale: Vec2f,
+    origin: Vec2f,
 }
 
 impl Default for C_Transform2D {
@@ -16,6 +17,7 @@ impl Default for C_Transform2D {
             position: Vec2f::new(0.0, 0.0),
             rotation: Rad(0.0),
             scale: Vec2f::new(1.0, 1.0),
+            origin: Vec2f::new(0.0, 0.0),
         }
     }
 }
@@ -69,6 +71,40 @@ impl C_Transform2D {
     pub fn rotation(&self) -> Rad<f32> {
         self.rotation
     }
+
+    pub fn set_origin(&mut self, x: f32, y: f32) {
+        self.origin = Vec2f::new(x, y);
+    }
+
+    pub fn get_matrix(&self) -> Matrix3<f32> {
+        let Rad(angle) = self.rotation.into();
+        let angle = -angle;
+        let cosine = angle.cos();
+        let sine = angle.sin();
+        let sxc = self.scale.x * cosine;
+        let syc = self.scale.y * cosine;
+        let sxs = self.scale.x * sine;
+        let sys = self.scale.y * sine;
+        let tx = -self.origin.x * sxc - self.origin.y * sys + self.position.x;
+        let ty = self.origin.x * sxs - self.origin.y * syc + self.position.y;
+
+        Matrix3::new(sxc, sys, tx, -sxs, syc, ty, 0.0, 0.0, 1.0)
+    }
+
+    pub fn get_matrix_sfml(&self) -> sfml::graphics::Transform {
+        let Rad(angle) = self.rotation.into();
+        let angle = -angle;
+        let cosine = angle.cos();
+        let sine = angle.sin();
+        let sxc = self.scale.x * cosine;
+        let syc = self.scale.y * cosine;
+        let sxs = self.scale.x * sine;
+        let sys = self.scale.y * sine;
+        let tx = -self.origin.x * sxc - self.origin.y * sys + self.position.x;
+        let ty = self.origin.x * sxs - self.origin.y * syc + self.position.y;
+
+        sfml::graphics::Transform::new(sxc, sys, tx, -sxs, syc, ty, 0.0, 0.0, 1.0)
+    }
 }
 
 #[cfg(test)]

src/ecs/components/transform.rs

@@ -20,6 +20,13 @@ pub struct Entity_Manager {
 pub type Entity = Generational_Index;
 type VecOpt<T> = Vec<Option<RefCell<T>>>;
 
+impl Entity {
+    pub const INVALID: Entity = Entity {
+        gen: u64::max_value(),
+        index: usize::max_value(),
+    };
+}
+
 impl Entity_Manager {
     pub fn new() -> Entity_Manager {
         Entity_Manager {

src/ecs/entity_manager.rs

@@ -1,27 +1,36 @@
 use crate::cfg::Cfg_Var;
+use crate::core::common::vector::Vec2f;
 use crate::core::input;
 use crate::core::time;
 use crate::ecs::components::base::C_Spatial2D;
 use crate::ecs::entity_manager::Entity_Manager;
 use std::time::Duration;
 use typename::TypeName;
 
-#[derive(Clone, Default, Debug, TypeName)]
+#[derive(Clone, Debug, TypeName)]
 pub struct C_Controllable {
     pub speed: Cfg_Var<f32>,
+    pub translation_this_frame: Vec2f,
+}
+
+impl Default for C_Controllable {
+    fn default() -> C_Controllable {
+        C_Controllable {
+            speed: Cfg_Var::default(),
+            translation_this_frame: Vec2f::new(0.0, 0.0),
+        }
+    }
 }
 
 pub fn update(dt: &Duration, actions: &input::Action_List, em: &mut Entity_Manager) {
     let movement = input::get_normalized_movement_from_input(actions);
     let dt_secs = time::to_secs_frac(&dt);
-    let controllables = em.get_component_tuple_mut::<C_Spatial2D, C_Controllable>();
+    let controllables = em.get_components_mut::<C_Controllable>();
 
-    for (spatial, ctrl) in controllables {
-        let speed = *ctrl.borrow().speed;
+    for mut ctrl in controllables {
+        let speed = *ctrl.speed;
         let velocity = movement * speed;
-        let mut spatial = spatial.borrow_mut();
         let v = velocity * dt_secs;
-        spatial.velocity.set(v);
-        spatial.transform.translate_v(v);
+        ctrl.translation_this_frame = v;
     }
 }