prefab.hpp

 
#pragma once
#include "core_types.hpp"
 
#include <any>
#include <array>
#include <cstdint>
#include <iosfwd>
#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <toast/reflect/reflect.hpp>
#include <unordered_set>
#include <vector>
 
namespace toast {
class Node;
}
 
namespace assets {
 
namespace _detail {
constexpr std::string_view array_str = "array_";
constexpr std::string_view bool_str = "bool";
constexpr std::string_view int_str = "int";
constexpr std::string_view float_str = "float";
constexpr std::string_view string_str = "string";
constexpr std::string_view double_str = "double";
constexpr std::string_view uid_str = "uid";
constexpr std::string_view vec2_str = "vec2";
constexpr std::string_view vec3_str = "vec3";
constexpr std::string_view vec4_str = "vec4";
constexpr std::string_view quaternion_str = "quat";
 
constexpr uint16_t format_version = 4;    
 
struct TOAST_API NodeFileBinaryHeader {
  const std::array<uint8_t, 6> magic = {'T', 'N', 'O', 'D', 'E', '\0'};
  uint16_t version = format_version;
  uint32_t node_count;
};
}
 
class TOAST_API Prefab final : public Asset, public ISaveable {
public:
  enum class Purpose : uint8_t {
    asset_definition,
    instance_copy,
    editor_snapshot
  };
  Prefab(std::istream& file);

  Prefab(std::span<const uint8_t> bytes);

  explicit Prefab(const toast::Node& node, toast::UID self_uid = toast::UID(0), Purpose purpose = Purpose::asset_definition);
 
  Prefab() = default;
  Prefab(const Prefab& other);
  Prefab(Prefab&& other) noexcept;
  auto operator=(const Prefab& other) -> Prefab&;
  auto operator=(Prefab&& other) noexcept -> Prefab&;
 
  [[nodiscard]]
  auto type() const -> std::string_view override {
    return "node";
  }

  auto serialize(SaveMode mode) const -> std::vector<uint8_t> override;

  auto toFile() const -> std::string;

  auto toBinary() const -> std::vector<uint8_t>;

  auto validate() const -> bool;

  static auto stringifyValue(toast::FieldType type, bool is_array, const std::any& value) -> std::string;

  static auto valueFromString(toast::FieldType type, bool is_array, std::string_view value) -> std::optional<std::any>;

  struct Field {
    std::string name;
    toast::FieldType type;
    bool is_array;
    std::any value;
 
    template<typename T>
    [[nodiscard]]
    auto as() const -> T {
      return std::any_cast<T>(value);
    }
  };

  struct Subgroup {
    std::string name;
    std::vector<Field> fields;
 
    [[nodiscard]]
    auto find(std::string_view name) const -> std::optional<Field> {
      auto it = std::ranges::find_if(fields, [name](const auto& field) { return field.name == name; });
      if (it != fields.end()) {
        return *it;
      }
      return {};
    }
  };

  struct Group {
    std::string name;
    std::vector<Field> fields;
    std::vector<Subgroup> subgroups;
 
    [[nodiscard]]
    auto find(std::string_view name) const -> std::optional<Field> {
      auto it = std::ranges::find_if(fields, [&name](const auto& field) { return field.name == name; });
      if (it != fields.end()) {
        return *it;
      }
      for (const auto& g : subgroups) {
        auto g_it = g.find(name);
        if (g_it.has_value()) {
          return g_it;
        }
      }
 
      return {};
    }
  };

  struct LuaVarOverride {
    std::string path;
    std::string value;
  };

  struct SignalConnection {
    toast::UID target;
    std::string function;
  };

  struct Signal {
    std::string name;
    std::vector<SignalConnection> connections;
  };

  struct BasicNode {
    std::string name;
    std::string type;
 
    std::vector<Field> fields;
    std::vector<Group> groups;
    std::vector<LuaVarOverride> lua_vars;    
    std::vector<Signal> signals;             
 
    [[nodiscard]]
    auto find(std::string_view name) const -> std::optional<Field> {
      auto it = std::ranges::find_if(fields, [&name](const auto& field) { return field.name == name; });
      if (it != fields.end()) {
        return *it;
      }
      for (const auto& g : groups) {
        auto g_it = g.find(name);
        if (g_it.has_value()) {
          return g_it;
        }
      }
 
      return {};
    }
 
    [[nodiscard]]
    auto findLuaVar(std::string_view path) const -> const LuaVarOverride* {
      auto it = std::ranges::find_if(lua_vars, [&](const auto& v) { return v.path == path; });
      return it != lua_vars.end() ? &*it : nullptr;
    }
  };
 
  std::vector<Field> global_fields;
  std::vector<BasicNode> nodes;
 
private:
  auto parseField(std::string_view line) -> std::optional<Field>;
  auto parseLuaVarOverride(std::string_view line) -> std::optional<LuaVarOverride>;
  auto parseSignal(std::string_view line) -> std::optional<Signal>;
  auto parseType(std::string_view type, bool& is_array) -> std::optional<toast::FieldType>;
  auto parseValue(toast::FieldType type, std::string_view value, bool& is_array) -> std::optional<std::any>;
 
  auto parseNodeChunk(std::span<const std::string> lines) -> std::optional<BasicNode>;
  auto parseGroupChunk(std::span<const std::string> lines) -> std::optional<Group>;
  auto parseSubgroupChunk(std::span<const std::string> lines) -> std::optional<Subgroup>;
 
  void serializeNode(const toast::Node& node, bool is_root);
 
  void writeNode(const BasicNode& node, std::stringstream& ss) const;
  void writeGroup(const Group& group, std::stringstream& ss) const;
  void writeSubgroup(const Subgroup& subgroup, std::stringstream& ss) const;
  void writeField(const Field& field, std::stringstream& ss, std::string offset = "") const;
  void writeSignal(const Signal& signal, std::stringstream& ss) const;
  auto writeType(toast::FieldType type, bool is_array = false) const -> std::string;
 
  auto fieldEquals(toast::FieldType type, bool is_array, const std::any& a, const std::any& b) const -> bool;
  auto flattenedRootFields(const Handle<Prefab>& source) const -> std::optional<BasicNode>;
 
  toast::UID m_self_uid;    
  Purpose m_purpose = Purpose::asset_definition;
  std::unordered_set<uint64_t>
      m_allowed_uids;    
};
 
}