1 files changed, 148 insertions, 0 deletions
diff --git a/src/window.rs b/src/window.rs
new file mode 100644
index 0000000..0be88e7
--- /dev/null
+++ b/src/window.rs
@@ -0,0 +1,148 @@
+pub mod ui;
+
+mod window {
+    pub use super::ui;
+}
+
+use std::cell::RefCell;
+use std::sync::{Arc};
+use std::time::Duration;
+
+use winit::event::{ElementState, WindowEvent};
+use winit::keyboard::KeyCode;
+
+use crate::tacmap::TacticalMap;
+use crate::{GameState, SystemicApp};
+use crate::solar_system::{SolarSystem, SystemId};
+use crate::wgpuctx::{RenderPassBuilder, WgpuCtx};
+use crate::eguictx::EguiCtx;
+
+use ui::*;
+
+pub struct GameWindow
+{
+    window: Arc<winit::window::Window>,
+    wgpuctx: WgpuCtx,
+    eguictx: EguiCtx,
+
+    tactical_map: TacticalMap,
+
+    ui_state: GameWindowUiState
+}
+
+impl GameWindow
+{
+    pub fn new(
+        instance: &wgpu::Instance,
+        event_loop: &winit::event_loop::ActiveEventLoop)
+    -> Result<GameWindow, ()>
+    {
+        let window_attrs = winit::window::Window::default_attributes()
+            .with_title("Systemic 4X")
+            .with_inner_size(winit::dpi::LogicalSize::new(640, 480));
+
+        let window = Arc::new(event_loop.create_window(window_attrs).unwrap());
+
+        let wgpuctx = pollster::block_on(WgpuCtx::new(instance, window.clone()));
+        let eguictx = EguiCtx::new(&window, &wgpuctx);
+
+        let tacmap = TacticalMap::new(
+            &wgpuctx,
+            winit::dpi::LogicalPosition::new(0.0, 0.0),
+            winit::dpi::LogicalSize::new(1.0, 1.0));
+
+        Ok(Self {
+        window: window,
+            wgpuctx: wgpuctx,
+            eguictx: eguictx,
+            tactical_map: tacmap,
+            
+            ui_state: Default::default()
+        })
+    }
+    
+    pub fn update(
+        &mut self,
+        game_state: &RefCell<GameState>,
+        dt: Duration)
+    {
+        self.tactical_map.update(game_state, &mut self.ui_state, dt);
+    }
+
+    pub fn keyboard_input(
+        &mut self,
+        game_state: &RefCell<GameState>,
+        key_code: KeyCode,
+        key_state: ElementState)
+    {
+        self.tactical_map.keyboard_input(game_state, key_code, key_state);
+    }
+
+    pub fn render(
+        &mut self,
+        game_state: &RefCell<GameState>)
+    -> Result<(), wgpu::SurfaceError> {
+        if !self.wgpuctx.is_ready() {
+            return Ok(());
+        }
+
+        self.tactical_map.draw(
+            &self.wgpuctx,
+            game_state,
+            self.ui_state.current_system)?;
+        
+        let mut encoder = self.wgpuctx.create_default_encoder("Systemic window command encoder");
+        let view = self.wgpuctx.prepare_surface(&wgpu::TextureViewDescriptor::default())?;
+        {
+            let mut pass = RenderPassBuilder::new("Systemic window render pass", &view)
+                .clear_color(wgpu::Color { r: 1.0, g: 1.0, b: 1.0, a: 1.0 })
+                .build(&mut encoder);
+
+            //Draw the tactical map canvas.
+            self.tactical_map.present(&mut pass)?;
+        }
+        {
+            self.eguictx.prepare(&self.window);
+            self.ui_state = GameWindowUiState::render(&self.ui_state, game_state, &self.eguictx);
+
+            self.eguictx.present(
+                &self.window, 
+                &self.wgpuctx, 
+                &mut encoder, 
+                &view);
+        }
+
+        self.wgpuctx.submit_encoder(encoder);
+        self.wgpuctx.present_surface();
+        self.window.request_redraw();
+
+        Ok(())
+    }
+
+    pub fn on_event(
+        &mut self,
+        event: &WindowEvent)
+    {
+        if self.eguictx.window_event(&self.window, event).consumed {
+            return;
+        }
+    }
+
+    pub fn resize(
+        &mut self,
+        width: u32,
+        height: u32
+    ) {
+        if width > 0 && height > 0 {
+            self.wgpuctx.resize(width, height);
+            self.tactical_map.resize(&self.wgpuctx, width, height);
+            self.window.request_redraw();
+        }
+    }
+
+    pub fn size(
+        &self)
+    -> winit::dpi::PhysicalSize<u32> {
+        self.window.inner_size()
+    }
+}