rename newgui -> gui now that it's main ui

engine/src/gfx.rs

@@ -263,7 +263,7 @@ impl GfxContext {
             backends = Backends::VULKAN;
         }
 
-        let mut flags = if cfg!(debug_assertions) {
+        let flags = if cfg!(debug_assertions) {
             // TODO: re enable validation when https://github.com/gfx-rs/wgpu/issues/5231 is fixed
             wgpu::InstanceFlags::DEBUG
         } else {

native_app/src/gui/debug_inspect.rs → native_app/src/debug_gui/debug_inspect.rs

@@ -1,7 +1,7 @@
 use egui::Ui;
 use egui::{Context, Window};
 
-use crate::gui::debug_window::DebugState;
+use crate::debug_gui::debug_window::DebugState;
 use egui_inspect::{Inspect, InspectArgs};
 use simulation::economy::Market;
 use simulation::transportation::Location;
@@ -10,8 +10,8 @@ use simulation::{
     WagonEnt,
 };
 
-use crate::newgui::follow::FollowEntity;
-use crate::newgui::InspectedEntity;
+use crate::gui::follow::FollowEntity;
+use crate::gui::InspectedEntity;
 use crate::uiworld::UiWorld;
 
 pub fn debug_inspector(ui: &Context, uiworld: &UiWorld, sim: &Simulation) {

native_app/src/gui/debug_window.rs → native_app/src/debug_gui/debug_window.rs

@@ -1,15 +1,15 @@
 #![allow(clippy::type_complexity)]
 
 use crate::game_loop::Timings;
-use crate::newgui::{GuiState, InspectedEntity};
+use crate::gui::{GuiState, InspectedEntity};
 use crate::uiworld::UiWorld;
 use simulation::map_dynamic::ParkingManagement;
 use simulation::transportation::TransportGrid;
 use simulation::{Simulation, TrainID};
 use std::time::{Duration, Instant};
 
+use crate::gui::windows::settings::Settings;
 use crate::inputmap::{InputAction, InputMap};
-use crate::newgui::windows::settings::Settings;
 use egui::{Context, Widget};
 use engine::{PerfCountersStatic, Tesselator};
 use geom::{Camera, Color, LinearColor, Spline3, Vec2};

native_app/src/debug_gui/hud.rs

@@ -0,0 +1,61 @@
+use egui::{Color32, Context, Id, RichText};
+
+use prototypes::Money;
+use simulation::economy::Government;
+use simulation::Simulation;
+
+use crate::debug_gui::debug_inspect::debug_inspector;
+use crate::debug_gui::debug_window::debug_window;
+use crate::gui::{ErrorTooltip, GuiState, PotentialCommands};
+use crate::uiworld::UiWorld;
+
+/// Root GUI entrypoint
+pub fn render_oldgui(ui: &Context, uiworld: &UiWorld, sim: &Simulation) {
+    profiling::scope!("hud::render");
+    if uiworld.read::<GuiState>().hidden {
+        return;
+    }
+
+    debug_inspector(ui, uiworld, sim);
+
+    debug_window(ui, uiworld, sim);
+
+    tooltip(ui, uiworld, sim);
+}
+
+pub fn tooltip(ui: &Context, uiworld: &UiWorld, sim: &Simulation) {
+    profiling::scope!("gui::tooltip");
+    let tooltip = std::mem::take(&mut *uiworld.write::<ErrorTooltip>());
+    if let Some(msg) = tooltip.msg {
+        if !(tooltip.isworld && ui.is_pointer_over_area()) {
+            let s = ui.available_rect().size();
+            egui::show_tooltip_at(
+                ui,
+                Id::new("tooltip_error"),
+                egui::Pos2::new(s.x, s.y),
+                |ui| ui.label(RichText::new(msg).color(Color32::from_rgb(255, 100, 100))),
+            );
+        }
+    }
+
+    if ui.is_pointer_over_area() {
+        return;
+    }
+    let pot = &mut uiworld.write::<PotentialCommands>().0;
+    let cost: Money = pot
+        .drain(..)
+        .map(|cmd| Government::action_cost(&cmd, sim))
+        .sum();
+
+    if cost == Money::ZERO {
+        return;
+    }
+
+    egui::show_tooltip(ui, Id::new("tooltip_command_cost"), |ui| {
+        if cost > sim.read::<Government>().money {
+            ui.colored_label(Color32::RED, format!("{cost} too expensive"));
+        } else {
+            ui.label(cost.to_string());
+        }
+    });
+}

native_app/src/debug_gui/mod.rs

@@ -0,0 +1,5 @@
+pub mod debug_inspect;
+pub mod debug_window;
+pub mod hud;
+
+pub use hud::*;

native_app/src/game_loop.rs

@@ -10,17 +10,17 @@ use geom::{vec2, vec3, Camera, LinearColor};
 use simulation::Simulation;
 
 use crate::audio::GameAudio;
-use crate::gui::debug_window::DebugObjs;
-use crate::gui::render_oldgui;
+use crate::debug_gui::debug_window::DebugObjs;
+use crate::debug_gui::render_oldgui;
+use crate::gui;
+use crate::gui::follow::FollowEntity;
+use crate::gui::keybinds::KeybindState;
+use crate::gui::terraforming::TerraformingResource;
+use crate::gui::toolbox::building;
+use crate::gui::windows::settings::{manage_settings, Settings};
+use crate::gui::UiTextures;
+use crate::gui::{render_newgui, ExitState, GuiState, TimeAlways, Tool};
 use crate::inputmap::{Bindings, InputAction, InputMap};
-use crate::newgui;
-use crate::newgui::follow::FollowEntity;
-use crate::newgui::keybinds::KeybindState;
-use crate::newgui::terraforming::TerraformingResource;
-use crate::newgui::toolbox::building;
-use crate::newgui::windows::settings::{manage_settings, Settings};
-use crate::newgui::UiTextures;
-use crate::newgui::{render_newgui, ExitState, GuiState, TimeAlways, Tool};
 use crate::rendering::{InstancedRender, MapRenderOptions, MapRenderer, OrbitCamera};
 use crate::uiworld::{SaveLoadState, UiWorld};
 use prototypes::GameTime;
@@ -160,7 +160,7 @@ impl engine::framework::State for State {
             !ctx.egui.last_kb_captured,
             !ctx.egui.last_mouse_captured,
         );
-        newgui::run_ui_systems(&self.sim.read().unwrap(), &self.uiw);
+        gui::run_ui_systems(&self.sim.read().unwrap(), &self.uiw);
 
         self.uiw.write::<Timings>().all.add_value(ctx.delta);
         self.uiw.write::<Timings>().per_game_system = self.game_schedule.times();

native_app/src/gui/hud.rs

@@ -1,61 +1,137 @@
-use egui::{Color32, Context, Id, RichText};
+use std::time::Instant;
 
-use prototypes::Money;
-use simulation::economy::Government;
+use goryak::{image_button, minrow, on_secondary_container, textc};
+use ordered_float::OrderedFloat;
+use prototypes::ItemID;
+use yakui::{reflow, Alignment, Color, Dim2, Pivot, Vec2};
+
+use simulation::map_dynamic::ElectricityFlow;
 use simulation::Simulation;
 
-use crate::gui::debug_inspect::debug_inspector;
-use crate::gui::debug_window::debug_window;
-use crate::newgui::{ErrorTooltip, GuiState, PotentialCommands};
-use crate::uiworld::UiWorld;
+use crate::gui::hud::menu::menu_bar;
+use crate::gui::hud::time_controls::time_controls;
+use crate::gui::hud::toolbox::new_toolbox;
+use crate::gui::inspect::new_inspector;
+use crate::gui::textures::UiTextures;
+use crate::gui::windows::settings::Settings;
+use crate::gui::GuiState;
+use crate::uiworld::{SaveLoadState, UiWorld};
+
+pub mod chat;
+pub mod keybinds;
+mod menu;
+mod time_controls;
+pub mod toolbox;
+pub mod windows;
 
 /// Root GUI entrypoint
-pub fn render_oldgui(ui: &Context, uiworld: &UiWorld, sim: &Simulation) {
+pub fn render_newgui(uiworld: &UiWorld, sim: &Simulation) {
     profiling::scope!("hud::render");
+    auto_save(uiworld);
+
     if uiworld.read::<GuiState>().hidden {
         return;
     }
 
-    debug_inspector(ui, uiworld, sim);
-
-    debug_window(ui, uiworld, sim);
-
-    tooltip(ui, uiworld, sim);
+    yakui::column(|| {
+        power_errors(uiworld, sim);
+        new_toolbox(uiworld, sim);
+        menu_bar(uiworld, sim);
+        chat::chat(uiworld, sim);
+        new_inspector(uiworld, sim);
+        uiworld.write::<GuiState>().windows.render(uiworld, sim);
+        time_controls(uiworld, sim);
+        keybinds::keybind_modal(uiworld, sim)
+    });
+    //goryak::debug_layout();
 }
 
-pub fn tooltip(ui: &Context, uiworld: &UiWorld, sim: &Simulation) {
-    profiling::scope!("gui::tooltip");
-    let tooltip = std::mem::take(&mut *uiworld.write::<ErrorTooltip>());
-    if let Some(msg) = tooltip.msg {
-        if !(tooltip.isworld && ui.is_pointer_over_area()) {
-            let s = ui.available_rect().size();
-            egui::show_tooltip_at(
-                ui,
-                Id::new("tooltip_error"),
-                egui::Pos2::new(s.x, s.y),
-                |ui| ui.label(RichText::new(msg).color(Color32::from_rgb(255, 100, 100))),
-            );
+fn auto_save(uiworld: &UiWorld) {
+    let every = uiworld.read::<Settings>().auto_save_every.into();
+    let mut gui = uiworld.write::<GuiState>();
+    if let Some(every) = every {
+        if gui.last_save.elapsed() > every {
+            uiworld.write::<SaveLoadState>().please_save = true;
+            uiworld.save_to_disk();
+            gui.last_save = Instant::now();
         }
     }
+}
 
-    if ui.is_pointer_over_area() {
-        return;
-    }
-    let pot = &mut uiworld.write::<PotentialCommands>().0;
-    let cost: Money = pot
-        .drain(..)
-        .map(|cmd| Government::action_cost(&cmd, sim))
-        .sum();
+fn power_errors(uiworld: &UiWorld, sim: &Simulation) {
+    profiling::scope!("hud::power_errors");
+    let map = sim.map();
+    let flow = sim.read::<ElectricityFlow>();
 
-    if cost == Money::ZERO {
-        return;
+    let no_power_img = uiworld.read::<UiTextures>().get("no_power");
+
+    for network in map.electricity.networks() {
+        if !flow.blackout(network.id) {
+            continue;
+        }
+
+        let mut buildings_with_issues = Vec::with_capacity(network.buildings.len());
+
+        for &building in &network.buildings {
+            let Some(b) = map.get(building) else {
+                continue;
+            };
+
+            let center = b.obb.center();
+
+            let pos = center
+                .z(b.height + 20.0 + 1.0 * f32::cos(uiworld.time_always() + center.mag() * 0.05));
+            let (screenpos, depth) = uiworld.camera().project(pos);
+
+            let size = 10000.0 / depth;
+
+            buildings_with_issues.push((screenpos, size));
+        }
+
+        buildings_with_issues.sort_by_key(|x| OrderedFloat(x.1));
+
+        for (screenpos, size) in buildings_with_issues {
+            reflow(
+                Alignment::TOP_LEFT,
+                Pivot::TOP_LEFT,
+                Dim2::pixels(screenpos.x - size * 0.5, screenpos.y - size * 0.5),
+                || {
+                    let mut image = yakui::widgets::Image::new(no_power_img, Vec2::new(size, size));
+                    image.color = Color::WHITE.with_alpha(0.7);
+                    image.show();
+                },
+            );
+        }
     }
+}
 
-    egui::show_tooltip(ui, Id::new("tooltip_command_cost"), |ui| {
-        if cost > sim.read::<Government>().money {
-            ui.colored_label(Color32::RED, format!("{cost} too expensive"));
+pub fn item_icon_yakui(uiworld: &UiWorld, id: ItemID, multiplier: i32) {
+    let item = id.prototype();
+    minrow(5.0, || {
+        if let Some(id) = uiworld
+            .read::<UiTextures>()
+            .try_get(&format!("icon/{}", item.name))
+        {
+            if image_button(
+                id,
+                Vec2::new(32.0, 32.0),
+                Color::WHITE,
+                Color::WHITE,
+                Color::WHITE,
+                "",
+            )
+            .hovering
+            {
+                reflow(Alignment::CENTER, Pivot::TOP_LEFT, Dim2::ZERO, || {
+                    textc(
+                        on_secondary_container(),
+                        format!("{} x{}", item.name, multiplier),
+                    );
+                });
+            }
         } else {
-            ui.label(cost.to_string());
+            textc(on_secondary_container(), format!("- {} ", &item.label));
         }
+        textc(on_secondary_container(), format!("x{multiplier}"))
     });
 }

native_app/src/newgui/hud/menu.rs → native_app/src/gui/hud/menu.rs

@@ -11,8 +11,8 @@ use goryak::{
 use simulation::economy::Government;
 use simulation::Simulation;
 
+use crate::gui::{ExitState, GuiState};
 use crate::inputmap::{InputAction, InputMap};
-use crate::newgui::{ExitState, GuiState};
 use crate::uiworld::{SaveLoadState, UiWorld};
 
 pub fn menu_bar(uiworld: &UiWorld, sim: &Simulation) {

native_app/src/newgui/hud/time_controls.rs → native_app/src/gui/hud/time_controls.rs

@@ -11,9 +11,9 @@ use goryak::{
 use prototypes::GameTime;
 use simulation::Simulation;
 
+use crate::gui::windows::settings::Settings;
+use crate::gui::GuiState;
 use crate::inputmap::{InputAction, InputMap};
-use crate::newgui::windows::settings::Settings;
-use crate::newgui::GuiState;
 use crate::uiworld::UiWorld;
 
 pub fn time_controls(uiworld: &UiWorld, sim: &Simulation) {

native_app/src/newgui/hud/toolbox/building.rs → native_app/src/gui/hud/toolbox/building.rs

@@ -6,7 +6,7 @@ use yakui::{
     TextureId, Vec2,
 };
 
-use crate::newgui::item_icon_yakui;
+use crate::gui::item_icon_yakui;
 use engine::wgpu::TextureFormat;
 use geom::{Camera, Degrees, Polygon, Vec3};
 use goryak::{
@@ -22,7 +22,7 @@ use simulation::world_command::WorldCommand;
 use std::path::PathBuf;
 use std::time::Instant;
 
-use crate::newgui::specialbuilding::{SpecialBuildKind, SpecialBuildingResource};
+use crate::gui::specialbuilding::{SpecialBuildKind, SpecialBuildingResource};
 use crate::uiworld::UiWorld;
 
 pub fn special_building_properties(uiw: &UiWorld) {

native_app/src/newgui/hud/toolbox/mod.rs → native_app/src/gui/hud/toolbox/mod.rs

@@ -11,9 +11,9 @@ use goryak::{
 };
 use simulation::Simulation;
 
+use crate::gui::textures::UiTextures;
+use crate::gui::Tool;
 use crate::inputmap::{InputAction, InputMap};
-use crate::newgui::textures::UiTextures;
-use crate::newgui::Tool;
 use crate::uiworld::UiWorld;
 
 pub mod building;

native_app/src/newgui/hud/toolbox/roadbuild.rs → native_app/src/gui/hud/toolbox/roadbuild.rs

@@ -7,9 +7,9 @@ use yakui::{
 use goryak::{image_button, mincolumn, minrow, padxy, primary};
 use simulation::map::LanePatternBuilder;
 
-use crate::newgui::hud::toolbox::updown_value;
-use crate::newgui::roadbuild::{HeightReference, RoadBuildResource, Snapping};
-use crate::newgui::textures::UiTextures;
+use crate::gui::hud::toolbox::updown_value;
+use crate::gui::roadbuild::{HeightReference, RoadBuildResource, Snapping};
+use crate::gui::textures::UiTextures;
 use crate::uiworld::UiWorld;
 
 pub fn roadbuild_properties(uiw: &UiWorld) {