script_runtime.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <any>
#include <atomic>
#include <cstdint>
#include <lua.hpp>
#include <luabridge3/LuaBridge/LuaBridge.h>
#include <memory>
#include <optional>
#include <set>
#include <span>
#include <string>
#include <string_view>
#include <toast/assets/script.hpp>
#include <toast/export.hpp>
#include <toast/reflect/reflect_node.hpp>
#include <toast/scripting/lua_signal.hpp>
#include <toast/scripting/node_proxy.hpp>
#include <toast/scripting/script_context.hpp>
#include <toast/scripting/script_schema.hpp>
#include <toast/world/box.hpp>
#include <unordered_map>
#include <vector>
 
namespace toast {
class Node;
}
 
namespace scripting {

struct ScriptBinding {
  explicit ScriptBinding(NodeProxy node_proxy) : proxy(std::move(node_proxy)) { }
 
  NodeProxy proxy;
  std::atomic<bool> alive {true};    
};
 
// One per script
class ScriptInstance {
public:
  ScriptInstance(
      size_t vm_index, lua_State* l, const assets::Handle<assets::Script>& script, NodeProxy proxy,
      std::shared_ptr<RuntimeToken> token
  );

  ~ScriptInstance();
 
  ScriptInstance(ScriptInstance&&) = delete;
  auto operator=(ScriptInstance&&) -> ScriptInstance& = delete;
  ScriptInstance(const ScriptInstance&) = delete;
  auto operator=(const ScriptInstance&) -> ScriptInstance& = delete;

  void call(std::string_view fn_name) noexcept;

  void callWithLuaStack(std::string_view name, lua_State* l, int args_base, int n_args) noexcept;

  auto callEventMethod(std::string_view name, lua_State* l, int event_index) noexcept -> bool;

  void callWithAnyArgs(std::string_view name, std::span<const std::any> args) noexcept;

  auto setVar(std::string_view name, const std::any& value) noexcept -> bool;

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

  [[nodiscard]]
  auto getVarByPath(std::string_view path) const noexcept -> std::any;

  auto setVarByPath(std::string_view path, const std::any& value) noexcept -> bool;

  [[nodiscard]]
  auto hasFunction(std::string_view fn_name) const noexcept -> bool;

  [[nodiscard]]
  auto knowsFunction(std::string_view fn_name) const noexcept -> bool {
    return m_function_names.contains(fn_name);
  }
 
  [[nodiscard]]
  auto luaSignals() const noexcept -> const std::unordered_map<std::string, LuaSignal>& {
    return m_lua_signals;
  }
 
  [[nodiscard]]
  auto luaSignals() noexcept -> std::unordered_map<std::string, LuaSignal>& {
    return m_lua_signals;
  }
 
  [[nodiscard]]
  auto schema() const noexcept -> const ScriptSchema& {
    return m_schema;
  }

  [[nodiscard]]
  auto isValid() const noexcept -> bool {
    return m_valid;
  }

  [[nodiscard]]
  auto tickMask() const noexcept -> toast::TickFunctionList {
    return m_tick_mask;
  }

  [[nodiscard]]
  auto name() const noexcept -> const std::string& {
    return m_name;
  }
 
private:
  lua_State* m_state = nullptr;
  size_t m_vm_index = 0;
  std::shared_ptr<ScriptBinding> m_binding;
  std::shared_ptr<RuntimeToken> m_token;
  std::unique_ptr<luabridge::LuaRef> m_self;
  bool m_valid = false;
  std::string m_name;
  ScriptSchema m_schema;
  std::unordered_map<std::string, LuaSignal> m_lua_signals;
  std::set<std::string, std::less<>>
      m_function_names;    
  toast::TickFunctionList m_tick_mask = toast::TickFunctionList::none;
 
  void installMetatable() noexcept;
  void extractSchema(std::string_view src) noexcept;
  void snapshotTickMask() noexcept;

