#1 - quicr module

modules/client/src/debug/DebugUI.cpp

@@ -0,0 +1,44 @@
+#include "DebugUI.hpp"
+#include <imgui.h>
+
+namespace tw::dbg {
+
+void DebugUI::draw_dockspace() {
+    const ImGuiViewport* viewport = ImGui::GetMainViewport();
+    ImGui::SetNextWindowPos(viewport->WorkPos);
+    ImGui::SetNextWindowSize(viewport->WorkSize);
+    ImGui::SetNextWindowViewport(viewport->ID);
+
+    const ImGuiWindowFlags flags =
+        ImGuiWindowFlags_MenuBar | ImGuiWindowFlags_NoDocking |
+        ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse |
+        ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
+        ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoNavFocus |
+        ImGuiWindowFlags_NoBackground;
+
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
+
+    ImGui::Begin("##debug_dockspace_host", nullptr, flags);
+
+    ImGui::PopStyleVar(3);
+
+    // A pass through centre leaves the middle empty until something is docked
+    // there, which is where the world is drawn.
+    ImGui::DockSpace(ImGui::GetID("debug_dockspace"), ImVec2(0.0f, 0.0f),
+                     ImGuiDockNodeFlags_PassthruCentralNode);
+
+    if(ImGui::BeginMenuBar()) {
+        m_windows.draw_menu();
+        ImGui::EndMenuBar();
+    }
+
+    ImGui::End();
+}
+
+void DebugUI::draw_windows() {
+    m_windows.draw_windows();
+}
+
+}

modules/client/src/debug/DebugUI.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "debug/DebugWindowRegistry.hpp"
+
+namespace tw::dbg {
+
+/**
+ * The full screen host the debug panels live in: a menu bar to toggle them and
+ * a dock space to arrange them in. Draws no background of its own, so the world
+ * stays visible underneath.
+ */
+class DebugUI {
+    DebugWindowRegistry m_windows;
+
+public:
+    DebugWindowRegistry& windows() {
+        return m_windows;
+    }
+
+    /**
+     * Opens the host for this frame. Has to run before anything that should be
+     * dockable is drawn, since the dock space has to exist by then.
+     */
+    void draw_dockspace();
+
+    void draw_windows();
+};
+
+}

modules/client/src/debug/DebugWindow.cpp

@@ -0,0 +1,26 @@
+#include "DebugWindow.hpp"
+#include <imgui.h>
+#include <utility>
+
+namespace tw::dbg {
+
+DebugWindow::DebugWindow(std::string id, std::string title, std::string category)
+    : m_id(std::move(id)),
+      m_title(std::move(title)),
+      m_category(std::move(category)),
+      m_label(m_title + "##" + m_id)
+{
+}
+
+void DebugWindow::draw() {
+    if(!m_open) {
+        return;
+    }
+
+    if(ImGui::Begin(m_label.c_str(), &m_open)) {
+        draw_contents();
+    }
+    ImGui::End();
+}
+
+}

modules/client/src/debug/DebugWindow.hpp

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <string>
+
+namespace tw::dbg {
+
+/**
+ * A debug panel that can be toggled from the menu bar.
+ *
+ * The frame around a panel is drawn here so every one of them gets the same
+ * close button and docking behaviour; subclasses only fill in the contents.
+ */
+class DebugWindow {
+    std::string m_id;
+    std::string m_title;
+    std::string m_category;
+
+    /**
+     * The label handed to the ui, "title##id". Saved positions are keyed by the
+     * whole label, so the visible half can change without losing the layout.
+     */
+    std::string m_label;
+
+    bool m_open = false;
+
+protected:
+    /**
+     * Fills the panel. Called only while it is open, between begin and end.
+     */
+    virtual void draw_contents() = 0;
+
+public:
+    DebugWindow(std::string id, std::string title, std::string category);
+    virtual ~DebugWindow() = default;
+
+    DebugWindow(const DebugWindow&) = delete;
+    DebugWindow& operator=(const DebugWindow&) = delete;
+
+    const std::string& id() const { return m_id; }
+    const std::string& title() const { return m_title; }
+    const std::string& category() const { return m_category; }
+
+    bool is_open() const { return m_open; }
+    void set_open(bool open) { m_open = open; }
+
+    /**
+     * The flag the menu item toggles, and the one the close button clears.
+     */
+    bool* open_flag() { return &m_open; }
+
+    void draw();
+};
+
+}

