1 files changed, 29 insertions, 41 deletions

diff --git a/src/tacmap/orbit_render.rs b/src/tacmap/orbit_render.rs
index c003366..7c0a089 100644
--- a/src/tacmap/orbit_render.rs
+++ b/src/tacmap/orbit_render.rs
@@ -3,17 +3,18 @@ use std::error::Error;
 use super::*;
 
 use crate::solar_system::body::{BodyId, OrbitalBody};
-use crate::timeman::{SYSTEM_TICK_INTERVAL, Second};
+use crate::solar_system::orbit::StaticOrbiter;
+use crate::timeman::{self, Second};
 use crate::wgpuctx::{WgpuCtx, pipeline::RenderPipelineBuilder};
 
 pub struct OrbitRenderer
 {
     needs_rebuild: bool,
-    last_time: Option<Second>,
+    last_tick: Option<Second>,
 
     pipeline: wgpu::RenderPipeline,
 
-    orbit_vertex_buffers: Option<Vec<(BodyId, Option<wgpu::Buffer>)>>,
+    orbit_vertex_buffers: Option<Vec<(BodyId, wgpu::Buffer)>>,
     origin_buffer: Option<wgpu::Buffer>,
     origin_bind_group: Option<wgpu::BindGroup>,
     origin_bind_group_layout: wgpu::BindGroupLayout
@@ -58,7 +59,7 @@ impl OrbitRenderer
 
         Self {
             needs_rebuild: true,
-            last_time: None,
+            last_tick: None,
             pipeline: render_pipeline,
             orbit_vertex_buffers: None,
             origin_buffer: None,
@@ -70,28 +71,29 @@ impl OrbitRenderer
     pub fn mark_to_rebuild(&mut self)
     { self.needs_rebuild = true; }
 
-    fn create_orbit_buffer_for_body(
+    fn create_orbit_buffer<T: StaticOrbiter>(
         &self,
         wgpuctx: &WgpuCtx,
-        body: &OrbitalBody,
+        orbiter: &T,
         time: Second)
-    -> (usize, Option<wgpu::Buffer>)
+    -> Option<(usize, wgpu::Buffer)>
     {
-        let orbit = match body.get_orbit() {
+        let orbit = match orbiter.orbit() {
             Some(orbit) => orbit,
-            None => return (0, None)
+            None => { return None; }
         };
 
-        let period = body.orbital_period();
+        let period = orbit.period(orbiter);
 
-        let num_points = ((period / (SYSTEM_TICK_INTERVAL)) as usize).clamp(90, 360);
+        let num_points = ((period / timeman::HOUR) as usize).clamp(90, 360);
         let period_interval = period as f64 / num_points as f64;
 
         let mut points = vec![
             OrbitVertex::default();(num_points+1)*2];
 
         for i in 0..num_points {
-            let position = body.calculate_orbit_at(
+            let position = orbit.calculate_position_at(
+                orbiter,
                 time + (i as f64 * period_interval) as Second);
 
             points[i*2].origin_id = orbit.parent() as _;
@@ -113,7 +115,7 @@ impl OrbitRenderer
                 contents: bytemuck::cast_slice(&points)
             }
         );
-        ((num_points+1)*2, Some(buffer))
+        Some(((num_points+1)*2, buffer))
     }
 
     pub fn rebuild(
@@ -129,10 +131,7 @@ impl OrbitRenderer
         match &self.orbit_vertex_buffers {
             Some(buffers) => {
                 for buffer in buffers {
-                    match &buffer.1 {
-                        Some(v) => v.destroy(),
-                        None => {}
-                    }
+                    buffer.1.destroy();
                 }
                 self.orbit_vertex_buffers = None;
             },
@@ -171,6 +170,10 @@ impl OrbitRenderer
             }
         ));
         self.origin_buffer = Some(origin_buffer);
+
+        self.orbit_vertex_buffers = Some(bodies.iter().filter_map(|body| {
+            self.create_orbit_buffer(wgpuctx, body, 0)
+        }).collect::<Vec<_>>());
     }
 
     pub fn update(
@@ -180,24 +183,14 @@ impl OrbitRenderer
         time: Second)
     -> Result<(), Box<dyn Error>>
     {
-        if self.last_time.is_some_and(|t| { t == time }) {
+        let tick = time / OrbitalBody::TICK_DURATION;
+        if self.last_tick.is_some_and(|t| { t == tick }) {
             return Ok(());
         }
-
-        let tick_time = match self.last_time {
-            Some(last_time) => {
-                let this_tick = time / SYSTEM_TICK_INTERVAL;
-                let last_tick = last_time / SYSTEM_TICK_INTERVAL;
-
-                if this_tick == last_tick { return Ok(()) }
-                this_tick * SYSTEM_TICK_INTERVAL
-            }
-            None => 0
-        };
         
-        self.last_time = Some(time);
+        self.last_tick = Some(time);
         let positions = solar_system.bodies().iter().map(|body| {
-            let pos = solar_system.body_position(body);
+            let pos = solar_system.body_position(body, time);
             [ pos.x as f32, pos.y as f32, pos.z as f32 ]
         }).collect::<Vec<_>>();
 
@@ -208,10 +201,10 @@ impl OrbitRenderer
             None => { return Err(Box::new(NeedsRebuildError)); }
         };
 
-        let bodies = solar_system.bodies();
-        self.orbit_vertex_buffers = Some(bodies.iter().map(|body| {
+        //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<_>>());
+        }).collect::<Vec<_>>());*/
         Ok(())
     }
 
@@ -234,13 +227,8 @@ impl OrbitRenderer
         }
 
         for (num_points, buffer) in buffers {
-            match &buffer {
-                Some(buffer) => {
-                    pass.set_vertex_buffer(0, buffer.slice(..));
-                    pass.draw(0..(*num_points as u32), 0..1);
-                },
-                None => {}
-            }
+            pass.set_vertex_buffer(0, buffer.slice(..));
+            pass.draw(0..(*num_points as u32), 0..1);
         }
     }
 }