node.hpp

Go to the documentation of this file.

 
#pragma once
#define NODEFILE
#include "box.hpp"
#include "control_box.hpp"
 
#include <list>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <toast/assets/prefab.hpp>
#include <toast/engine_defs.hpp>
#include <toast/events/listener.hpp>
#include <toast/events/signals.hpp>
#include <toast/export.hpp>
#include <toast/log.hpp>
#include <toast/reflect/reflect_node.hpp>
#include <toast/uid.hpp>
#include <toast/world/node_owner.hpp>
 
namespace physics {
class Collider;
}
 
namespace assets {
class Script;
}
 
namespace scripting {
class ScriptRuntime;
}
 
namespace toast {
class INodeOwner;
 
namespace _detail {
struct NodeCluster;
}
 
enum class NodeState : uint8_t {
  null,
  root,       
  cached,     
  global,     
  loading,    
  destroy,    
};
 
enum class NodeType : uint8_t {
  null,
  child,         
  root,          
  world_root,    
};
 
struct NodeMessage {
  enum Severity : uint8_t {
    warning,
    error
  } severity;
 
  uint8_t id;
  std::string text;
 
  auto operator==(const NodeMessage& rhs) const noexcept -> bool { return id == rhs.id; }
};
 
class [[ToastNode, Icon("Circle")]] TOAST_API Node {
  friend class INodeOwner;
  friend class World;
  friend class Workspace;
  friend class PlayWorkspace;
  friend class TickScheduler;
  friend class Node3D;
  friend class assets::Prefab;
  friend struct _detail::ControlBox;
  friend struct _detail::NodeCluster;
  friend struct toast::_detail::WorldTestAccess;
  friend class physics::Collider;
 
public:
  Node();
  virtual ~Node();

  [[nodiscard]]
  auto uid() const noexcept -> const UID&;

  [[nodiscard]]
  auto rid() const noexcept -> std::uintptr_t;

  [[nodiscard]]
  auto name() const noexcept -> std::string_view;

  void name(std::string_view name) noexcept;

  [[nodiscard]]
  auto enabled() const noexcept -> bool;
 
  [[nodiscard]]
  auto participatesIn(NodeOwnerParticipation use) const noexcept -> bool {
    return m_owner != nullptr && m_owner->participatesIn(use);
  }

  [[nodiscard]]
  auto owner() const noexcept -> INodeOwner* {
    return m_owner;
  }

  void enabled(bool value) noexcept;

  [[nodiscard]]
  auto box() const noexcept -> Box<Node>;

  [[nodiscard]]
  auto info() const -> const NodeInfo*;

  [[nodiscard]]
  auto sourcePrefab() const noexcept -> const assets::Handle<assets::Prefab>&;

  [[nodiscard]]
  auto isInstanceRoot() const noexcept -> bool;

  [[nodiscard]]
  auto root() const noexcept -> Box<Node>;

  [[nodiscard]]
  auto state() const noexcept -> NodeState {
    return m_state;
  }

  [[nodiscard]]
  auto type() const noexcept -> NodeType {
    return m_type;
  }

  [[nodiscard]]
  auto listener() noexcept -> event::Listener&;

  [[nodiscard]]
  auto parent() noexcept -> Box<Node>;

  [[nodiscard]]
  auto children() const noexcept -> const std::vector<Box<Node>>& {
    return m_children;
  }
 
  [[nodiscard]]
  auto childrenSnapshot() const -> std::vector<Box<Node>>;

  auto create(std::string_view type = "toast::Node") noexcept -> Box<Node> {
    if (m_state == NodeState::root or m_state == NodeState::global) {
      return m_owner->requestRuntimeCreate(*this, type);
    }
 
    // TODO: implement
    TOAST_NOT_IMPLEMENTED;
    return {};
  }

