ActionTimelineWidget.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "action/ActionNotifyRegistry.h"
#include "action/editor/ActionTimelineEditor.h"
#include "editor/EditorPresentation.h"
 
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace eve::editor {
 
enum class TimelineHitPart : std::uint8_t { Body, StartHandle, EndHandle };
 
enum class TimelineDragStatus : std::uint8_t { Idle, Active };
 
enum class TimelineItemVisual : std::uint8_t {
    Animation,
    Gameplay,
    Damage,
    Vfx,
    Audio,
    Prefab,
    Camera,
    Hitbox,
    Defense,
    Input,
    Collision,
    Movement,
    Curve,
    Custom
};
 
[[nodiscard]] EVENGINE_API_EDITORS std::string_view timelineItemVisualName(TimelineItemVisual visual) noexcept;
 
struct TimelineItemGeometry {
    LogicalId trackId;
    LogicalId itemId;
    LogicalId type;
    bool      state    = false;
    bool      selected = false;
    float     minimumX = 0.0f;
    float     maximumX = 0.0f;
    float     minimumY = 0.0f;
    float     maximumY = 0.0f;
    std::string displayName;
    std::string detail;
    TimelineItemVisual visual = TimelineItemVisual::Custom;
};
 
struct TimelineRulerTick {
    Duration time;
    float    x     = 0.0f;
    bool     major = false;
};
 
struct TimelineHit {
    LogicalId       itemId;
    TimelineHitPart part = TimelineHitPart::Body;
};
 
struct TimelineWidgetLayout {
    float                             width     = 0.0f;
    float                             height    = 0.0f;
    float                             playheadX = 0.0f;
    bool                              audioWaveformsAvailable = false;
    std::vector<TimelineItemGeometry> items;
    std::vector<TimelineRulerTick>    rulerTicks;
};
 
enum class TimelineWidgetCommand : std::uint8_t {
    Copy,
    Paste,
    DeleteSelection,
    Undo,
    Redo,
    PlayPause,
    AlignSelectionStart,
    AlignSelectionEnd
};
 
struct TimelineWidgetCommandDescriptor {
    TimelineWidgetCommand command = TimelineWidgetCommand::Copy;
    std::string           label;
    std::string           shortcut;
    bool                  enabled = false;
};
 
class EVENGINE_API_EDITORS ActionTimelineWidget {
public:
    ActionTimelineWidget(ActionTimelineEditor& editor, const action::ActionNotifyRegistry& registry);
 
    [[nodiscard]] Result<void> setViewport(float width, float rowHeight, float labelWidth = 120.0f);
    [[nodiscard]] Result<void> setSnapInterval(Duration interval);
    [[nodiscard]] Result<void> setVisibleRange(Duration start, Duration end);
    [[nodiscard]] Result<void> zoom(double factor, double normalizedAnchor = 0.5);
    [[nodiscard]] Result<void> pan(Duration delta);
    [[nodiscard]] TimelineWidgetLayout layout() const;
    void draw(IEditorOverlay& overlay) const;
    [[nodiscard]] std::optional<TimelineHit> hitTest(float x, float y) const;
 
    [[nodiscard]] Result<void> pointerDown(float x, float y, bool additiveSelection = false);
    [[nodiscard]] Result<void> pointerMove(float x);
    [[nodiscard]] Result<void> pointerUp(float x);
    void cancelPointer() noexcept { drag_.reset(); }
    TimelineDragStatus dragStatus() const noexcept {
        return drag_ ? TimelineDragStatus::Active : TimelineDragStatus::Idle;
    }
 
    [[nodiscard]] Result<void> seek(float x);
    [[nodiscard]] Duration timeAt(float x) const noexcept { return xToTime(x); }
    [[nodiscard]] Result<void> inspectSelection(IEditorInspector& inspector);
 
    [[nodiscard]] std::vector<TimelineWidgetCommandDescriptor> commands() const;
    [[nodiscard]] Result<void> invoke(TimelineWidgetCommand command);
    [[nodiscard]] Result<void> handleShortcut(std::string_view shortcut);
 
    [[nodiscard]] std::vector<action::ActionNotifyDescriptor> insertableTypes(action::ActionNotifyShape shape) const;
    [[nodiscard]] Result<void> addNotifyAtCursor(const LogicalId& trackId, std::string_view type,
                                                       Value::Object payload);
    [[nodiscard]] Result<void> addStateAtCursor(const LogicalId& trackId, std::string_view type,
                                                      Duration duration, Value::Object payload);
 
private:
    struct DragState {
        LogicalId       itemId;
        TimelineHitPart part = TimelineHitPart::Body;
        Duration        anchorTime;
        Duration        originalStart;
        Duration        originalEnd;
        Duration        previewStart;
        Duration        previewEnd;
        bool            state = false;
    };
 
    [[nodiscard]] float                   timeToX(Duration time) const noexcept;
    [[nodiscard]] Duration                xToTime(float x) const noexcept;
    [[nodiscard]] std::optional<Duration> magneticSnap(Duration candidate,
                                                       const LogicalId& excludedItem) const noexcept;
    [[nodiscard]] Result<void>      updateDrag(float x);
    [[nodiscard]] LogicalId               generatedItemId();
 
    ActionTimelineEditor&               editor_;
    const action::ActionNotifyRegistry& registry_;
    float                               width_      = 800.0f;
    float                               rowHeight_  = 24.0f;
    float                               labelWidth_ = 120.0f;
    Duration                            snapInterval_ = Duration::zero();
    Duration                            visibleStart_ = Duration::zero();
    Duration                            visibleEnd_   = Duration::zero();
    std::optional<DragState>            drag_;
    std::optional<Duration>             clipboardAnchor_;
    std::uint64_t                       generatedSequence_ = 0;
};
 
}  // namespace eve::editor