node_owner.hpp

 
#pragma once
#include "box.hpp"
 
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <shared_mutex>
#include <string_view>
#include <toast/assets/prefab.hpp>
#include <toast/export.hpp>
#include <toast/physics/accumulator.hpp>
#include <toast/scripting/lua_value_codec.hpp>
#include <toast/uid.hpp>
#include <unordered_set>
#include <vector>
 
namespace toast {
class Workspace;
class CameraController;
class Camera;
enum class NodeOwnerParticipation : uint8_t {
  render,
  runtime_input,
  gameplay_tick,
};
 
class TOAST_API INodeOwner {
public:
  INodeOwner();
  virtual ~INodeOwner();
  virtual auto name() -> std::string = 0;
 
  virtual void tick() = 0;

  virtual auto asWorkspace() -> Workspace* { return nullptr; }

  [[nodiscard]]
  virtual auto participatesIn(NodeOwnerParticipation use) const noexcept -> bool = 0;

  [[nodiscard]]
  virtual auto receivesEvents() const noexcept -> bool {
    return true;
  }
 
  void syncListenerState() noexcept;

  [[nodiscard]]
  auto isEditing() noexcept -> bool;
 
  [[nodiscard]]
  auto treeMutex() const noexcept -> std::shared_mutex& {
    return m_tree_mutex;
  }
 
  virtual void registerDependency(Node& from, Node& to) = 0;
  virtual void unregisterDependency(Node& from, Node& to) = 0;
 
  virtual void registerInteraction(Node& /*first*/, Node& /*second*/) { }
 
  virtual void nodeEnabledChanged(Node& node) noexcept { (void)node; }
 
  virtual auto findFrom(const Node& origin, std::string_view query) -> Box<Node> = 0;
  virtual auto findFrom(const Node& origin, const UID& uid) -> Box<Node> = 0;
  virtual auto searchFrom(const Node& origin, std::string_view query) -> std::vector<Box<Node>> = 0;
 
  void activateCamera(Camera& camera);
  void setMainCamera(Camera& camera);
  void deactivateCamera(Camera& camera);
  void activateCameraController(CameraController& controller);
  void deactivateCameraController(CameraController& controller);
 
  auto requestRuntimeCreate(Node& parent, std::string_view type) -> Box<Node>;
  auto requestRuntimeSpawn(Node& parent, UID uid) -> Box<Node>;
  auto requestRuntimeSpawn(Node& parent, std::string_view) -> Box<Node>;
 
  void reloadScriptsUsing(UID script_uid) noexcept;
  void refreshNodeInfos() noexcept;
  void rebindAssetHandles(UID asset_uid) noexcept;
  static void reapOrphanedControlBoxes() noexcept;
 
  struct InstantiateContext {
    std::vector<uint64_t> asset_chain;    
    std::function<assets::Handle<assets::Prefab>(toast::UID)> resolver;    
    uint64_t script_group = 0;
    bool nested = false;
  };
 
protected:
  [[nodiscard]]
  virtual auto owningPrefabUid() const -> UID {
    return {0};
  }
 
  void seedPrefabContext(InstantiateContext& context, const Node* parent = nullptr) const;
  static void updateTransforms(Node& root);

  static void generateUid(Node& node);

  static auto stripNamespace(std::string_view type) -> std::string_view;

  static auto uniqueChildName(const Node& parent, std::string_view base) -> std::string;

  auto nodeAllocation(std::string_view type = "toast::Node") noexcept -> Box<Node>;

  auto nodeAllocation(const assets::Prefab::BasicNode& node_data, uint64_t script_group = 0, bool build_scripts = true) noexcept
      -> Box<Node>;
 
  void buildLeaves(
      const assets::Handle<assets::Prefab>& file, uint64_t group, const std::vector<size_t>& leaf_slots,
      std::vector<Box<Node>>& slots
  );

  auto buildTree(std::vector<Box<Node>>&& nodes, const assets::Handle<assets::Prefab>& file) -> Box<Node>;

  auto instantiate(const assets::Handle<assets::Prefab>& file, InstantiateContext& ctx) -> Box<Node>;

  void applyFields(Node& node, const assets::Prefab::BasicNode& data);

  void applyLuaOverrides(Node& node, const assets::Prefab::BasicNode& data, const scripting::NodeResolver& find_node);

  void releaseNode(_detail::ControlBox& control) noexcept;

  void reapTombstones() noexcept;
 
  void findCamera();
  void findCameraController();
  void tickActiveCameraController();
  void beginCameraShutdown() noexcept;
 
  [[nodiscard]]
  auto activeCamera() noexcept -> Box<Camera>&;
 
  [[nodiscard]]
  auto activeRenderCamera() noexcept -> Camera*;
  virtual void applyActiveCamera() = 0;
 
  template<typename Fn>
  void forEachNode(Fn&& fn) const {
    for (const auto& cb : nodes) {
      fn(cb);
    }
  }
 
  std::mutex nodes_mutex;
  size_t tombstones = 0;    
 
  physics::Accumulator m_accumulator;
 
private:
  friend class CameraController;
 
  mutable std::shared_mutex m_tree_mutex;
  std::unordered_set<_detail::ControlBox> nodes;
 
  std::unique_ptr<Camera> m_fallback_camera;
  Box<Camera> m_active_camera;
  Box<CameraController> m_active_camera_controller;
  bool m_has_camera_controller = false;
  bool m_is_shutting_down = false;
};
 
}