AttackVfxRuntime.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
#include "common/Identity.h"
#include "common/Result.h"
#include "stylize/AttackVfxRecipe.h"
 
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace eve::stylize {
 
struct AttackVfxHandle {
    std::uint32_t slot       = 0;
    std::uint32_t generation = 0;
 
    friend bool operator==(const AttackVfxHandle&, const AttackVfxHandle&) = default;
};
 
enum class AttackVfxStopMode : std::uint8_t {
    StopEmitting,     
    ClearImmediately, 
    Cancel            
};
 
struct AttackVfxRequest {
    std::optional<LogicalId> skinOverride;
    std::uint32_t            sourceId         = 0;
    std::uint32_t            sourceGeneration = 0;
    std::uint32_t            targetId         = 0;
    std::uint32_t            targetGeneration = 0;
    std::string              clockName        = "absolute"; 
};
 
struct AttackVfxPhaseState {
    AttackVfxPhaseKind kind      = AttackVfxPhaseKind::Release;
    bool               armed     = false; 
    bool               active    = false;
    bool               completed = false;
    double             localTime = 0.0;
    std::size_t        layerCount = 0;
};
 
struct AttackVfxInstanceState {
    AttackVfxHandle                handle;
    LogicalId                      recipeId;
    std::optional<LogicalId>       activeSkinId;
    double                         age = 0.0;
    bool                           stopping = false;
    AttackVfxRequest               request;
    std::vector<AttackVfxPhaseState> phases;
};
 
struct AttackVfxFrameEvent {
    enum class Kind : std::uint8_t {
        PhaseEnter,
        PhaseExit,
        InstanceStopped,
        CueConsumed,
        CueIgnored,
        LayerStarted,
        LayerSkipped
    };
 
    Kind               kind  = Kind::CueIgnored;
    AttackVfxHandle    handle{};
    AttackVfxPhaseKind phase = AttackVfxPhaseKind::Release;
    AttackVfxLayerRole role  = AttackVfxLayerRole::Particles;
    std::string        cue;
    std::size_t        layerCount = 0;
    std::size_t        layerIndex = 0;
};
 
struct AttackVfxFrame {
    std::vector<AttackVfxHandle>     advanced;
    std::vector<AttackVfxHandle>     stopped;
    std::vector<AttackVfxFrameEvent> events;
};
 
class EVENGINE_API_WORLD AttackVfxRuntime {
public:
    AttackVfxRuntime();
    ~AttackVfxRuntime();
 
    AttackVfxRuntime(const AttackVfxRuntime&) = delete;
    AttackVfxRuntime& operator=(const AttackVfxRuntime&) = delete;
 
    [[nodiscard]] Result<void> configurePool(std::uint32_t capacity);
 
    [[nodiscard]] Result<void> registerRecipe(const AttackVfxRecipe& recipe);
 
    [[nodiscard]] Result<void> registerSkin(const AttackVfxSkin& skin);
 
    [[nodiscard]] std::optional<AttackVfxRecipe> findRecipe(const LogicalId& id) const;
 
    [[nodiscard]] std::optional<AttackVfxSkin> findSkin(const LogicalId& id) const;
 
    [[nodiscard]] Result<AttackVfxHandle> play(const LogicalId& recipeId, const AttackVfxRequest& request);
 
    [[nodiscard]] Result<AttackVfxFrame> signal(AttackVfxHandle handle, std::string_view cue);
 
    [[nodiscard]] Result<AttackVfxFrame> advance(double dtSeconds);
 
    [[nodiscard]] Result<AttackVfxFrame> stop(AttackVfxHandle handle, AttackVfxStopMode mode);
 
    [[nodiscard]] std::optional<AttackVfxInstanceState> inspect(AttackVfxHandle handle) const;
 
    [[nodiscard]] std::size_t activeCount() const noexcept;
 
    [[nodiscard]] std::size_t capacity() const noexcept;
 
private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
};
 
}  // namespace eve::stylize