ActionTimeline.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Identity.h"
#include "common/Result.h"
#include "common/SchemaVersion.h"
#include "common/Time.h"
#include "common/Value.h"
 
#include <cstdint>
#include <optional>
#include <string>
#include <utility>
#include <vector>
 
namespace eve::action {
 
inline constexpr std::string_view kActionTimelineSchemaId = "eve.action.timeline";
inline constexpr std::uint64_t kActionTimelineSchemaVersion = 4;
 
enum class ActionBlendCurve : std::uint8_t {
    Linear,
    EaseInOut,
};
 
struct ActionMontageSettings {
    double        basePlayRate         = 1.0;
    bool          looping              = false;
    bool          footIk               = false;
    std::uint32_t animationLayer       = 0;
    Duration      defaultBlendIn       = Duration::zero();
    Duration      defaultBlendOut      = Duration::zero();
    Duration      blendOutOffset       = Duration::zero();
    bool          rootMotionHorizontal = true;
    bool          rootMotionVertical   = true;
    bool          rootMotionRotation   = true;
 
    auto operator<=>(const ActionMontageSettings&) const = default;
};
 
struct ActionAnimationSection {
    LogicalId   id;
    std::string animationUri;
    Duration    start   = Duration::zero();
    Duration    end     = Duration::zero();
    Duration    blendIn = Duration::zero();
    Duration sourceStart = Duration::zero();
    Duration sourceEnd = Duration::zero();
    ActionBlendCurve blendCurve = ActionBlendCurve::EaseInOut;
 
    auto operator<=>(const ActionAnimationSection&) const = default;
};
 
[[nodiscard]] EVENGINE_API_PLATFORM std::string_view actionBlendCurveName(ActionBlendCurve curve) noexcept;
[[nodiscard]] EVENGINE_API_PLATFORM std::optional<ActionBlendCurve> actionBlendCurveFromName(
    std::string_view name) noexcept;
 
enum class ActionTrackKind : std::uint8_t {
    Animation,
    Gameplay,
    Effect,
    Audio,
    Camera,
    Movement,
    Tag,
    Custom,
};
 
[[nodiscard]] EVENGINE_API_PLATFORM std::string_view actionTrackKindName(ActionTrackKind kind) noexcept;
[[nodiscard]] EVENGINE_API_PLATFORM Result<ActionTrackKind> parseActionTrackKind(std::string_view text);
 
struct ActionNotify {
    LogicalId     id;
    LogicalId     type;
    Duration      time = Duration::zero();
    Value::Object payload;
    bool          enabled = true;
 
    auto operator<=>(const ActionNotify&) const = default;
};
 
struct ActionNotifyState {
    LogicalId     id;
    LogicalId     type;
    Duration      start = Duration::zero();
    Duration      end   = Duration::zero();
    Value::Object payload;
    bool          enabled = true;
 
    auto operator<=>(const ActionNotifyState&) const = default;
};
 
struct ActionTrack {
    LogicalId                      id;
    std::string                    label;
    ActionTrackKind                kind   = ActionTrackKind::Custom;
    bool                           muted  = false;
    bool                           locked = false;
    std::vector<ActionNotify>      notifies;
    std::vector<ActionNotifyState> states;
 
    auto operator<=>(const ActionTrack&) const = default;
};
 
enum class ActionTimelineEventKind : std::uint8_t { Notify, StateEnter, StateExit };
 
struct ActionTimelineEvent {
    ActionTimelineEventKind kind = ActionTimelineEventKind::Notify;
    LogicalId               trackId;
    LogicalId               itemId;
    LogicalId               type;
    Duration                time = Duration::zero();
    Value::Object           payload;
 
    auto operator<=>(const ActionTimelineEvent&) const = default;
};
 
struct ActionActiveBlock {
    LogicalId     trackId;
    LogicalId     itemId;
    LogicalId     type;
    Duration      localTime = Duration::zero();
    Duration      duration  = Duration::zero();
    Value::Object payload;
 
    auto operator<=>(const ActionActiveBlock&) const = default;
};
 
struct EVENGINE_API_PLATFORM ActionTimeline {
    SchemaVersion schemaVersion{kActionTimelineSchemaVersion};
    LogicalId     actionId;
    Duration      duration = Duration::zero();
    std::string                         animationUri;
    std::vector<ActionAnimationSection> animationSections;
    ActionMontageSettings               montage;
    std::vector<Duration>    splitTimestamps;
    std::vector<ActionTrack> tracks;
    Value::Object            metadata;
 
    [[nodiscard]] Result<void> validate() const;
    [[nodiscard]] std::size_t sectionCount() const noexcept { return splitTimestamps.size() + 1; }
    [[nodiscard]] Result<std::pair<Duration, Duration>> sectionRange(std::size_t index) const;
 
    [[nodiscard]] Result<std::vector<ActionTimelineEvent>> sample(Duration previous, Duration current,
                                                                  bool includePrevious = false) const;
 
    [[nodiscard]] Result<std::vector<ActionActiveBlock>> activeBlocks(Duration time) const;
 
    [[nodiscard]] Result<Value> toValue() const;
    [[nodiscard]] static Result<ActionTimeline> fromValue(const Value& value);
};
 
}  // namespace eve::action