AttackVfxRecipe.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
#include "common/Identity.h"
#include "common/Result.h"
 
#include <cstdint>
#include <map>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace eve::stylize {
 
enum class AttackVfxPhaseKind : std::uint8_t {
    Anticipate, 
    Release,    
    Travel,     
    Impact,     
    Aftermath,  
    Status      
};
 
enum class AttackVfxLayerRole : std::uint8_t {
    BlockingMesh, 
    MeshVfx,      
    Trail,        
    Particles,    
    Decal,        
    Distortion,   
    Camera,       
    Prefab,       
    Audio         
};
 
enum class AttackVfxStopBehavior : std::uint8_t {
    StopEmitting,     
    ClearImmediately  
};
 
enum class AttackVfxSpatialAttachment : std::uint8_t {
    FollowTarget,
    FollowPositionOnly,
    WorldTransformAtStart
};
 
enum class AttackVfxSpatialAnchor : std::uint8_t { Source, Target };
 
struct AttackVfxVec3 {
    float x = 0.f;
    float y = 0.f;
    float z = 0.f;
 
    auto operator<=>(const AttackVfxVec3&) const = default;
};
 
struct EVENGINE_API_WORLD AttackVfxSpatial {
    AttackVfxSpatialAttachment attachment = AttackVfxSpatialAttachment::FollowTarget;
    AttackVfxSpatialAnchor     anchor     = AttackVfxSpatialAnchor::Source;
    std::size_t                targetIndex = 0;
    std::string                bone;
    AttackVfxVec3              positionOffset;
    AttackVfxVec3              rotationOffsetDegrees;
    AttackVfxVec3              scale{1.f, 1.f, 1.f};
 
    auto operator<=>(const AttackVfxSpatial&) const = default;
 
    [[nodiscard]] Result<void> validate(std::string_view path) const;
};
 
struct EVENGINE_API_WORLD AttackVfxLayer {
    AttackVfxLayerRole    role         = AttackVfxLayerRole::Particles;
    std::string           uri;
    AttackVfxSpatial      spatial;
    std::map<std::string, float> floatParams;
    AttackVfxStopBehavior stopBehavior = AttackVfxStopBehavior::StopEmitting;
 
    [[nodiscard]] Result<void> validate(std::string_view path) const;
};
 
struct EVENGINE_API_WORLD AttackVfxPhase {
    AttackVfxPhaseKind         kind               = AttackVfxPhaseKind::Release;
    std::string                startCue;
    std::string                endCue;
    double                     startOffsetSeconds = 0.0;
    double                     durationSeconds    = 0.0;
    std::vector<AttackVfxLayer> layers;
 
    [[nodiscard]] Result<void> validate(std::string_view path) const;
};
 
struct AttackVfxPalette {
    AttackVfxVec3 primary{1.f, 1.f, 1.f};
    AttackVfxVec3 secondary{1.f, 1.f, 1.f};
    AttackVfxVec3 emissive{1.f, 1.f, 1.f};
 
    auto operator<=>(const AttackVfxPalette&) const = default;
};
 
struct EVENGINE_API_WORLD AttackVfxSkin {
    LogicalId                        id;
    AttackVfxPalette                 palette;
    std::map<std::string, std::string> styleHints;
    std::map<std::string, float>     shakeProfile;
    std::map<std::string, float>     distortionProfile;
    std::string                      statusOverlayUri;
 
    [[nodiscard]] Result<void> validate() const;
 
    [[nodiscard]] static Result<AttackVfxSkin> fromJson(std::string_view json);
 
    [[nodiscard]] Result<std::string> toJson() const;
};
 
struct AttackVfxBudget {
    int  lod              = 0;
    int  maxParticles     = 0; 
    bool allowDistortion  = true;
 
    auto operator<=>(const AttackVfxBudget&) const = default;
};
 
struct EVENGINE_API_WORLD AttackVfxRecipe {
    static constexpr std::string_view schemaId      = "eve.stylize.attack-vfx";
    static constexpr std::uint32_t    schemaVersion = 1;
 
    LogicalId                  id;
    std::vector<AttackVfxPhase> phases;
    std::optional<LogicalId>   skinId; 
    std::optional<AttackVfxSkin> skin; 
    AttackVfxBudget            budget;
 
    [[nodiscard]] static Result<AttackVfxRecipe> fromJson(std::string_view json);
 
    [[nodiscard]] Result<std::string> toJson() const;
 
    [[nodiscard]] Result<void> validate() const;
};
 
class EVENGINE_API_WORLD AttackVfxRecipeSlot {
public:
    explicit AttackVfxRecipeSlot(AttackVfxRecipe recipe);
 
    [[nodiscard]] Result<std::uint64_t> reload(std::string_view json);
    [[nodiscard]] const AttackVfxRecipe& recipe() const noexcept { return recipe_; }
    [[nodiscard]] std::uint64_t revision() const noexcept { return revision_; }
 
private:
    AttackVfxRecipe recipe_;
    std::uint64_t   revision_ = 1;
};
 
[[nodiscard]] EVENGINE_API_WORLD std::string_view attackVfxPhaseKindName(AttackVfxPhaseKind kind) noexcept;
[[nodiscard]] EVENGINE_API_WORLD std::string_view attackVfxLayerRoleName(AttackVfxLayerRole role) noexcept;
[[nodiscard]] EVENGINE_API_WORLD std::string_view attackVfxStopBehaviorName(AttackVfxStopBehavior behavior) noexcept;
[[nodiscard]] EVENGINE_API_WORLD std::string_view attackVfxSpatialAttachmentName(
    AttackVfxSpatialAttachment mode) noexcept;
[[nodiscard]] EVENGINE_API_WORLD std::string_view attackVfxSpatialAnchorName(AttackVfxSpatialAnchor anchor) noexcept;
 
}  // namespace eve::stylize