ParticleSystem.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "ParticleEvents.hpp"
#include "ParticleRenderer.hpp"
#include "ecs/components/Projectile.hpp"
#include "ecs/registry/Registry.hpp"
#include "effects/BulletHoleDecal.hpp"
#include "effects/EnergyTeslaArcEffect.hpp"
#include "effects/DeathDissolveEffect.hpp"
#include "effects/ExplosionVfxEffect.hpp"
#include "effects/HitscanEffect.hpp"
#include "effects/ImpactEffect.hpp"
#include "effects/RibbonTrail.hpp"
#include "effects/SmokeEffect.hpp"
#include "effects/TeslaBeamEffect.hpp"
#include "effects/TracerEffect.hpp"
#include "renderer-new/Camera.hpp"
#include "sdf/SdfRenderer.hpp"
 
#include <entt/entt.hpp>
#include <glm/glm.hpp>
#include <string_view>
#include <unordered_map>

class ParticleSystem
{
public:
    bool init(SDL_GPUDevice* dev, SDL_GPUTextureFormat colorFmt, SDL_GPUShaderFormat shaderFmt);

    void quit();
 
    // Spawn API (call from weapon / game event logic)

    void spawnProjectileTracer(entt::entity e, Registry& reg);

    void spawnRibbonTrail(entt::entity e, Registry& reg);

    void spawnBulletTracer(glm::vec3 origin, glm::vec3 dir, float range = 500.f);

    void spawnHitscanBeam(glm::vec3 origin, glm::vec3 hitPos, WeaponType wt);

    void spawnImpactEffect(glm::vec3 pos, glm::vec3 normal, SurfaceType surf, WeaponType wt);

    void spawnBulletHole(glm::vec3 pos, glm::vec3 normal, WeaponType wt);

    void spawnSmoke(glm::vec3 pos, float radius);

    void spawnFire(glm::vec3 pos, float radius);

    void spawnExplosion(glm::vec3 pos, float blastRadius);

    void spawnDeathDissolve(const std::vector<glm::vec3>& worldPoints, glm::vec3 center, glm::vec4 color);

    void spawnExplosionVfx(glm::vec3 pos,
                           glm::vec3 normal,
                           float blastRadius,
                           ExplosionVfxKind kind = ExplosionVfxKind::Rocket);

    void driveGroundFire(entt::entity fieldEntity, glm::vec3 pos, float radius, float remaining, float duration);

    void debugEnergyTeslaArc(glm::vec3 origin, glm::vec3 guidePoint, glm::vec3 hitPoint, bool locked, float lockStrength);
    void debugEnergyTeslaPreview(glm::vec3 origin,
                                  glm::vec3 guidePoint,
                                  glm::vec3 hitPoint,
                                  bool locked,
                                  float lockStrength);
 
    // SDF text (queued per frame, flushed in render)

    void drawWorldText(glm::vec3 worldPos, std::string_view text, glm::vec4 color, float worldHeight);

    void drawScreenText(glm::vec2 pixelPos, std::string_view text, glm::vec4 color, float pixelHeight);
 
    // Frame lifecycle

    void setScreenSize(float w, float h)
    {
        screenW_ = w;
        screenH_ = h;
    }

    void update(float dt, const NewCamera& cam, Registry& reg);
    void update(float dt, glm::vec3 eye, glm::vec3 forward, glm::vec3 right, glm::vec3 up, Registry& reg);

    void setLocalEnergyBeamOriginOverride(glm::vec3 origin)
    {
        localEnergyBeamOriginOverride_ = origin;
        localEnergyBeamOriginOverrideValid_ = true;
    }

    void clearLocalEnergyBeamOriginOverride() { localEnergyBeamOriginOverrideValid_ = false; }

    void uploadToGpu(SDL_GPUCommandBuffer* cmd);

    void render(SDL_GPURenderPass* pass, SDL_GPUCommandBuffer* cmd);
 
    // entt::dispatcher event handlers
    void onWeaponFired(const WeaponFiredEvent& e);

    void onImpact(const ProjectileImpactEvent& e);

    void onExplosion(const ExplosionEvent& e);
 
    // Live-count accessors (for debug UI)
    [[nodiscard]] uint32_t impactCount() const { return impact_.count(); }
    [[nodiscard]] uint32_t tracerCount() const { return tracers_.count(); }
    [[nodiscard]] uint32_t ribbonVertexCount() const { return ribbons_.count(); }
    [[nodiscard]] uint32_t hitscanBeamCount() const { return hitscan_.activeBeamCount(); }
    [[nodiscard]] uint32_t railgunArcVertexCount() const { return hitscan_.arcCount(); }
    [[nodiscard]] uint32_t energyTeslaArcVertexCount() const { return energyTesla_.arcCount(); }
    [[nodiscard]] uint32_t energyTeslaBeamCount() const { return energyTesla_.activeBeamCount(); }
    [[nodiscard]] uint32_t arcVertexCount() const { return hitscan_.arcCount() + tesla_.arcCount() + energyTesla_.arcCount(); }
    [[nodiscard]] uint32_t smokeCount() const { return smoke_.count(); }
    [[nodiscard]] uint32_t explosionSpriteCount() const { return explosionVfx_.spriteCount(); }
    [[nodiscard]] uint32_t explosionDebrisCount() const { return explosionVfx_.debrisCount(); }
    [[nodiscard]] uint32_t decalCount() const { return decals_.count(); }
    [[nodiscard]] bool sdfReady() const { return sdf_.ready(); }

    [[nodiscard]] const SdfAtlas& sdfAtlas() const { return sdf_.atlas(); }
 
private:
    void driveRocketSmokeTrails(float dt, Registry& reg);
 
    ParticleRenderer renderer_;
    TracerEffect tracers_;
    RibbonTrail ribbons_;
    HitscanEffect hitscan_;
    TeslaBeamEffect tesla_;
    EnergyTeslaArcEffect energyTesla_;
    SmokeEffect smoke_;
    ImpactEffect impact_;
    BulletHoleDecal decals_;
    ExplosionVfxEffect explosionVfx_;
    DeathDissolveEffect death_;
    SdfRenderer sdf_;
 
    // Cached each frame from Camera
    glm::vec3 camPos_{};
    glm::vec3 camForward_{};
    glm::vec3 camRight_{};
    glm::vec3 camUp_{};
    glm::vec3 localEnergyBeamOriginOverride_{0.0f};
    bool localEnergyBeamOriginOverrideValid_ = false;
    float screenW_ = 1280.f;
    float screenH_ = 720.f;
 
    float frameDt_ = 0.016f; // last dt, needed by spawn callbacks
 
    std::unordered_map<entt::entity, float> rocketSmokeAccumulators_;
 
    // Scratch buffer: railgun + legacy tesla + energy tesla arc verts merged for a single upload.
    std::vector<ArcVertex> arcScratch_;
};