ActionTimelineEditor.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "action/ActionTimeline.h"
#include "action/ActionParameterCurve.h"
#include "editor/EditorAuthority.h"
#include "editor/EditorDocumentService.h"
#include "editor/EditorProperty.h"
#include "editor/EditorSelection.h"
#include "editor/EditorTransactionService.h"
#include "editor/EditorWorkspace.h"
 
#include <memory>
#include <optional>
#include <set>
#include <string>
#include <vector>
 
namespace eve::editor {
 
struct TimelineSelectionRange {
    Duration start = Duration::zero();
    Duration end   = Duration::zero();
};
 
struct ActionTimelinePreviewPlan {
    unsigned long long                       timelineRevision = 0;
    Duration                                 previous;
    Duration                                 current;
    bool                                     includeStart = false;
    bool                                     reachesEnd   = false;
    std::vector<action::ActionTimelineEvent> events;
};
 
class ActionTimelineClipboard {
public:
    void clear() noexcept;
    bool empty() const noexcept;
 
private:
    friend class ActionTimelineEditor;
 
    struct Item {
        enum class Kind : std::uint8_t { AnimationSection, Notify, NotifyState };
        Kind                           kind = Kind::Notify;
        LogicalId                      trackId;
        action::ActionAnimationSection animationSection;
        action::ActionNotify           notify;
        action::ActionNotifyState      notifyState;
    };
 
    std::vector<Item>                 items_;
    std::optional<action::ActionTrack> track_;
};
 
class EVENGINE_API_EDITORS ActionTimelineTarget final : public IDomainOperationTarget,
                                                        public IDomainOperationTargetStaging,
                                                        public IPropertyProvider,
                                                        public eve::editing::IEditingSnapshotProvider {
public:
    explicit ActionTimelineTarget(std::string targetId);
    ActionTimelineTarget(std::string targetId, action::ActionTimeline timeline);
 
    static CapabilityId propertyCapabilityId() { return CapabilityId("eve.editor.target.action-properties"); }
 
    TargetId targetId() const override { return TargetId(targetId_); }
    std::uint64_t revision() const override { return revision_; }
    EditRegion dirtyRegion() const override { return {}; }
    void clearDirtyRegion() override {}
    TargetDescriptor describe() const override;
    void* queryCapability(const CapabilityId& capability) override;
 
    const action::ActionTimeline& timeline() const noexcept { return timeline_; }
    [[nodiscard]] 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;
 
    [[nodiscard]] eve::Result<eve::Revision> currentRevision(const SelectionSnapshot& selection) const override;
    PropertySchema                           schema(const SelectionSnapshot& selection) const override;
    PropertyReadResult read(const SelectionSnapshot& selection, const PropertyPath& path) const override;
    [[nodiscard]] Result<DomainOperation> makeSet(const SelectionSnapshot& selection, const PropertyPath& path,
                                                        const EditorValue& value, PropertySetMode mode) const override;
    [[nodiscard]] Result<DomainOperation> makeReset(const SelectionSnapshot& selection,
                                                          const PropertyPath&      path) const override;
 
    EditorValue snapshotValue() const override;
    [[nodiscard]] Result<void> loadSnapshot(const EditorValue& snapshot);
 
private:
    bool                                        matches(const SelectionSnapshot& selection) const;
    [[nodiscard]] Result<DomainOperation> replacement(const action::ActionTimeline& candidate,
                                                            std::string                   property) const;
    [[nodiscard]] Result<void>            assign(action::ActionTimeline candidate);
 
    std::string            targetId_;
    action::ActionTimeline timeline_;
    unsigned long long     revision_ = 0;
};
 
class EVENGINE_API_EDITORS ActionTimelineEditor {
public:
    ActionTimelineEditor(std::string targetId, action::ActionTimeline timeline);
    ActionTimelineEditor(std::string targetId, action::ActionTimeline timeline,
                         std::shared_ptr<ActionTimelineClipboard> clipboard);
 
