reflect_node.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <toast/reflect/reflect.hpp>
#include <type_traits>
#include <unordered_map>
#include <utility>
 
namespace toast {
 
class Node;
struct NodeInfo;
 
namespace _detail {
// hi dante
void TOAST_API callNodeScripts(Node* node, std::string_view name, std::span<const std::any> args) noexcept;
void TOAST_API setNodeScriptVar(Node* node, std::string_view name, const std::any& value) noexcept;
auto TOAST_API getNodeScriptVar(const Node* node, std::string_view name) noexcept -> std::any;
 
template<typename R = void, typename... Args>
auto callMethodChain(const NodeInfo* info, void* obj, std::string_view method_name, const Args&... args) -> R;
}

enum class TickFunctionList : uint16_t {
  none = 0,
  editor_tick = 1 << 1,
  init = 1 << 2,
  destroy = 1 << 3,
  begin = 1 << 4,
  end = 1 << 5,
  on_enable = 1 << 6,
  on_disable = 1 << 7,
  early_tick = 1 << 8,
  tick = 1 << 9,
  post_physics = 1 << 10,
  late_tick = 1 << 11,
  load = 1 << 12,
  save = 1 << 13,
  physics_tick = 1 << 14,
  tick_mask = early_tick | tick | physics_tick | post_physics | late_tick | editor_tick,
  all = 0xFFFF,
};
 
// Bitwise operators for TickFunctionList
constexpr auto operator&(TickFunctionList lhs, TickFunctionList rhs) -> TickFunctionList {
  return static_cast<TickFunctionList>(static_cast<uint16_t>(lhs) & static_cast<uint16_t>(rhs));
}
 
constexpr auto operator|(TickFunctionList lhs, TickFunctionList rhs) -> TickFunctionList {
  return static_cast<TickFunctionList>(static_cast<uint16_t>(lhs) | static_cast<uint16_t>(rhs));
}
 
constexpr auto operator&=(TickFunctionList& lhs, TickFunctionList rhs) -> TickFunctionList& {
  lhs = lhs & rhs;
  return lhs;
}
 
constexpr auto operator|=(TickFunctionList& lhs, TickFunctionList rhs) -> TickFunctionList& {
  lhs = lhs | rhs;
  return lhs;
}
 
// Helper to check if a flag is set
constexpr auto hasFlag(TickFunctionList flags, TickFunctionList flag) -> bool {
  return (flags & flag) == flag;
}
 
constexpr auto tickFunctionName(TickFunctionList func) -> std::string_view {
  switch (func) {
    case TickFunctionList::load: return "load";
    case TickFunctionList::save: return "save";
    case TickFunctionList::editor_tick: return "editor_tick";
    case TickFunctionList::init: return "init";
    case TickFunctionList::destroy: return "destroy";
    case TickFunctionList::begin: return "begin";
    case TickFunctionList::end: return "end";
    case TickFunctionList::on_enable: return "on_enable";
    case TickFunctionList::on_disable: return "on_disable";
    case TickFunctionList::early_tick: return "early_tick";
    case TickFunctionList::tick: return "tick";
    case TickFunctionList::physics_tick: return "physics_tick";
    case TickFunctionList::post_physics: return "post_physics";
    case TickFunctionList::late_tick: return "late_tick";
    default: return "none";
  }
}

struct TickFunctions {
  using Invoker = void (*)(void*);
 
  TickFunctionList list;
 
  Invoker load = nullptr;
  Invoker save = nullptr;
  Invoker editor_tick = nullptr;
  Invoker init = nullptr;
  Invoker destroy = nullptr;
  Invoker begin = nullptr;
  Invoker end = nullptr;
  Invoker on_enable = nullptr;
  Invoker on_disable = nullptr;
  Invoker early_tick = nullptr;
  Invoker tick = nullptr;
  Invoker physics_tick = nullptr;
  Invoker post_physics = nullptr;
  Invoker late_tick = nullptr;
};

struct TOAST_API SubgroupInfo {
  std::string_view name;
  std::span<const FieldInfo* const> fields;

