refactor(engine): use new Single get* fns

10 files changed, 161 insertions, 33 deletions

diff --git a/engine/src/asset.rs b/engine/src/asset.rs
index 76d664a..ebcf5c7 100644
--- a/engine/src/asset.rs
+++ b/engine/src/asset.rs
@@ -860,6 +860,10 @@ impl crate::ecs::extension::Extension for Extension
 
 fn add_received_assets(mut assets: Single<Assets>)
 {
+    let Ok(assets) = assets.get_mut() else {
+        unreachable!();
+    };
+
     let Events { curr_tick_events, last_tick_events } = &mut assets.events;
 
     std::mem::swap(last_tick_events, curr_tick_events);
@@ -869,7 +873,7 @@ fn add_received_assets(mut assets: Single<Assets>)
     while let Some(import_work_msg) = assets.import_work_msg_receiver.try_recv().ok() {
         match import_work_msg {
             ImportWorkMessage::Store { do_store, label, asset } => {
-                do_store(&mut assets, label, asset);
+                do_store(assets, label, asset);
             }
             ImportWorkMessage::Load { do_load, label, asset_settings } => {
                 do_load(
@@ -887,6 +891,10 @@ fn add_received_assets(mut assets: Single<Assets>)
 
 fn check_import_wq_thread_not_panicked(assets: Single<Assets>, mut actions: Actions<'_>)
 {
+    let Ok(assets) = assets.get() else {
+        unreachable!();
+    };
+
     if assets.import_work_queue.get_thread_panic().is_some() {
         cold_path();
 
diff --git a/engine/src/camera/fly.rs b/engine/src/camera/fly.rs
index 589ba8a..9d5658b 100644
--- a/engine/src/camera/fly.rs
+++ b/engine/src/camera/fly.rs
@@ -87,8 +87,12 @@ fn update(
     delta_time: Single<DeltaTime>,
     options: Local<Options>,
     mut actions: Actions,
-)
+) -> Result<(), crate::Error>
 {
+    let keyboard = keyboard.get()?;
+    let mouse = mouse.get()?;
+    let delta_time = delta_time.get()?;
+
     for (
         camera_ent_id,
         (mut camera, mut camera_world_pos, mut fly_camera, controllable_camera),
@@ -158,4 +162,6 @@ fn update(
 
         camera.target = camera_world_pos.position + direction;
     }
+
+    Ok(())
 }
diff --git a/engine/src/delta_time.rs b/engine/src/delta_time.rs
index 6f75247..a26007d 100644
--- a/engine/src/delta_time.rs
+++ b/engine/src/delta_time.rs
@@ -22,6 +22,10 @@ pub struct LastUpdate
 /// Will panic if no delta time component exists.
 pub fn update(mut delta_time: Single<DeltaTime>, mut last_update: Local<LastUpdate>)
 {
+    let Ok(delta_time) = delta_time.get_mut() else {
+        unreachable!();
+    };
+
     let current_time = Instant::now();
 
     if let Some(last_update_time) = last_update.time {
diff --git a/engine/src/rendering.rs b/engine/src/rendering.rs
index 94e5000..46e47e9 100644
--- a/engine/src/rendering.rs
+++ b/engine/src/rendering.rs
@@ -413,6 +413,14 @@ fn enqueue_commands_from_render_passes(
     mut active_draw_props: Local<ActiveDrawProperties>,
 )
 {
+    let Ok(command_queue) = command_queue.get_mut() else {
+        unreachable!();
+    };
+
+    let Ok(render_passes) = render_passes.get_mut() else {
+        unreachable!();
+    };
+
     let mut last_render_pass_draw_props = active_draw_props.draw_properties.clone();
 
     for render_pass in render_passes.passes.drain(..) {
@@ -454,6 +462,10 @@ fn handle_window_changed(
     mut command_queue: Single<CommandQueue>,
 )
 {
+    let Ok(command_queue) = command_queue.get_mut() else {
+        unreachable!();
+    };
+
     for evt_match in &observe {
         let window_ent = evt_match.get_entity();
 
@@ -491,6 +503,10 @@ fn handle_window_removed(
     mut actions: Actions,
 )
 {
+    let Ok(command_queue) = command_queue.get_mut() else {
+        unreachable!();
+    };
+
     for evt_match in &observe {
         let window_ent_id = evt_match.entity_id();
 
diff --git a/engine/src/rendering/backend/opengl.rs b/engine/src/rendering/backend/opengl.rs
index 41d6968..c545ccc 100644
--- a/engine/src/rendering/backend/opengl.rs
+++ b/engine/src/rendering/backend/opengl.rs
@@ -196,10 +196,13 @@ fn prepare_windows(
     windowing_context: Single<WindowingContext>,
     graphics_props: Single<GraphicsProperties>,
     mut actions: Actions,
-)
+) -> Result<(), crate::Error>
 {
+    let windowing_context = windowing_context.get()?;
+    let graphics_props = graphics_props.get()?;
+
     let Some(display_handle) = windowing_context.display_handle() else {
-        return;
+        return Ok(());
     };
 
     for (window_ent_id, (window, mut window_creation_attrs)) in
@@ -259,6 +262,8 @@ fn prepare_windows(
             actions.add_components(window_ent_id, (CreationReady,));
         }
     }
+
+    Ok(())
 }
 
 #[tracing::instrument(skip_all)]
@@ -271,8 +276,15 @@ fn init_window_graphics(
     graphics_props: Single<GraphicsProperties>,
     mut graphics_ctx: Single<GraphicsContext>,
     mut actions: Actions,
-)
+) -> Result<(), crate::Error>
 {
+    let Ok(graphics_ctx) = graphics_ctx.get_mut() else {
+        unreachable!();
+    };
+
+    let windowing_context = windowing_context.get()?;
+    let graphics_props = graphics_props.get()?;
+
     for (window_ent_id, (window, window_gl_config)) in window_query.iter_with_euids() {
         tracing::info!(
             window_entity_id=%window_ent_id,
@@ -409,6 +421,8 @@ fn init_window_graphics(
             },
         );
     }
+
+    Ok(())
 }
 
 #[tracing::instrument(skip_all)]
@@ -418,8 +432,17 @@ fn handle_commands(
     mut command_queue: Single<CommandQueue>,
     assets: Single<Assets>,
     shader_context: Single<ShaderContext>,
-)
+) -> Result<(), crate::Error>
 {
+    let Ok(graphics_ctx) = graphics_ctx.get_mut() else {
+        unreachable!();
+    };
+
+    let object_store = object_store.get_mut()?;
+    let command_queue = command_queue.get_mut()?;
+    let assets = assets.get()?;
+    let shader_context = shader_context.get()?;
+
     let GraphicsContext {
         ref gl_context,
         ref mut surfaces,
@@ -429,7 +452,7 @@ fn handle_commands(
     } = *graphics_ctx;
 
     let Some(gl_context) = gl_context else {
-        return;
+        return Ok(());
     };
 
     let mut activated_gl_shader_program: Option<(ObjectId, GlShaderProgram)> = None;
@@ -676,8 +699,8 @@ fn handle_commands(
             Command::CreateTexture(texture_asset) => {
                 if let Err(err) = create_texture_object(
                     gl_context,
-                    &mut object_store,
-                    &assets,
+                    object_store,
+                    assets,
                     &texture_asset,
                 ) {
                     tracing::error!("Failed to create texture object: {err}");
@@ -1015,6 +1038,8 @@ fn handle_commands(
             }
         }
     }
+
+    Ok(())
 }
 
 fn create_gl_context(
diff --git a/engine/src/rendering/main_render_pass.rs b/engine/src/rendering/main_render_pass.rs
index ec30dc5..02e0ca0 100644
--- a/engine/src/rendering/main_render_pass.rs
+++ b/engine/src/rendering/main_render_pass.rs
@@ -3,6 +3,7 @@ use crate::draw_flags::{DrawFlags, NoDraw, PolygonModeConfig};
 use crate::ecs::query::term::{With, Without};
 use crate::ecs::sole::Single;
 use crate::ecs::Query;
+use crate::error;
 use crate::model::{MaterialSearchResult, Model};
 use crate::rendering::object::{Id as ObjectId, Store as ObjectStore};
 use crate::rendering::shader::default::ASSET_LABEL as DEFAULT_SHADER_ASSET_LABEL;
@@ -42,13 +43,17 @@ pub fn add_main_render_passes(
     shader_context: Single<ShaderContext>,
     mut render_passes: Single<RenderPasses>,
     mut object_store: Single<ObjectStore>,
-)
+) -> Result<(), crate::Error>
 {
+    let assets = assets.get()?;
+    let shader_context = shader_context.get()?;
+    let render_passes = render_passes.get_mut()?;
+    let object_store = object_store.get_mut()?;
+
     let Some(default_shader_asset) = assets
         .get_handle_to_loaded::<ShaderModuleSource>(DEFAULT_SHADER_ASSET_LABEL.clone())
     else {
-        tracing::error!("Default shader asset is not loaded");
-        return;
+        return Err(error!("Default shader asset is not loaded"));
     };
 
     let render_pass = render_passes.passes.push_front_mut(RenderPass {
@@ -237,4 +242,6 @@ pub fn add_main_render_passes(
             }
         }
     }
+
+    Ok(())
 }
diff --git a/engine/src/rendering/shader.rs b/engine/src/rendering/shader.rs
index 961bea2..6b68e1e 100644
--- a/engine/src/rendering/shader.rs
+++ b/engine/src/rendering/shader.rs
@@ -1016,14 +1016,27 @@ pub(super) fn prepare(collector: &mut crate::ecs::extension::Collector<'_>)
     );
 }
 
-fn initialize(mut assets: Single<Assets>)
+fn initialize(mut assets: Single<Assets>) -> Result<(), crate::Error>
 {
+    let assets = assets.get_mut()?;
+
     assets.set_importer::<_, _>(["slang"], import_slang_asset);
+
+    Ok(())
 }
 
 #[tracing::instrument(skip_all)]
-fn load_modules(mut context: Single<Context>, assets: Single<Assets>)
+fn load_modules(
+    mut context: Single<Context>,
+    assets: Single<Assets>,
+) -> Result<(), crate::Error>
 {
+    let Ok(context) = context.get_mut() else {
+        unreachable!();
+    };
+
+    let assets = assets.get()?;
+
     for AssetEvent::Stored(asset_id, asset_label) in assets.events().last_tick_events() {
         let asset_handle = AssetHandle::<ModuleSource>::from_id(*asset_id);
 
@@ -1124,6 +1137,8 @@ fn load_modules(mut context: Single<Context>, assets: Single<Assets>)
             );
         }
     }
+
+    Ok(())
 }
 
 fn load_module(
diff --git a/engine/src/rendering/shader/default.rs b/engine/src/rendering/shader/default.rs
index a60fd61..3194706 100644
--- a/engine/src/rendering/shader/default.rs
+++ b/engine/src/rendering/shader/default.rs
@@ -42,9 +42,9 @@ pub static ASSET_LABEL: LazyLock<AssetLabel> = LazyLock::new(|| AssetLabel {
     name: Some("default_shader".into()),
 });
 
-pub fn initialize(mut assets: Single<Assets>)
+pub fn initialize(mut assets: Single<Assets>) -> Result<(), crate::Error>
 {
-    assets.store_with_label(
+    assets.get_mut()?.store_with_label(
         ASSET_LABEL.clone(),
         ShaderModuleSource {
             name: "default_shader.slang".into(),
@@ -54,6 +54,8 @@ pub fn initialize(mut assets: Single<Assets>)
                 | ShaderEntrypointFlags::FRAGMENT,
         },
     );
+
+    Ok(())
 }
 
 pub fn enqueue_set_shader_bindings(
@@ -66,11 +68,15 @@ pub fn enqueue_set_shader_bindings(
     shader_context: Single<ShaderContext>,
     global_light: Single<GlobalLight>,
     mut actions: Actions,
-)
+) -> Result<(), crate::Error>
 {
+    let assets = assets.get()?;
+    let shader_context = shader_context.get()?;
+    let global_light = global_light.get()?;
+
     let Some((camera, camera_world_pos, _)) = camera_query.iter().next() else {
         tracing::trace!("No current camera");
-        return;
+        return Ok(());
     };
 
     let default_shader_asset = assets
@@ -344,6 +350,8 @@ pub fn enqueue_set_shader_bindings(
             actions.add_components(entity_id, (shader_bindings.clone(),));
         }
     }
+
+    Ok(())
 }
 
 fn create_model_matrix(transform: Transform) -> Matrix<f32, 4, 4>
diff --git a/engine/src/ui/imgui.rs b/engine/src/ui/imgui.rs
index 45efc6d..1cb3b98 100644
--- a/engine/src/ui/imgui.rs
+++ b/engine/src/ui/imgui.rs
@@ -170,6 +170,10 @@ fn handle_window_changed(
     mut context: Single<Context>,
 )
 {
+    let Ok(context) = context.get_mut() else {
+        unreachable!();
+    };
+
     let Some(event_match) = observe
         .iter()
         .find(|event_match| event_match.get_entity().has_component(TargetWindow::id()))
@@ -204,16 +208,29 @@ fn update(
     delta_time: Single<DeltaTime>,
     mut assets: Single<Assets>,
     mut render_passes: Single<RenderPasses>,
-    renderer_object_store: Single<RenderingObjectStore>,
+    rendering_object_store: Single<RenderingObjectStore>,
     shader_context: Single<ShaderContext>,
     keyboard: Single<Keyboard>,
     mouse: Single<Mouse>,
     mouse_buttons: Single<MouseButtons>,
     mut state: Local<State>,
-)
+) -> Result<(), crate::Error>
 {
+    let Ok(context) = context.get_mut() else {
+        unreachable!();
+    };
+
+    let delta_time = delta_time.get()?;
+    let assets = assets.get_mut()?;
+    let render_passes = render_passes.get_mut()?;
+    let rendering_object_store = rendering_object_store.get()?;
+    let shader_context = shader_context.get()?;
+    let keyboard = keyboard.get()?;
+    let mouse = mouse.get()?;
+    let mouse_buttons = mouse_buttons.get()?;
+
     let Some((window, window_surface_spec)) = target_window_query.iter().next() else {
-        return;
+        return Ok(());
     };
 
     let curr_state = std::mem::replace(&mut *state, State::Unreachable);
@@ -222,16 +239,16 @@ fn update(
         State::NotInitialized => {
             let Some((font_texture_asset, shader_asset, mesh_obj_id, mesh)) =
                 initialize_context(
-                    &mut context,
+                    context,
                     &window,
                     window_surface_spec.id,
-                    &mut assets,
-                    &mut render_passes,
-                    &shader_context,
+                    assets,
+                    render_passes,
+                    shader_context,
                 )
             else {
                 *state = State::NotInitialized;
-                return;
+                return Ok(());
             };
 
             *state = State::Initializing {
@@ -247,7 +264,7 @@ fn update(
             mesh_obj_id,
             mesh,
         } => {
-            let Some(font_texture_obj) = renderer_object_store
+            let Some(font_texture_obj) = rendering_object_store
                 .get_obj(&RenderingObjectId::Asset(font_texture_asset.id()))
             else {
                 *state = State::Initializing {
@@ -256,7 +273,7 @@ fn update(
                     mesh_obj_id,
                     mesh,
                 };
-                return;
+                return Ok(());
             };
 
             context
@@ -291,7 +308,7 @@ fn update(
                     mesh_obj_id,
                     mesh,
                 };
-                return;
+                return Ok(());
             }
 
             context
@@ -299,12 +316,12 @@ fn update(
                 .get_io_mut()
                 .set_delta_time(delta_time.duration.as_secs_f32());
 
-            update_inputs(&mut context, &window, &keyboard, &mouse, &mouse_buttons);
+            update_inputs(context, &window, keyboard, mouse, mouse_buttons);
 
             add_drawing_render_pass(
-                &mut context,
-                &mut render_passes,
-                &shader_context,
+                context,
+                render_passes,
+                shader_context,
                 window_surface_spec.id,
                 font_texture_asset.clone(),
                 shader_asset.clone(),
@@ -323,6 +340,8 @@ fn update(
         }
         State::Unreachable => unreachable!(),
     }
+
+    Ok(())
 }
 
 #[derive(Debug, Component)]
diff --git a/engine/src/windowing.rs b/engine/src/windowing.rs
index d1eadf7..eae7616 100644
--- a/engine/src/windowing.rs
+++ b/engine/src/windowing.rs
@@ -105,6 +105,10 @@ fn handle_window_creation_ready(
     context: Single<Context>,
 )
 {
+    let Ok(context) = context.get() else {
+        unreachable!();
+    };
+
     for evt_match in &observe {
         let Some(ent) = evt_match.try_get_entity() else {
             unreachable!();
@@ -135,6 +139,14 @@ fn update_stuff(
     entity_obtainer: EntityObtainer,
 ) -> Result<(), EngineError>
 {
+    let Ok(context) = context.get_mut() else {
+        unreachable!();
+    };
+
+    let keyboard = keyboard.get_mut()?;
+    let mouse = mouse.get_mut()?;
+    let mouse_buttons = mouse_buttons.get_mut()?;
+
     if context.display_handle.is_none() {
         cold_path();
         actions.stop();
@@ -296,6 +308,10 @@ fn handle_window_changed(
     context: Single<Context>,
 )
 {
+    let Ok(context) = context.get() else {
+        unreachable!();
+    };
+
     for evt_match in &observe {
         let window_ent_id = evt_match.entity_id();
 
@@ -330,6 +346,10 @@ fn handle_window_removed(
     mut actions: Actions,
 )
 {
+    let Ok(context) = context.get_mut() else {
+        unreachable!();
+    };
+
     for evt_match in &observe {
         let window = evt_match.get_ent_target_comp();