multithreaded world loading

1 files changed, 33 insertions, 12 deletions

diff --git a/client/src/state.rs b/client/src/state.rs
index 00a8c0b..cd11d4a 100644
--- a/client/src/state.rs
+++ b/client/src/state.rs
@@ -18,17 +18,26 @@ use crate::{camera::Camera, download::Downloader, network::Network, renderer::Re
 use anyhow::{Context, Result};
 use glam::{Vec2, Vec3};
 use log::{info, warn};
-use std::{net::TcpStream, time::Instant};
-use weareshared::{store::ResourceStore, tree::SceneTree};
+use std::{net::TcpStream, sync::Arc, time::Instant};
+use weareshared::{
+    packets::{Packet, Resource},
+    resources::PrefabIndex,
+    store::ResourceStore,
+    tree::SceneTree,
+};
 use winit::event::MouseButton;
 
 pub struct State<'a> {
-    pub network: Network,
-    pub downloader: Downloader,
+    pub network: Arc<Network>,
+    pub downloader: Arc<Downloader>,
     pub renderer: Renderer<'a>,
     pub tree: SceneTree,
     pub camera: Camera,
     pub delta: DeltaState,
+
+    pub prefab_index: PrefabIndex,
+    pub prefab_index_res_loaded: Option<Resource<PrefabIndex>>,
+    pub prefab_index_res: Option<Resource<PrefabIndex>>,
 }
 
 pub struct DeltaState {
@@ -41,18 +50,22 @@ pub struct DeltaState {
 impl<'a> State<'a> {
     pub fn new(conn: TcpStream, window: &'a winit::window::Window) -> Result<State<'a>> {
         info!("new state");
+        let downloader = Arc::new(Downloader::new(ResourceStore::new_memory()));
         Ok(Self {
             camera: Camera::new(),
-            network: Network::new(conn),
+            network: Network::new(conn).into(),
             tree: SceneTree::default(),
-            renderer: Renderer::new(window)?,
-            downloader: Downloader::new(ResourceStore::new_memory()),
+            renderer: Renderer::new(window, downloader.clone())?,
+            downloader,
             delta: DeltaState {
                 time: Instant::now(),
                 move_dir: Vec3::ZERO,
                 mouse_acc: Vec2::ZERO,
                 cursor_pos: Vec2::ZERO,
             },
+            prefab_index_res: None,
+            prefab_index_res_loaded: None,
+            prefab_index: PrefabIndex::default(),
         })
     }
     pub fn draw(&mut self) {
@@ -92,15 +105,23 @@ impl<'a> State<'a> {
         for p in self.network.packet_recv.try_iter() {
             self.downloader.packet(&p)?;
             self.tree.packet(&p);
+            if let Packet::PrefabIndex(res) = &p {
+                self.prefab_index_res = Some(res.to_owned());
+            }
         }
         self.downloader
-            .update(&mut self.network)
+            .update(&self.network)
             .context("downloader state")?;
-        self.renderer
-            .scene_prepare
-            .update(&mut self.downloader)
-            .context("scene preparation")?;
 
+        if self.prefab_index_res != self.prefab_index_res_loaded {
+            if let Some(res) = &self.prefab_index_res {
+                if let Some(index) = self.downloader.try_get(res.to_owned())? {
+                    info!("prefab index loaded");
+                    self.prefab_index = index;
+                    self.prefab_index_res_loaded = Some(res.to_owned());
+                }
+            }
+        }
         Ok(())
     }
 }