From 961f8c6d405c9c6fcf9aaf4fb6f199b0e5c60d88 Mon Sep 17 00:00:00 2001
From: Jon Santmyer <jon@jonsantmyer.com>
Date: Thu, 30 Apr 2026 10:06:32 -0400
Subject: add orbit rendering for bodies

---
 src/tacmap.rs | 71 +++++++++++++++++++++++++++--------------------------------
 1 file changed, 32 insertions(+), 39 deletions(-)

(limited to 'src/tacmap.rs')

diff --git a/src/tacmap.rs b/src/tacmap.rs
index abae50e..de2ddcd 100644
--- a/src/tacmap.rs
+++ b/src/tacmap.rs
@@ -16,6 +16,7 @@ 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;
@@ -30,8 +31,11 @@ pub struct TacticalMap
     pmatrix: Projection,
  
     camera_controller: CameraController,
-    body_renderer: Option<(SystemId, BodyRenderer)>,
-    grid_renderer: GridRenderer
+
+    system_for_render: Option<SystemId>,
+    body_renderer: BodyRenderer,
+    grid_renderer: GridRenderer,
+    orbit_renderer: OrbitRenderer
 }
 
 impl TacticalMap
@@ -69,8 +73,11 @@ impl TacticalMap
             camera: camera,
             pmatrix: projection,
             camera_controller: CameraController::new(),
-            body_renderer: None,
-            grid_renderer: GridRenderer::new(wgpuctx)
+
+            system_for_render: None,
+            body_renderer: BodyRenderer::new(wgpuctx),
+            grid_renderer: GridRenderer::new(wgpuctx),
+            orbit_renderer: OrbitRenderer::new(wgpuctx),
         }
     }
 
@@ -86,7 +93,7 @@ impl TacticalMap
 
     pub fn update(
         &mut self,
-        game_state: &RefCell<GameState>,
+        solar_system: &SolarSystem,
         ui_state: &mut ui::State,
         dt: Duration)
     {
@@ -95,12 +102,11 @@ impl TacticalMap
         ui_state.camera_info.camera_rot = Some(self.camera.get_rotation());
         self.camera.set_target(ui_state.camera_info.target);
 
-        self.camera_controller.update(&mut self.camera, game_state, ui_state, dt);
+        self.camera_controller.update(&mut self.camera, solar_system, ui_state, dt);
     }
 
     pub fn keyboard_input(
         &mut self,
-        game_state: &RefCell<GameState>,
         key_code: KeyCode,
         key_state: ElementState)
     {
@@ -110,41 +116,27 @@ impl TacticalMap
     pub fn draw(
         &mut self,
         wgpuctx: &WgpuCtx,
-        game_state: &RefCell<GameState>,
-        current_system: Option<SystemId>)
-    -> Result<(), wgpu::SurfaceError>
+        solar_system: &SolarSystem,
+        timeman: &TimeMan,
+    ) -> Result<(), wgpu::SurfaceError>
     {
-        let game_state = game_state.borrow();
-
-        let current_system_id = match current_system {
-            Some(system) => system,
-            None => return Ok(())
-        };
-        let solar_systems = game_state.solar_systems();
-        let current_system = &solar_systems[current_system_id];
-
         self.camera.update_buffer(wgpuctx, &self.pmatrix);
+        
+        if self.system_for_render.is_none() 
+            || self.system_for_render.unwrap() != solar_system.id() {
 
-        let body_renderer = match &mut self.body_renderer {
-            Some((id, render)) => {
-                if *id != current_system_id {
-                    *id = current_system_id;
-                    render.mark_to_rebuild();
-                }
-                render
-            },
-            None => {
-                let tmp = render::BodyRenderer::new(wgpuctx);
-                self.body_renderer = Some((current_system_id, tmp));
-                &mut self.body_renderer.as_mut().unwrap().1
-            }
-        };
+                self.body_renderer.mark_to_rebuild();
+                self.orbit_renderer.mark_to_rebuild();
+        }
+        self.system_for_render = Some(solar_system.id());
 
         //Update buffers for the current system and time.
-        body_renderer.rebuild(wgpuctx, current_system);
-        match body_renderer.update(
-            wgpuctx, current_system, &self.camera,
-            game_state.timeman().seconds())
+        self.body_renderer.rebuild(wgpuctx, solar_system);
+        self.orbit_renderer.rebuild(wgpuctx, solar_system);
+
+        self.orbit_renderer.update(wgpuctx, solar_system, timeman.seconds());
+        match self.body_renderer.update(
+            wgpuctx, solar_system, timeman.seconds())
         {
             Ok(()) => {},
             Err(e) => println!("Tactical map render update error: {}", e)
@@ -158,8 +150,9 @@ impl TacticalMap
         {
             let mut pass = pass_builder.build_from_scene(&mut scene);
 
-            self.grid_renderer.render(wgpuctx, &mut pass, &self.camera);
-            body_renderer.render(wgpuctx, &mut pass, &self.camera);
+            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);
-- 
cgit v1.2.3