DebugUI.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "ecs/components/Hitbox.hpp"
#include "ecs/physics/SweptCollision.hpp"
#include "ecs/registry/Registry.hpp"
#include "network/MatchStatus.hpp"
#include "network/ShotDebugReport.hpp" // PR-20: ShotDebugCapture.
 
// Forward-declared so DebugUI doesn't drag in raycast / hitbox headers via the
// gamepad aim-assist system.  Full definition pulled in by DebugUI.cpp.
namespace systems
{
struct GamepadAimAssistConfig;
}
 
#include <SDL3/SDL.h>
 
#include <array>
#include <cstdint>
#include <glm/mat4x4.hpp>
#include <glm/vec3.hpp>
#include <initializer_list>
 
struct NetworkStats;  
class ParticleSystem; 

class DebugUI
{
public:
    bool init(SDL_Window* window);

    void shutdown();

    void processEvent(const SDL_Event* event);

    void newFrame();

    void buildUI(const Registry& registry,
                 int tickCount,
                 float& mouseSensitivity,
                 float& gamepadLookSensitivity,
                 systems::GamepadAimAssistConfig& aimAssistCfg,
                 bool& renderSeparateFromPhysics,
                 bool& inputSyncedWithPhysics,
                 bool& limitFPSToMonitor,
                 int& ssrMode,
                 float physicsHz,
                 float fpsCurrent,
                 float fpsMin,
                 float fpsMax,
                 float fps1pLow,
                 float fps5pLow);

    void buildParticleUI(ParticleSystem& ps, glm::vec3 eyePos, glm::vec3 forward);

    void buildRenderTogglesUI(class Renderer& renderer);

    void buildSkyboxUI(class Renderer& renderer);

    void buildLightingUI(class Renderer& renderer);

    void buildNetworkUI(const NetworkStats& stats);

    void buildNetworkSimUI();

    [[nodiscard]] int getSimulatedLatencyMs() const noexcept { return simulatedLatencyMs_; }

    [[nodiscard]] int getSimulatedLossPercent() const noexcept { return simulatedLossPct_; }
 
    void buildWeaponUI(const Registry& registry);

    void buildHitboxUI(const Registry& registry,
                       HitboxRig& hitboxRig,
                       const glm::mat4& viewProj,
                       float screenWidth,
                       float screenHeight);
 
    bool showHitboxWindow = false;  
    bool drawHitboxOverlay = false; 

    void buildCollisionUI(const physics::WorldGeometry& world,
                          const glm::mat4& viewProj,
                          float screenWidth,
                          float screenHeight);
 
    bool showCollisionWindow = false;  
    bool drawCollisionOverlay = false; 

    void
    buildWeaponSpawnerUI(const Registry& registry, const glm::mat4& viewProj, float screenWidth, float screenHeight);
 
    bool showWeaponSpawnerWindow = false;  
    bool drawWeaponSpawnerOverlay = false; 

    void buildSpawnPointUI(const Registry& registry, const glm::mat4& viewProj, float screenWidth, float screenHeight);
 
    bool showSpawnPointWindow = false;  
    bool drawSpawnPointOverlay = false; 
 
    // ── PR-20: Shot-debug visualizer (CSGO sv_showimpacts-style) ─────
    //
    // Holds a ring buffer of paired (client-side fire-time snapshot,
    // server-side rewound snapshot) entries.  ImGui panel lets the
    // user pick how many recent shots to keep (1-30) and which to
    // highlight in the 3-D overlay.
    //
    // The two snapshots reuse the same `ShotDebugCapture` type:
    //   - clientView is populated by `pushClientShot()` from Game.cpp
    //     when the local player fires a shot (with the visible-on-
    //     screen capsules of remote players at fire time).
    //   - serverView is populated by `pushServerShot()` from the
    //     `Client::onShotDebugReport` callback (with the historical
    //     capsules the server raycast against).
    //
    // The two halves are paired by `shotInputTick`; either may
    // arrive first.
    struct ShotDebugPair
    {
        std::uint32_t shotInputTick = 0;
        bool hasClient = false;
        bool hasServer = false;
        net::shotdebug::ShotDebugCapture clientView;
        net::shotdebug::ShotDebugCapture serverView;
    };
    static constexpr int k_shotRingMax = 30;
    std::array<ShotDebugPair, k_shotRingMax> shotRing{};
    int shotRingHead = 0;  
    int shotRingCount = 0; 

    bool showShotDebugWindow = false;
    bool drawShotDebugOverlay = false;
    int shotDebugVisibleCount = 5;
    int shotDebugSelectIdx = 0;

    int shotDebugViewMode = 0;

    void pushClientShot(const net::shotdebug::ShotDebugCapture& cap);

    void pushServerShot(const net::shotdebug::ShotDebugCapture& cap);

    void buildShotDebugUI(const glm::mat4& viewProj, float screenWidth, float screenHeight);
 
    // Per-type visibility toggles (all default on when overlay is active).
    bool drawCollisionPlanes = true;
    bool drawCollisionBoxes = true;
    bool drawCollisionBrushes = true;
    bool drawCollisionCylinders = true;
    bool drawCollisionSpheres = true;
    bool drawCollisionTriMeshes = true;

    void render();

    void toggleDebugMenu();

    struct ExternalPanel
    {
        const char* name; 
        bool* visible;    
    };
    void buildDebugMenu(std::initializer_list<ExternalPanel> externalPanels);
 
    bool showDebugMenu = false;      
 
    bool pendingAmmoRefill_ = false; 
 
private:
    bool showInspector = false;        
    bool showRenderToggles = false;    
    bool showLightingControls = false; 
    bool showSkybox = false;           
    bool showNetworkStats = false;     
    bool showNetworkSim = false;       
    bool showWeaponHud = false;        

    int simulatedLatencyMs_ = 0;

    int simulatedLossPct_ = 0;

    bool showPosition = true;       
    bool showPrevPosition = false;  
    bool showVelocity = true;       
    bool showCollisionShape = true; 
    bool showPlayerState = true;    
    bool showInputSnapshot = true;  
    bool showViewAngles = true;     
    bool showMovementChart = false; 
    bool showBhopAnalyzer = false;  

    void buildInspectorContents(const Registry& registry,
                                int tickCount,
                                float& mouseSensitivity,
                                float& gamepadLookSensitivity,
                                systems::GamepadAimAssistConfig& aimAssistCfg,
                                bool& renderSeparateFromPhysics,
                                bool& inputSyncedWithPhysics,
                                bool& limitFPSToMonitor,
                                int& ssrMode,
                                float physicsHz,
                                float fpsCurrent,
                                float fpsMin,
                                float fpsMax,
                                float fps1pLow,
                                float fps5pLow);

    void buildMovementChart(const Registry& registry);

    void buildBhopAnalyzer(const Registry& registry);
 
    // Bhop analyzer rolling state (ring buffers, persist across frames).
    static constexpr int k_bhopHistorySize = 256;
    float bhopSpeedHistory_[k_bhopHistorySize] = {};
    float bhopGainHistory_[k_bhopHistorySize] = {};
    bool bhopAirborneHistory_[k_bhopHistorySize] = {};
    bool bhopGainingHistory_[k_bhopHistorySize] = {};
    int bhopHistoryIdx_ = 0;      
    int bhopHistoryFill_ = 0;     
    float bhopPrevHSpeed_ = 0.0f; 
    bool bhopHasPrevSample_ = false;
 
    // Particle UI state
    float particleSpawnDist_ = 200.f; 
    bool showParticleWindow_ = false;
};