world_test_access.hpp

#pragma once
 
#include "world.hpp"
 
#include <any>
#include <memory>
#include <string_view>
#include <toast/assets/script.hpp>
#include <toast/export.hpp>
#include <toast/scripting/lua_value_codec.hpp>
 
namespace toast::_detail {
 
struct TOAST_API WorldTestAccess {
  struct TOAST_API WorldDeleter {
    void operator()(World* world) const noexcept;
  };
 
  using WorldPtr = std::unique_ptr<World, WorldDeleter>;
 
  static auto createWorld() -> WorldPtr;
 
  static auto createNode(World& world, std::string_view name, NodeState state = NodeState::root) -> Box<Node>;
 
  static auto createTypedNode(World& world, std::string_view type, std::string_view name) -> Box<Node>;
  static void callTick(Node& node, TickFunctionList stage);
 
  // activeRenderCamera() is protected on INodeOwner
  static auto activeRenderCamera(World& world) -> Camera*;
  static auto hasActiveCamera(World& world) -> bool;
 
  static void registerDependency(Node& from, Node& to);
 
  // Test-only: make `node` participate in the given tick stage by attaching a fabricated
  // NodeInfo (the per-instance NodeFunctionTable no longer exists).
  static void addTickStage(Node& node, TickFunctionList stage);
 
  // Test-only: like addTickStage(), but the fabricated NodeInfo also calls `callback` for onEnable
  static void setEnableCallback(Node& node, void (*callback)(void*));
 
  // Test-only: like addTickStage(tick), but the fabricated NodeInfo also calls `callback` as the C++ tick of the node
  static void setTickCallback(Node& node, void (*callback)(void*));
 
  // Test-only: the fabricated NodeInfo of the node calls `callback` as its C++ function for `stage` (init, begin or onEnable)
  static void setStageCallback(Node& node, TickFunctionList stage, void (*callback)(void*));
 
  // Test-only: TickScheduler::runLifecycle() of the world's scheduler
  static void runLifecycle(World& world, Node& root, TickFunctionList stage);
 
  // Test-only: the node counts as enabled, without the callbacks that enabling it would run
  static void markEnabled(Node& node);
 
  // Test-only: Node::propagateCallTick(), one node after the other on the calling thread
  static void propagateCallTick(Node& node, TickFunctionList stage);
 
  // Test-only: appends a script asset to the node and (re)builds its ScriptRuntime;
  // requires a LuaState to exist
  static void attachScript(Node& node, const assets::Handle<assets::Script>& script);

  static void attachScriptInGroup(Node& node, const assets::Handle<assets::Script>& script, uint64_t group);
 
  static void applyLuaOverrides(
      World& world, Node& node, const assets::Prefab::BasicNode& data, const scripting::NodeResolver& find_node
  );
 
  static auto tickSchedule(World& world) noexcept -> _detail::TickSchedule&;

  static auto scheduler(World& world) noexcept -> TickScheduler&;

  static void runTickFrame(World& world);
 
  static auto dependencyGraph(World& world) noexcept -> World::DependencyGraph&;
 
  static void computeDependencyGraph(World& world);
 
  static auto instantiate(World& world, const assets::Handle<assets::Prefab>& file, INodeOwner::InstantiateContext& ctx)
      -> Box<Node>;
 
  static auto childrenOf(const Node& node) -> const std::vector<Box<Node>>&;
  static auto changeField(Node& node, std::string_view name, const std::any& value) -> bool;
  static auto setScriptVar(Node& node, std::string_view path, const std::any& value) -> bool;
  static void attachChild(Node& parent, Node& child);
  static auto isPrefabInterior(const Node& node) -> bool;
 
  static void initThreadPool();
 
  static void setWorldRoot(World& world, Node& node);

  static auto moveToChild(World& world, Node& node, Node& parent) -> Box<Node>;
 
  // Moves a freshly instantiated tree to the cache, then World::swapRoot() it so begin/onEnable run
  static auto activateLoadedRoot(World& world, Node& node) -> Box<Node>;
 
  static auto
      spawnSync(World& world, const assets::Handle<assets::Prefab>& file, Node& parent, INodeOwner::InstantiateContext& ctx)
          -> Box<Node>;
 
  static void initAssetManager(std::string_view assets_dir, std::string_view cache_dir);
 
  static void waitForLoads(World& world);
 
  static void drainLoadQueue(World& world);
 
  static auto dependencyGraphGraphviz(const World& world) -> std::string;
 
  static void loadNode(toast::UID uid);
  static auto findCached(std::string_view name) -> Box<Node>;
  static auto findNode(const UID& uid, Node* scope = nullptr) -> Box<Node>;
  static auto findNode(std::string_view path) -> Box<Node>;
  static auto uidPath(const Node& node) -> std::string;
};
 
}