unprojecting to ui surf is hard

1 files changed, 46 insertions, 17 deletions

diff --git a/client/src/state.rs b/client/src/state.rs
index cd11d4a..5176ca1 100644
--- a/client/src/state.rs
+++ b/client/src/state.rs
@@ -33,18 +33,19 @@ pub struct State<'a> {
     pub renderer: Renderer<'a>,
     pub tree: SceneTree,
     pub camera: Camera,
-    pub delta: DeltaState,
+    pub input_state: InputState,
 
-    pub prefab_index: PrefabIndex,
+    pub prefab_index: Arc<PrefabIndex>,
     pub prefab_index_res_loaded: Option<Resource<PrefabIndex>>,
     pub prefab_index_res: Option<Resource<PrefabIndex>>,
 }
 
-pub struct DeltaState {
+pub struct InputState {
     time: Instant,
     pub move_dir: Vec3,
     pub mouse_acc: Vec2,
     pub cursor_pos: Vec2,
+    pub egui_events: Vec<egui::Event>,
 }
 
 impl<'a> State<'a> {
@@ -57,19 +58,23 @@ impl<'a> State<'a> {
             tree: SceneTree::default(),
             renderer: Renderer::new(window, downloader.clone())?,
             downloader,
-            delta: DeltaState {
+            input_state: InputState {
                 time: Instant::now(),
                 move_dir: Vec3::ZERO,
                 mouse_acc: Vec2::ZERO,
                 cursor_pos: Vec2::ZERO,
+                egui_events: Vec::new(),
             },
             prefab_index_res: None,
             prefab_index_res_loaded: None,
-            prefab_index: PrefabIndex::default(),
+            prefab_index: PrefabIndex::default().into(),
         })
     }
     pub fn draw(&mut self) {
-        if let Err(e) = self.renderer.draw(&self.tree, &self.camera) {
+        if let Err(e) = self
+            .renderer
+            .draw(&self.tree, &self.camera, &self.input_state)
+        {
             warn!("draw failed: {e:?}");
         }
     }
@@ -78,29 +83,51 @@ impl<'a> State<'a> {
         self.camera.aspect = width as f32 / height as f32;
     }
     pub fn click(&mut self, button: MouseButton, down: bool) {
+        self.input_state
+            .egui_events
+            .push(egui::Event::PointerButton {
+                pos: egui::Pos2::new(self.input_state.cursor_pos.x, self.input_state.cursor_pos.y),
+                button: match button {
+                    MouseButton::Left => egui::PointerButton::Primary,
+                    MouseButton::Right => egui::PointerButton::Secondary,
+                    MouseButton::Middle => egui::PointerButton::Middle,
+                    MouseButton::Back => egui::PointerButton::Extra1,
+                    MouseButton::Forward => egui::PointerButton::Extra2,
+                    MouseButton::Other(_) => egui::PointerButton::Extra1,
+                },
+                pressed: down,
+                modifiers: egui::Modifiers::default(),
+            });
+
         if !down || button != MouseButton::Right {
             return;
         }
+        let pi = self.prefab_index.clone();
         self.renderer
             .ui_renderer
-            .add_surface(self.camera.new_ui_affine(), |ctx| {
-                egui::Window::new("Funny window")
-                    .default_open(true)
+            .add_surface(self.camera.new_ui_affine(), move |ctx| {
+                let mut open = true;
+                egui::Window::new("Prefab Index")
+                    .open(&mut open)
                     .show(ctx, |ui| {
-                        ui.label("world space ui actually kinda works now");
-                        ui.label("Does input work?");
-                        ui.button("Yes").clicked();
+                        for (key, _res) in &pi.0 {
+                            ui.horizontal(|ui| {
+                                ui.label(key);
+                                if ui.button("Add").clicked() {}
+                            });
+                        }
                     });
+                open
             });
     }
     pub fn update(&mut self) -> Result<()> {
         let now = Instant::now();
-        let dt = (now - self.delta.time).as_secs_f32();
-        self.delta.time = now;
+        let dt = (now - self.input_state.time).as_secs_f32();
+        self.input_state.time = now;
 
         self.camera
-            .update(self.delta.move_dir, self.delta.mouse_acc, dt);
-        self.delta.mouse_acc = Vec2::ZERO;
+            .update(self.input_state.move_dir, self.input_state.mouse_acc, dt);
+        self.input_state.mouse_acc = Vec2::ZERO;
 
         for p in self.network.packet_recv.try_iter() {
             self.downloader.packet(&p)?;
@@ -117,11 +144,13 @@ impl<'a> State<'a> {
             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 = index.into();
                     self.prefab_index_res_loaded = Some(res.to_owned());
                 }
             }
         }
+
+        self.input_state.egui_events.clear();
         Ok(())
     }
 }