MeshVfxAsset.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
#include "common/AttachmentPoint.h"
#include "common/AnimationEventSource.h"
#include "stylize/MeshEffect.h"
#include "stylize/TrailEffect.h"
 
#include <cstdint>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace eve::stylize {
 
struct MeshVfxFloatKey {
    float time = 0.f;
    float value = 0.f;
};
 
struct EVENGINE_API_WORLD MeshVfxFloatCurve {
    std::vector<MeshVfxFloatKey> keys;
 
    [[nodiscard]] float evaluate(float normalizedTime) const noexcept;
};
 
struct MeshVfxEventAsset {
    float       time = 0.f;
    std::string name;
};
 
struct MeshVfxTrailBinding {
    std::string          rootAttachment;
    std::string          tipAttachment;
    eve::AttachmentPoint rootOffset;
    eve::AttachmentPoint tipOffset;
};
 
struct MeshVfxAnimationTriggers {
    std::vector<std::string> play;
    std::vector<std::string> stop;
    std::vector<std::string> trailBreak;
};
 
struct MeshVfxAnimationDispatch {
    std::size_t handled = 0;
    std::size_t played = 0;
    std::size_t stopped = 0;
    std::size_t trailBreaks = 0;
};
 
struct MeshVfxLayerAsset {
    std::string                  style;
    MeshEffectPlayback          playback;
    std::map<std::string, float> floatParameters;
    std::map<std::string, MeshVfxFloatCurve> floatCurves;
};
 
struct EVENGINE_API_WORLD MeshVfxAsset {
    static constexpr std::string_view schemaId = "eve.stylize.mesh-vfx";
    static constexpr std::uint32_t schemaVersion = 1;
 
    std::vector<MeshVfxLayerAsset> layers;
    std::optional<TrailSettings>   trail;
    std::optional<MeshVfxTrailBinding> trailBinding;
    std::vector<MeshVfxEventAsset> events;
    MeshVfxAnimationTriggers       animationTriggers;
 
    [[nodiscard]] static eve::Result<MeshVfxAsset> fromJson(std::string_view json);
 
    [[nodiscard]] eve::Result<std::string> toJson() const;
 
    [[nodiscard]] eve::Result<void> validate() const;
};
 
class EVENGINE_API_WORLD MeshVfxAssetInstance {
public:
    [[nodiscard]] static eve::Result<std::unique_ptr<MeshVfxAssetInstance>> create(const MeshVfxAsset& asset);
    [[nodiscard]] static eve::Result<std::unique_ptr<MeshVfxAssetInstance>> create(
        const MeshVfxAsset& asset, const std::map<std::string, std::map<std::string, float>>& externalStyles);
 
    void bindTarget(MeshEffectTargetHandle target);
    void play() noexcept;
    void stop(float fadeOutSeconds = -1.f);
    void update(float dtSeconds);
    [[nodiscard]] std::vector<std::string> drainEvents();
    [[nodiscard]] eve::Result<TrailAppendResult> sampleTrail(const eve::IAttachmentPointSource& source);
    [[nodiscard]] MeshVfxAnimationDispatch processAnimationEvents(const eve::IAnimationEventSource& source);
 
    [[nodiscard]] std::size_t layerCount() const noexcept { return layers_.size(); }
    [[nodiscard]] MeshEffectInstance& layer(std::size_t index) { return *layers_.at(index); }
    [[nodiscard]] const MeshEffectInstance& layer(std::size_t index) const { return *layers_.at(index); }
    [[nodiscard]] bool hasTrail() const noexcept { return trail_ != nullptr; }
    [[nodiscard]] bool isFinished() const noexcept;
    [[nodiscard]] TrailEmitter& trail();
 
private:
    explicit MeshVfxAssetInstance(const MeshVfxAsset&                                        asset,
                                  const std::map<std::string, std::map<std::string, float>>& externalStyles);
 
    std::vector<std::unique_ptr<MeshEffectInstance>> layers_;
    std::vector<std::map<std::string, MeshVfxFloatCurve>> curves_;
    std::unique_ptr<TrailEmitter>                    trail_;
    std::optional<MeshVfxTrailBinding>               trailBinding_;
    std::vector<MeshVfxEventAsset>                   events_;
    MeshVfxAnimationTriggers                         animationTriggers_;
    std::vector<std::string>                         pendingEvents_;
    float                                            previousNormalizedTime_ = 0.f;
};
 
class EVENGINE_API_WORLD MeshVfxAssetSlot {
public:
    explicit MeshVfxAssetSlot(MeshVfxAsset asset);
 
    [[nodiscard]] eve::Result<std::uint64_t> reload(std::string_view json);
    [[nodiscard]] const MeshVfxAsset& asset() const noexcept { return asset_; }
    [[nodiscard]] std::uint64_t revision() const noexcept { return revision_; }
 
private:
    MeshVfxAsset asset_;
    std::uint64_t revision_ = 1;
};
 
}  // namespace eve::stylize