  auto spawn(UID uid) noexcept -> Box<Node> {
    if (m_state == NodeState::root or m_state == NodeState::global) {
      return m_owner->requestRuntimeSpawn(*this, uid);
    }
 
    // TODO: implement
    TOAST_NOT_IMPLEMENTED;
    return {};
  }

  auto spawn(std::string_view uri) noexcept -> Box<Node> {
    if (m_state == NodeState::root or m_state == NodeState::global) {
      return m_owner->requestRuntimeSpawn(*this, uri);
    }
 
    // TODO: implement
    TOAST_NOT_IMPLEMENTED;
    return {};
  }

  [[nodiscard]]
  auto find(std::string_view query) -> Box<Node>;

  [[nodiscard]]
  auto find(const UID& uid) -> Box<Node>;

  [[nodiscard]]
  auto search(std::string_view query) -> std::vector<Box<Node>>;
 
  [[nodiscard]]
  auto childrenOfType(const NodeInfo* type) const -> std::vector<Box<Node>>;
 
  [[nodiscard]]
  auto searchType(const NodeInfo* type) const -> std::vector<Box<Node>>;
 
  void addDependsOn(Node& other);
  void removeDependsOn(Node& other);

  void interactsWith(Node& other);
 
  [[nodiscard]]
  auto scriptRuntime() noexcept -> scripting::ScriptRuntime* {
    return m_script_runtime.get();
  }

  [[nodiscard]]
  auto hasTickFunction(TickFunctionList mask) const noexcept -> bool;

  [[nodiscard]]
  auto scriptVm(TickFunctionList func) const noexcept -> std::optional<size_t>;

  [[nodiscard]]
  auto scriptVmAny() const noexcept -> std::optional<size_t>;

  [[nodiscard]]
  auto hasCallable(std::string_view name) const noexcept -> bool;

  void reloadScripts() noexcept;

  [[nodiscard]]
  auto scripts() const noexcept -> const std::vector<assets::Handle<assets::Script>>& {
    return m_scripts;
  }

  void setScripts(std::vector<assets::Handle<assets::Script>> scripts) noexcept {
    m_scripts = std::move(scripts);
    loadScripts();
    onScriptsReloaded();
  }

  void addScript(const assets::Handle<assets::Script>& script) noexcept {
    m_scripts.push_back(script);
    loadScripts();
  }

  template<typename R = void, typename... Args>
  auto call(std::string_view name, Args&&... args) -> R {
    std::array<std::any, sizeof...(Args)> any_args {std::any(std::decay_t<Args>(args))...};
    if constexpr (std::is_void_v<R>) {
      if (m_info && m_info->getMethod(name)) {
        _detail::callMethodChain(m_info, this, name, args...);
      }
      _detail::callNodeScripts(this, name, any_args);
    } else {
      R result {};
      if (m_info && m_info->getMethod(name)) {
        result = _detail::callMethodChain<R>(m_info, this, name, args...);
      }
      _detail::callNodeScripts(this, name, any_args);
      return result;
    }
  }

  template<typename T>
  [[nodiscard]]
  auto get(std::string_view name) const -> T {
    if (m_info) {
      if (const auto* f = m_info->getField(name)) {
        std::any v = f->get(const_cast<Node*>(this));
        if (auto* p = std::any_cast<T>(&v)) {
          return *p;
        }
      }
    }
    std::any v = _detail::getNodeScriptVar(this, name);
    if (auto* p = std::any_cast<T>(&v)) {
      return *p;
    }
    return T {};
  }

  template<typename T>
  void set(std::string_view name, const T& value) {
    if (m_info) {
      if (const auto* f = m_info->getField(name)) {
        f->set(this, std::any(value));
        onReflectedFieldChanged(f->name);
      }
    }
    _detail::setNodeScriptVar(this, name, std::any(value));
  }
 
  signals::Signal<Box<Node>> on_enable;
  signals::Signal<Box<Node>> on_disable;
  signals::Signal<Box<Node>> on_begin;
  signals::Signal<Box<Node>> on_end;
 
protected:
  INodeOwner* m_owner = nullptr;
 
