dl_particle.h

浏览该文件的文档.

#pragma once
 
#include "io/dl_log.h"
#include "render/dl_particle_config.h"
#include "memory/dl_memory_reuse.h"
#include "render/dl_sprite.h"
 
namespace dl
{
    struct ParicleNode
    {
        bool _active; // 是否活动中
        Position _pos;
        Position _v;
        float _tEnd;
        float _tLife;
 
        gcSprite _spr;
 
        ParicleNode() :
            _active{ false }
        {}
    };

    struct ParticleConfigX
    {
        ParticleConfig _config;
        std::array<float, 2> _radin;
        Position _gravity;
 
        void Calc()
        {
            _radin[0] = Math::Angle2Radian(_config.node.angle[0]);
            _radin[1] = Math::Angle2Radian(_config.node.angle[1]);
 
            Math::RangeRadian(_radin);
 
            _gravity = toArray(_config.system.gravity);
        }
    };

    enum class ParticleState
    {
        NORMAL,   // 运行中
        WAIT,   // 等待播放完成
        STOP    // 已停止
    };

    class Particle
    {
        friend class ParticleSystem;
        friend class Memory::Reuse<Particle>;
    public:
        void Render();
        void SetSprite(gcSprite spr);
        void SetPosition(const Position& pos)
        {
            _pos = pos;
        }

        void SetPositionEmitter(const Position& pos)
        {
            _posEmitter = pos;
        }

        void Replay();
        ParticleState GetState()
        {
            return _state;
        }

        const ParticleConfigX* GetConfig()
        {
            return _config;
        }
    private:
        Particle(ParticleConfigX* config);
        ~Particle() {}
        
        ParticleConfigX* _config;
        ParticleState _state;  // 状态 0.激活 1.等待删除 2.休眠
        float _tCreate; // 创建时间
        float _tEmitter;    // 上次发射时间
        gcSprite _spr;  // 模板精灵
        Quad _sprQuad;
        Position _pos;
        Position _posEmitter;
        // 等于最大数量
        std::vector<ParicleNode> _allNode;
 
        void _reset();
    };

    class ParticleSystem
    {
    public:
        Particle* Create(std::string_view name);
        void Delete(Particle* par, bool wait = true);
        void Load(std::string_view path_name, std::string_view res_name);
        void LoadPath(std::string_view path);

        void SetReadOverwirte(bool overwrite)
        {
            _bReadOverwrite = overwrite;
        }

        void Clear();
 
        ParticleSystem() :
            _bReadOverwrite{ false }
        {}
        ~ParticleSystem();
    private:
        bool _bReadOverwrite;
 
        std::unordered_map<std::string, ParticleConfigX> _allConfig;
 
        dl::Memory::Reuse<Particle> _memoryReuse;
        std::list<Particle*> _listDelete;
 
        void _update();
    };
 
    extern ParticleSystem* g_particle;
}