Game.hpp

Go to the documentation of this file.

 
 
#pragma once
 
#include "animation/AnimationLibrary.hpp"
#include "animation/AnimationTesterUI.hpp"
#include "animation/CharacterRig.hpp"
#include "animation/SkinningBackend.hpp"
#include "debug/DebugUI.hpp"
#include "debug/FrameRecorder.hpp"
#include "ecs/components/ViewmodelConfig.hpp"
#include "ecs/registry/Registry.hpp"
#include "network/Client.hpp"
#include "network/MatchStatus.hpp"
#include "network/NetworkConfig.hpp"
#include "particles/ParticleSystem.hpp"
#include "sfx/SfxSystem.hpp"
#ifdef USE_HYBRID_RENDERER
#include "renderer/HybridRenderer.hpp"
#else
#include "renderer/Renderer.hpp"
#endif
 
#include <SDL3/SDL.h>
 
#include <entt/entt.hpp>
#include <glm/glm.hpp>
 
class Game
{
public:
    bool init();
 
    SDL_AppResult event(SDL_Event* event);
 
    SDL_AppResult iterate();
 
    void quit();
    void refreshRemotePlayerRenderables();
    void refreshRemoteProjectileRenderables();
 
private:
    static constexpr int k_physicsHz = 128;                                      
    static constexpr float k_physicsDt = 1.0f / static_cast<float>(k_physicsHz); 
    static constexpr int k_maxTicksPerFrame = 8; 
    static constexpr int k_fpsHistorySize = 512; 
 
    NetworkConfig netCfg;                        
    SDL_Window* window = nullptr;                
    DebugUI debugUI;                             
#ifdef USE_HYBRID_RENDERER
    HybridRenderer renderer;                     
#else
    Renderer renderer; 
#endif
    Registry registry;             
    Client client;                 
    ParticleSystem particleSystem; 
    SfxSystem sfxSystem;           
    entt::dispatcher dispatcher;   
 
    Uint64 prevTime = 0;           
    float accumulator = 0.0f;      
    int tickCount = 0;             
    bool mouseCaptured = true;     
 
    // Runtime-tunable loop settings (exposed via ImGui)
    float mouseSensitivity = 0.001f;       
    bool renderSeparateFromPhysics = true; 
    bool inputSyncedWithPhysics = true;    
    bool limitFPSToMonitor = true;         
 
    Uint64 softLimitPeriod = 0;            
    Uint64 softLimitNextFrame = 0;         
 
    void applyFrameRateLimit();
 
    FrameRecorder recorder;  
    uint64_t frameCount = 0; 
 
    // Cached camera state — updated each iterate(), used by event() key shortcuts.
    glm::vec3 cachedEye_{0.f, 100.f, 0.f};
    glm::vec3 cachedCamFwd_{0.f, 0.f, 1.f};
    float currentCameraRoll_{0.0f}; 
 
    // Model indices for entity rendering (loaded at init).
    int wraithModelIdx = -1;                       
    int glowSphereModelIdx_ = -1;                  
    int movableSphereModelIdx_ = -1;               
    int weaponModelIndices_[4] = {-1, -1, -1, -1}; 
 
    // Dynamic lighting test controls (ImGui-tunable)
    bool showDynLightUI_ = false;                        
    bool flashlightEnabled_ = false;                     
    float flashlightIntensity_ = 8.0f;                   
    float flashlightRange_ = 800.0f;                     
    float flashlightOffset_ = 30.0f;                     
    bool movableSphereEnabled_ = false;                  
    float sphereFollowDist_ = 150.0f;                    
    float sphereIntensity_ = 5.0f;                       
    float sphereRange_ = 500.0f;                         
    int glowCylinderModelIdx_ = -1;                      
    bool beamEnabled_ = false;                           
    glm::vec3 beamStartOff_{30.0f, -5.0f, 10.0f};        
    glm::vec3 beamEndOff_{200.0f, -5.0f, 10.0f};         
    float beamRadius_ = 3.0f;                            
    glm::vec3 beamColor_{0.6f, 0.1f, 1.0f};              
    float beamLightIntensity_ = 4.0f;                    
    float beamLightRange_ = 300.0f;                      
    float beamLightSpacing_ = 60.0f;                     
    WeaponType currentEquippedType_ = WeaponType::Rifle; 
    WeaponType lastEquippedType_ = WeaponType::Rifle; 
 