  virtual void onReflectedFieldChanged(std::string_view /*field_name*/) { }
 
  virtual void onScriptsReloaded() { }

  virtual void onScriptsReloading() { }
 
  [[nodiscard]]
  virtual auto luaAffinity() const noexcept -> std::optional<size_t> {
    return std::nullopt;
  }

  virtual void onScriptVarChanged(std::string_view path) { }
 
  virtual void updateInspectorMessages() { }
 
  void addInspectorMessage(const NodeMessage& message) {
    for (auto& existing : m_messages) {
      if (existing == message) {
        existing = message;
        return;
      }
    }
    m_messages.emplace_back(message);
  }
 
  void removeInspectorMessage(const NodeMessage& message) { m_messages.remove(message); }
 
private:
  bool m_recursive_prefab = false;
 
public:
  [[nodiscard]]
  auto isRecursivePrefab() const noexcept -> bool {
    return m_recursive_prefab;
  }
 
private:
  [[Reflect, Hidden]]
  UID m_uid;    // serialized unique id
  std::string m_name;
 
  [[Reflect, Hidden]]
  bool m_local_enabled = false;        // is this object enabled?
  bool m_inherited_enabled = false;    // is any parent of this object enabled?
 
  [[Reflect, Name("Parent"), InspectorNoModify]]
  Box<Node> m_parent;
 
  [[Reflect, Name("Prefab"), InspectorNoModify]]
  assets::Handle<assets::Prefab> m_source_prefab;
 
  NodeState m_state = NodeState::null;
  NodeType m_type = NodeType::null;
  std::array<uint8_t, 5> m_wave = {
    255, 255, 255, 255, 255
  };    
 
  Box<Node> m_box;
  const NodeInfo* m_info = nullptr;
  std::string m_reflect_type_name;
  bool m_prefab_interior =
      false;                 
  std::vector<Box<Node>> m_children;
  std::shared_ptr<const assets::Prefab::BasicNode>
      m_unresolved_chunk;    
 
  std::unique_ptr<event::Listener> m_listener = nullptr;
 
  [[Reflect]]
  std::vector<assets::Handle<assets::Script>> m_scripts;

  std::unique_ptr<scripting::ScriptRuntime> m_script_runtime;
 
  uint64_t m_script_group = 0;
  std::optional<size_t> m_script_vm;
 
  enum LifecycleBits : uint8_t {
    lifecycle_loaded = 1 << 0,
    lifecycle_initialized = 1 << 1,
    lifecycle_begun = 1 << 2,
    lifecycle_enabled = 1 << 3,
  };
 
  uint8_t m_lifecycle = 0;
 
  [[nodiscard]]
  auto parentInternal() const noexcept -> Box<Node> {
    return m_parent;
  }
 
  [[nodiscard]]
  auto rootUnlocked() const noexcept -> Box<Node>;
 
  void inheritedEnabled(bool value) noexcept;
  void changeNodeState(NodeState state) noexcept;

  void callTick(const NodeInfo* info, TickFunctionList func_type) noexcept;

  void callTickNative(const NodeInfo* info, TickFunctionList func_type) noexcept;
 
  void callTickScripts(TickFunctionList func_type) noexcept;

  void propagateCallTick(const NodeInfo* info, TickFunctionList func_type) noexcept;

  void propagateEnable() noexcept;

  void refreshInfo();

  void loadScripts() noexcept;
 
  std::list<NodeMessage> m_messages;
};
 
}

template<typename T>
auto reflect_cast(toast::Node* n) -> T* {    // NOLINT
  if (n && n->info() && n->info()->isA(toast::nodeTypeInfo<T>())) {
    return static_cast<T*>(n);
  }
  return nullptr;
}
 
#undef NODEFILE
#include <toast/events/signals.inl>