ParticleEffect.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
#include "common/Result.h"
#include "common/Time.h"
 
#include <span>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace eve::particles {
 
class ParticleEmitter;
 
struct ParticleEffectEventRoute {
    std::string from;
    std::string on             = "death";
    std::string to;
    float       inheritVelocity = 0.f;
};
 
struct ParticleEffectTimelineCue {
    float       time      = 0.f;
    std::string action;
    std::string emitter;
    std::string parameter;
    float       value     = 0.f;
    int         count     = 0;
};
 
struct ParticleEffectTimeline {
    float                                duration = 0.f;
    bool                                 looping  = false;
    std::vector<ParticleEffectTimelineCue> cues;
};
 
class EVENGINE_API_DOMAINS ParticleEffect {
public:
    static constexpr int kMaxSupportedVersion = 2;
    static constexpr int kMinSupportedVersion = 1;
 
    ~ParticleEffect();
 
    ParticleEffect(const ParticleEffect&)            = delete;
    ParticleEffect& operator=(const ParticleEffect&) = delete;
 
    static ParticleEffect* fromText(const std::string& json, const std::string& sourcePath,
                                    std::string* error = nullptr);
    static ParticleEffect* fromFile(const std::string& path, std::string* error = nullptr);
 
    [[nodiscard]] static Result<ParticleEffect*> tryFromText(const std::string& json,
                                                             const std::string& sourcePath = {});
    [[nodiscard]] static Result<ParticleEffect*> tryFromFile(const std::string& path);
 
    int getVersion() const { return version_; }
    std::string getSourcePath() const { return sourcePath_; }
    int getEmitterCount() const;
    std::string getEmitterName(int index) const;
    ParticleEmitter* getEmitter(int index) const;
    ParticleEmitter* getEmitterByName(const std::string& name) const;
 
    [[nodiscard]] std::span<const ParticleEffectEventRoute> eventRoutes() const;
    [[nodiscard]] const ParticleEffectTimeline& timeline() const { return timeline_; }
    [[nodiscard]] float getTimelineSeconds() const { return static_cast<float>(timelineSeconds_); }
    [[nodiscard]] bool isTimelinePlaying() const { return timelinePlaying_ && !timelinePaused_; }
 
    [[nodiscard]] Result<Duration> naturalDuration() const;
 
    [[nodiscard]] Result<void> reloadFromText(const std::string& json);
    [[nodiscard]] Result<void> reloadFromFile(const std::string& path = {});
 
    [[nodiscard]] Result<void> advanceTimeline(const SimulationStep& step);
    void updateTimeline(float dt);
    static void tickRegisteredTimelines(float dt);
    [[nodiscard]] static Result<void> advanceRegisteredTimelines(const SimulationStep& step);
 
    void setPosition(float x, float y);
    float getX() const { return x_; }
    float getY() const { return y_; }
    void setRotation(float radians);
    float getRotation() const { return rotation_; }
    void setScale(float scale);
    float getScale() const { return scale_; }
    void setLayer(int layer);
    int getLayer() const { return layer_; }
    void setVisible(bool visible);
    bool isVisible() const { return visible_; }
 
    void start();
    void stop();
    void pause();
    void reset();
    bool emit(const std::string& emitterName, int count);
 
    void setFloatParameter(const std::string& name, float value);
    float getFloatParameter(const std::string& name) const;
    bool hasFloatParameter(const std::string& name) const;
 
private:
    struct Layer {
        std::string      name;
        ParticleEmitter* emitter       = nullptr;
        float            offsetX       = 0.f;
        float            offsetY       = 0.f;
        float            baseDirection = 0.f;
        int              baseLayer     = 0;
        bool             enabled       = true;
    };
    struct RuntimeCue {
        ParticleEffectTimelineCue cue;
        bool                      fired = false;
    };
 
    ParticleEffect() = default;
    [[nodiscard]] static Result<ParticleEffect*> parse(const std::string& json,
                                                       const std::string& sourcePath);
    void syncTransform();
    void syncLayer();
    void wireEventRoutes();
    void rewindTimelineClock();
    void registerForTimelineTicks();
    void unregisterFromTimelineTicks();
    [[nodiscard]] Result<void> fireDueCues(double previousSeconds, double currentSeconds);
    [[nodiscard]] Result<void> applyCue(const ParticleEffectTimelineCue& cue);
    void adoptParsed(ParticleEffect&& other, bool preserveWorldState);
 
    int                                      version_ = 1;
    std::string                              sourcePath_;
    std::vector<Layer>                       layers_;
    std::unordered_map<std::string, float>   parameters_;
    std::vector<ParticleEffectEventRoute>    eventRoutes_;
    ParticleEffectTimeline                   timeline_;
    std::vector<RuntimeCue>                  runtimeCues_;
    double                                   timelineSeconds_ = 0.0;
    bool                                     timelinePlaying_ = false;
    bool                                     timelinePaused_  = false;
    bool                                     timelineRegistered_ = false;
    float                                    x_        = 0.f;
    float                                    y_        = 0.f;
    float                                    rotation_ = 0.f;
    float                                    scale_    = 1.f;
    int                                      layer_    = 0;
    bool                                     visible_  = true;
};
 
}  // namespace eve::particles