modules/client/src/debug/DebugWindowRegistry.cpp

@@ -0,0 +1,59 @@
+#include "DebugWindowRegistry.hpp"
+#include "DebugWindow.hpp"
+#include <imgui.h>
+#include <algorithm>
+
+namespace tw::dbg {
+
+void DebugWindowRegistry::add(DebugWindow* window) {
+    auto remembered = m_open_state.find(window->id());
+    if(remembered != m_open_state.end()) {
+        window->set_open(remembered->second);
+    }
+
+    m_windows.push_back(window);
+}
+
+void DebugWindowRegistry::remove(DebugWindow* window) {
+    m_open_state[window->id()] = window->is_open();
+    std::erase(m_windows, window);
+}
+
+void DebugWindowRegistry::draw_menu() {
+    if(!ImGui::BeginMenu("Windows")) {
+        return;
+    }
+
+    // Ordered by the first panel that asked for the category, so the menu does
+    // not reshuffle as panels come and go.
+    std::vector<std::string> categories;
+    for(auto* window : m_windows) {
+        if(std::find(categories.begin(), categories.end(), window->category()) == categories.end()) {
+            categories.push_back(window->category());
+        }
+    }
+
+    for(const auto& category : categories) {
+        if(!ImGui::BeginMenu(category.c_str())) {
+            continue;
+        }
+
+        for(auto* window : m_windows) {
+            if(window->category() == category) {
+                ImGui::MenuItem(window->title().c_str(), nullptr, window->open_flag());
+            }
+        }
+
+        ImGui::EndMenu();
+    }
+
+    ImGui::EndMenu();
+}
+
+void DebugWindowRegistry::draw_windows() {
+    for(auto* window : m_windows) {
+        window->draw();
+    }
+}
+
+}

modules/client/src/debug/DebugWindowRegistry.hpp

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace tw::dbg {
+
+class DebugWindow;
+
+/**
+ * The debug panels that exist right now.
+ *
+ * Panels are listed by whatever owns them, for as long as it lives, so the menu
+ * follows what the client is currently doing. Whether a panel was open is kept
+ * here rather than on the panel, since the owner is built again on every
+ * reconnect and the panel would come back closed.
+ */
+class DebugWindowRegistry {
+    std::vector<DebugWindow*> m_windows;
+
+    /**
+     * Keyed by panel id, remembered across the panels themselves.
+     */
+    std::unordered_map<std::string, bool> m_open_state;
+
+public:
+    /**
+     * Lists a panel, restoring whether it was open last time one with the same
+     * id was listed. Ownership stays with the caller, which has to remove it
+     * again before the panel dies.
+     */
+    void add(DebugWindow* window);
+
+    void remove(DebugWindow* window);
+
+    /**
+     * One submenu per category, listing every panel in it. Expects to be called
+     * inside a menu bar.
+     */
+    void draw_menu();
+
+    void draw_windows();
+};
+
+}

modules/client/src/debug/metrics/NetworkMetrics.hpp

