AnimationClipEditor.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
#include "animation/editing/AnimationClip.h"
#include "animation/editing/SkeletonOverlay.h"
#include "editing/EditingGizmo.h"
#include "editor/EditorAuthority.h"
#include "editor/EditorTransactionService.h"
#include "editor/EditorWorkspace.h"
 
#include <cstdint>
#include <string>
#include <vector>
 
namespace eve::animation {
class AnimClip;
class AnimSkeleton;
}
 
namespace eve::animation_editor {
 
class EVENGINE_API_EDITORS AnimationClipEditor {
public:
    explicit AnimationClipEditor(std::string targetId);
 
    [[nodiscard]] animation_editing::Result<void> loadRuntimeClip(const animation::AnimSkeleton& skeleton,
                                                                        const animation::AnimClip& clip);
    [[nodiscard]] animation_editing::Result<void> writeRuntimeClip(animation::AnimClip& clip,
                                                                         const animation::AnimSkeleton& skeleton) const;
 
    AnimationClipEditor(const AnimationClipEditor&)            = delete;
    AnimationClipEditor& operator=(const AnimationClipEditor&) = delete;
 
    const animation_editing::AnimationClipDocumentTarget& target() const noexcept { return target_; }
 
    [[nodiscard]] animation_editing::Result<void> configureWorkspace(editor::EditorWorkspace& workspace) const;
 
    [[nodiscard]] animation_editing::Result<void> setViewport(float width, float rowHeight, float labelWidth);
 
    [[nodiscard]] animation_editing::Result<void> seekSeconds(double seconds);
    [[nodiscard]] animation_editing::Result<void> seekX(float x);
    [[nodiscard]] animation_editing::Result<void> pointerDown(float x, float y);
    [[nodiscard]] animation_editing::Result<void> selectBone(std::string bone);
    [[nodiscard]] animation_editing::Result<void> setMaskWeight(double weight);
    [[nodiscard]] animation_editing::Result<void> setDuration(double duration);
    [[nodiscard]] animation_editing::Result<void> setSampleRate(double sampleRate);
    [[nodiscard]] animation_editing::Result<void> setLoop(bool loop);
    [[nodiscard]] animation_editing::Result<void> keySelectedBone();
    [[nodiscard]] animation_editing::Result<void> deleteSelectedKey();
    [[nodiscard]] animation_editing::Result<void> setSelectedPosition(double x, double y, double z);
    [[nodiscard]] animation_editing::Result<void> setSelectedRotation(double xDegrees, double yDegrees,
                                                                            double zDegrees);
    [[nodiscard]] animation_editing::Result<void> setSelectedScale(double x, double y, double z);
    [[nodiscard]] animation_editing::Result<void> moveSelectedKey(double time);
 
    [[nodiscard]] animation_editing::Result<editor::TransactionReceipt> undo();
    [[nodiscard]] animation_editing::Result<editor::TransactionReceipt> redo();
 
    void play() noexcept;
    void pause() noexcept;
    void stop() noexcept;
    [[nodiscard]] animation_editing::Result<void> update(double deltaSeconds);
 
    bool          canUndo() const noexcept { return transactions_.canUndo(); }
    bool          canRedo() const noexcept { return transactions_.canRedo(); }
    bool          isPlaying() const noexcept { return playing_; }
    std::uint64_t revision() const noexcept { return target_.revision(); }
    double        duration() const noexcept { return target_.duration(); }
    double        sampleRate() const noexcept { return target_.sampleRate(); }
    bool          isLooping() const noexcept { return target_.isLooping(); }
    double        playhead() const noexcept { return playhead_; }
    float         layoutWidth() const noexcept { return viewportWidth_; }
    float         layoutHeight() const noexcept;
    float         playheadX() const noexcept;
    std::string   selectedBone() const { return selectedBone_; }
    double        selectedMaskWeight() const;
    bool          hasSelectedKey() const noexcept { return !selectedKeyId_.empty(); }
    double        selectedKeyTime() const;
    double        selectedPositionX() const;
    double        selectedPositionY() const;
    double        selectedPositionZ() const;
    double        selectedRotationX() const;
    double        selectedRotationY() const;
    double        selectedRotationZ() const;
    double        selectedScaleX() const;
    double        selectedScaleY() const;
    double        selectedScaleZ() const;
    int           boneCount() const noexcept;
    std::string   boneName(int index) const;
    std::string   boneParent(int index) const;
 
    int         trackCount() const;
    std::string trackBone(int index) const;
    std::string trackId(int index) const;
    bool        isTrackSelected(int index) const;
    int         keyCount() const;
    float       keyX(int index) const;
    float       keyY(int index) const;
    bool        isKeySelected(int index) const;
    int         eventCount() const;
    float       eventX(int index) const;
    std::string eventName(int index) const;
 
    int         primitiveCount() const;
    std::string primitiveKind(int index) const;
    float       primitiveX(int index) const;
    float       primitiveY(int index) const;
    float       primitiveDirX(int index) const;
    float       primitiveDirY(int index) const;
    float       primitiveLength(int index) const;
    float       primitiveRadius(int index) const;
    float       primitiveR(int index) const;
    float       primitiveG(int index) const;
    float       primitiveB(int index) const;
 
    const animation_editing::AnimationClipPreview& preview() const noexcept { return preview_; }
 
private:
    struct SkeletonBone {
        std::string name;
        std::string parent;
    };
    struct TimelineKey {
        animation_editing::StableId trackId;
        std::string                 bone;
        int                         keyIndex = 0;
        double                      time     = 0.0;
        int                         row      = 0;
    };
 
    [[nodiscard]] animation_editing::Result<void> commit(
        animation_editing::Result<animation_editing::DomainOperation> operation, std::string label);
    [[nodiscard]] animation_editing::Result<void> refreshPreview();
    [[nodiscard]] animation_editing::Result<void> updateSelectedTransform(
        const animation_editing::AnimationTransformKey& value, std::string label);
    [[nodiscard]] animation_editing::AnimationTransformKey sampledSelectedTransform() const;
    void                                                seedPreviewClip();
    std::vector<std::string>                            skeletonBones() const;
    std::string                                         skeletonParent(const std::string& bone) const;
    float                                               timeToX(double time) const;
    double                                              xToTime(float x) const;
    const eve::editing::GizmoPrimitive*                 primitiveAt(int index) const;
    std::vector<TimelineKey>                            flattenKeys() const;
 
    animation_editing::AnimationClipDocumentTarget target_;
    editor::LocalWorldAuthority                    authority_;
    editor::LocalTransactionBackend                transactions_;
    animation_editing::SkeletonOverlayBuilder      overlayBuilder_;
    animation_editing::AnimationClipPreview        preview_;
    eve::editing::GizmoSnapshot                    overlay_;
    std::string                                    selectedBone_ = "Hips";
    animation_editing::StableId                    selectedKeyTrack_;
    animation_editing::StableId                    selectedKeyId_;
    std::uint64_t                                  txSequence_       = 0;
    double                                         playhead_         = 0.0;
    bool                                           playing_          = false;
    float                                          viewportWidth_    = 800.0f;
    float                                          rowHeight_        = 36.0f;
    float                                          labelWidth_       = 120.0f;
    std::vector<SkeletonBone>                      skeleton_;
};
 
}  // namespace eve::animation_editor