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/ExplosionEffect.hpp"
#include "effects/HitscanEffect.hpp"
#include "effects/ImpactEffect.hpp"
#include "effects/RibbonTrail.hpp"
#include "effects/SmokeEffect.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>

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);
 
    // 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 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 arcVertexCount() const { return hitscan_.arcCount(); }
    [[nodiscard]] uint32_t smokeCount() const { return smoke_.count(); }
    [[nodiscard]] uint32_t decalCount() const { return decals_.count(); }
    [[nodiscard]] bool sdfReady() const { return sdf_.ready(); }

    [[nodiscard]] const SdfAtlas& sdfAtlas() const { return sdf_.atlas(); }
 
private:
    ParticleRenderer renderer_;
    TracerEffect tracers_;
    RibbonTrail ribbons_;
    HitscanEffect hitscan_;
    SmokeEffect smoke_;
    ImpactEffect impact_;
    BulletHoleDecal decals_;
    ExplosionEffect explosions_;
    SdfRenderer sdf_;
 
    // Cached each frame from Camera
    glm::vec3 camPos_{};
    glm::vec3 camForward_{};
    glm::vec3 camRight_{};
    glm::vec3 camUp_{};
    float screenW_ = 1280.f;
    float screenH_ = 720.f;
 
    float frameDt_ = 0.016f; // last dt, needed by spawn callbacks
};