    const ActionTimelineTarget& target() const noexcept { return target_; }
    [[nodiscard]] Result<void> reloadDocument(const EditorValue& snapshot);
    [[nodiscard]] Result<void> configureWorkspace(EditorWorkspace& workspace) const;
    [[nodiscard]] Result<void> addTrack(action::ActionTrack track);
    [[nodiscard]] Result<void> removeTrack(const LogicalId& trackId);
    [[nodiscard]] Result<void> renameTrack(const LogicalId& trackId, std::string label);
    [[nodiscard]] Result<void> setMontageSettings(action::ActionMontageSettings settings);
    [[nodiscard]] Result<void> addSectionSplit(Duration time);
    [[nodiscard]] Result<void> setSectionSplit(std::size_t index, Duration time);
    [[nodiscard]] Result<void> removeSectionSplit(std::size_t index);
    [[nodiscard]] Result<void> addAnimationSection(action::ActionAnimationSection section);
    [[nodiscard]] Result<void> moveAnimationSection(const LogicalId& sectionId, Duration delta);
    [[nodiscard]] Result<void> resizeAnimationSection(const LogicalId& sectionId, Duration start, Duration end,
                                                            Duration blendIn);
    [[nodiscard]] Result<void> editAnimationSection(const LogicalId& sectionId, Duration start, Duration end,
                                                          Duration blendIn, std::string animationUri);
    [[nodiscard]] Result<void> editAnimationSectionSource(const LogicalId& sectionId, Duration sourceStart,
                                                                Duration                 sourceEnd,
                                                                action::ActionBlendCurve blendCurve);
    [[nodiscard]] Result<void> editAnimationSectionFull(action::ActionAnimationSection section);
    [[nodiscard]] Result<void> removeAnimationSection(const LogicalId& sectionId);
    [[nodiscard]] Result<void> addNotify(const LogicalId& trackId, action::ActionNotify notify);
    [[nodiscard]] Result<void> addState(const LogicalId& trackId, action::ActionNotifyState state);
    [[nodiscard]] Result<void> moveItem(const LogicalId& itemId, Duration delta);
    [[nodiscard]] Result<void> resizeState(const LogicalId& itemId, Duration start, Duration end);
    [[nodiscard]] Result<void> updateItem(const LogicalId& itemId, LogicalId type, Value::Object payload);
    [[nodiscard]] Result<void> addParameterKey(const LogicalId& itemId, action::ActionParameterKey key);
    [[nodiscard]] Result<void> editParameterKey(const LogicalId& itemId, std::size_t index,
                                                      action::ActionParameterKey key);
    [[nodiscard]] Result<void> removeParameterKey(const LogicalId& itemId, std::size_t index);
    [[nodiscard]] Result<void> editItem(const LogicalId& itemId, Duration start, Duration end, LogicalId type,
                                              Value::Object payload);
    [[nodiscard]] Result<void> setItemEnabled(const LogicalId& itemId, bool enabled);
    [[nodiscard]] Result<void> removeItem(const LogicalId& itemId);
    [[nodiscard]] Result<void> setTrackMuted(const LogicalId& trackId, bool muted);
    [[nodiscard]] Result<void> setTrackLocked(const LogicalId& trackId, bool locked);
 
    [[nodiscard]] Result<std::size_t> boxSelect(Duration start, Duration end);
    void clearSelection() { selection_.clear(); }
    [[nodiscard]] Result<void> selectItem(const LogicalId& itemId, bool additive = false);
    std::size_t selectionCount() const noexcept { return selection_.size(); }
    [[nodiscard]] std::vector<LogicalId> selectedItemIds() const;
    [[nodiscard]] Result<TimelineSelectionRange> selectionRange() const;
    [[nodiscard]] Result<void> moveSelection(Duration delta);
    [[nodiscard]] Result<void> alignSelectionStart();
    [[nodiscard]] Result<void> alignSelectionEnd();
    [[nodiscard]] Result<void> scaleSelection(Duration start, Duration end);
    [[nodiscard]] Result<std::size_t> copySelection();
    [[nodiscard]] Result<std::size_t> paste(Duration offset);
    [[nodiscard]] Result<std::size_t> pasteToTrack(const LogicalId& trackId, Duration offset);
    [[nodiscard]] Result<void> copyTrack(const LogicalId& trackId);
    [[nodiscard]] Result<LogicalId> pasteTrack();
    [[nodiscard]] Result<void> deleteSelection();
 
    [[nodiscard]] Result<TransactionReceipt> undo();
    [[nodiscard]] Result<TransactionReceipt> redo();
    bool canUndo() const noexcept { return transactions_.canUndo(); }
    bool canRedo() const noexcept { return transactions_.canRedo(); }
 
