EditorTool.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "editor/EditorTarget.h"
#include "editor/EditorResult.h"
 
#include <memory>
#include <string>
 
namespace eve::editor {
 
class EditorSession;
class EditorTransactions;
class IEditCommand;
class IEditorOverlay;
class IEditorInspector;
 
struct EditorPointerEvent {
    enum class Phase { Down, Move, Up, Cancel };
 
    Phase phase     = Phase::Move;
    int   pointerId = 0;
    int   button    = 0;
    float x         = 0.f;
    float y         = 0.f;
    float z         = 0.f;
    float deltaX    = 0.f;
    float deltaY    = 0.f;
    float deltaZ    = 0.f;
    float pressure  = 1.f;
    bool  shift     = false;
    bool  control   = false;
    bool  alt       = false;
};
 
struct EditorKeyEvent {
    std::string key;
    bool        pressed  = false;
    bool        repeated = false;
    bool        shift    = false;
    bool        control  = false;
    bool        alt      = false;
};
 
struct ToolResponse {
    bool handled        = false;
    bool capturePointer = false;
    bool releasePointer = false;
 
    static ToolResponse ignored() { return {}; }
    static ToolResponse consumed() { return {true, false, false}; }
    static ToolResponse capture() { return {true, true, false}; }
    static ToolResponse release() { return {true, false, true}; }
};
 
class EVENGINE_API_ORCHESTRATION EditorContext {
public:
    explicit EditorContext(EditorSession* session = nullptr) : session_(session) {}
 
    EditorSession* session() const { return session_; }
    IEditableTarget* target() const;
    EditorTransactions& transactions() const;
    bool execute(std::unique_ptr<IEditCommand> command) const;
    [[nodiscard]] Result<void> executeChecked(std::unique_ptr<IEditCommand> command) const;
 
    template <typename Capability>
    Capability* targetCapability() const;
 
private:
    friend class EditorSession;
    EditorSession* session_ = nullptr;
};
 
struct ToolDescriptor {
    std::string id;
    std::string label;
    std::string shortcut;
};
 
class IEditorTool {
public:
    virtual ~IEditorTool() = default;
 
    virtual const ToolDescriptor& descriptor() const = 0;
 
    virtual void activate(EditorContext& context) { (void)context; }
    virtual void deactivate(EditorContext& context) { (void)context; }
 
    virtual ToolResponse pointerEvent(EditorContext& context, const EditorPointerEvent& event) {
        (void)context;
        (void)event;
        return ToolResponse::ignored();
    }
 
    virtual ToolResponse keyEvent(EditorContext& context, const EditorKeyEvent& event) {
        (void)context;
        (void)event;
        return ToolResponse::ignored();
    }
 
    virtual void update(EditorContext& context, float dt) {
        (void)context;
        (void)dt;
    }
 
    virtual void drawOverlay(EditorContext& context, IEditorOverlay& overlay) {
        (void)context;
        (void)overlay;
    }
 
    virtual void inspect(EditorContext& context, IEditorInspector& inspector) {
        (void)context;
        (void)inspector;
    }
 
    virtual void cancel(EditorContext& context) { (void)context; }
};
 
}  // namespace eve::editor
 
namespace eve::editor {
 
template <typename Capability>
Capability* EditorContext::targetCapability() const {
    IEditableTarget* current = target();
    return current ? current->query<Capability>() : nullptr;
}
 
}  // namespace eve::editor