more file loading work

.vscode/settings.json

@@ -3,6 +3,5 @@
         "clippy",
         "raylib",
         "renderable"
-    ],
+    ]
-    "rust-analyzer.checkOnSave.command": "clippy"
 }

.vscode/tasks.json

@@ -10,6 +10,18 @@
 			"group": "build",
 			"label": "Rust: Build Code"
 		},
+		{
+			"type": "cargo",
+			"command": "clippy",
+			"args": [
+				"--fix"
+			],
+			"problemMatcher": [
+				"$rustc"
+			],
+			"group": "build",
+			"label": "Rust: Clippy Fix"
+		},
 		{
 			"type": "cargo",
 			"command": "run",

game/src/lib.rs

@@ -153,7 +153,7 @@ pub async fn game_begin(game_config: &GameConfig) -> Result<(), Box<dyn std::err
     // Get the main state machine
     info!("Setting up the scene management state machine");
     let mut game_state_machine =
-        build_screen_state_machine(&context.renderer.borrow_mut(), &raylib_thread).unwrap();
+        build_screen_state_machine(&mut context.renderer.borrow_mut(), &raylib_thread).unwrap();
     game_state_machine
         .force_change_state(Scenes::LoadingScreen)
         .unwrap();

game/src/scenes/loading_screen.rs

@@ -1,11 +1,8 @@
 use chrono::{DateTime, Utc};
 use dirty_fsm::{Action, ActionFlag};
-use raylib::RaylibThread;
+use raylib::{RaylibThread, texture::Texture2D};
 
-use crate::{
+use crate::{context::GameContext, utilities::{datastore::{ResourceLoadError, load_texture_from_internal_data}, non_ref_raylib::HackedRaylibHandle, render_layer::ScreenSpaceRender}};
-    context::GameContext,
-    utilities::{non_ref_raylib::HackedRaylibHandle, render_layer::ScreenSpaceRender},
-};
 
 use super::{Scenes, ScreenError};
 use tracing::{debug, info, trace};
@@ -16,20 +13,20 @@ const LOADING_SCREEN_DURATION_SECONDS: u8 = 3;
 #[derive(Debug)]
 pub struct LoadingScreen {
     start_timestamp: Option<DateTime<Utc>>,
+    game_logo_texture: Texture2D
 }
 
 impl LoadingScreen {
     /// Construct a new `LoadingScreen`
-    pub fn new(raylib_handle: &HackedRaylibHandle, thread: &RaylibThread) -> Self {
+    pub fn new(raylib_handle: &mut HackedRaylibHandle, thread: &RaylibThread) -> Result<Self, ResourceLoadError> {
 
         // Load the game logo asset
-        // TODO: in-memory texture loading
+        let game_logo = load_texture_from_internal_data(raylib_handle, thread, "logos/game-logo.png")?;
-        // raylib_handle.load_texture_from_image(, image)
 
-
+        Ok(Self {
-        Self {
             start_timestamp: None,
-        }
+            game_logo_texture: game_logo
+        })
     }
 }
 

game/src/scenes/mod.rs

@@ -1,6 +1,6 @@
 use dirty_fsm::StateMachine;
 use raylib::RaylibThread;
-use crate::{context::GameContext, utilities::non_ref_raylib::HackedRaylibHandle};
+use crate::{context::GameContext, utilities::{datastore::ResourceLoadError, non_ref_raylib::HackedRaylibHandle}};
 use self::{fsm_error_screen::FsmErrorScreen, loading_screen::LoadingScreen};
 
 pub mod fsm_error_screen;
@@ -16,16 +16,19 @@ pub enum Scenes {
 
 /// Contains any possible errors thrown while rendering
 #[derive(Debug, Error)]
-pub enum ScreenError {}
+pub enum ScreenError {
+    #[error(transparent)]
+    ResourceLoad(#[from] ResourceLoadError)
+}
 
 /// Build the state machine for all scenes
-pub fn build_screen_state_machine(raylib_handle: &HackedRaylibHandle, thread: &RaylibThread) -> Result<
+pub fn build_screen_state_machine(raylib_handle: &mut HackedRaylibHandle, thread: &RaylibThread) -> Result<
     // StateMachine<Scenes, ScreenError, RefCell<(NonRefDrawHandle, Rc<RefCell<GameContext>>)>>,
     StateMachine<Scenes, ScreenError, GameContext>,
     ScreenError,
 > {
     let mut machine = StateMachine::new();
     machine.add_action(Scenes::FsmErrorScreen, FsmErrorScreen::new())?;
-    machine.add_action(Scenes::LoadingScreen, LoadingScreen::new(raylib_handle, thread))?;
+    machine.add_action(Scenes::LoadingScreen, LoadingScreen::new(raylib_handle, thread)?)?;
     Ok(machine)
 }

game/src/utilities/datastore.rs

@@ -22,7 +22,7 @@ pub enum ResourceLoadError {
 }
 
 pub fn load_texture_from_internal_data(
-    raylib_handle: &RaylibHandle,
+    raylib_handle: &mut RaylibHandle,
     thread: &RaylibThread,
     path: &str,
 ) -> Result<Texture2D, ResourceLoadError> {
@@ -31,14 +31,14 @@ pub fn load_texture_from_internal_data(
 
     // Unpack the raw image data to a real file on the local filesystem so raylib will read it correctly
     std::fs::write(
-        tmp_path,
+        &tmp_path,
         &StaticGameData::get(path)
             .ok_or(ResourceLoadError::AssetNotFound(path.to_string()))?
             .data,
     )?;
 
     // Call through via FFI to re-load the file
-    let texture = raylib_handle.load_texture(thread, tmp_path.to_str().unwrap()).map_err(|e| ResourceLoadError::Generic(e));
+    let texture = raylib_handle.load_texture(thread, tmp_path.to_str().unwrap()).map_err(|e| ResourceLoadError::Generic(e))?;
 
     // Close the file
     tmp_path.close()?;

rust-toolchain.toml

@@ -8,4 +8,4 @@
 # Make sure to check the build status before changing this
 # https://rust-lang.github.io/rustup-components-history/
 channel = "nightly-2021-09-30"
-components = ["clippy", "rustfmt"]
+# components = ["clippy", "rustfmt"]