AnimationClip.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "animation/editing/AnimationEditingTypes.h"
 
#include <map>
#include <memory>
#include <string>
#include <vector>
 
namespace eve::animation {
class AnimClip;
class AnimSkeleton;
}
 
namespace eve::animation_editing {
 
struct AnimationTransformKey {
    StableId id;
    double time = 0.0;
    double positionX = 0.0, positionY = 0.0, positionZ = 0.0;
    double rotationX = 0.0, rotationY = 0.0, rotationZ = 0.0, rotationW = 1.0;
    double scaleX = 1.0, scaleY = 1.0, scaleZ = 1.0;
};
 
struct AnimationBoneTrack {
    StableId id;
    std::string bone;
    std::vector<AnimationTransformKey> keys;
};
 
struct AnimationEventRecord {
    StableId id;
    double time = 0.0;
    std::string name;
    std::string payload;
};
 
struct AnimationMaskEntry {
    std::string bone;
    double weight = 1.0;
};
 
struct AnimationSampledBone {
    std::string bone;
    double positionX = 0.0, positionY = 0.0, positionZ = 0.0;
    double rotationX = 0.0, rotationY = 0.0, rotationZ = 0.0, rotationW = 1.0;
    double scaleX = 1.0, scaleY = 1.0, scaleZ = 1.0;
    double maskWeight = 1.0;
};
 
struct AnimationClipPreview {
    EditorStatus status = EditorStatus::Failed;
    Revision documentRevision = 0;
    double time = 0.0;
    std::vector<AnimationSampledBone> bones;
    std::vector<EditorDiagnostic> diagnostics;
};
 
struct AnimationRetargetPreview {
    EditorStatus status = EditorStatus::Failed;
    Revision documentRevision = 0;
    std::map<std::string, std::string> mapping;
    std::vector<std::string> unmatchedSourceBones;
    std::vector<std::string> unmatchedTargetBones;
    std::vector<EditorDiagnostic> diagnostics;
};
 
class IAnimationClipEditTarget {
public:
    virtual ~IAnimationClipEditTarget() = default;
    static CapabilityId editingCapabilityId() { return CapabilityId("eve.editor.target.animation-clip"); }
    static CapabilityId editorCapabilityId() { return editingCapabilityId(); }
    virtual Result<DomainOperation> makeSetSettings(double duration, double sampleRate, bool loop) const = 0;
    virtual Result<DomainOperation> makeSetTrack(const AnimationBoneTrack& track) const = 0;
    virtual Result<DomainOperation> makeDeleteTrack(const StableId& track) const = 0;
    virtual Result<DomainOperation> makeSetEvent(const AnimationEventRecord& event) const = 0;
    virtual Result<DomainOperation> makeDeleteEvent(const StableId& event) const = 0;
    virtual Result<DomainOperation> makeSetMask(const AnimationMaskEntry& mask) const = 0;
};
 
class EVENGINE_API_DOMAINS AnimationClipDocumentTarget final : public ::eve::editing::EditableTargetState,
                                                               public virtual IEditableTarget,
                                                               public IDomainOperationTarget,
                                                               public IDomainOperationTargetStaging,
                                                               public eve::editing::IEditingSnapshotProvider,
                                                               public IAnimationClipEditTarget {
public:
    explicit AnimationClipDocumentTarget(std::string id);
    TargetId         targetId() const override { return TargetId(id_); }
    TargetDescriptor describe() const override;
    void* queryCapability(const CapabilityId& capability) override;
    Result<void> applyDomainOperation(const DomainOperation& operation) override;
    [[nodiscard]] std::unique_ptr<IDomainOperationTarget> cloneDomainState() const override;
    [[nodiscard]] Result<void> commitDomainState(std::unique_ptr<IDomainOperationTarget> candidate) override;
 
    Result<DomainOperation> makeSetSettings(double duration, double sampleRate, bool loop) const override;
    Result<DomainOperation> makeSetTrack(const AnimationBoneTrack& track) const override;
    Result<DomainOperation> makeDeleteTrack(const StableId& track) const override;
    Result<DomainOperation> makeSetEvent(const AnimationEventRecord& event) const override;
    Result<DomainOperation> makeDeleteEvent(const StableId& event) const override;
    Result<DomainOperation> makeSetMask(const AnimationMaskEntry& mask) const override;
 
    double duration() const noexcept { return duration_; }
    double sampleRate() const noexcept { return sampleRate_; }
    bool isLooping() const noexcept { return loop_; }
    std::vector<AnimationBoneTrack> tracks() const;
    std::vector<AnimationEventRecord> events() const;
    std::vector<EditorDiagnostic> validate(const std::vector<std::string>& skeletonBones = {}) const;
    AnimationClipPreview preview(double time, const std::vector<std::string>& skeletonBones = {}) const;
    AnimationRetargetPreview previewRetarget(const std::vector<std::string>& targetBones) const;
    EditorValue snapshotValue() const override;
    Result<void> loadSnapshot(const EditorValue& snapshot);
 
private:
    std::string                              id_;
    double duration_ = 1.0;
    double sampleRate_ = 30.0;
    bool loop_ = true;
    std::map<StableId, AnimationBoneTrack> tracks_;
    std::map<StableId, AnimationEventRecord> events_;
    std::map<std::string, double> mask_;
};
 
[[nodiscard]] Result<AnimationBoneTrack> parseAnimationBoneTrack(const EditorValue& value);
[[nodiscard]] Result<AnimationEventRecord> parseAnimationEventRecord(const EditorValue& value);
 
class EVENGINE_API_DOMAINS AnimationClipRuntimeBuilder {
public:
    Result<animation::AnimClip*> build(const AnimationClipDocumentTarget& document,
                                             const animation::AnimSkeleton* skeleton) const;
};
 
}  // namespace eve::animation_editing