  [[nodiscard]]
  auto getField(std::string_view field_name) const -> const FieldInfo* {
    for (const auto& f : fields) {
      if (field_name == f->name) {
        return f;
      }
    }
    return nullptr;
  }
};

struct TOAST_API GroupInfo {
  std::string_view name;
  std::span<const FieldInfo* const> fields;
  std::span<const SubgroupInfo> subgroups;

  [[nodiscard]]
  auto getSubgroup(std::string_view group_name) const -> const SubgroupInfo* {
    for (const auto& g : subgroups) {
      if (group_name == g.name) {
        return &g;
      }
    }
    return nullptr;
  }

  [[nodiscard]]
  auto getField(std::string_view field_name) const -> const FieldInfo* {
    for (const auto& f : fields) {
      if (field_name == f->name) {
        return f;
      }
    }
    return nullptr;
  }
};

struct TOAST_API NodeInfo {
  using Factory = Node* (*)();
  using Deleter = void (*)(Node*);
 
  std::string_view type;
  const NodeInfo* base_type;
  std::span<const SignalInfo> signals;
  std::span<const FieldInfo> all_fields;
  std::span<const FieldInfo* const> fields;
  std::span<const GroupInfo> groups;
  std::span<const FunctionInfo> methods;
 
  TickFunctions functions;
 
  Factory construct = nullptr;
  Deleter destroy = nullptr;

  [[nodiscard]]
  auto getSignal(std::string_view field_name) const -> const SignalInfo* {
    for (const auto& f : signals) {
      if (field_name == f.name) {
        return &f;
      }
    }
    if (base_type) {
      return base_type->getSignal(field_name);
    }
    return nullptr;
  }
 
  [[nodiscard]]
  auto getSignal(std::string_view declaring_type, std::string_view signal_name) const -> const SignalInfo* {
    for (const auto* info = this; info != nullptr; info = info->base_type) {
      if (info->type != declaring_type) {
        continue;
      }
      for (const auto& signal : info->signals) {
        if (signal.name == signal_name) {
          return &signal;
        }
      }
      return nullptr;
    }
    return nullptr;
  }
 
  template<typename F>
  void forEachSignal(F&& callback) const {
    for (const auto* info = this; info != nullptr; info = info->base_type) {
      for (const auto& signal : info->signals) {
        callback(*info, signal);
      }
    }
  }

  [[nodiscard]]
  auto getField(std::string_view field_name) const -> const FieldInfo* {
    for (const auto& f : all_fields) {
      if (field_name == f.name) {
        return &f;
      }
    }
    if (base_type) {
      return base_type->getField(field_name);
    }
    return nullptr;
  }

  [[nodiscard]]
  auto getMethod(std::string_view method_name) const -> const FunctionInfo* {
    for (const auto& m : methods) {
      if (method_name == m.name) {
        return &m;
      }
    }
    if (base_type) {
      return base_type->getMethod(method_name);
    }
    return nullptr;
  }

  template<typename R = void, typename... Args>
  auto call(void* obj, std::string_view method_name, Args&&... args) const -> R {
    if (!getMethod(method_name)) {
      TOAST_WARN("Reflect", "call(): reflected function '{}' not found on '{}'", method_name, type);
      assert(false && "NodeInfo::call(): reflected function not found");
      if constexpr (std::is_void_v<R>) {
        return;
      } else {
        return R {};
      }
    }
    // Build an any-args array so args are forwarded to Lua scripts as well
    std::array<std::any, sizeof...(Args)> any_args {std::any(std::decay_t<Args>(args))...};
    if constexpr (std::is_void_v<R>) {
      _detail::callMethodChain(this, obj, method_name, std::forward<Args>(args)...);
      _detail::callNodeScripts(static_cast<Node*>(obj), method_name, any_args);
    } else {
      R result = _detail::callMethodChain<R>(this, obj, method_name, std::forward<Args>(args)...);
      _detail::callNodeScripts(static_cast<Node*>(obj), method_name, any_args);
      return result;
    }
  }

