Asset layout

Bigfoot/Sources/Engine/Include/Engine/BigFile/Asset/AssetHeader.fbs

@@ -0,0 +1,18 @@
+include "System/UUID/UUID.fbs";
+include "System/Time/Time.fbs";
+
+namespace Bigfoot.Flat;
+
+table AssetHeader
+{
+	uuid: UUID (native_inline);
+	name: string;
+	type_id: ulong;
+	type_name: string;
+	version: uint;
+
+	create_time: Time (native_inline);
+	modification_time: Time (native_inline);
+}
+
+root_type AssetHeader;

Bigfoot/Sources/Engine/Include/Engine/BigFile/Asset/AssetHeader_generated.hpp

@@ -0,0 +1,289 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_ASSETHEADER_BIGFOOT_FLAT_H_
+#define FLATBUFFERS_GENERATED_ASSETHEADER_BIGFOOT_FLAT_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
+              FLATBUFFERS_VERSION_MINOR == 12 &&
+              FLATBUFFERS_VERSION_REVISION == 19,
+             "Non-compatible flatbuffers version included");
+
+#include "System/UUID/FlatUUID.hpp"
+#include "System/Time/FlatTime.hpp"
+#include "System/Time/Time_generated.hpp"
+#include "System/UUID/UUID_generated.hpp"
+
+#include "EASTL/unique_ptr.h"
+#include "EASTL/string.h"
+
+namespace Bigfoot {
+namespace Flat {
+
+struct AssetHeader;
+struct AssetHeaderBuilder;
+struct AssetHeaderT;
+
+inline const ::flatbuffers::TypeTable *AssetHeaderTypeTable();
+
+struct AssetHeaderT : public ::flatbuffers::NativeTable {
+  typedef AssetHeader TableType;
+  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
+    return "Bigfoot.Flat.AssetHeaderT";
+  }
+  ::Bigfoot::UUID uuid{};
+  eastl::string name{};
+  uint64_t type_id = 0;
+  eastl::string type_name{};
+  uint32_t version = 0;
+  ::Bigfoot::Time create_time{};
+  ::Bigfoot::Time modification_time{};
+};
+
+struct AssetHeader FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef AssetHeaderT NativeTableType;
+  typedef AssetHeaderBuilder Builder;
+  struct Traits;
+  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
+    return AssetHeaderTypeTable();
+  }
+  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
+    return "Bigfoot.Flat.AssetHeader";
+  }
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_UUID = 4,
+    VT_NAME = 6,
+    VT_TYPE_ID = 8,
+    VT_TYPE_NAME = 10,
+    VT_VERSION = 12,
+    VT_CREATE_TIME = 14,
+    VT_MODIFICATION_TIME = 16
+  };
+  const Bigfoot::Flat::UUID *uuid() const {
+    return GetStruct<const Bigfoot::Flat::UUID *>(VT_UUID);
+  }
+  const ::flatbuffers::String *name() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
+  }
+  uint64_t type_id() const {
+    return GetField<uint64_t>(VT_TYPE_ID, 0);
+  }
+  const ::flatbuffers::String *type_name() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_TYPE_NAME);
+  }
+  uint32_t version() const {
+    return GetField<uint32_t>(VT_VERSION, 0);
+  }
+  const Bigfoot::Flat::Time *create_time() const {
+    return GetStruct<const Bigfoot::Flat::Time *>(VT_CREATE_TIME);
+  }
+  const Bigfoot::Flat::Time *modification_time() const {
+    return GetStruct<const Bigfoot::Flat::Time *>(VT_MODIFICATION_TIME);
+  }
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<Bigfoot::Flat::UUID>(verifier, VT_UUID, 1) &&
+           VerifyOffset(verifier, VT_NAME) &&
+           verifier.VerifyString(name()) &&
+           VerifyField<uint64_t>(verifier, VT_TYPE_ID, 8) &&
+           VerifyOffset(verifier, VT_TYPE_NAME) &&
+           verifier.VerifyString(type_name()) &&
+           VerifyField<uint32_t>(verifier, VT_VERSION, 4) &&
+           VerifyField<Bigfoot::Flat::Time>(verifier, VT_CREATE_TIME, 8) &&
+           VerifyField<Bigfoot::Flat::Time>(verifier, VT_MODIFICATION_TIME, 8) &&
+           verifier.EndTable();
+  }
+  AssetHeaderT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(AssetHeaderT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static ::flatbuffers::Offset<AssetHeader> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AssetHeaderT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct AssetHeaderBuilder {
+  typedef AssetHeader Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_uuid(const Bigfoot::Flat::UUID *uuid) {
+    fbb_.AddStruct(AssetHeader::VT_UUID, uuid);
+  }
+  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
+    fbb_.AddOffset(AssetHeader::VT_NAME, name);
+  }
+  void add_type_id(uint64_t type_id) {
+    fbb_.AddElement<uint64_t>(AssetHeader::VT_TYPE_ID, type_id, 0);
+  }
+  void add_type_name(::flatbuffers::Offset<::flatbuffers::String> type_name) {
+    fbb_.AddOffset(AssetHeader::VT_TYPE_NAME, type_name);
+  }
+  void add_version(uint32_t version) {
+    fbb_.AddElement<uint32_t>(AssetHeader::VT_VERSION, version, 0);
+  }
+  void add_create_time(const Bigfoot::Flat::Time *create_time) {
+    fbb_.AddStruct(AssetHeader::VT_CREATE_TIME, create_time);
+  }
+  void add_modification_time(const Bigfoot::Flat::Time *modification_time) {
+    fbb_.AddStruct(AssetHeader::VT_MODIFICATION_TIME, modification_time);
+  }
+  explicit AssetHeaderBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<AssetHeader> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<AssetHeader>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<AssetHeader> CreateAssetHeader(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    const Bigfoot::Flat::UUID *uuid = nullptr,
+    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
+    uint64_t type_id = 0,
+    ::flatbuffers::Offset<::flatbuffers::String> type_name = 0,
+    uint32_t version = 0,
+    const Bigfoot::Flat::Time *create_time = nullptr,
+    const Bigfoot::Flat::Time *modification_time = nullptr) {
+  AssetHeaderBuilder builder_(_fbb);
+  builder_.add_type_id(type_id);
+  builder_.add_modification_time(modification_time);
+  builder_.add_create_time(create_time);
+  builder_.add_version(version);
+  builder_.add_type_name(type_name);
+  builder_.add_name(name);
+  builder_.add_uuid(uuid);
+  return builder_.Finish();
+}
+
+struct AssetHeader::Traits {
+  using type = AssetHeader;
+  static auto constexpr Create = CreateAssetHeader;
+};
+
+::flatbuffers::Offset<AssetHeader> CreateAssetHeader(::flatbuffers::FlatBufferBuilder &_fbb, const AssetHeaderT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+inline AssetHeaderT *AssetHeader::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = std::make_unique<AssetHeaderT>();
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void AssetHeader::UnPackTo(AssetHeaderT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = uuid(); if (_e) _o->uuid = ::flatbuffers::UnPack(*_e); }
+  { auto _e = name(); if (_e) _o->name = eastl::string(_e->c_str(), _e->size()); }
+  { auto _e = type_id(); _o->type_id = _e; }
+  { auto _e = type_name(); if (_e) _o->type_name = eastl::string(_e->c_str(), _e->size()); }
+  { auto _e = version(); _o->version = _e; }
+  { auto _e = create_time(); if (_e) _o->create_time = ::flatbuffers::UnPack(*_e); }
+  { auto _e = modification_time(); if (_e) _o->modification_time = ::flatbuffers::UnPack(*_e); }
+}
+
+inline ::flatbuffers::Offset<AssetHeader> CreateAssetHeader(::flatbuffers::FlatBufferBuilder &_fbb, const AssetHeaderT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  return AssetHeader::Pack(_fbb, _o, _rehasher);
+}
+
+inline ::flatbuffers::Offset<AssetHeader> AssetHeader::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AssetHeaderT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const AssetHeaderT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _uuid = ::flatbuffers::Pack(_o->uuid);
+  auto _name = _o->name.empty() ? _fbb.CreateSharedString("") : _fbb.CreateString(_o->name);
+  auto _type_id = _o->type_id;
+  auto _type_name = _o->type_name.empty() ? _fbb.CreateSharedString("") : _fbb.CreateString(_o->type_name);
+  auto _version = _o->version;
+  auto _create_time = ::flatbuffers::Pack(_o->create_time);
+  auto _modification_time = ::flatbuffers::Pack(_o->modification_time);
+  return Bigfoot::Flat::CreateAssetHeader(
+      _fbb,
+      &_uuid,
+      _name,
+      _type_id,
+      _type_name,
+      _version,
+      &_create_time,
+      &_modification_time);
+}
+
+inline const ::flatbuffers::TypeTable *AssetHeaderTypeTable() {
+  static const ::flatbuffers::TypeCode type_codes[] = {
+    { ::flatbuffers::ET_SEQUENCE, 0, 0 },
+    { ::flatbuffers::ET_STRING, 0, -1 },
+    { ::flatbuffers::ET_ULONG, 0, -1 },
+    { ::flatbuffers::ET_STRING, 0, -1 },
+    { ::flatbuffers::ET_UINT, 0, -1 },
+    { ::flatbuffers::ET_SEQUENCE, 0, 1 },
+    { ::flatbuffers::ET_SEQUENCE, 0, 1 }
+  };
+  static const ::flatbuffers::TypeFunction type_refs[] = {
+    Bigfoot::Flat::UUIDTypeTable,
+    Bigfoot::Flat::TimeTypeTable
+  };
+  static const char * const names[] = {
+    "uuid",
+    "name",
+    "type_id",
+    "type_name",
+    "version",
+    "create_time",
+    "modification_time"
+  };
+  static const ::flatbuffers::TypeTable tt = {
+    ::flatbuffers::ST_TABLE, 7, type_codes, type_refs, nullptr, nullptr, names
+  };
+  return &tt;
+}
+
+inline const Bigfoot::Flat::AssetHeader *GetAssetHeader(const void *buf) {
+  return ::flatbuffers::GetRoot<Bigfoot::Flat::AssetHeader>(buf);
+}
+
+inline const Bigfoot::Flat::AssetHeader *GetSizePrefixedAssetHeader(const void *buf) {
+  return ::flatbuffers::GetSizePrefixedRoot<Bigfoot::Flat::AssetHeader>(buf);
+}
+
+template <bool B = false>
+inline bool VerifyAssetHeaderBuffer(
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
+  return verifier.template VerifyBuffer<Bigfoot::Flat::AssetHeader>(nullptr);
+}
+
+template <bool B = false>
+inline bool VerifySizePrefixedAssetHeaderBuffer(
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
+  return verifier.template VerifySizePrefixedBuffer<Bigfoot::Flat::AssetHeader>(nullptr);
+}
+
+inline void FinishAssetHeaderBuffer(
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<Bigfoot::Flat::AssetHeader> root) {
+  fbb.Finish(root);
+}
+
+inline void FinishSizePrefixedAssetHeaderBuffer(
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<Bigfoot::Flat::AssetHeader> root) {
+  fbb.FinishSizePrefixed(root);
+}
+
+inline eastl::unique_ptr<Bigfoot::Flat::AssetHeaderT> UnPackAssetHeader(
+    const void *buf,
+    const ::flatbuffers::resolver_function_t *res = nullptr) {
+  return eastl::unique_ptr<Bigfoot::Flat::AssetHeaderT>(GetAssetHeader(buf)->UnPack(res));
+}
+
+inline eastl::unique_ptr<Bigfoot::Flat::AssetHeaderT> UnPackSizePrefixedAssetHeader(
+    const void *buf,
+    const ::flatbuffers::resolver_function_t *res = nullptr) {
+  return eastl::unique_ptr<Bigfoot::Flat::AssetHeaderT>(GetSizePrefixedAssetHeader(buf)->UnPack(res));
+}
+
+}  // namespace Flat
+}  // namespace Bigfoot
+
+#endif  // FLATBUFFERS_GENERATED_ASSETHEADER_BIGFOOT_FLAT_H_

