working on loading screen system

src/gamecore.rs

@@ -5,7 +5,7 @@ use std::fmt;
 use crate::resources::GlobalResources;
 
 /// Overall states for the game
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub enum GameState {
     Loading,
     MainMenu,
@@ -22,6 +22,7 @@ pub struct GameCore {
     /// The game's overall state
     pub state: GameState,
     pub last_state_change_time: f64,
+    pub has_rendered_first_frame: bool,
 
     /// Resources
     pub resources: Option<GlobalResources>,
@@ -32,6 +33,7 @@ impl GameCore {
         Self {
             state: GameState::Loading,
             last_state_change_time: 0.0,
+            has_rendered_first_frame:false,
             resources: None,
         }
     }

src/logic/loadingscreen.rs

@@ -1,13 +1,222 @@
 use raylib::prelude::*;
 
-use crate::gamecore::{GameCore, GameState};
+use crate::{
+    gamecore::{GameCore, GameState},
+    lib::wrappers::audio::player::AudioPlayer,
+    resources::GlobalResources,
+};
 
+use super::screen::Screen;
 
-pub fn handle_loading_screen(draw_handle: &mut RaylibDrawHandle, game_core: &mut GameCore) -> Option<GameState> {
+const SECONDS_PER_LOGO: f64 = 2.0;
+const RUST_ORANGE: Color = Color::new(222, 165, 132, 255);
 
-    // Clear frame
+#[derive(Debug, PartialEq)]
-    draw_handle.clear_background(Color::WHITE);
+enum LoadingScreenState {
+    Preload,
+    LoadingResources,
+    GameLogo,
+    RaylibLogo,
+    Finished,
+}
 
+pub struct LoadingScreen {
+    state: LoadingScreenState,
+    last_state_switch_time: f64,
+}
 
-    return None;
+impl LoadingScreen {
-}
+    pub fn new() -> Self {
+        Self {
+            state: LoadingScreenState::Preload,
+            last_state_switch_time: 0.0,
+        }
+    }
+
+    fn load_global_resources(
+        &mut self,
+        draw_handle: &mut RaylibDrawHandle,
+        game_core: &mut GameCore,
+        win_height: i32,
+        win_width: i32,
+    ) {
+        // Show a loading message (this will stay on screen until all resources are loaded)
+        draw_handle.draw_text(
+            "Loading Assets...",
+            (win_width / 2) - 90,
+            (win_height / 3) * 2,
+            25,
+            Color::BLACK,
+        );
+
+        if self.state == LoadingScreenState::LoadingResources {
+            // Load the global resources
+            let resources = GlobalResources::load_all();
+
+            // Handle a loading error
+            if resources.is_err() {
+                println!("ERROR: Failed to load game resources!");
+                panic!("{:?}", resources.err());
+            }
+
+            // Set the global resources
+            game_core.resources = Some(resources.unwrap());
+
+            // Set the loading screen state to move on to the game logo
+            self.state = LoadingScreenState::GameLogo;
+            self.last_state_switch_time = draw_handle.get_time();
+            return;
+        }
+
+        // Update internal state
+        self.state = LoadingScreenState::LoadingResources;
+    }
+
+    fn get_logo_mask(&self, draw_handle: &RaylibDrawHandle, playthrough_percent: f64) -> Color {
+        // Determine the alpha
+        let alpha;
+        if playthrough_percent < 0.25 {
+            alpha = playthrough_percent / 0.25
+        } else if playthrough_percent > 0.75 {
+            alpha = 1.0 - ((playthrough_percent - 0.75) / 0.25);
+        } else {
+            alpha = 1.0;
+        }
+
+        // Build a color mask
+        Color {
+            r: 255,
+            g: 255,
+            b: 255,
+            a: (255.0 * alpha) as u8,
+        }
+    }
+
+    fn show_game_logo(
+        &mut self,
+        draw_handle: &mut RaylibDrawHandle,
+        game_core: &mut GameCore,
+        win_height: i32,
+        win_width: i32,
+    ) {
+        // Determine how far through rendering this logo we are
+        // This value is used to determine the logo alpha
+        let playthrough_percent =
+            (draw_handle.get_time() - self.last_state_switch_time) / SECONDS_PER_LOGO;
+
+        // Build a color mask
+        let mask = self.get_logo_mask(draw_handle, playthrough_percent);
+
+        // Render the logo
+        // TODO
+
+        // Move on to next logo if needed
+        if playthrough_percent >= 1.0 {
+            self.state = LoadingScreenState::RaylibLogo;
+            self.last_state_switch_time = draw_handle.get_time();
+        }
+    }
+
+    fn show_raylib_logo(
+        &mut self,
+        draw_handle: &mut RaylibDrawHandle,
+        game_core: &mut GameCore,
+        win_height: i32,
+        win_width: i32,
+    ) {
+        // Determine how far through rendering this logo we are
+        // This value is used to determine the logo alpha
+        let playthrough_percent =
+            (draw_handle.get_time() - self.last_state_switch_time) / SECONDS_PER_LOGO;
+
+        // Build a color mask
+        let mask = self.get_logo_mask(draw_handle, playthrough_percent);
+
+        // Create modified colors
+        let alpha_orange = Color {
+            r: RUST_ORANGE.r,
+            g: RUST_ORANGE.g,
+            b: RUST_ORANGE.b,
+            a: mask.a
+        };
+        let alpha_black = Color {
+            r: Color::BLACK.r,
+            g: Color::BLACK.g,
+            b: Color::BLACK.b,
+            a: mask.a
+        };
+
+        // Render the raylib logo
+        draw_handle.draw_rectangle(
+            win_width / 2 - 128,
+            win_height / 2 - 128,
+            256,
+            256,
+            alpha_orange,
+        );
+        draw_handle.draw_rectangle(
+            win_width / 2 - 112,
+            win_height / 2 - 112,
+            224,
+            224,
+            Color::WHITE,
+        );
+        draw_handle.draw_text(
+            "rust",
+            win_width / 2 - 69,
+            win_height / 2 + 18,
+            50,
+            alpha_orange,
+        );
+        draw_handle.draw_text(
+            "raylib",
+            win_width / 2 - 44,
+            win_height / 2 + 48,
+            50,
+            alpha_orange,
+        );
+
+        // Move on to next logo if needed
+        if playthrough_percent >= 1.0 {
+            self.state = LoadingScreenState::Finished;
+            self.last_state_switch_time = draw_handle.get_time();
+        }
+    }
+}
+
+impl Screen for LoadingScreen {
+    fn render(
+        &mut self,
+        draw_handle: &mut RaylibDrawHandle,
+        _audio_system: &mut AudioPlayer,
+        game_core: &mut GameCore,
+    ) -> Option<GameState> {
+        // Clear frame
+        draw_handle.clear_background(Color::WHITE);
+
+        // Window dimensions
+        let win_height = draw_handle.get_screen_height();
+        let win_width = draw_handle.get_screen_width();
+
+        //TODO: Debug mode skip button
+
+        // Call the appropriate internal handler function
+        match self.state {
+            LoadingScreenState::Preload => {
+                self.load_global_resources(draw_handle, game_core, win_height, win_width)
+            }
+            LoadingScreenState::LoadingResources => {
+                self.load_global_resources(draw_handle, game_core, win_height, win_width)
+            }
+            LoadingScreenState::GameLogo => {
+                self.show_game_logo(draw_handle, game_core, win_height, win_width)
+            }
+            LoadingScreenState::RaylibLogo => {
+                self.show_raylib_logo(draw_handle, game_core, win_height, win_width)
+            }
+            LoadingScreenState::Finished => return Some(GameState::MainMenu),
+        }
+
+        return None;
+    }
+}

src/logic/mainmenu.rs

@@ -1,11 +1,24 @@
 use raylib::prelude::*;
 
-use crate::gamecore::{GameCore, GameState};
+use crate::{gamecore::{GameCore, GameState}, lib::wrappers::audio::player::AudioPlayer};
 
+use super::screen::Screen;
 
-pub fn handle_main_menu(draw_handle: &mut RaylibDrawHandle, game_core: &mut GameCore) -> Option<GameState>{
+pub struct MainMenuScreen {}
-    
 
-    return None;
+impl MainMenuScreen {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
 
-}
+impl Screen for MainMenuScreen {
+    fn render(
+        &mut self,
+        draw_handle: &mut RaylibDrawHandle,
+        audio_system: &mut AudioPlayer,
+        game_core: &mut GameCore,
+    ) -> Option<GameState> {
+        return None;
+    }
+}

src/logic/mod.rs

@@ -1,2 +1,4 @@
+pub mod screen;
 pub mod loadingscreen;
-pub mod mainmenu;
+pub mod mainmenu;
+

src/logic/screen.rs

@@ -0,0 +1,13 @@
+use raylib::prelude::RaylibDrawHandle;
+
+use crate::{gamecore::{GameCore, GameState}, lib::wrappers::audio::player::AudioPlayer};
+
+/// A trait describing all game screens
+pub trait Screen {
+    fn render(
+        &mut self,
+        draw_handle: &mut RaylibDrawHandle,
+        audio_system: &mut AudioPlayer,
+        game_core: &mut GameCore,
+    ) -> Option<GameState>;
+}

src/main.rs

@@ -5,11 +5,14 @@ mod resources;
 
 use gamecore::{GameCore, GameState};
 use lib::{utils::profiler::GameProfiler, wrappers::audio::player::AudioPlayer};
-use logic::{loadingscreen::handle_loading_screen, mainmenu::handle_main_menu};
+use logic::{loadingscreen::LoadingScreen, mainmenu::MainMenuScreen, screen::Screen};
 use raylib::prelude::*;
 
 // Game Launch Configuration
-const DEFAULT_WINDOW_DIMENSIONS: Vector2 = Vector2 { x: 800.0, y: 600.0 };
+const DEFAULT_WINDOW_DIMENSIONS: Vector2 = Vector2 {
+    x: 1080.0,
+    y: 720.0,
+};
 const WINDOW_TITLE: &str = r"Ludum Dare 48";
 const MAX_FPS: u32 = 60;
 
@@ -37,14 +40,22 @@ fn main() {
     // Init the audio subsystem
     let mut audio_system = AudioPlayer::new(RaylibAudio::init_audio_device());
 
+    // Create all the game screens
+    let mut loading_screen = LoadingScreen::new();
+    let mut main_menu_screen = MainMenuScreen::new();
+
     // Main rendering loop
     while !raylib.window_should_close() {
         let mut draw_handle = raylib.begin_drawing(&raylib_thread);
 
         // Call appropriate render function
         let new_state: Option<GameState> = match game_core.state {
-            GameState::Loading => handle_loading_screen(&mut draw_handle, &mut game_core),
+            GameState::Loading => {
-            GameState::MainMenu => handle_main_menu(&mut draw_handle, &mut game_core),
+                loading_screen.render(&mut draw_handle, &mut audio_system, &mut game_core)
+            }
+            GameState::MainMenu => {
+                main_menu_screen.render(&mut draw_handle, &mut audio_system, &mut game_core)
+            }
         };
 
         if new_state.is_some() {
@@ -67,6 +78,9 @@ fn main() {
             // Send telemetry data
             profiler.update();
         }
+
+        // Set the first frame flag
+        game_core.has_rendered_first_frame = true;
     }
 
     // Cleanup

src/resources.rs

@@ -5,7 +5,7 @@ pub struct GlobalResources {}
 
 impl GlobalResources {
     /// Load all resources. **THIS WILL HANG!**
-    pub fn load_all(&mut self) -> Result<GlobalResources, Error> {
+    pub fn load_all() -> Result<GlobalResources, Error> {
         Ok(GlobalResources {})
     }
 }