  [[nodiscard]]
  auto pushByPath(std::string_view path) const noexcept -> bool;
};

[[nodiscard]]
auto nodeOfSelfTable(const luabridge::LuaRef& table) -> NodeProxy;
 
// One per node
class TOAST_API ScriptRuntime {
public:
  ScriptRuntime(
      toast::Box<toast::Node> node, const std::vector<assets::Handle<assets::Script>>& scripts, uint64_t group = 0,
      std::optional<size_t> placed = std::nullopt
  );
  ~ScriptRuntime();
 
  ScriptRuntime(const ScriptRuntime&) = delete;
  auto operator=(const ScriptRuntime&) -> ScriptRuntime& = delete;

  void call(toast::TickFunctionList phase) noexcept;

  void call(std::string_view fn_name) noexcept;

  [[nodiscard]]
  auto hasFunction(std::string_view fn_name) const noexcept -> bool;
 
  [[nodiscard]]
  auto functions() const noexcept -> std::vector<LuaFunctionDesc>;
 
  void callWithLuaStack(std::string_view name, lua_State* l, int args_base, int n_args) noexcept;
  auto callEventMethod(std::string_view name, lua_State* l, int event_index) noexcept -> bool;

  void callWithAnyArgs(std::string_view name, std::span<const std::any> args) noexcept;

  void setVar(std::string_view name, const std::any& value) noexcept;

  [[nodiscard]]
  auto getVar(std::string_view name) const noexcept -> std::any;
 
  [[nodiscard]]
  auto luaSignals() const -> std::vector<std::string>;
  [[nodiscard]]
  auto luaSignalConnections(std::string_view name) const -> std::vector<signals::ConnectionInfo>;
  [[nodiscard]]
  auto luaSignalArgTypes(std::string_view name) const -> std::vector<std::string>;
  auto connectLuaSignal(std::string_view name, toast::Node& target, std::string_view function, bool forwards_args) -> bool;
  auto disconnectLuaSignal(std::string_view name, toast::Node& target, std::string_view function) -> bool;
  void clearLuaSignal(std::string_view name);

  [[nodiscard]]
  auto instanceCount() const noexcept -> size_t {
    return m_instances.size();
  }

  [[nodiscard]]
  auto instanceSchema(size_t index) const noexcept -> const ScriptSchema*;

  [[nodiscard]]
  auto instanceScript(size_t index) const noexcept -> std::string_view;

  [[nodiscard]]
  auto getVarByPath(size_t index, std::string_view path) const noexcept -> std::any;

  auto setVarByPath(size_t index, std::string_view path, const std::any& value) noexcept -> bool;

  [[nodiscard]]
  auto schemaVersion() const noexcept -> uint32_t {
    return m_schema_version;
  }

  [[nodiscard]]
  auto hasTick(toast::TickFunctionList mask = toast::TickFunctionList::tick_mask) const noexcept -> bool {
    return (m_tick_mask & mask) != toast::TickFunctionList::none;
  }

  [[nodiscard]]
  auto stateIndex() const noexcept -> size_t {
    return m_state_index;
  }

  [[nodiscard]]
  auto token() const noexcept -> const std::shared_ptr<RuntimeToken>& {
    return m_token;
  }

  [[nodiscard]]
  auto executing() const noexcept -> bool {
    return m_active_calls.load(std::memory_order_acquire) != 0;
  }

  static void retire(std::unique_ptr<ScriptRuntime> runtime) noexcept;

  static void drainRetired() noexcept;
 
private:
  std::vector<std::unique_ptr<ScriptInstance>> m_instances;
  size_t m_state_index = 0;
  uint64_t m_group = 0;
  bool m_placed = false;    
  lua_State* m_lua = nullptr;
  toast::Box<toast::Node> m_node;
  std::shared_ptr<RuntimeToken> m_token;
  toast::TickFunctionList m_tick_mask = toast::TickFunctionList::none;
  uint32_t m_schema_version = 0;
  mutable std::atomic<int> m_active_calls {0};

  template<typename F>
  void deferToDispatch(F&& work) const;
};
 
}