    // Sound state tracking
    bool wasChargingRailgun_ = false; 
    bool wasBeamActive_ = false;      
 
    // Hitmarker
    float hitmarkerTimer_ = 0.0f; 
 
    // Viewmodel tuning (live-adjustable via ImGui)
    float vmScale = 0.03f;        
    float vmForward = 21.0f;      
    float vmRight = 5.5f;         
    float vmDown = 22.5f;         
    float vmYawOffset = 58.0f;    
    float vmPitchOffset = 12.0f;  
    float vmRollOffset = 2.0f;    
    bool showViewmodelUI = false; 
 
    // Weapon sway state (CoD-style barrel lead)
    float prevSwayYaw_ = 0.0f;
    float prevSwayPitch_ = 0.0f;
    float swayOffsetX_ = 0.0f;     
    float swayOffsetY_ = 0.0f;     
    bool swayInitialized_ = false; 
 
    // Sway tuning (ImGui-adjustable)
    float swayAmplitudeYaw_ = 3.0f;
    float swayAmplitudePitch_ = 2.0f;
    float swayDecayRate_ = 8.0f;  
    float swaySmoothing_ = 0.15f; 
 
    // Visual recoil state (viewmodel-only, does not affect aim)
    float recoilPitch_ = 0.0f;    
    float recoilPushBack_ = 0.0f; 
    float recoilRoll_ = 0.0f;     
 
    // Local weapon fire cooldown (mirrors server's per-weapon cooldown for VFX)
    float localFireCooldown_ = 0.0f; 
 
    // Crosshair settings (ImGui-adjustable)
    float crosshairSize_ = 6.0f;                           
    float crosshairThickness_ = 2.0f;                      
    float crosshairGap_ = 3.0f;                            
    glm::vec4 crosshairColor_ = {0.0f, 1.0f, 0.0f, 0.85f}; 
    bool crosshairDot_ = true;                             
    bool showCrosshair_ = true;                            
 
    // Scroll-wheel weapon switching
    int pendingScrollSwitch_ = 0; 
 
    // Third-person weapon tuning (per weapon type, live-adjustable via ImGui)
    ThirdPersonWeaponParams tpWeaponParams_[4]; 
    int tpTuneWeaponIdx_ = 0;                   
    bool showTPWeaponUI_ = false;               
 
    // Animation subsystem — shared rig + clip library + skinning backend.
    // CharacterAnimators (one per animated entity) hold non-owning refs.
    CharacterRig charRig_;              
    AnimationLibrary animLibrary_;      
    CpuLbsSkinningBackend skinBackend_; 
    AnimationTesterState animUI_;       
    float kRigScale_ = 1.0f;            
    float kRigVerticalOffset_ =
        -90.0f;                
    float rigMeshMinY_ = 0.0f; 
 
    // FPS ring buffer -- inter-render deltas, newest at (head-1) % size
    float fpsHistory[k_fpsHistorySize] = {}; 
    int fpsHistoryHead = 0;                  
    int fpsHistoryCount = 0;                 
    Uint64 prevRenderTime = 0;               
 
    // Network ping timer
    float pingTimer = 0.0f; 
 
    // Performance stats -- refreshed every 0.5 s
    Uint64 statsPrevTime = 0;       
    int statsPhysTicks = 0;         
    float measuredPhysicsHz = 0.0f; 
    float statsFPSCurrent = 0.0f;   
    float statsFPSMin = 0.0f;       
    float statsFPSMax = 0.0f;       
    float statsFPS1pLow = 0.0f;     
    float statsFPS5pLow = 0.0f;     
 
    void attachAnimatedCharacter(entt::entity e);
 
    // Match State
    MatchPhase currentMatchPhase = MatchPhase::WARMUP; 
    float countdownTimer = 0.0f; 
};