  [[nodiscard]]
  auto callAllDynamic(void* obj, std::string_view method_name, std::span<const std::any> args) const -> std::any {
    std::any result;
    if (base_type) {
      result = base_type->callAllDynamic(obj, method_name, args);
    }
    for (const auto& m : methods) {
      if (m.name == method_name) {
        result = m.callDynamic(obj, args);
        break;
      }
    }
    return result;
  }

  [[nodiscard]]
  auto isA(const NodeInfo* other) const -> bool {
    for (const NodeInfo* cur = this; cur; cur = cur->base_type) {
      if (cur == other) {
        return true;
      }
    }
    return false;
  }

  [[nodiscard]]
  auto hasFunction(TickFunctionList mask) const -> bool {
    for (const NodeInfo* cur = this; cur; cur = cur->base_type) {
      if ((cur->functions.list & mask) != TickFunctionList::none) {
        return true;
      }
    }
    return false;
  }

  [[nodiscard]]
  constexpr auto id() const -> uint32_t {
    uint32_t hash = 2166136261u;
    for (char c : type) {
      hash ^= static_cast<uint8_t>(c);
      hash *= 16777619u;
    }
    return hash;
  }

  [[nodiscard]]
  auto getGroup(std::string_view group_name) const -> const GroupInfo* {
    for (const auto& g : groups) {
      if (group_name == g.name) {
        return &g;
      }
    }
    if (base_type) {
      return base_type->getGroup(group_name);
    }
    return nullptr;
  }

  [[nodiscard]]
  auto search(std::string_view field_name) const -> const FieldInfo* {
    for (const auto& f : all_fields) {
      if (field_name == f.name) {
        return &f;
      }
    }
    if (base_type) {
      return base_type->search(field_name);
    }
    return nullptr;
  }

  template<typename F>
  void forEachBaseType(F&& fn) const {
    if (base_type) {
      base_type->forEachBaseType(fn);
    }
    fn(*this);
  }
};
 
template<class T>
struct NodeTypeInfo {
  [[nodiscard]]
  static auto get() noexcept -> const NodeInfo*;
};
 
namespace _detail {
 
// Walks base->derived, calling the method at every level where it is defined
template<typename R, typename... Args>
auto callMethodChain(const NodeInfo* info, void* obj, std::string_view method_name, const Args&... args) -> R {
  if constexpr (std::is_void_v<R>) {
    if (info->base_type) {
      callMethodChain(info->base_type, obj, method_name, args...);
    }
    for (const auto& m : info->methods) {
      if (m.name == method_name) {
        m.call(obj, args...);
        break;
      }
    }
  } else {
    R result {};
    if (info->base_type) {
      result = callMethodChain<R>(info->base_type, obj, method_name, args...);
    }
    for (const auto& m : info->methods) {
      if (m.name == method_name) {
        result = m.call<R>(obj, args...);
        break;
      }
    }
    return result;
  }
}
 
}

class TOAST_API NodeRegistry {
public:
  NodeRegistry();

  static void registerNode(const NodeInfo* info);

  [[nodiscard]]
  static auto reflect(std::string_view name) -> const NodeInfo* {
    // remove empty namespace indicator if in global space
    if (name.starts_with("::")) {
      name.remove_prefix(2);
    }
    auto types = (*instance).types;
    auto it = (*instance).types.find(name);
    return it != (*instance).types.end() ? it->second : nullptr;
  }

  template<typename F>
  static void forEachType(F&& fn) {
    if (instance) {
      for (const auto& [key, info] : instance->types) {
        fn(info);
      }
    }
  }
 
private:
  std::unordered_map<std::string_view, const NodeInfo*> types;
  static NodeRegistry* instance;
};
 
TOAST_API void registerEngineTypes();
 
template<class T>
auto nodeTypeInfo() noexcept -> const NodeInfo*;
 
}