Bigfoot/Tests/Engine/Include/EngineTests/BigFile/Asset/AssetA.fbs

@@ -0,0 +1,13 @@
+include "Engine/BigFile/Asset/AssetHeader.fbs";
+
+namespace Bigfoot.Flat;
+
+table AssetA
+{
+    asset_header: AssetHeader;
+
+    health: uint;
+    hp: uint;
+}
+
+root_type AssetA;

Bigfoot/Tests/Engine/Include/EngineTests/BigFile/Asset/AssetA_generated.hpp

@@ -0,0 +1,239 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_ASSETA_BIGFOOT_FLAT_H_
+#define FLATBUFFERS_GENERATED_ASSETA_BIGFOOT_FLAT_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
+              FLATBUFFERS_VERSION_MINOR == 12 &&
+              FLATBUFFERS_VERSION_REVISION == 19,
+             "Non-compatible flatbuffers version included");
+
+#include "System/UUID/FlatUUID.hpp"
+#include "System/Time/FlatTime.hpp"
+#include "Engine/BigFile/Asset/AssetHeader_generated.hpp"
+
+#include "EASTL/unique_ptr.h"
+#include "EASTL/string.h"
+
+namespace Bigfoot {
+namespace Flat {
+
+struct AssetA;
+struct AssetABuilder;
+struct AssetAT;
+
+inline const ::flatbuffers::TypeTable *AssetATypeTable();
+
+struct AssetAT : public ::flatbuffers::NativeTable {
+  typedef AssetA TableType;
+  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
+    return "Bigfoot.Flat.AssetAT";
+  }
+  eastl::unique_ptr<Bigfoot::Flat::AssetHeaderT> asset_header{};
+  uint32_t health = 0;
+  uint32_t hp = 0;
+  AssetAT() = default;
+  AssetAT(const AssetAT &o);
+  AssetAT(AssetAT&&) FLATBUFFERS_NOEXCEPT = default;
+  AssetAT &operator=(AssetAT o) FLATBUFFERS_NOEXCEPT;
+};
+
+struct AssetA FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef AssetAT NativeTableType;
+  typedef AssetABuilder Builder;
+  struct Traits;
+  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
+    return AssetATypeTable();
+  }
+  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
+    return "Bigfoot.Flat.AssetA";
+  }
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_ASSET_HEADER = 4,
+    VT_HEALTH = 6,
+    VT_HP = 8
+  };
+  const Bigfoot::Flat::AssetHeader *asset_header() const {
+    return GetPointer<const Bigfoot::Flat::AssetHeader *>(VT_ASSET_HEADER);
+  }
+  uint32_t health() const {
+    return GetField<uint32_t>(VT_HEALTH, 0);
+  }
+  uint32_t hp() const {
+    return GetField<uint32_t>(VT_HP, 0);
+  }
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_ASSET_HEADER) &&
+           verifier.VerifyTable(asset_header()) &&
+           VerifyField<uint32_t>(verifier, VT_HEALTH, 4) &&
+           VerifyField<uint32_t>(verifier, VT_HP, 4) &&
+           verifier.EndTable();
+  }
+  AssetAT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(AssetAT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static ::flatbuffers::Offset<AssetA> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AssetAT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct AssetABuilder {
+  typedef AssetA Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_asset_header(::flatbuffers::Offset<Bigfoot::Flat::AssetHeader> asset_header) {
+    fbb_.AddOffset(AssetA::VT_ASSET_HEADER, asset_header);
+  }
+  void add_health(uint32_t health) {
+    fbb_.AddElement<uint32_t>(AssetA::VT_HEALTH, health, 0);
+  }
+  void add_hp(uint32_t hp) {
+    fbb_.AddElement<uint32_t>(AssetA::VT_HP, hp, 0);
+  }
+  explicit AssetABuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<AssetA> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<AssetA>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<AssetA> CreateAssetA(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<Bigfoot::Flat::AssetHeader> asset_header = 0,
+    uint32_t health = 0,
+    uint32_t hp = 0) {
+  AssetABuilder builder_(_fbb);
+  builder_.add_hp(hp);
+  builder_.add_health(health);
+  builder_.add_asset_header(asset_header);
+  return builder_.Finish();
+}
+
+struct AssetA::Traits {
+  using type = AssetA;
+  static auto constexpr Create = CreateAssetA;
+};
+
+::flatbuffers::Offset<AssetA> CreateAssetA(::flatbuffers::FlatBufferBuilder &_fbb, const AssetAT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+inline AssetAT::AssetAT(const AssetAT &o)
+      : asset_header((o.asset_header) ? new Bigfoot::Flat::AssetHeaderT(*o.asset_header) : nullptr),
+        health(o.health),
+        hp(o.hp) {
+}
+
+inline AssetAT &AssetAT::operator=(AssetAT o) FLATBUFFERS_NOEXCEPT {
+  std::swap(asset_header, o.asset_header);
+  std::swap(health, o.health);
+  std::swap(hp, o.hp);
+  return *this;
+}
+
+inline AssetAT *AssetA::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = std::make_unique<AssetAT>();
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void AssetA::UnPackTo(AssetAT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = asset_header(); if (_e) { if(_o->asset_header) { _e->UnPackTo(_o->asset_header.get(), _resolver); } else { _o->asset_header = eastl::unique_ptr<Bigfoot::Flat::AssetHeaderT>(_e->UnPack(_resolver)); } } else if (_o->asset_header) { _o->asset_header.reset(); } }
+  { auto _e = health(); _o->health = _e; }
+  { auto _e = hp(); _o->hp = _e; }
+}
+
+inline ::flatbuffers::Offset<AssetA> CreateAssetA(::flatbuffers::FlatBufferBuilder &_fbb, const AssetAT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  return AssetA::Pack(_fbb, _o, _rehasher);
+}
+
+inline ::flatbuffers::Offset<AssetA> AssetA::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AssetAT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const AssetAT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _asset_header = _o->asset_header ? CreateAssetHeader(_fbb, _o->asset_header.get(), _rehasher) : 0;
+  auto _health = _o->health;
+  auto _hp = _o->hp;
+  return Bigfoot::Flat::CreateAssetA(
+      _fbb,
+      _asset_header,
+      _health,
+      _hp);
+}
+
+inline const ::flatbuffers::TypeTable *AssetATypeTable() {
+  static const ::flatbuffers::TypeCode type_codes[] = {
+    { ::flatbuffers::ET_SEQUENCE, 0, 0 },
+    { ::flatbuffers::ET_UINT, 0, -1 },
+    { ::flatbuffers::ET_UINT, 0, -1 }
+  };
+  static const ::flatbuffers::TypeFunction type_refs[] = {
+    Bigfoot::Flat::AssetHeaderTypeTable
+  };
+  static const char * const names[] = {
+    "asset_header",
+    "health",
+    "hp"
+  };
+  static const ::flatbuffers::TypeTable tt = {
+    ::flatbuffers::ST_TABLE, 3, type_codes, type_refs, nullptr, nullptr, names
+  };
+  return &tt;
+}
+
+inline const Bigfoot::Flat::AssetA *GetAssetA(const void *buf) {
+  return ::flatbuffers::GetRoot<Bigfoot::Flat::AssetA>(buf);
+}
+
+inline const Bigfoot::Flat::AssetA *GetSizePrefixedAssetA(const void *buf) {
+  return ::flatbuffers::GetSizePrefixedRoot<Bigfoot::Flat::AssetA>(buf);
+}
+
+template <bool B = false>
+inline bool VerifyAssetABuffer(
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
+  return verifier.template VerifyBuffer<Bigfoot::Flat::AssetA>(nullptr);
+}
+
+template <bool B = false>
+inline bool VerifySizePrefixedAssetABuffer(
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
+  return verifier.template VerifySizePrefixedBuffer<Bigfoot::Flat::AssetA>(nullptr);
+}
+
+inline void FinishAssetABuffer(
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<Bigfoot::Flat::AssetA> root) {
+  fbb.Finish(root);
+}
+
+inline void FinishSizePrefixedAssetABuffer(
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<Bigfoot::Flat::AssetA> root) {
+  fbb.FinishSizePrefixed(root);
+}
+
+inline eastl::unique_ptr<Bigfoot::Flat::AssetAT> UnPackAssetA(
+    const void *buf,
+    const ::flatbuffers::resolver_function_t *res = nullptr) {
+  return eastl::unique_ptr<Bigfoot::Flat::AssetAT>(GetAssetA(buf)->UnPack(res));
+}
+
+inline eastl::unique_ptr<Bigfoot::Flat::AssetAT> UnPackSizePrefixedAssetA(
+    const void *buf,
+    const ::flatbuffers::resolver_function_t *res = nullptr) {
+  return eastl::unique_ptr<Bigfoot::Flat::AssetAT>(GetSizePrefixedAssetA(buf)->UnPack(res));
+}
+
+}  // namespace Flat
+}  // namespace Bigfoot
+
+#endif  // FLATBUFFERS_GENERATED_ASSETA_BIGFOOT_FLAT_H_