Make window size configurable; Move format to YAML

Author: Yatekii

config/default.toml

@@ -0,0 +1,32 @@
+general:
+  display-framerate: false
+  data-root: ""
+  log:
+    level: "WARN"
+
+window:
+  size:
+    windowed:
+      width: 1200
+      height: 800
+
+renderer:
+  vertex-shader: "config/shader.vert"
+  fragment-shader: "config/shader.frag"
+  css: "config/style.css"
+  ui-font: "config/Ruda-Bold.ttf"
+  max-tiles: 200
+  max-features: 1000
+  tile-size: 384
+  msaa-samples: 4
+  selection-tags: []
+  temperature:
+    vertex-shader: "config/temperature/shader.vert"
+    fragment-shader: "config/temperature/shader.frag"
+
+map:
+  initial:
+    zoom: 13.0
+    center:
+      latitude: 47.3769
+      longitude: 8.5417

config/default.yaml

@@ -7,6 +7,7 @@ use osm::math::{deg2num, tile_to_world_space, Screen, TileId};
 use osm::object::Object;
 use std::sync::{Arc, Mutex, RwLock};
 use std::thread;
+use winit::dpi::PhysicalSize;
 
 use crate::config::CONFIG;
 use crate::drawing::ui::state::UIState;
@@ -29,8 +30,7 @@ impl AppState {
     pub fn new(
         style: impl Into<String>,
         center: Point,
-        width: u32,
-        height: u32,
+        size: PhysicalSize<u32>,
         zoom: f32,
         hidpi_factor: f64,
     ) -> Self {
@@ -40,8 +40,8 @@ impl AppState {
                 .expect("Unable to load the style file. Please consult the log."),
             screen: Screen::new(
                 center,
-                width,
-                height,
+                size.width,
+                size.height,
                 CONFIG.renderer.tile_size,
                 hidpi_factor,
             ),

src/bin/app_state.rs

@@ -9,6 +9,20 @@ pub struct Config {
     pub general: General,
     pub map: MapState,
     pub renderer: Renderer,
+    pub window: Window,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct Window {
+    pub size: WindowSize,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum WindowSize {
+    Windowed { width: f64, height: f64 },
+    Fullscreen,
 }
 
 #[derive(Debug, Deserialize)]

src/bin/config.rs

@@ -16,8 +16,8 @@ use util::StagingBelt;
 use wgpu::naga::ShaderStage;
 use wgpu::util::{BufferInitDescriptor, DeviceExt};
 use wgpu::*;
-use winit::window::WindowAttributes;
-use winit::{dpi::LogicalSize, event_loop::EventLoop, window::Window};
+use winit::dpi::PhysicalSize;
+use winit::window::Window;
 
 use crate::app_state::AppState;
 use crate::drawing::helpers::load_glsl;
@@ -53,18 +53,8 @@ pub struct Painter {
 
 impl Painter {
     /// Initializes the entire draw machinery.
-    pub fn init(event_loop: &EventLoop<()>, width: u32, height: u32, app_state: &AppState) -> Self {
-        #[allow(deprecated)]
-        let window = Arc::new(
-            event_loop
-                .create_window(WindowAttributes::default().with_inner_size(LogicalSize {
-                    width: width as f64,
-                    height: height as f64,
-                }))
-                .unwrap(),
-        );
+    pub fn init(window: Arc<Window>, size: PhysicalSize<u32>, app_state: &AppState) -> Self {
         let factor = window.scale_factor();
-        let size = window.inner_size();
 
         let instance = wgpu::Instance::new(InstanceDescriptor::default());
         let surface = instance.create_surface(window.clone()).unwrap();

src/bin/drawing/painter.rs

@@ -3,16 +3,18 @@ mod config;
 mod drawing;
 mod stats;
 
+use std::sync::Arc;
+
 use crate::config::CONFIG;
 use lyon::math::vector;
 use osm::math::{deg2num, tile_to_world_space};
 use winit::{
     application::ApplicationHandler,
-    dpi::{LogicalPosition, PhysicalPosition},
+    dpi::{LogicalPosition, LogicalSize, PhysicalPosition},
     event::{ElementState, KeyEvent, MouseButton, MouseScrollDelta, WindowEvent},
     event_loop::ActiveEventLoop,
     keyboard::{Key, ModifiersState, NamedKey},
-    window::WindowId,
+    window::{WindowAttributes, WindowId},
 };
 
 fn main() {
@@ -26,21 +28,31 @@ fn main() {
     );
     let initial_center = tile_to_world_space(&tile_coordinate);
 
-    let width = 1200;
-    let height = 800;
-
     let event_loop = winit::event_loop::EventLoop::new().unwrap();
 
+    let attributes = WindowAttributes::default();
+    let window_attributes = match CONFIG.window.size {
+        config::WindowSize::Windowed { width, height } => attributes
+            .with_inner_size(LogicalSize { width, height })
+            .with_decorations(false),
+        config::WindowSize::Fullscreen => {
+            attributes.with_fullscreen(Some(winit::window::Fullscreen::Borderless(None)))
+        }
+    };
+
+    #[allow(deprecated)]
+    let window = Arc::new(event_loop.create_window(window_attributes).unwrap());
+    let size = window.inner_size();
+
     let app_state = app_state::AppState::new(
         CONFIG.renderer.css.clone(),
         initial_center,
-        width,
-        height,
+        size,
         CONFIG.map.initial.zoom,
         2.0,
     );
 
-    let mut painter = drawing::Painter::init(&event_loop, width, height, &app_state);
+    let mut painter = drawing::Painter::init(window, size, &app_state);
     let hud = drawing::ui::Hud::new(
         &painter.window,
         &mut painter.device,