@@ -0,0 +1,159 @@
+#pragma once
+
+#include "metrics/MetricSeries.hpp"
+
+#include <chrono>
+#include <cstdint>
+
+namespace tw::dbg {
+
+/**
+ * Per-second history of what the client sends, receives and waits for.
+ *
+ * Traffic arrives as running totals, one reading per tick: sample() keeps the
+ * change since the previous reading, so a bucket sums to the traffic of that
+ * second and its extremes are the quietest and busiest tick within it.
+ * Durations are recorded as they are measured.
+ */
+class NetworkMetrics {
+public:
+    using Interval = std::chrono::seconds;
+    using Series   = metrics::MetricSeries<Interval>;
+
+    /** How many seconds of history are kept. */
+    static constexpr size_t DEFAULT_HISTORY = 300;
+
+    /** Running totals as of one tick. */
+    struct Totals {
+        uint64_t bytes_sent        = 0;
+        uint64_t bytes_received    = 0;
+        uint64_t messages_sent     = 0;
+        uint64_t messages_received = 0;
+    };
+
+private:
+    Series m_bytes_out;
+    Series m_bytes_in;
+    Series m_messages_out;
+    Series m_messages_in;
+    Series m_response_ms;
+    Series m_update_ms;
+
+    Series m_rollbacks;
+    Series m_correction_distance;
+    Series m_ack_lag_frames;
+    Series m_replayed_frames;
+
+    Totals m_previous;
+    bool   m_has_previous = false;
+
+    static uint64_t delta(uint64_t current, uint64_t previous) {
+        return current > previous ? current - previous : 0;
+    }
+
+    static double to_millis(std::chrono::nanoseconds elapsed) {
+        return std::chrono::duration<double, std::milli>(elapsed).count();
+    }
+
+public:
+    explicit NetworkMetrics(size_t history_in_seconds = DEFAULT_HISTORY) :
+        m_bytes_out(history_in_seconds),
+        m_bytes_in(history_in_seconds),
+        m_messages_out(history_in_seconds),
+        m_messages_in(history_in_seconds),
+        m_response_ms(history_in_seconds),
+        m_update_ms(history_in_seconds),
+        m_rollbacks(history_in_seconds),
+        m_correction_distance(history_in_seconds),
+        m_ack_lag_frames(history_in_seconds),
+        m_replayed_frames(history_in_seconds)
+    { }
+
+    /**
+     * Records how much `totals` grew since the previous call. The first call
+     * only remembers where the counters started.
+     */
+    void sample(const Totals& totals) {
+        if(m_has_previous) {
+            m_bytes_out.push((double)delta(totals.bytes_sent, m_previous.bytes_sent));
+            m_bytes_in.push((double)delta(totals.bytes_received, m_previous.bytes_received));
+            m_messages_out.push((double)delta(totals.messages_sent, m_previous.messages_sent));
+            m_messages_in.push((double)delta(totals.messages_received, m_previous.messages_received));
+        }
+
+        m_previous     = totals;
+        m_has_previous = true;
+    }
+
+    /** Time between sending an input and seeing the answer to it. */
+    void record_response_time(std::chrono::nanoseconds elapsed) {
+        m_response_ms.push(to_millis(elapsed));
+    }
+
+    /** Time one tick spent moving messages in and out, handlers included. */
+    void record_update_time(std::chrono::nanoseconds elapsed) {
+        m_update_ms.push(to_millis(elapsed));
+    }
+
+    const Series& bytes_out() const {
+        return m_bytes_out;
+    }
+
+    const Series& bytes_in() const {
+        return m_bytes_in;
+    }
+
+    const Series& messages_out() const {
+        return m_messages_out;
+    }
+
+    const Series& messages_in() const {
+        return m_messages_in;
+    }
+
+    const Series& response_ms() const {
+        return m_response_ms;
+    }
+
+    const Series& update_ms() const {
+        return m_update_ms;
+    }
+
+    /** Records a rollback event (one sample per rollback). */
+    void record_rollback() {
+        m_rollbacks.push(1.0);
+    }
+
+    /** Records the distance in meters of a position correction. */
+    void record_correction_distance(double meters) {
+        m_correction_distance.push(meters);
+    }
+
+    /** Records how many frames behind the ack is trailing the current frame. */
+    void record_ack_lag(uint32_t frames) {
+        m_ack_lag_frames.push((double)frames);
+    }
+
+    /** Records how many frames were replayed during a rollback. */
+    void record_replayed_frames(uint32_t frames) {
+        m_replayed_frames.push((double)frames);
+    }
+
+    const Series& rollbacks() const {
+        return m_rollbacks;
+    }
+
+    const Series& correction_distance() const {
+        return m_correction_distance;
+    }
+
+    const Series& ack_lag_frames() const {
+        return m_ack_lag_frames;
+    }
+
+    const Series& replayed_frames() const {
+        return m_replayed_frames;
+    }
+};
+
+}

modules/client/src/debug/tools/EntityManagerGui.cpp

