workspace.hpp

 
#pragma once
 
#include "editor_camera.hpp"
#include "gizmo_layout.hpp"
#include "node_owner.hpp"
#include "workspace_history.hpp"
 
#include <atomic>
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
#include <memory>
#include <toast/events/listener.hpp>
#include <utility>
 
namespace toast {
 
class ProceduralVoxel;

class TOAST_API Workspace : public INodeOwner {
public:
  struct SizeHandlePoint {
    glm::vec3 world_position {0.0f};
    GizmoHandle handle = GizmoHandle::none;
  };
 
  static constexpr size_t k_max_size_handles = 6;

  Workspace(std::string_view type, UID handle);

  Workspace(UID uid);

  Workspace(UID uid, std::string_view source_uri);
 
  ~Workspace() override;
 
  auto name() -> std::string override;
 
  auto asWorkspace() -> Workspace* override { return this; }

  void registerDependency(Node& from, Node& to) override;
  void unregisterDependency(Node& from, Node& to) override;
 
  void nodeEnabledChanged(Node& node) noexcept override;
 
  [[nodiscard]]
  auto participatesIn(NodeOwnerParticipation use) const noexcept -> bool override;
 
  [[nodiscard]]
  auto receivesEvents() const noexcept -> bool override;

  auto findFrom(const Node& origin, std::string_view query) -> Box<Node> override;

  auto findFrom(const Node& origin, const UID& uid) -> Box<Node> override;

  auto searchFrom(const Node& origin, std::string_view query) -> std::vector<Box<Node>> override;

  [[nodiscard]]
  virtual auto isPlaying() const -> bool {
    return false;
  }
 
  [[nodiscard]]
  auto usesGameCamera() const noexcept -> bool {
    return m_game_camera;
  }
 
  void inheritEditorCamera(const Workspace& source);
  void preparePrefabReload(UID uid);
  void finishPrefabReload();
 
protected:
  [[nodiscard]]
  auto owningPrefabUid() const -> UID override {
    return m_handle;
  }

  struct EmptyTag { };

  Workspace(UID handle, EmptyTag);
 
  UID m_handle;
  // In-memory source assets must outlive the handles held by the node tree.
  std::unique_ptr<assets::Prefab> m_owned_source_prefab;
  Box<Node> m_root_node;
  Box<Node> m_focused_node;
  event::Listener m_listener;
 
  // mirrored editor toolbar state; defaults match the editor's
  struct SnapSetting {
    bool enabled = true;
    float value = 0.0f;
  };
 
  GizmoTool m_gizmo_tool = GizmoTool::select;
  bool m_world_space = false;    
  SnapSetting m_translate_snap {true, 0.10f};
  SnapSetting m_rotate_snap {true, 30.0f};
  SnapSetting m_scale_snap {true, 0.10f};
  bool m_game_camera = false;                           
  std::unique_ptr<Camera> m_editor_camera;
  EditorCameraController m_editor_camera_controller;    
  std::unique_ptr<WorkspaceHistory> m_history;
  std::mutex m_enabled_changes_mutex;
  std::vector<Box<Node>> m_enabled_changes;
 
  void sendEnabledChanges();
 
  [[nodiscard]]
  auto isActiveWorkspace() const noexcept -> bool;

  // Translate-gizmo interaction
  glm::vec2 m_gizmo_mouse_pos {0.0f, 0.0f};
  GizmoHandle m_gizmo_hover = GizmoHandle::none;
  GizmoHandle m_gizmo_drag = GizmoHandle::none;
  glm::vec3 m_gizmo_drag_start_world_pos {0.0f};
  glm::quat m_gizmo_drag_start_rotation {1.0f, 0.0f, 0.0f, 0.0f};
  glm::vec3 m_gizmo_drag_start_scale {1.0f};
  glm::vec3 m_gizmo_drag_anchor {0.0f};          
  glm::vec3 m_gizmo_drag_axis {0.0f};            
  glm::vec3 m_gizmo_drag_plane_normal {0.0f};    
  float m_gizmo_drag_start_angle = 0.0f;         
  float m_gizmo_drag_current_factor = 1.0f;      
 
  glm::vec3 m_gizmo_drag_start_size {0.0f};
  glm::vec3 m_gizmo_drag_start_local_pos {0.0f};
  glm::quat m_gizmo_drag_start_local_rot {1.0f, 0.0f, 0.0f, 0.0f};
  std::optional<std::string> m_gizmo_history_start;
 
