profiling and code cleanup

Cargo.toml

@@ -10,3 +10,4 @@ raylib = { version = "3.5", git = "https://github.com/ewpratten/raylib-rs", bran
 serialstudio = "0.1.0"
 serde = "1.0.125"
 serde_json = "1.0.64"
+failure = "0.1.8"

src/gamecore.rs

@@ -1,13 +1,38 @@
+//! This file contains the global state of the game. Data here is passed around to all handler functions.
+
+use std::fmt;
+
+use crate::resources::GlobalResources;
+
 /// Overall states for the game
+#[derive(Debug)]
 pub enum GameState {
     Loading,
     MainMenu,
 }
 
+impl fmt::Display for GameState {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
 /// This structure contains the entire game state, and should be passed around to various logic functions.
 pub struct GameCore {
-
     /// The game's overall state
-    pub state: GameState
+    pub state: GameState,
+    pub last_state_change_time: f64,
 
+    /// Resources
+    pub resources: Option<GlobalResources>,
+}
+
+impl GameCore {
+    pub fn new() -> Self {
+        Self {
+            state: GameState::Loading,
+            last_state_change_time: 0.0,
+            resources: None,
+        }
+    }
 }

src/lib/mod.rs

@@ -1,2 +1,2 @@
 pub mod wrappers;
-pub mod profiler;
+pub mod utils;

src/lib/profiler/mod.rs

@@ -1,83 +0,0 @@
-use serde_json::json;
-use serialstudio::{
-    data::{DataGroup, DataSet, TelemetryFrame},
-    SerialStudioSource,
-};
-
-/// The development profiler
-#[derive(Default)]
-pub struct GameProfiler {
-    /// The SerialStudio server
-    server: Option<SerialStudioSource>,
-
-    /// The data
-    pub frames_per_second: u32,
-    pub seconds_per_frame: f32,
-}
-
-/// Dev mode
-#[cfg(debug_assertions)]
-impl GameProfiler {
-    pub fn new() -> Self {
-        Self {
-            server: Some(SerialStudioSource::new()),
-            ..Default::default()
-        }
-    }
-
-    pub fn start(&mut self) {
-        println!("Starting debug server on: tcp://localhost:8019");
-        self.server
-            .as_mut()
-            .unwrap()
-            .start("localhost:8019".to_string());
-    }
-
-    pub fn stop(&mut self) {
-        println!("Stopping debug server");
-        self.server.as_mut().unwrap().stop();
-    }
-
-    pub fn update(&mut self) {
-        // Build telemetry frame
-        let frame = TelemetryFrame {
-            title: "Game status".to_string(),
-            groups: vec![DataGroup {
-                title: "Rendering engine".to_string(),
-                widget_type: None,
-                datasets: vec![
-                    DataSet {
-                        title: Some("Frames per Second".to_string()),
-                        value: json!(self.frames_per_second),
-                        graph: Some(true),
-                        unit: Some("fps".to_string()),
-                        w_type: None,
-                    },
-                    DataSet {
-                        title: Some("Seconds per Frame".to_string()),
-                        value: json!(self.seconds_per_frame),
-                        graph: Some(true),
-                        unit: Some("seconds".to_string()),
-                        w_type: None,
-                    },
-                ],
-            }],
-        };
-
-        // Send the frame
-        self.server.as_mut().unwrap().publish(frame);
-    }
-}
-
-/// Release mode: We do nothing here
-#[cfg(not(debug_assertions))]
-impl GameProfiler {
-    pub fn new() -> Self {
-        Self {
-            ..Default::default()
-        }
-    }
-    pub fn start(&mut self) {}
-    pub fn stop(&mut self) {}
-    pub fn update(&mut self) {}
-}

src/lib/utils/mod.rs

@@ -0,0 +1 @@
+pub mod profiler;

src/lib/utils/profiler.rs

@@ -0,0 +1,139 @@
+use serde_json::json;
+use serialstudio::{
+    data::{DataGroup, DataSet, TelemetryFrame},
+    SerialStudioSource,
+};
+
+#[derive(Default)]
+pub struct ProfilerData {
+    // Rendering
+    pub frames_per_second: u32,
+    pub seconds_per_frame: f32,
+    pub monitor_count: i32,
+
+    // Audio
+    pub audio_volume: f32,
+    pub active_sounds: i32,
+
+    // Game core
+    pub game_state: String
+}
+
+/// The development profiler
+#[derive(Default)]
+pub struct GameProfiler {
+    /// The SerialStudio server
+    server: Option<SerialStudioSource>,
+
+    /// The data
+    pub data: ProfilerData,
+}
+
+/// Dev mode
+#[cfg(debug_assertions)]
+impl GameProfiler {
+    pub fn new() -> Self {
+        Self {
+            server: Some(SerialStudioSource::new()),
+            ..Default::default()
+        }
+    }
+
+    pub fn start(&mut self) {
+        println!("Starting debug server on: tcp://localhost:8019");
+        self.server
+            .as_mut()
+            .unwrap()
+            .start("localhost:8019".to_string());
+    }
+
+    pub fn stop(&mut self) {
+        println!("Stopping debug server");
+        self.server.as_mut().unwrap().stop();
+    }
+
+    pub fn update(&mut self) {
+        // Build telemetry frame
+        let frame = TelemetryFrame {
+            title: "Game status".to_string(),
+            groups: vec![
+                DataGroup {
+                    title: "Rendering engine".to_string(),
+                    widget_type: None,
+                    datasets: vec![
+                        DataSet {
+                            title: Some("Frames per Second".to_string()),
+                            value: json!(self.data.frames_per_second),
+                            graph: Some(true),
+                            unit: Some("fps".to_string()),
+                            w_type: None,
+                        },
+                        DataSet {
+                            title: Some("Seconds per Frame".to_string()),
+                            value: json!(self.data.seconds_per_frame),
+                            graph: Some(true),
+                            unit: Some("seconds".to_string()),
+                            w_type: None,
+                        },
+                        DataSet {
+                            title: Some("Monitor Count".to_string()),
+                            value: json!(self.data.monitor_count),
+                            graph: Some(false),
+                            unit: None,
+                            w_type: None,
+                        },
+                    ],
+                },
+                DataGroup {
+                    title: "Audio engine".to_string(),
+                    widget_type: None,
+                    datasets: vec![
+                        DataSet {
+                            title: Some("Master Volume".to_string()),
+                            value: json!(self.data.audio_volume),
+                            graph: Some(false),
+                            unit: None,
+                            w_type: None,
+                        },
+                        DataSet {
+                            title: Some("Active Sounds".to_string()),
+                            value: json!(self.data.active_sounds),
+                            graph: Some(true),
+                            unit: None,
+                            w_type: None,
+                        },
+                    ],
+                },
+                DataGroup {
+                    title: "Game".to_string(),
+                    widget_type: None,
+                    datasets: vec![
+                        DataSet {
+                            title: Some("Global State".to_string()),
+                            value: json!(self.data.game_state),
+                            graph: Some(false),
+                            unit: None,
+                            w_type: None,
+                        },
+                    ],
+                },
+            ],
+        };
+
+        // Send the frame
+        self.server.as_mut().unwrap().publish(frame);
+    }
+}
+
+/// Release mode: We do nothing here
+#[cfg(not(debug_assertions))]
+impl GameProfiler {
+    pub fn new() -> Self {
+        Self {
+            ..Default::default()
+        }
+    }
+    pub fn start(&mut self) {}
+    pub fn stop(&mut self) {}
+    pub fn update(&mut self) {}
+}

src/lib/wrappers/audio.rs

@@ -1,41 +0,0 @@
-use raylib::{
-    audio::{Music, RaylibAudio},
-    prelude::RaylibDrawHandle,
-};
-
-/// A simple wrapper around a single audio clip.
-pub struct AudioWrapper {
-    music: Music,
-}
-
-impl AudioWrapper {
-    /// Create a new AudioWrapper from a `Music` struct
-    pub fn new(music: Music) -> Self {
-        Self { music }
-    }
-
-    /// Begin playing the audio
-    pub fn play(&mut self, audio_handle: &mut RaylibAudio) {
-        audio_handle.play_music_stream(&mut self.music);
-    }
-
-    /// Stop playing the audio
-    pub fn stop(&mut self, audio_handle: &mut RaylibAudio) {
-        audio_handle.stop_music_stream(&mut self.music);
-    }
-
-    /// Pause the audio
-    pub fn pause(&mut self, audio_handle: &mut RaylibAudio) {
-        audio_handle.pause_music_stream(&mut self.music);
-    }
-
-    /// Call this every frame
-    pub fn update(&mut self, audio_handle: &mut RaylibAudio) {
-        audio_handle.update_music_stream(&mut self.music);
-    }
-
-    /// Check if this audio clip is playing
-    pub fn is_playing(&mut self, audio_handle: &mut RaylibAudio) -> bool {
-        return audio_handle.is_music_playing(&mut self.music);
-    }
-}

src/lib/wrappers/audio.rs.old

@@ -0,0 +1,41 @@
+// use raylib::{
+//     audio::{Music, RaylibAudio},
+//     prelude::RaylibDrawHandle,
+// };
+
+// /// A simple wrapper around a single audio clip.
+// pub struct AudioWrapper {
+//     music: Music,
+// }
+
+// impl AudioWrapper {
+//     /// Create a new AudioWrapper from a `Music` struct
+//     pub fn new(music: Music) -> Self {
+//         Self { music }
+//     }
+
+//     /// Begin playing the audio
+//     pub fn play(&mut self, audio_handle: &mut RaylibAudio) {
+//         audio_handle.play_music_stream(&mut self.music);
+//     }
+
+//     /// Stop playing the audio
+//     pub fn stop(&mut self, audio_handle: &mut RaylibAudio) {
+//         audio_handle.stop_music_stream(&mut self.music);
+//     }
+
+//     /// Pause the audio
+//     pub fn pause(&mut self, audio_handle: &mut RaylibAudio) {
+//         audio_handle.pause_music_stream(&mut self.music);
+//     }
+
+//     /// Call this every frame
+//     pub fn update(&mut self, audio_handle: &mut RaylibAudio) {
+//         audio_handle.update_music_stream(&mut self.music);
+//     }
+
+//     /// Check if this audio clip is playing
+//     pub fn is_playing(&mut self, audio_handle: &mut RaylibAudio) -> bool {
+//         return audio_handle.is_music_playing(&mut self.music);
+//     }
+// }

src/lib/wrappers/audio/mod.rs

@@ -0,0 +1 @@
+pub mod player;

src/lib/wrappers/audio/player.rs

@@ -0,0 +1,41 @@
+use raylib::audio::RaylibAudio;
+
+/// A thin wrapper around `raylib::core::audio::RaylibAudio` that keeps track of the volume of its audio channels.
+pub struct AudioPlayer {
+    backend: RaylibAudio,
+
+    // Volume
+    pub master_volume: f32,
+}
+
+impl AudioPlayer {
+    /// Construct an AudioPlayer around a RaylibAudio
+    pub fn new(backend: RaylibAudio) -> Self {
+        Self {
+            backend,
+            master_volume: 1.0,
+        }
+    }
+
+    /// Set the master volume for all tracks. `0.0` to `1.0`
+    pub fn set_master_volume(&mut self, volume: f32) {
+        // The volume must be 0-1
+        let volume = volume.clamp(0.0, 1.0);
+
+        // Set the volume
+        self.master_volume = volume;
+        self.backend.set_master_volume(volume);
+    }
+
+    /// Get the master volume
+    pub fn get_master_volume(&self) -> f32 {
+        self.master_volume
+    }
+}
+
+impl std::ops::Deref for AudioPlayer {
+    type Target = RaylibAudio;
+    fn deref(&self) -> &Self::Target {
+        &self.backend
+    }
+}

src/logic/loadingscreen.rs

@@ -0,0 +1,13 @@
+use raylib::prelude::*;
+
+use crate::gamecore::{GameCore, GameState};
+
+
+pub fn handle_loading_screen(draw_handle: &mut RaylibDrawHandle, game_core: &mut GameCore) -> Option<GameState> {
+
+    // Clear frame
+    draw_handle.clear_background(Color::WHITE);
+
+
+    return None;
+}

src/logic/mainmenu.rs

@@ -0,0 +1,11 @@
+use raylib::prelude::*;
+
+use crate::gamecore::{GameCore, GameState};
+
+
+pub fn handle_main_menu(draw_handle: &mut RaylibDrawHandle, game_core: &mut GameCore) -> Option<GameState>{
+    
+
+    return None;
+
+}

src/logic/mod.rs

@@ -0,0 +1,2 @@
+pub mod loadingscreen;
+pub mod mainmenu;

src/main.rs

@@ -1,8 +1,11 @@
-mod lib;
 mod gamecore;
+mod lib;
+mod logic;
+mod resources;
 
 use gamecore::{GameCore, GameState};
-use lib::profiler::GameProfiler;
+use lib::{utils::profiler::GameProfiler, wrappers::audio::player::AudioPlayer};
+use logic::{loadingscreen::handle_loading_screen, mainmenu::handle_main_menu};
 use raylib::prelude::*;
 
 // Game Launch Configuration
@@ -21,32 +24,50 @@ fn main() {
         .build();
     raylib.set_target_fps(MAX_FPS);
 
+    // Override the default exit key
+    raylib.set_exit_key(None);
+
     // Set up the game's core state
-    let mut game_core = GameCore{
-        state: GameState::Loading
-    };
+    let mut game_core = GameCore::new();
 
     // Set up the game's profiler
     let mut profiler = GameProfiler::new();
     profiler.start();
 
+    // Init the audio subsystem
+    let mut audio_system = AudioPlayer::new(RaylibAudio::init_audio_device());
+
     // Main rendering loop
     while !raylib.window_should_close() {
         let mut draw_handle = raylib.begin_drawing(&raylib_thread);
 
-        // Clear frame
-        draw_handle.clear_background(Color::WHITE);
-
         // Call appropriate render function
-        // TODO: the usual match statement on `game_core.state`
+        let new_state: Option<GameState> = match game_core.state {
+            GameState::Loading => handle_loading_screen(&mut draw_handle, &mut game_core),
+            GameState::MainMenu => handle_main_menu(&mut draw_handle, &mut game_core),
+        };
+
+        if new_state.is_some() {
+            game_core.state = new_state.unwrap();
+            game_core.last_state_change_time = draw_handle.get_time();
+        }
 
         // Feed the profiler
-        profiler.seconds_per_frame = draw_handle.get_frame_time();
-        profiler.frames_per_second = draw_handle.get_fps();
+        // This only runs in the dev profile.
+        #[cfg(debug_assertions)]
+        {
+            // Update all data
+            profiler.data.seconds_per_frame = draw_handle.get_frame_time();
+            profiler.data.frames_per_second = draw_handle.get_fps();
+            profiler.data.monitor_count = raylib::core::window::get_monitor_count();
+            profiler.data.audio_volume = audio_system.get_master_volume();
+            profiler.data.active_sounds = audio_system.get_sounds_playing();
+            profiler.data.game_state = game_core.state.to_string();
 
             // Send telemetry data
             profiler.update();
         }
+    }
 
     // Cleanup
     profiler.stop();

src/resources.rs

@@ -0,0 +1,11 @@
+use failure::Error;
+
+/// This struct contains all textures and sounds that must be loaded into (V)RAM at the start of the game
+pub struct GlobalResources {}
+
+impl GlobalResources {
+    /// Load all resources. **THIS WILL HANG!**
+    pub fn load_all(&mut self) -> Result<GlobalResources, Error> {
+        Ok(GlobalResources {})
+    }
+}