    void play() noexcept { playing_ = true; }
    void pause() noexcept { playing_ = false; }
    [[nodiscard]] Result<void> stop();
    [[nodiscard]] Result<Duration> frameStepTarget(std::int64_t frames, double frameRate) const;
    [[nodiscard]] Result<void> stepFrames(std::int64_t frames, double frameRate);
    [[nodiscard]] Result<void> jumpToEnd();
    [[nodiscard]] Result<void> seek(Duration time);
    [[nodiscard]] Result<std::size_t> update(Duration delta);
    [[nodiscard]] Result<ActionTimelinePreviewPlan> planPreview(Duration delta) const;
    [[nodiscard]] Result<std::size_t> applyPreviewPlan(ActionTimelinePreviewPlan plan);
    Duration previewTime() const noexcept { return previewTime_; }
    bool playing() const noexcept { return playing_; }
    const std::vector<action::ActionTimelineEvent>& previewEvents() const noexcept { return previewEvents_; }
 
private:
    [[nodiscard]] Result<void> commit(action::ActionTimeline candidate, std::string label, std::string mergeKey);
    [[nodiscard]] static Result<void> rejected(std::string rule, std::string message);
    [[nodiscard]] LogicalId copiedId(const LogicalId& source, const action::ActionTimeline& candidate);
    [[nodiscard]] Result<std::size_t> pasteItems(Duration offset, const LogicalId* destinationTrack);
 
    ActionTimelineTarget                     target_;
    LocalWorldAuthority                      authority_;
    LocalTransactionBackend                  transactions_;
    std::set<std::string>                    selection_;
    std::shared_ptr<ActionTimelineClipboard> clipboard_;
    std::uint64_t                            transactionSequence_ = 0;
    std::uint64_t                            copySequence_        = 0;
    Duration                                 previewTime_         = Duration::zero();
    bool                                     playing_             = false;
    bool                                     previewStarted_      = false;
    std::vector<action::ActionTimelineEvent> previewEvents_;
};
 
enum class ActionTimelineCloseMode : std::uint8_t { ProtectDirty, Discard };
 
struct ActionTimelineTabSnapshot {
    DocumentSnapshot document;
    bool             active = false;
    bool             dirty  = false;
};
 
class EVENGINE_API_EDITORS ActionTimelineDocumentWorkspace {
public:
    explicit ActionTimelineDocumentWorkspace(DocumentService& documents);
 
    ActionTimelineDocumentWorkspace(const ActionTimelineDocumentWorkspace&)            = delete;
    ActionTimelineDocumentWorkspace& operator=(const ActionTimelineDocumentWorkspace&) = delete;
    ActionTimelineDocumentWorkspace(ActionTimelineDocumentWorkspace&&)                 = default;
    ActionTimelineDocumentWorkspace& operator=(ActionTimelineDocumentWorkspace&&)      = default;
 
    [[nodiscard]] Result<DocumentId> open(DocumentKey key, std::string title, std::string resourceUri,
                                                action::ActionTimeline initialTimeline);
    [[nodiscard]] Result<void> activate(const DocumentId& document);
    [[nodiscard]] Result<DocumentSnapshot> save(const DocumentId& document);
    [[nodiscard]] Result<DocumentSnapshot> reconcile(const DocumentId& document);
    [[nodiscard]] Result<void> close(const DocumentId& document, ActionTimelineCloseMode mode);
 
    [[nodiscard]] Result<std::vector<ActionTimelineTabSnapshot>> tabs() const;
    ActionTimelineEditor* activeEditor() noexcept;
    const DocumentId& activeDocument() const noexcept { return activeDocument_; }
 
private:
    struct Tab {
        DocumentId                            document;
        std::unique_ptr<ActionTimelineEditor> editor;
        std::uint64_t                         synchronizedEditorRevision = 0;
        std::uint64_t                         savedEditorRevision        = 0;
    };
 
    Tab*       find(const DocumentId& document);
    const Tab* find(const DocumentId& document) const;
    [[nodiscard]] Result<DocumentSnapshot> synchronize(Tab& tab);
    [[nodiscard]] static Result<action::ActionTimeline> decode(const EditorValue& content);
 
    DocumentService*                         documents_ = nullptr;
    std::shared_ptr<ActionTimelineClipboard> clipboard_ = std::make_shared<ActionTimelineClipboard>();
    std::vector<Tab>                         tabs_;
    DocumentId                               activeDocument_;
};
 
}  // namespace eve::editor