@@ -19,6 +19,7 @@
 namespace tw::dbg::tools {
 
 EntityManagerGui::EntityManagerGui(World* world) :
+    DebugWindow("entity_manager", "Entities", "World"),
     m_world(world) {
 
 }
@@ -64,9 +65,7 @@ void EntityManagerGui::draw_entity_components() {
     ImGui::EndChild();
 }
 
-void EntityManagerGui::draw() {
-    ImGui::Begin("Transforms");
-
+void EntityManagerGui::draw_contents() {
     ImGui::BeginChild("Entities", ImVec2(0, 260), ImGuiChildFlags_Border);
 
     ImGui::SeparatorText("Entities");
@@ -87,8 +86,6 @@ void EntityManagerGui::draw() {
     if(m_selected_entity.has_value()) {
         draw_entity_components();
     }
-
-    ImGui::End();
 }
 
 }

modules/client/src/debug/tools/EntityManagerGui.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "debug/ComponentGui.hpp"
+#include "debug/DebugWindow.hpp"
 #include "entt/entity/fwd.hpp"
 #include "world/World.hpp"
 
@@ -8,7 +9,7 @@
 
 namespace tw::dbg::tools {
 
-class EntityManagerGui {
+class EntityManagerGui : public tw::dbg::DebugWindow {
 private:
     World* m_world;
 
@@ -29,14 +30,15 @@ private:
         ...);
     }
 
+protected:
+    void draw_contents() override;
+
 public:
     entt::entity& selected() {
         return m_selected;
     }
 
     EntityManagerGui(World* world);
-
-    void draw();
 };
 
 }

modules/client/src/debug/tools/MetricWidget.hpp

@@ -2,95 +2,109 @@
 
 #include <imgui.h>
 #include <implot.h>
-#include <implot_internal.h>
 
-#include "metrics/BucketMetric.hpp"
+#include "metrics/MetricSeries.hpp"
+
+#include <algorithm>
+#include <chrono>
+#include <string>
+#include <vector>
 
 namespace tw::dbg::tools {
 
-template<typename T, typename Interval, typename Op = net::SumOp<T>>
+/**
+ * Plots one series against the seconds behind now, ending at the last second
+ * that has fully elapsed.
+ *
+ * The line follows whichever statistic the series is read with. Reading an
+ * average also shades the quietest and busiest value of each second behind it;
+ * a total has no such range to show, since its buckets already hold every value
+ * of that second added together.
+ */
 class MetricWidget {
-    std::string m_name;
-
-    net::BucketMetric<T, Interval, Op>& m_metric;
-
-    using Self = MetricWidget<T, Interval, Op>;
-
-    struct {
-        T constraint_from;
-        T constraint_to;
-
-        T from;
-        T to;
-    } y_axis;
-    
-    bool m_is_scrolling = true;
-
 public:
-    MetricWidget(
-            const std::string& name,
-            net::BucketMetric<T, Interval, Op>& metric
-    ) :
-        m_name(name),
-        m_metric(metric)
-    {
-        y_axis = {
-            .constraint_from = 0,
-            .constraint_to = 500,
-            .from = 0,
-            .to = 250
-        };
+    using Series = metrics::MetricSeries<std::chrono::seconds>;
+
+private:
+    std::string                m_name;
+    std::string                m_unit;
+    const Series*              m_series;
+    metrics::MetricField       m_field;
+
+    /**
+     * The second in progress is left out: it only holds the part of itself
+     * that has elapsed, so drawing it makes the newest point drop and climb
+     * back once a second.
+     */
+    static constexpr size_t SKIP_IN_PROGRESS = 1;
+
+    std::vector<double> m_ages;
+    std::vector<double> m_values;
+    std::vector<double> m_lows;
+    std::vector<double> m_highs;
+
+    bool has_range() const {
+        return m_field == metrics::MetricField::Avg;
     }
 
-    Self& set_x_axis_limits_contraints(T from, T to) {
-        ImPlot::SetupAxisLimits(ImAxis_X1, from, to);
-        return *this;
-    }
-
-    Self& set_y_axis_limits(double from, double to) {
-        return *this;
-    }
-
-    Self& enable_scrolling() {
-        m_is_scrolling = true;
-    }
-
-    Self& disable_scrolling() {
-        m_is_scrolling = true;
-    }
-
-    
-    void draw() {
-        ImGui::PushID(m_name.c_str());
-
-        auto head = m_metric.get_head();
-        auto head_timeline = m_metric.get_head_timeline();
-
-        auto tail = m_metric.get_tail();
-        auto tail_timeline = m_metric.get_tail_timeline();
-
-        static float m_metric_history = 10.0f;
-        ImGui::Checkbox("Is Scrolling", &m_is_scrolling);
-        if(m_is_scrolling) {
-            ImGui::SliderFloat("History", &m_metric_history,1,30,"%.1f s");
+    /** Describes what is drawn, so the numbers always match the line. */
+    void draw_summary() const {
+        if(m_values.empty()) {
+            ImGui::TextUnformatted("no samples yet");
+            return;
         }
 
-        ImGui::Text("Min: %i", m_metric.min());
-        ImGui::Text("Max: %i", m_metric.max());
+        auto [low, high] = std::minmax_element(m_values.begin(), m_values.end());
 
-        if(ImPlot::BeginPlot(m_name.c_str())) {
-            auto from = tail_timeline.empty() ? *(head_timeline.end() - 1) : *(tail_timeline.end() - 1);
+        double total = 0.0;
+        for(double value : m_values) {
+            total += value;
+        }
 
-            ImPlot::SetupAxes("Time", m_name.c_str(), ImPlotAxisFlags_None, ImPlotAxisFlags_None);
-            if(m_is_scrolling) {
-                ImPlot::SetupAxisLimits(ImAxis_X1, from - m_metric_history, from, ImGuiCond_Always);
+        ImGui::Text("min %.1f %s   avg %.1f %s   max %.1f %s",
+            *low, m_unit.c_str(),
+            total / (double)m_values.size(), m_unit.c_str(),
+            *high, m_unit.c_str());
+    }
+
+public:
+    MetricWidget(std::string name, std::string unit, const Series& series, metrics::MetricField field) :
+        m_name(std::move(name)),
+        m_unit(std::move(unit)),
+        m_series(&series),
+        m_field(field)
+    { }
+
+    /** Draws the last `history_in_seconds` seconds of the series. */
+    void draw(size_t history_in_seconds) {
+        ImGui::PushID(m_name.c_str());
+
+        m_series->linearize(m_ages, m_values, m_field, history_in_seconds, SKIP_IN_PROGRESS);
+
+        if(has_range()) {
+            m_series->linearize(m_ages, m_lows, metrics::MetricField::Min,
+                history_in_seconds, SKIP_IN_PROGRESS);
+            m_series->linearize(m_ages, m_highs, metrics::MetricField::Max,
+                history_in_seconds, SKIP_IN_PROGRESS);
+        }
+
+        draw_summary();
+
+        if(ImPlot::BeginPlot(m_name.c_str(), ImVec2(-1.0f, 150.0f))) {
+            ImPlot::SetupAxes("seconds ago", m_unit.c_str(),
+                ImPlotAxisFlags_None, ImPlotAxisFlags_AutoFit);
+            ImPlot::SetupAxisLimits(ImAxis_X1, -(double)history_in_seconds, 0.0, ImGuiCond_Always);
+
+            const int count = (int)m_values.size();
+
+            if(has_range() && count > 0) {
+                ImPlot::PlotShaded("range", m_ages.data(), m_lows.data(), m_highs.data(), count);
             }
 
-            ImPlot::SetupAxisLimits(ImAxis_Y1, 0, m_metric.max() * 2, ImGuiCond_Always);
-            // ImPlot::SetupAxisLimitsConstraints(ImAxis_Y1, 0, 10000);
+            if(count > 0) {
+                ImPlot::PlotLine(m_name.c_str(), m_ages.data(), m_values.data(), count);
+            }
 
-            ImPlot::PlotLine(m_name.c_str(), head_timeline.data(), head.data(), head.size());
-            ImPlot::PlotLine(m_name.c_str(), tail_timeline.data(), tail.data(), tail.size());
             ImPlot::EndPlot();
         }
 

modules/client/src/debug/tools/NetworkStatsGui.hpp

@@ -1,62 +1,70 @@
 #pragma once
 
-#include "metrics/BucketMetric.hpp"
-#include "metrics/NetworkStatsLogger.hpp"
+#include "debug/DebugWindow.hpp"
+#include "debug/metrics/NetworkMetrics.hpp"
 #include "debug/tools/MetricWidget.hpp"
 
-#include <implot.h>
-#include <implot_internal.h>
+#include <imgui.h>
 
 namespace tw::dbg::tools {
 
-class NetworkStatsGui {
-private:
-    // MetricWidget<uint32_t, std::chrono::seconds, net::AverageOp<uint32_t>> m_ping_widget;
-    // MetricWidget<uint32_t, std::chrono::seconds> m_outgoing_widget;
-    // MetricWidget<uint32_t, std::chrono::seconds> m_incoming_widget;
+/**
+ * Panel over everything the client measured about its traffic.
+ *
+ * Traffic is shown as the total of each second, since that is the rate the
+ * connection actually carried. Durations are shown as the average of each
+ * second, with the range behind them.
+ */
+class NetworkStatsGui : public tw::dbg::DebugWindow {
+    MetricWidget m_response;
+    MetricWidget m_update;
+    MetricWidget m_bytes_in;
+    MetricWidget m_bytes_out;
+    MetricWidget m_messages_in;
+    MetricWidget m_messages_out;
+
+    MetricWidget m_rollbacks;
+    MetricWidget m_correction_distance;
+    MetricWidget m_ack_lag_frames;
+    MetricWidget m_replayed_frames;
+
+    int m_history_in_seconds = 30;
+
+protected:
+    void draw_contents() override {
+        ImGui::SliderInt("History", &m_history_in_seconds, 5, 300, "%d s");
+
+        const size_t history = (size_t)m_history_in_seconds;
+
+        m_response.draw(history);
+        m_update.draw(history);
+        m_bytes_in.draw(history);
+        m_bytes_out.draw(history);
+        m_messages_in.draw(history);
+        m_messages_out.draw(history);
+
+        ImGui::Separator();
+        ImGui::TextUnformatted("Prediction");
+        m_rollbacks.draw(history);
+        m_correction_distance.draw(history);
+        m_ack_lag_frames.draw(history);
+        m_replayed_frames.draw(history);
+    }
 
 public:
-    // NetworkStatsGui() :
-    //     m_ping_widget("Ping", net::NetworkStatsLogger::instance()->ping()),
-    //     m_outgoing_widget("Outgoing", net::NetworkStatsLogger::instance()->outgoing()),
-    //     m_incoming_widget("Incoming", net::NetworkStatsLogger::instance()->incoming())
-    // {
-    // }
-
-    void draw() {
-        // auto* instance = net::NetworkStatsLogger::instance();
-        // auto& ping = instance->ping();
-
-        ImGui::Begin("Network Stats");
-
-        /* auto head = ping.get_head();
-        auto head_timeline = ping.get_head_timeline();
-
-        auto tail = ping.get_tail();
-        auto tail_timeline = ping.get_tail_timeline();
-
-        static float ping_history = 10.0f;
-        ImGui::SliderFloat("Ping History", &ping_history,1,30,"%.1f s");
-
-        if(ImPlot::BeginPlot("Ping")) {
-            auto from = tail_timeline.empty() ? *(head_timeline.end() - 1) : *(tail_timeline.end() - 1);
-
-            ImPlot::SetupAxes("FrameIdx","FPS", ImPlotAxisFlags_None, ImPlotAxisFlags_None);
-            ImPlot::SetupAxisLimits(ImAxis_X1, from - ping_history, from, ImGuiCond_Always);
-            ImPlot::SetupAxisLimits(ImAxis_Y1, 0, 120);
-            ImPlot::SetupAxisLimitsConstraints(ImAxis_Y1, 0, 10000);
-
-            ImPlot::PlotLine("Ping", head_timeline.data(), head.data(), head.size());
-            ImPlot::PlotLine("Ping", tail_timeline.data(), tail.data(), tail.size());
-            ImPlot::EndPlot();
-        } */
-
-        // m_ping_widget.draw();
-        // m_outgoing_widget.draw();
-        // m_incoming_widget.draw();
-
-        ImGui::End();
-    }
+    explicit NetworkStatsGui(const NetworkMetrics& metrics) :
+        DebugWindow("network_stats", "Network Stats", "Network"),
+        m_response("Response", "ms", metrics.response_ms(), metrics::MetricField::Avg),
+        m_update("Network update", "ms", metrics.update_ms(), metrics::MetricField::Avg),
+        m_bytes_in("Bytes in", "B/s", metrics.bytes_in(), metrics::MetricField::Sum),
+        m_bytes_out("Bytes out", "B/s", metrics.bytes_out(), metrics::MetricField::Sum),
+        m_messages_in("Messages in", "1/s", metrics.messages_in(), metrics::MetricField::Sum),
+        m_messages_out("Messages out", "1/s", metrics.messages_out(), metrics::MetricField::Sum),
+        m_rollbacks("Rollbacks", "1/s", metrics.rollbacks(), metrics::MetricField::Sum),
+        m_correction_distance("Correction distance", "m", metrics.correction_distance(), metrics::MetricField::Avg),
+        m_ack_lag_frames("Ack lag", "frames", metrics.ack_lag_frames(), metrics::MetricField::Avg),
+        m_replayed_frames("Replayed frames", "frames", metrics.replayed_frames(), metrics::MetricField::Avg)
+    { }
 };
 
 }

modules/client/src/debug/tools/PacketBacklogGui.hpp

@@ -1,57 +0,0 @@
-#pragma once
-
-#include <format>
-#include <vector>
-
-#include "imgui.h"
-
-#include "metrics/NetworkStatsLogger.hpp"
-
-namespace tw::dbg::tools {
-
-class PacketBacklogGui {
-private:
-    std::vector<uint32_t> m_buckets;
-    uint32_t m_last_backlog_idx;
-
-public:
-    void draw() {
-        // auto* instance = net::NetworkStatsLogger::instance();
-        // size_t size = instance->get_size();
-
-        // if(ImGui::BeginTable("Network Packets", 5)) {
-        //     ImGui::TableSetupColumn("Message Type");
-        //     ImGui::TableSetupColumn("Time");
-        //     ImGui::TableSetupColumn("Is From Us");
-        //     ImGui::TableSetupColumn("Target");
-        //     ImGui::TableSetupColumn("Size");
-
-        //     for(int32_t i = size-1; i >= 0; i--) {
-        //         auto& item = instance->get_item(i);
-        //         ImGui::PushID(item.timepoint.time_since_epoch().count());
-
-        //         ImGui::TableNextRow();
-
-        //         ImGui::TableNextColumn();
-        //         ImGui::Text("%i", item.message_type);
-
-        //         ImGui::TableNextColumn();
-        //         ImGui::Text(std::format("{}", item.timepoint.time_since_epoch()).c_str());
-
-        //         ImGui::TableNextColumn();
-        //         ImGui::Checkbox("is_sent_from_us", &item.is_sent_by_us);
-
-        //         ImGui::TableNextColumn();
-        //         ImGui::Text(item.target.to_string().c_str());
-
-        //         ImGui::TableNextColumn();
-        //         ImGui::Text("%ld", item.buffer.size());
-
-        //         ImGui::PopID();
-        //     }
-        //     ImGui::EndTable();
-        // }
-    }
-};
-
-}

modules/client/src/debug/tools/PacketLogger.hpp

@@ -2,7 +2,6 @@
 
 #include "Address.hpp"
 #include "ByteBuffer.hpp"
-#include "packets/Packet.hpp"
 #include <cstring>
 
 namespace tw::dbg::tools {

modules/client/src/debug/tools/PerformanceStatsGui.cpp

@@ -7,14 +7,14 @@
 namespace tw::dbg::tools {
 
 PerformanceStatsGui::PerformanceStatsGui(LockStep& lock_step) :
+    DebugWindow("performance_stats", "Performance", "General"),
     m_lockstep(lock_step),
     fps_history(1000),
     frame_idxs(1000)
 {
 }
 
-void PerformanceStatsGui::draw() {
-    ImGui::Begin("Stats");
+void PerformanceStatsGui::draw_contents() {
 
     ImGui::Text("FPS: %ld", m_lockstep.fps());
     fps_history[fps_history_idx] = m_lockstep.fps();
@@ -34,8 +34,6 @@ void PerformanceStatsGui::draw() {
         ImPlot::PlotLine("FPS", frame_idxs.data(), fps_history.data(), is_plot_filled ? (int)fps_history.size() : (int)fps_history_idx - 1);
         ImPlot::EndPlot();
     }
-
-    ImGui::End();
 }
 
 }

modules/client/src/debug/tools/PerformanceStatsGui.hpp

@@ -1,10 +1,11 @@
 #pragma once
 
+#include "debug/DebugWindow.hpp"
 #include "runtime/LockStep.hpp"
 
 namespace tw::dbg::tools {
 
-class PerformanceStatsGui {
+class PerformanceStatsGui : public tw::dbg::DebugWindow {
 private:
     LockStep& m_lockstep;
 
@@ -15,10 +16,11 @@ private:
     uint32_t frame_idx = 0;
     bool is_plot_filled = false;
 
+protected:
+    void draw_contents() override;
+
 public:
     PerformanceStatsGui(LockStep& lock_step);
-
-    void draw();
 };
 
 }