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,
                 float physicsHz,
                 float fpsCurrent,
                 float fpsMin,
                 float fpsMax,
                 float fps1pLow,
                 float fps5pLow);

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

    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
    buildDroppedWeaponUI(const Registry& registry, const glm::mat4& viewProj, float screenWidth, float screenHeight);
 
    bool showDroppedWeaponWindow = false;  
    bool drawDroppedWeaponOverlay = false; 

    void buildSpawnPointUI(const Registry& registry, const glm::mat4& viewProj, float screenWidth, float screenHeight);
 
    bool showSpawnPointWindow = false;  
    bool drawSpawnPointOverlay = false; 

    void buildKillzoneUI(const Registry& registry, const glm::mat4& viewProj, float screenWidth, float screenHeight);
 
    bool showKillzoneWindow = false;  
    bool drawKillzoneOverlay = 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 buildContactDebugUI(const glm::mat4& viewProj, float screenWidth, float screenHeight);
 
    bool showContactDebugWindow = false; 
    bool drawContactOverlay = false;     
 
    // Per-source visibility toggles for the contact overlay.
    bool drawContactPlaneSweep = true;
    bool drawContactBoxSweep = true;
    bool drawContactBrushSweep = true;
    bool drawContactCylinderSweep = true;
    bool drawContactSphereSweep = true;
    bool drawContactTriMeshSweep = true;
    bool drawContactPlaneDepen = true;
    bool drawContactBoxDepen = true;
    bool drawContactBrushDepen = true;
    bool drawContactCylinderDepen = true;
    bool drawContactSphereDepen = true;
    bool drawContactTriMeshDepen = true;

    float contactNormalLength = 16.0f;

    float contactPointRadius = 4.0f;

    bool drawMeshEdgeOverlay = false;

    bool drawMeshVertexOverlay = false;

    void render();

    void toggleDebugMenu();

    struct ExternalPanel
    {
        const char* name; 
        bool* visible;    
    };
    void buildDebugMenu(std::initializer_list<ExternalPanel> externalPanels);
 
    bool showDebugMenu = false; 

    bool consumePhysicsCsvRecordingRequest(bool& enabled) noexcept;
 
    bool pendingAmmoRefill_ = false;             
    bool pendingAbilityLevelGrant_ = false;      
    std::int8_t pendingSetPrimaryWeapon_ = -1;   
    std::int8_t pendingSetSecondaryWeapon_ = -1; 
 
private:
    bool showInspector = false;    
    bool showNetworkStats = false; 
    bool showNetworkSim = false;   
    bool showWeaponHud = false;    
 
    bool pendingPhysicsCsvRecordingRequest_ = false;
    bool pendingPhysicsCsvRecordingEnabled_ = 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,
                                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 energyTeslaPreviewLive_ = false;
    bool energyTeslaPreviewLocked_ = true;
    float energyTeslaGuideDist_ = 200.f;
    float energyTeslaEndpointForward_ = 136.f;
    float energyTeslaEndpointRight_ = 95.f;
    float energyTeslaEndpointUp_ = 32.f;
    float energyTeslaPreviewLockStrength_ = 1.f;
    bool showParticleWindow_ = false;
};