add label rendering for planetary bodies

1 files changed, 54 insertions, 41 deletions

diff --git a/src/tacmap.rs b/src/tacmap.rs
index de2ddcd..461d819 100644
--- a/src/tacmap.rs
+++ b/src/tacmap.rs
@@ -1,24 +1,16 @@
 pub mod camera;
 pub mod render;
 
-mod tacmap {
-    pub use super::render;
-    pub use super::camera;
-}
-
-use std::cell::RefCell;
 use std::time::Duration;
 
+use cgmath::InnerSpace;
 use winit::event::ElementState;
 use winit::keyboard::KeyCode;
 
-use crate::GameState;
-use crate::canvas::Canvas;
 use crate::solar_system::SolarSystem;
 use crate::solar_system::SystemId;
 use crate::timeman::TimeMan;
 use crate::ui;
-use crate::wgpuctx::RenderPassBuilder;
 use crate::wgpuctx::SceneCtx;
 use crate::wgpuctx::WgpuCtx;
 use render::*;
@@ -26,7 +18,6 @@ use camera::*;
 
 pub struct TacticalMap
 {
-    canvas: Canvas,
     camera: Camera,
     pmatrix: Projection,
  
@@ -40,21 +31,12 @@ pub struct TacticalMap
 
 impl TacticalMap
 {
-    pub fn new(
-        wgpuctx: &WgpuCtx,
-        position: winit::dpi::LogicalPosition<f32>,
-        size: winit::dpi::LogicalSize<f32>)
+    pub fn new(wgpuctx: &WgpuCtx)
     -> Self {
         let surface_size = winit::dpi::PhysicalSize::new(
             wgpuctx.surface_config().width,
             wgpuctx.surface_config().height
         );
-
-        let canvas = Canvas::new(
-            wgpuctx,
-            surface_size,
-            position,
-            size).unwrap();
     
         let camera = Camera::new(
             wgpuctx,
@@ -69,7 +51,6 @@ impl TacticalMap
             (0.01, 1000.0));
 
         Self {
-            canvas: canvas,
             camera: camera,
             pmatrix: projection,
             camera_controller: CameraController::new(),
@@ -83,11 +64,9 @@ impl TacticalMap
 
     pub fn resize(
         &mut self,
-        wgpuctx: &WgpuCtx,
         width: u32,
         height: u32)
     {
-        self.canvas.resize(wgpuctx, width, height);
         self.pmatrix.resize(width, height);
     }
 
@@ -142,29 +121,63 @@ impl TacticalMap
             Err(e) => println!("Tactical map render update error: {}", e)
         }
 
-        let mut scene = SceneCtx::from_view_default(wgpuctx, self.canvas.view(), Some("Tactical map scene"));
-        let pass_builder = RenderPassBuilder::new(Some("Tactical map render pass"), scene.view())
-            .clear_color(wgpu::Color { r: 0.0, g: 0.0, b: 0.1, a: 1.0 });
+        Ok(())
+    }
 
+    pub fn prepare(
+        &self,
+        scene: &mut SceneCtx)
+    {
         self.camera.stage_changes(scene.encoder_mut());
-        {
-            let mut pass = pass_builder.build_from_scene(&mut scene);
-
-            self.grid_renderer.render(&mut pass, &self.camera);
-            self.orbit_renderer.render(&mut pass, &self.camera);
-            self.body_renderer.render(&mut pass, &self.camera);
-        }
+    }
 
-        scene.submit(wgpuctx);
-        Ok(())
+    pub fn paint(
+        &self,
+        pass: &mut wgpu::RenderPass<'_>)
+    {
+        self.grid_renderer.render( pass, &self.camera);
+        self.orbit_renderer.render(pass, &self.camera);
+        self.body_renderer.render( pass, &self.camera);
     }
 
-    pub fn present(
-        &mut self,
-        screen_pass: &mut wgpu::RenderPass)
-    -> Result<(), wgpu::SurfaceError>
+    pub fn paint_labels(
+        &self,
+        solar_system: &SolarSystem,
+        screen_size: egui::Vec2,
+        ui: &mut egui::Ui)
     {
-        self.canvas.present(screen_pass)?;
-        Ok(())
+        let view_matrix = self.camera.view_matrix();
+        let proj_matrix = self.pmatrix.projection_matrix();
+        let pv_matrix = proj_matrix * view_matrix;
+
+        //Paint body labels
+        let bodies = solar_system.bodies();
+        bodies.iter().for_each(|body| {
+            let scaled_radius = (2.0 * body.radius() * self.camera.get_scale()).max(16.0);
+
+            let world_pos = solar_system.body_position(body);
+            let local_pos = world_pos - self.camera.get_abs_position();
+            
+            let relative_pos = body.position() * self.camera.get_scale() as f64;
+            if relative_pos.magnitude() < 0.05 && relative_pos.magnitude() != 0.0
+                { return; }
+
+            let scaled_pos = local_pos * self.camera.get_scale() as f64;
+
+            let clip_pos = pv_matrix * scaled_pos.map(|v| { v as f32 }).extend(1.0);
+            let ndc_pos = clip_pos.truncate() / clip_pos.w;
+
+            let screen_pos = egui::pos2(
+                ((ndc_pos.x + 1.0) * 0.5) * screen_size.x,
+                (((-ndc_pos.y + 1.0) * 0.5) * screen_size.y) + scaled_radius);
+            if clip_pos.z < 0.0 { return; }
+
+            ui.put(
+                egui::Rect::from_pos(screen_pos).expand(64.0), 
+                egui::Label::new(
+                    egui::RichText::new(body.name())
+                        .color(egui::Color32::WHITE)
+                    ).selectable(false).sense(egui::Sense::empty()));
+        });
     }
 } // impl SystemViewport