world.hpp

 
#pragma once
#include "box.hpp"
#include "control_box.hpp"
#include "node.hpp"
#include "node_owner.hpp"
#include "tick_scheduler.hpp"
#include "world_events.hpp"
 
#include <compare>
#include <concepts>
#include <future>
#include <iterator>
#include <mutex>
#include <queue>
#include <stack>
#include <toast/assets/prefab.hpp>
#include <toast/events/listener.hpp>
#include <toast/log.hpp>
#include <toast/reflect/reflect.hpp>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <variant>
 
namespace toast {
 
class Node;
 
class World final : public INodeOwner {
public:
  World();
  ~World() override;
 
  auto name() -> std::string override { return "World"; }
 
  void tick() override;
 
  [[nodiscard]]
  auto participatesIn(NodeOwnerParticipation /*use*/) const noexcept -> bool override {
    return true;
  }

  void registerDependency(Node& from, Node& to) override;
  void unregisterDependency(Node& from, Node& to) override;
  void registerInteraction(Node& first, Node& second) override;

  static void loadNode(UID uid);

  static void loadNode(std::string_view uri);
 
  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;

  static auto setRoot(Node& node) -> Box<Node>;

  static auto cacheNode(Node& node) -> Box<Node>;

  static void destroyNode(Node& node);

  [[nodiscard]]
  static auto findCached(std::string_view name) -> Box<Node>;

  [[nodiscard]]
  static auto graphviz() -> std::string;

  static void hotReload();

  static void hotReloadScripts(toast::UID script_uid);
 
  [[nodiscard]]
  auto dependencyGraphGraphviz() const -> std::string;
 
private:
  inline static World* instance = nullptr;

  void computeDependencyGraph();
  void applyActiveCamera() override;

  auto swapRoot(Node& node) -> Box<Node>;

  auto moveToCached(Node& node) -> Box<Node>;

  auto moveToGlobal(Node& node) -> Box<Node>;

  auto moveToChild(Node& node, Node& parent) -> Box<Node>;

  void detachFromParent(Node& node);

  void drainLoadQueue();

  void drainDestroyQueue();

  void drainSpawnQueue();

  static void spawn(UID prefab, Node& parent);

  [[nodiscard]]
  static auto findNode(const UID& uid, Node* scope = nullptr) -> Box<Node>;

  [[nodiscard]]
  static auto findNode(std::string_view path) -> Box<Node>;

  [[nodiscard]]
  static auto uidPath(const Node& node) -> std::string;

  [[nodiscard]]
  static auto findScoped(Node& scope, std::string_view seg) -> Box<Node>;

  static void searchScoped(Node& scope, std::string_view seg, std::vector<Box<Node>>& out);
 
  struct {
    event::Listener listener;
    std::mutex load_mutex;
    std::vector<std::future<void>> load_futures;
    std::vector<std::pair<Box<Node>, Box<Node>>> spawn_queue;
  } m;
 
  struct Trees {
    Box<Node> root;                          
    std::vector<Box<Node>> global;           
    std::vector<Box<Node>> cached;           
    std::vector<Box<Node>> load_queue;       
    std::vector<Box<Node>> destroy_queue;    
  } trees;
 
  using DependencyGraph = TickScheduler::DependencyGraph;
  TickScheduler m_scheduler;
 
  // for testing only
  friend struct toast::_detail::WorldTestAccess;
};
 
}