  [[nodiscard]]
  auto gizmoOrigin() const -> glm::vec3;
  [[nodiscard]]
  auto gizmoOrientation() const -> glm::quat;
  [[nodiscard]]
  auto gizmoScale() const -> float;
  [[nodiscard]]
  auto gizmoInteractionAllowed() const -> bool;
 
  [[nodiscard]]
  auto collectSizeHandles() const -> std::pair<std::array<SizeHandlePoint, k_max_size_handles>, uint32_t>;
 
  void gizmoApplySizeDrag(float delta);
  void gizmoUpdateHover();
  void gizmoBeginDrag(GizmoHandle handle);
  void gizmoUpdateDrag();
  void gizmoEndDrag();
 
  void eventSubscriptions();
  void initializeHistory(bool available, bool initially_saved);
  auto restoreHistorySnapshot(const assets::Prefab& snapshot) -> bool;
  void destroyOwnedTree(Box<Node>& root);
  auto duplicateNode(Box<Node> src, Box<Node> par, bool after_source) -> Box<Node>;

  void subscribeVoxelEditing();

  struct VoxelToolState {
    enum class Phase : uint8_t {
      idle,
      face,         
      part,         
      box,          
      height,       
      cut,          
      pick_side,    
    };
 
    uint32_t tool = 0;
    uint8_t paint_id = 1;
    UID default_script;          
    uint8_t default_mode = 0;    
    Phase phase = Phase::idle;
    bool dragging = false;       
    UID extrude_source;          
    int axis = 2;                
    int32_t surface = 0;         
    float plane = 0.0f;          
    int32_t sign = 1;            
    int32_t depth = 1;
    glm::ivec3 anchor {0};
    glm::ivec3 current {0};
    glm::ivec3 face_min {std::numeric_limits<int32_t>::min()};    
    glm::ivec3 face_max {std::numeric_limits<int32_t>::max()};
    int cut_axis = 0;                                             
    int32_t cut_at = 0;                                           
    glm::vec2 cut_start {0.0f};
    glm::vec4 cut_plane {0.0f};

    [[nodiscard]]
    auto box() const -> std::pair<glm::ivec3, glm::ivec3>;
  };
 
  VoxelToolState m_voxel_tool;
 
  Box<Node> m_voxel_preview;
  void voxelUpdatePreview(uint8_t kind);
 
  void voxelReparent(Box<Node> node, Box<Node> parent, size_t index);
  auto voxelWrapInGroup(Box<Node> node, std::string_view name) -> Box<Node>;
 
  [[nodiscard]]
  auto voxelToolShape() -> ProceduralVoxel*;
  void voxelToolMouseMove();
  auto voxelToolMouseButton(uint32_t button, bool pressed, int mods) -> bool;
  void voxelToolCancel();
 
  auto pickNodeUnderMouse() -> Box<Node>;
  std::optional<glm::vec2> m_pick_press;
 
  auto retypeNode(Box<Node>& target, std::string_view type, bool keep_fields) -> Box<Node>;
  void promoteNode(Box<Node>& target, std::string_view path);
 
  template<typename F>
  void recordHistory(WorkspaceHistory::Context context, F&& mutation) {
    const bool owned = m_history && m_history->beginAtomic(std::move(context));
    std::forward<F>(mutation)();
    if (m_history) {
      m_history->finishAtomic(owned);
    }
  }

  void initFromPrefab(const assets::Handle<assets::Prefab>& file);
  void applyActiveCamera() override;
 
private:
  struct PendingPrefabReload {
    Box<Node> node;
    assets::Prefab reference;
  };
 
  std::vector<PendingPrefabReload> m_prefab_reloads;
  double m_inspector_accum = 0.0;

  void tickAnimationPreviews(const Node& node);
 
public:
  void tick() override;
 
  [[nodiscard]]
  auto rootNode() const -> const Node& {
    return *m_root_node;
  }
 
  [[nodiscard]]
  auto isValid() const -> bool {
    return m_root_node.exists();
  }
 
  [[nodiscard]]
  auto findPrefabInstance(UID prefab, UID instance) -> Box<Node>;
 
  struct GizmoRenderState {
    bool visible = false;
    GizmoTool tool = GizmoTool::select;
    glm::vec3 origin {0.0f};
    glm::quat orientation {1.0f, 0.0f, 0.0f, 0.0f};
    GizmoHandle hover = GizmoHandle::none;
    GizmoHandle active = GizmoHandle::none;
    float drag_scale_factor = 1.0f;    
 
    std::array<SizeHandlePoint, k_max_size_handles> size_handles {};
    uint32_t size_handle_count = 0;
    float size_handle_scale = 1.0f;
  };

  [[nodiscard]]
  auto gizmoRenderState() const -> GizmoRenderState;
};
}