update packages to latest versionsHEADmain

1 files changed, 52 insertions, 29 deletions

diff --git a/src/tacmap/orbit_render.rs b/src/tacmap/orbit_render.rs
index 7c0a089..32c0abb 100644
--- a/src/tacmap/orbit_render.rs
+++ b/src/tacmap/orbit_render.rs
@@ -2,6 +2,7 @@ use std::error::Error;
 
 use super::*;
 
+use crate::fleet::FleetId;
 use crate::solar_system::body::{BodyId, OrbitalBody};
 use crate::solar_system::orbit::StaticOrbiter;
 use crate::timeman::{self, Second};
@@ -10,12 +11,15 @@ use crate::wgpuctx::{WgpuCtx, pipeline::RenderPipelineBuilder};
 pub struct OrbitRenderer
 {
     needs_rebuild: bool,
-    last_tick: Option<Second>,
+    last_time: Option<Second>,
 
     pipeline: wgpu::RenderPipeline,
 
-    orbit_vertex_buffers: Option<Vec<(BodyId, wgpu::Buffer)>>,
+    body_orbit_vertex_buffers: Option<Vec<(BodyId, wgpu::Buffer)>>,
+    fleet_orbit_vertex_buffers: Option<Vec<(FleetId, wgpu::Buffer)>>,
+
     origin_buffer: Option<wgpu::Buffer>,
+
     origin_bind_group: Option<wgpu::BindGroup>,
     origin_bind_group_layout: wgpu::BindGroupLayout
 }
@@ -59,9 +63,12 @@ impl OrbitRenderer
 
         Self {
             needs_rebuild: true,
-            last_tick: None,
+            last_time: None,
             pipeline: render_pipeline,
-            orbit_vertex_buffers: None,
+
+            body_orbit_vertex_buffers: None,
+            fleet_orbit_vertex_buffers: None,
+
             origin_buffer: None,
             origin_bind_group: None,
             origin_bind_group_layout: origin_bind_group_layout
@@ -123,19 +130,23 @@ impl OrbitRenderer
         wgpuctx: &WgpuCtx,
         solar_system: &SolarSystem)
     {
-        if self.orbit_vertex_buffers.is_some() && !self.needs_rebuild {
+        if self.body_orbit_vertex_buffers.is_some() && !self.needs_rebuild {
             return;
         }
         self.needs_rebuild = false;
 
-        match &self.orbit_vertex_buffers {
-            Some(buffers) => {
-                for buffer in buffers {
-                    buffer.1.destroy();
-                }
-                self.orbit_vertex_buffers = None;
-            },
-            None => {}
+        if let Some(buffers) = &self.body_orbit_vertex_buffers {
+            for buffer in buffers {
+                buffer.1.destroy();
+            }
+            self.body_orbit_vertex_buffers = None;
+        };
+
+        if let Some(buffers) = &self.fleet_orbit_vertex_buffers {
+            for buffer in buffers {
+                buffer.1.destroy();
+            }
+            self.fleet_orbit_vertex_buffers = None;
         };
 
         //From the solar system's bodies, calculate the orbits.
@@ -171,7 +182,7 @@ impl OrbitRenderer
         ));
         self.origin_buffer = Some(origin_buffer);
 
-        self.orbit_vertex_buffers = Some(bodies.iter().filter_map(|body| {
+        self.body_orbit_vertex_buffers = Some(bodies.iter().filter_map(|body| {
             self.create_orbit_buffer(wgpuctx, body, 0)
         }).collect::<Vec<_>>());
     }
@@ -179,16 +190,29 @@ impl OrbitRenderer
     pub fn update(
         &mut self,
         wgpuctx: &WgpuCtx,
+        fleets_man: &FleetsManager,
         solar_system: &SolarSystem,
         time: Second)
     -> Result<(), Box<dyn Error>>
     {
-        let tick = time / OrbitalBody::TICK_DURATION;
-        if self.last_tick.is_some_and(|t| { t == tick }) {
+        if self.last_time.is_some_and(|t| { t == time }) {
             return Ok(());
         }
+
+        self.fleet_orbit_vertex_buffers =
+            Some(fleets_man.all_in_system(solar_system.id()).iter().filter_map(|id| {
+            let fleet = fleets_man.entry(*id).unwrap();
+            self.create_orbit_buffer(wgpuctx, fleet, time)
+        }).collect::<Vec<_>>());
         
-        self.last_tick = Some(time);
+        let body_tick = time / OrbitalBody::TICK_DURATION;
+        let last_body_tick = self.last_time.unwrap_or(i64::MAX) / OrbitalBody::TICK_DURATION;
+        self.last_time = Some(time);
+
+        if body_tick == last_body_tick {
+            return Ok(());
+        }
+
         let positions = solar_system.bodies().iter().map(|body| {
             let pos = solar_system.body_position(body, time);
             [ pos.x as f32, pos.y as f32, pos.z as f32 ]
@@ -201,10 +225,6 @@ impl OrbitRenderer
             None => { return Err(Box::new(NeedsRebuildError)); }
         };
 
-        //let bodies = solar_system.bodies();
-        /*self.orbit_vertex_buffers = Some(bodies.iter().map(|body| {
-            self.create_orbit_buffer_for_body(wgpuctx, body, tick_time)
-        }).collect::<Vec<_>>());*/
         Ok(())
     }
 
@@ -213,11 +233,6 @@ impl OrbitRenderer
         pass: &mut wgpu::RenderPass,
         camera: &Camera)
     {
-        let buffers = match &self.orbit_vertex_buffers {
-            Some(v) => v,
-            None => return
-        };
-
         pass.set_pipeline(&self.pipeline);
         pass.set_bind_group(0, camera.bindgroup(), &[]);
 
@@ -226,9 +241,17 @@ impl OrbitRenderer
             None => { return; }
         }
 
-        for (num_points, buffer) in buffers {
-            pass.set_vertex_buffer(0, buffer.slice(..));
-            pass.draw(0..(*num_points as u32), 0..1);
+        if let Some(body_buffers) = &self.body_orbit_vertex_buffers {
+            for (num_points, buffer) in body_buffers {
+                pass.set_vertex_buffer(0, buffer.slice(..));
+                pass.draw(0..(*num_points as u32), 0..1);
+            }
+        }
+        if let Some(fleet_buffers) = &self.fleet_orbit_vertex_buffers {
+            for (num_points, buffer) in fleet_buffers {
+                pass.set_vertex_buffer(0, buffer.slice(..));
+                pass.draw(0..(*num_points as u32), 0..1);
+            }
         }
     }
 }