1 files changed, 33 insertions, 13 deletions

diff --git a/src/tacmap.rs b/src/tacmap.rs
index cd9d878..9ff69f6 100644
--- a/src/tacmap.rs
+++ b/src/tacmap.rs
@@ -1,6 +1,7 @@
 pub mod camera;
 mod render;
 mod body_render; 
+mod fleet_render;
 mod orbit_render;
 
 use std::time::Duration;
@@ -9,14 +10,18 @@ use cgmath::InnerSpace;
 use winit::event::ElementState;
 use winit::keyboard::KeyCode;
 
+use crate::fleet::FleetsManager;
 use crate::solar_system::SolarSystem;
 use crate::solar_system::SystemId;
+use crate::timeman::Second;
 use crate::timeman::TimeMan;
 use crate::ui;
 use crate::wgpuctx::SceneCtx;
 use crate::wgpuctx::WgpuCtx;
+
 use render::*;
 use body_render::*;
+use fleet_render::*;
 use orbit_render::*;
 use camera::*;
 
@@ -29,6 +34,7 @@ pub struct TacticalMap
 
     system_for_render: Option<SystemId>,
     body_renderer: BodyRenderer,
+    fleet_renderer: FleetRenderer,
     grid_renderer: GridRenderer,
     orbit_renderer: OrbitRenderer
 }
@@ -61,6 +67,7 @@ impl TacticalMap
 
             system_for_render: None,
             body_renderer: BodyRenderer::new(wgpuctx),
+            fleet_renderer: FleetRenderer::new(wgpuctx),
             grid_renderer: GridRenderer::new(wgpuctx),
             orbit_renderer: OrbitRenderer::new(wgpuctx),
         }
@@ -78,11 +85,12 @@ impl TacticalMap
         &mut self,
         solar_system: &SolarSystem,
         ui_state: &mut ui::State,
+        time: Second,
         dt: Duration)
     {
         self.camera.set_target(ui_state.camera_target);
 
-        self.camera_controller.update(&mut self.camera, solar_system, ui_state, dt);
+        self.camera_controller.update(&mut self.camera, solar_system, ui_state, time, dt);
     }
 
     pub fn keyboard_input(
@@ -96,6 +104,7 @@ impl TacticalMap
     pub fn draw(
         &mut self,
         wgpuctx: &WgpuCtx,
+        fleets_manager: &FleetsManager,
         solar_system: &SolarSystem,
         timeman: &TimeMan,
     ) -> Result<(), wgpu::SurfaceError>
@@ -126,6 +135,16 @@ impl TacticalMap
             Err(e) => println!("Tactical map body render update error: {}", e)
         }
 
+        match self.fleet_renderer.update(
+            wgpuctx,
+            fleets_manager,
+            solar_system, 
+            timeman.seconds())
+        {
+            Ok(()) => {},
+            Err(e) => println!("Tactical map fleet render update error: {}", e)
+        }
+
         Ok(())
     }
 
@@ -142,12 +161,14 @@ impl TacticalMap
     {
         self.grid_renderer.render( pass, &self.camera);
         self.orbit_renderer.render(pass, &self.camera);
+        self.fleet_renderer.render(pass, &self.camera);
         self.body_renderer.render( pass, &self.camera);
     }
 
     pub fn paint_labels(
         &self,
         solar_system: &SolarSystem,
+        time: Second,
         screen_size: egui::Vec2,
         ui: &mut egui::Ui)
     {
@@ -160,28 +181,27 @@ impl TacticalMap
         bodies.iter().for_each(|body| {
             let scaled_radius = (screen_size.y * 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_combined_position();
-            
+            let offset_pos = body.relative_position(time);
             let origin_pos = match body.get_orbit() {
                 Some(orbit) => {
-                    solar_system.body_position(&bodies[orbit.parent()])
+                    solar_system.body_position(&bodies[orbit.parent()], time)
                 },
                 None => cgmath::vec3(0.0, 0.0, 0.0)
             };
-            let origin_local_pos = origin_pos - self.camera.get_origin_position();
+            let origin_local_pos = origin_pos - self.camera.get_combined_position();
 
-            let scaled_pos = local_pos * self.camera.get_scale() as f64;
-            let scaled_origin_pos = origin_local_pos * self.camera.get_scale() as f64;
+            let offset_pos_scaled = offset_pos * self.camera.get_scale() as f64;
+            let origin_pos_scaled = origin_local_pos * self.camera.get_scale() as f64;
 
-            let clip_pos = pv_matrix * scaled_pos.map(|v| { v as f32 }).extend(1.0);
-            let origin_clip_pos = pv_matrix * scaled_origin_pos.map(|v| { v as f32 }).extend(1.0);
+            let origin_clip_pos = pv_matrix * origin_pos_scaled.map(|v| { v as f32 }).extend(1.0);
+            let offset_clip_pos = pv_matrix * offset_pos_scaled.map(|v| { v as f32}).extend(0.0);
+            let clip_pos = origin_clip_pos + offset_clip_pos;
 
             let ndc_pos = clip_pos.truncate() / clip_pos.w;
-            let origin_ndc_pos = origin_clip_pos.truncate() / origin_clip_pos.w;
+            let offset_ndc = offset_clip_pos.truncate() / origin_clip_pos.w;
 
-            if (ndc_pos - origin_ndc_pos).magnitude() < 0.05 {
-                if ndc_pos != origin_ndc_pos {
+            if offset_ndc.truncate().magnitude() < 0.1 {
+                if offset_pos != cgmath::vec3(0.0, 0.0, 0.0) {
                     return;
                 }
             }