Merge pull request #151 from Jupeyy/pr_client_improvements12

Various improvements

Author: Jupeyy

DEVELOPMENT.md

@@ -103,4 +103,6 @@ cargo run --release --no-default-features --features bench_slow_paths
 ```
 
 which enables tracing support for the sync update code and prints how long paths took,
-as soon as the whole update took over a certain amount of time (e.g. 17ms which is slower than 1/60 fps).
+as soon as the whole update took over a certain amount of time.
+The threshold can be adjusted with the environment variable `BENCHMARK_IGNORE_UNDER_NS` in nanoseconds, the default
+is 17ms which is just above the frametime of a single frame in 60 fps.

examples/wasm-modules/hud/src/hud/page.rs

@@ -2,6 +2,7 @@ use api_ui_game::render::{create_ctf_container, create_skin_container};
 use base::{linked_hash_map_view::FxLinkedHashMap, network_string::PoolNetworkString};
 use client_containers::{ctf::CtfContainer, skins::SkinContainer};
 use client_render_base::render::tee::RenderTee;
+use client_ui::hud::user_data::RenderDateTime;
 use game_interface::types::{
     character_info::{NetworkCharacterInfo, NetworkSkinInfo},
     id_gen::IdGenerator,
@@ -18,7 +19,7 @@ use graphics::{
     graphics::graphics::Graphics,
     handles::{canvas::canvas::GraphicsCanvasHandle, stream::stream::GraphicsStreamHandle},
 };
-use pool::rc::PoolRc;
+use pool::{datatypes::PoolString, rc::PoolRc};
 use ui_base::types::{UiRenderPipe, UiState};
 use ui_generic::traits::UiPageInterface;
 
@@ -108,6 +109,10 @@ impl HudPage {
                     character_infos: &self.character_infos,
                     canvas_handle: &self.canvas_handle,
                     stream_handle: &self.stream_handle,
+                    date_time: &Some(RenderDateTime {
+                        time: PoolString::new_str_without_pool("22:14:14"),
+                        date: PoolString::new_str_without_pool("Saturday, 27. September 2025"),
+                    }),
                 },
             ),
             ui_state,

game/client-demo/src/lib.rs

@@ -519,6 +519,7 @@ impl DemoViewerImpl {
         let stages = game.all_stages(intra_tick_ratio);
 
         let scoreboard_info = None; // game.collect_scoreboard_info();
+        let date_time = None;
 
         let load_events = !last_monotonic_tick.is_some_and(|tick| tick == monotonic_tick);
         last_monotonic_tick.replace(monotonic_tick);
@@ -560,6 +561,7 @@ impl DemoViewerImpl {
             character_infos,
             stages,
             scoreboard_info,
+            date_time,
             chat_msgs,
             game_time_info,
             settings: if let Some(DemoEncoder {

game/client-render-game/src/components/hud.rs

@@ -10,6 +10,7 @@ use client_containers::{
 };
 use client_render::hud::page::{HudRender, HudRenderPipe};
 use client_render_base::render::tee::RenderTee;
+use client_ui::hud::user_data::RenderDateTime;
 use game_interface::types::{
     emoticons::{EnumCount, IntoEnumIterator},
     game::{GameTickType, NonZeroGameTickType},
@@ -53,6 +54,7 @@ pub struct RenderHudPipe<'a> {
     pub skin_renderer: &'a RenderTee,
     pub ctf_container: &'a mut CtfContainer,
     pub character_infos: &'a FxLinkedHashMap<CharacterId, CharacterInfo>,
+    pub date_time: &'a Option<RenderDateTime>,
 }
 
 pub struct RenderOffsetsVanilla {
@@ -803,6 +805,7 @@ impl RenderHud {
             skin_renderer: pipe.skin_renderer,
             ctf_container: pipe.ctf_container,
             character_infos: pipe.character_infos,
+            date_time: pipe.date_time,
         });
 
         let hud = pipe.hud_container.get_or_default_opt(pipe.hud_key);

game/client-render-game/src/render_game.rs

@@ -47,6 +47,7 @@ use client_types::{
 use client_ui::{
     chat::user_data::{ChatEvent, ChatMode, MsgInChat},
     emote_wheel::user_data::EmoteWheelEvent,
+    hud::user_data::RenderDateTime,
     spectator_selection::user_data::SpectatorSelectionEvent,
     thumbnail_container::{
         DEFAULT_THUMBNAIL_CONTAINER_PATH, ThumbnailContainer, load_thumbnail_container,
@@ -402,6 +403,8 @@ pub struct RenderGameInput {
     pub stages: PoolFxLinkedHashMap<StageId, StageRenderInfo>,
     pub scoreboard_info: Option<Scoreboard>,
 
+    pub date_time: Option<RenderDateTime>,
+
     pub game_time_info: GameTimeInfo,
 
     pub settings: RenderGameSettings,
@@ -1008,6 +1011,7 @@ impl RenderGame {
                 skin_renderer: &self.players.tee_renderer,
                 ctf_container: &mut self.containers.ctf_container,
                 character_infos: &render_info.character_infos,
+                date_time: &render_info.date_time,
             });
             if let Some(scoreboard_info) = local_render_info
                 .scoreboard_active

game/client-render/src/hud/page.rs

@@ -3,7 +3,10 @@ use std::time::Duration;
 use base::linked_hash_map_view::FxLinkedHashMap;
 use client_containers::{ctf::CtfContainer, skins::SkinContainer};
 use client_render_base::render::tee::RenderTee;
-use client_ui::hud::{page::HudUi, user_data::UserData};
+use client_ui::hud::{
+    page::HudUi,
+    user_data::{RenderDateTime, UserData},
+};
 use egui::Color32;
 use game_interface::types::{
     game::{GameTickType, NonZeroGameTickType},
@@ -20,9 +23,8 @@ use graphics::{
 use ui_base::{
     types::UiRenderPipe,
     ui::{UiContainer, UiCreator},
-    ui_render::render_ui,
 };
-use ui_generic::traits::UiPageInterface;
+use ui_generic::generic_ui_renderer;
 
 pub struct HudRenderPipe<'a> {
     pub race_timer_counter: &'a GameTickType,
@@ -33,6 +35,7 @@ pub struct HudRenderPipe<'a> {
     pub skin_renderer: &'a RenderTee,
     pub ctf_container: &'a mut CtfContainer,
     pub character_infos: &'a FxLinkedHashMap<CharacterId, CharacterInfo>,
+    pub date_time: &'a Option<RenderDateTime>,
 }
 
 pub struct HudRender {
@@ -61,10 +64,6 @@ impl HudRender {
     }
 
     pub fn render(&mut self, pipe: &mut HudRenderPipe) {
-        let canvas_width = self.canvas_handle.canvas_width();
-        let canvas_height = self.canvas_handle.canvas_height();
-        let pixels_per_point = self.canvas_handle.pixels_per_point();
-
         let mut user_data = UserData {
             race_round_timer_counter: pipe.race_timer_counter,
             ticks_per_second: pipe.ticks_per_second,
@@ -75,27 +74,19 @@ impl HudRender {
             character_infos: pipe.character_infos,
             canvas_handle: &self.canvas_handle,
             stream_handle: &self.stream_handle,
+            date_time: pipe.date_time,
         };
         let mut dummy_pipe = UiRenderPipe::new(*pipe.cur_time, &mut user_data);
-        let (screen_rect, full_output, zoom_level) = self.ui.render_cached(
-            canvas_width,
-            canvas_height,
-            pixels_per_point,
-            |ui, inner_pipe, ui_state| self.hud_ui.render(ui, inner_pipe, ui_state),
-            &mut dummy_pipe,
-            Default::default(),
-            false,
-            true,
-        );
-        render_ui(
-            &mut self.ui,
-            full_output,
-            &screen_rect,
-            zoom_level,
+
+        generic_ui_renderer::render(
             &self.backend_handle,
             &self.texture_handle,
             &self.stream_handle,
-            false,
+            &self.canvas_handle,
+            &mut self.ui,
+            &mut self.hud_ui,
+            &mut dummy_pipe,
+            Default::default(),
         );
     }
 }

game/client-ui/src/hud/main_frame.rs

@@ -384,6 +384,52 @@ pub fn render(ui: &mut egui::Ui, pipe: &mut UiRenderPipe<UserData>, ui_state: &m
         }
     };
 
+    // Floating overlay for date/time
+    if let Some(dt) = pipe.user_data.date_time {
+        let res = Window::new("date_time_overlay")
+            .order(egui::Order::Tooltip)
+            .interactable(false)
+            .title_bar(false)
+            .resizable(false)
+            .frame(
+                Frame::new()
+                    .fill(Color32::from_black_alpha(50))
+                    .inner_margin(10)
+                    .corner_radius(CornerRadius {
+                        nw: 0,
+                        ne: 0,
+                        sw: 10,
+                        se: 10,
+                    }),
+            )
+            .max_width(200.0)
+            .anchor(Align2::CENTER_TOP, Vec2::new(400.0, 0.0))
+            .show(ui.ctx(), |ui| {
+                ui.with_layout(
+                    Layout::top_down(egui::Align::Center)
+                        .with_main_wrap(true)
+                        .with_main_justify(false)
+                        .with_cross_justify(false),
+                    |ui| {
+                        ui.label(RichText::new(dt.time.as_str()).color(Color32::WHITE));
+                        ui.label(RichText::new(dt.date.as_str()).color(Color32::LIGHT_GRAY));
+                    },
+                );
+            });
+
+        if let Some(res) = res {
+            ui_state.add_blur_rect(
+                res.response.rect,
+                CornerRadius {
+                    nw: 0,
+                    ne: 0,
+                    sw: 10,
+                    se: 10,
+                },
+            );
+        }
+    }
+
     let res = Window::new("")
         .resizable(false)
         .title_bar(false)

game/client-ui/src/hud/user_data.rs

@@ -9,6 +9,14 @@ use game_interface::types::{
 use graphics::handles::{
     canvas::canvas::GraphicsCanvasHandle, stream::stream::GraphicsStreamHandle,
 };
+use pool::datatypes::PoolString;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct RenderDateTime {
+    pub time: PoolString,
+    pub date: PoolString,
+}
 
 pub struct UserData<'a> {
     pub canvas_handle: &'a GraphicsCanvasHandle,
@@ -23,4 +31,6 @@ pub struct UserData<'a> {
     pub ctf_container: &'a mut CtfContainer,
 
     pub character_infos: &'a FxLinkedHashMap<CharacterId, CharacterInfo>,
+
+    pub date_time: &'a Option<RenderDateTime>,
 }

game/client-ui/src/main_menu/settings/list/list.rs

@@ -54,7 +54,7 @@ pub fn render<'a>(
                             |ui| {
                                 for (entry_index, (entry_name, ty)) in
                                     entries.enumerate().filter(|(_, (name, _))| {
-                                        let matcher = fuzzy_matcher::skim::SkimMatcherV2::default();
+                                        let matcher = fuzzy_matcher::skim::SkimMatcherV2::default().ignore_case();
                                         matcher.fuzzy_match(name, &search_str).is_some()
                                     })
                                 {

game/game-server/src/server.rs

@@ -2732,7 +2732,8 @@ impl Server {
             || config.client_server_sync_log.players
             || config.client_server_sync_log.projectiles
         {
-            // breaks prediction, but currently only way to get useful information
+            // breaks prediction (except with instant input),
+            // but currently only way to get useful information
             let cur_snap = game.snapshot_for(SnapshotClientInfo::Everything);
             game.build_from_snapshot_for_prev(&cur_snap);
 
@@ -2764,9 +2765,14 @@ impl Server {
                         || now.duration_since(dbg_game.time)
                             > Duration::from_millis(1000 / ticks_in_a_second))
                         && config.client_server_sync_log.time
+                        // for prediction times are wrong and this makes the check kinda useless
+                        && !caller_name.contains("pred")
+                        && !dbg_game.caller.contains("pred")
                     {
                         println!(
-                            "out of sync: instant: {:?}, tick_time: {:?}, tick: {:?}",
+                            "out of sync {} vs. {caller_name}: \
+                            instant: {:?}, tick_time: {:?}, tick: {:?}",
+                            dbg_game.caller,
                             now.duration_since(dbg_game.time),
                             (*last_tick_time).max(dbg_game.tick_time)
                                 - (*last_tick_time).min(dbg_game.tick_time),