improvements

config/input.toml

@@ -7,11 +7,11 @@ vk_code = "VK_ESCAPE"
 
 [[button]]
 name = "toggle_edit"
-scan_code = 59
+vk_code = "VK_F1"
 
 [[button]]
 name = "reload_shaders"
-scan_code = 63
+vk_code = "VK_F5"
 
 [[button]]
 name = "print_framerate"
@@ -19,31 +19,31 @@ scan_code = 33
 
 [[button]]
 name = "button_forward"
-scan_code = 17
+vk_code = "VK_W"
 
 [[button]]
 name = "button_backward"
-scan_code = 31
+vk_code = "VK_S"
 
 [[button]]
 name = "button_left"
-scan_code = 30
+vk_code = "VK_A"
 
 [[button]]
 name = "button_right"
-scan_code = 32
+vk_code = "VK_D"
 
 [[button]]
 name = "test"
-scan_code = 20
+vk_code = "VK_T"
 
 [[button]]
 name = "quicksave"
-scan_code = 63
+vk_code = "VK_F6"
 
 [[button]]
 name = "quickload"
-scan_code = 64
+vk_code = "VK_F7"
 
 [[button]]
 name = "select"

levels/test.lvl

@@ -50,15 +50,15 @@
   "player": {
     "mesh_index": null,
     "position": [
-      8.637261,
+      2.5716693,
       1.304583,
-      -7.3298244
+      -8.255934
     ],
     "rotation": [
-      0.22436175,
-      -0.6880533,
-      -0.21394368,
-      0.6561041
+      -0.23996419,
+      -0.011724341,
+      0.9695545,
+      0.047371186
     ],
     "scale": [
       1.0,

src/game/components.rs

@@ -1,11 +1,18 @@
-use crate::{input::InputState, text::update_text, vulkan::{PERF_COUNTER_SIZE, VulkanRenderer, gameobject::{GameObject, GameObjectHandle, Updatable}}};
+use crate::{input::InputState, text::{create_text_object, update_text}, vulkan::{PERF_COUNTER_SIZE, VulkanRenderer, gameobject::{GameObject, GameObjectHandle, Updatable}}};
 
-use super::GameState;
+use super::{GameState, TestGame};
 
 pub struct FpsCounter {
     pub game_object: GameObjectHandle
 }
 
+impl FpsCounter {
+    pub fn new(game: &mut TestGame, renderer: &mut VulkanRenderer) -> Box<FpsCounter> {
+        let text_mesh = create_text_object(&mut game.game_state.brush, renderer, "", 30.);
+        Box::new(FpsCounter { game_object: game.add_game_object(renderer, text_mesh) })
+    }
+}
+
 impl Updatable for FpsCounter {
     fn update(&mut self, _delta_time: f32, _input: &InputState, game_state: &mut GameState, game_objects: &mut Vec<GameObject>, renderer: &mut VulkanRenderer) {
         let update_duration = renderer.game_data.update_perf_counters.iter().sum::<u128>() / PERF_COUNTER_SIZE as u128;

src/game/mod.rs

@@ -7,7 +7,7 @@ use level::{load_level, save_level};
 use player::Player;
 
 use crate::game::components::FpsCounter;
-use crate::text::{create_brush, create_text_object};
+use crate::text::create_brush;
 use crate::{config::LogConfig, vulkan};
 use crate::input::InputState;
 use crate::vulkan::{Game, MeshHandle, TextVertex, Vertex, VulkanRenderer};
@@ -151,11 +151,11 @@ impl TestGame {
 
     pub fn game_start(self: &mut Self, renderer: &mut VulkanRenderer) {
         load_level("levels/test.lvl", self, renderer).unwrap();
-        println!("Game loaded!");
 
-        let text_mesh = create_text_object(&mut self.game_state.brush, renderer, "aaxx", 30.);
-        let fps = Box::new(FpsCounter { game_object: self.add_game_object(renderer, text_mesh) });
+        let fps = FpsCounter::new(self, renderer);
         self.components.push(fps);
+        
+        println!("Game loaded!");
     }
 
     pub fn offset_texture_id(&mut self, local_tex_id: Option<usize>) -> usize {

src/game/player.rs

@@ -213,8 +213,7 @@ impl Updatable for Player {
         if self.movement_mode == FirstPerson {
             let mut world_input = self.camera.local_to_world(local_input);
             world_input.y = 0.0;
-            self.camera.position += world_input.normalize();
-            self.camera.position.y = self.height;
+            self.camera.position += world_input;
         } else if self.movement_mode == Flying {
             self.camera.position += self.camera.local_to_world(local_input);
         }

src/text.rs

@@ -44,7 +44,13 @@ pub fn create_text_object(brush: &mut GlyphBrush<Vec<TextVertex>>, renderer: &mu
         uploaded_texture = update_text_texture(None, renderer, rect, text_data);
     }, convert_vertices) {
         Ok(BrushAction::Draw(quads)) => {
-            uploaded_mesh = update_text_quads(quads, uploaded_texture.unwrap(), None, renderer);
+            let t = if let Some(tex) = uploaded_texture {
+                tex
+            } else {
+                let brush_size = brush.texture_dimensions();
+                update_text_texture(None, renderer, Rectangle { min: [0, 0], max: [brush_size.0, brush_size.1] }, &[]).unwrap()
+            };
+            uploaded_mesh = update_text_quads(quads, t, None, renderer);
         },
         Ok(BrushAction::ReDraw) => {},
         Err(BrushError::TextureTooSmall { suggested }) => {