From b5ced3af46c96ceb959fbbf1addfeba3bd4f76d5 Mon Sep 17 00:00:00 2001
From: Jon Santmyer <jon@jonsantmyer.com>
Date: Wed, 15 Apr 2026 16:53:58 -0400
Subject: first commit. working body rendering

---
 src/tacmap.rs | 158 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 158 insertions(+)
 create mode 100644 src/tacmap.rs

(limited to 'src/tacmap.rs')

diff --git a/src/tacmap.rs b/src/tacmap.rs
new file mode 100644
index 0000000..89d21aa
--- /dev/null
+++ b/src/tacmap.rs
@@ -0,0 +1,158 @@
+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 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::wgpuctx::WgpuCtx;
+use render::*;
+use camera::*;
+use crate::window::ui::GameWindowUiState;
+
+pub struct TacticalMap
+{
+    canvas: Canvas,
+    camera: Camera,
+    pmatrix: Projection,
+ 
+    camera_controller: CameraController,
+    renderstate: Option<(SystemId, BodyRenderer)>
+}
+
+impl TacticalMap
+{
+    pub fn new(
+        wgpuctx: &WgpuCtx,
+        position: winit::dpi::LogicalPosition<f32>,
+        size: winit::dpi::LogicalSize<f32>)
+    -> 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,
+            cgmath::Point3::<f32>::new(0.0, 0.0, 1.0),
+            cgmath::Deg(-90.0),
+            cgmath::Rad(0.0));
+
+        let projection = Projection::new(
+            surface_size.width,
+            surface_size.height,
+            cgmath::Deg(60.0),
+            (0.1, 1000.0));
+
+        Self {
+            canvas: canvas,
+            camera: camera,
+            pmatrix: projection,
+            camera_controller: CameraController::new(),
+            renderstate: None,
+        }
+    }
+
+    pub fn resize(
+        &mut self,
+        wgpuctx: &WgpuCtx,
+        width: u32,
+        height: u32)
+    {
+        self.canvas.resize(wgpuctx, width, height);
+        self.pmatrix.resize(width, height);
+    }
+
+    pub fn update(
+        &mut self,
+        game_state: &RefCell<GameState>,
+        ui_state: &mut GameWindowUiState,
+        dt: Duration)
+    {
+        self.camera_controller.update(&mut self.camera, dt);
+        ui_state.camera_scale = self.camera.get_scale();
+    }
+
+    pub fn keyboard_input(
+        &mut self,
+        game_state: &RefCell<GameState>,
+        key_code: KeyCode,
+        key_state: ElementState)
+    {
+        self.camera_controller.keyboard_input(key_code, key_state);
+    }
+
+    pub fn draw(
+        &mut self,
+        wgpuctx: &WgpuCtx,
+        game_state: &RefCell<GameState>,
+        current_system: Option<SystemId>)
+    -> 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);
+
+        let tacrender = match &mut self.renderstate {
+            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.renderstate = Some((current_system_id, tmp));
+                &mut self.renderstate.as_mut().unwrap().1
+            }
+        };
+
+        //Update buffers for the current system and time.
+        tacrender.rebuild(wgpuctx, current_system);
+        match tacrender.update(
+            wgpuctx, current_system, 
+            game_state.timeman().seconds())
+        {
+            Ok(()) => {},
+            Err(e) => println!("Tactical map render update error: {}", e)
+        }
+
+        tacrender.render(wgpuctx, &self.canvas, &self.camera);
+
+        Ok(())
+    }
+
+    pub fn present(
+        &mut self,
+        screen_pass: &mut wgpu::RenderPass)
+    -> Result<(), wgpu::SurfaceError>
+    {
+        self.canvas.present(screen_pass)?;
+        Ok(())
+    }
+} // impl SystemViewport
-- 
cgit v1.2.3