Toying with Reference (not compiling)

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

@@ -58,7 +58,7 @@ class Asset
     Asset(const Asset& p_asset) = delete;
     Asset(Asset&& p_asset) = default;
 
-    ~Asset() = default;
+    virtual ~Asset() = default;
 
     void IncrementHardRefCount()
     {

Bigfoot/Sources/Engine/Include/Engine/Asset/AssetHelper.hpp

@@ -9,7 +9,7 @@
 #include <Engine/Asset/AssetContainer.hpp>
 #include <Engine/Asset/AssetLibrary.hpp>
 
-#define ASSET_CONTAINER(AssetName, AssetType)                                                                                     \
+#define ASSET_CONTAINER(AssetName, AssetType)                                                                          \
     namespace Bigfoot                                                                                                  \
     {                                                                                                                  \
     AssetContainer<AssetType> g_containerFor##AssetName;                                                               \

Bigfoot/Sources/Engine/Include/Engine/Asset/Reference.fbs

@@ -0,0 +1,15 @@
+include "System/UUID/UUID.fbs";
+
+native_include "Engine/Asset/Reference.hpp";
+
+namespace Flat.Bigfoot;
+
+struct HardReference (native_type_template: "::Bigfoot::HardReference")
+{
+    uuid: UUID;
+}
+
+struct SoftReference (native_type_template: "::Bigfoot::SoftReference")
+{
+    uuid: UUID;
+}

Bigfoot/Sources/Engine/Include/Engine/Asset/Reference.hpp

@@ -82,7 +82,7 @@ class HardReference
   private:
     void Acquire()
     {
-        if (AssetContainer<ASSET>* assetContainer = g_assetLibrary.Get<ASSET>() ; assetContainer && m_uuid)
+        if (AssetContainer<ASSET>* assetContainer = g_assetLibrary.Get<ASSET>(); assetContainer && m_uuid)
         {
             if (!m_slotKey.Valid())
             {

Bigfoot/Sources/Engine/Include/Engine/Asset/Reference_generated.hpp

@@ -0,0 +1,122 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_REFERENCE_FLAT_BIGFOOT_H_
+#define FLATBUFFERS_GENERATED_REFERENCE_FLAT_BIGFOOT_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/UUID.hpp"
+#include "Engine/Asset/Reference.hpp"
+#include "System/UUID/UUID_generated.hpp"
+
+#include "EASTL/unique_ptr.h"
+#include "EASTL/string.h"
+#include "EASTL/vector.h"
+
+namespace Flat {
+namespace Bigfoot {
+
+struct HardReference;
+
+struct SoftReference;
+
+inline const ::flatbuffers::TypeTable *HardReferenceTypeTable();
+
+inline const ::flatbuffers::TypeTable *SoftReferenceTypeTable();
+
+FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) HardReference FLATBUFFERS_FINAL_CLASS {
+ private:
+  Flat::Bigfoot::UUID uuid_;
+
+ public:
+  struct Traits;
+  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
+    return HardReferenceTypeTable();
+  }
+  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
+    return "Flat.Bigfoot.HardReference";
+  }
+  HardReference()
+      : uuid_() {
+  }
+  HardReference(const Flat::Bigfoot::UUID &_uuid)
+      : uuid_(_uuid) {
+  }
+  const Flat::Bigfoot::UUID &uuid() const {
+    return uuid_;
+  }
+};
+FLATBUFFERS_STRUCT_END(HardReference, 16);
+
+struct HardReference::Traits {
+  using type = HardReference;
+};
+
+FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) SoftReference FLATBUFFERS_FINAL_CLASS {
+ private:
+  Flat::Bigfoot::UUID uuid_;
+
+ public:
+  struct Traits;
+  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
+    return SoftReferenceTypeTable();
+  }
+  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
+    return "Flat.Bigfoot.SoftReference";
+  }
+  SoftReference()
+      : uuid_() {
+  }
+  SoftReference(const Flat::Bigfoot::UUID &_uuid)
+      : uuid_(_uuid) {
+  }
+  const Flat::Bigfoot::UUID &uuid() const {
+    return uuid_;
+  }
+};
+FLATBUFFERS_STRUCT_END(SoftReference, 16);
+
+struct SoftReference::Traits {
+  using type = SoftReference;
+};
+
+inline const ::flatbuffers::TypeTable *HardReferenceTypeTable() {
+  static const ::flatbuffers::TypeCode type_codes[] = {
+    { ::flatbuffers::ET_SEQUENCE, 0, 0 }
+  };
+  static const ::flatbuffers::TypeFunction type_refs[] = {
+    Flat::Bigfoot::UUIDTypeTable
+  };
+  static const int64_t values[] = { 0, 16 };
+  static const ::flatbuffers::TypeTable tt = {
+    ::flatbuffers::ST_STRUCT, 1, type_codes, type_refs, nullptr, values, nullptr
+  };
+  return &tt;
+}
+
+inline const ::flatbuffers::TypeTable *SoftReferenceTypeTable() {
+  static const ::flatbuffers::TypeCode type_codes[] = {
+    { ::flatbuffers::ET_SEQUENCE, 0, 0 }
+  };
+  static const ::flatbuffers::TypeFunction type_refs[] = {
+    Flat::Bigfoot::UUIDTypeTable
+  };
+  static const int64_t values[] = { 0, 16 };
+  static const ::flatbuffers::TypeTable tt = {
+    ::flatbuffers::ST_STRUCT, 1, type_codes, type_refs, nullptr, values, nullptr
+  };
+  return &tt;
+}
+
+}  // namespace Bigfoot
+}  // namespace Flat
+
+#endif  // FLATBUFFERS_GENERATED_REFERENCE_FLAT_BIGFOOT_H_

Bigfoot/Tests/Engine/Asset/Asset.cpp

@@ -90,9 +90,9 @@ TEST_F(AssetFixture, AssetBTests)
     AssetB assetB;
     assetB.SetName(nameB);
     assetB.SetVersion(versionB);
-    //assetB.GetAsset().asset_a_ref = HardReference<AssetA> {assetA.GetHeader().uuid};
+    // assetB.GetAsset().asset_a_ref = HardReference<AssetA> {assetA.GetHeader().uuid};
-    //assetB.GetAsset().asset_a_refs = {SoftReference<AssetA> {assetA.GetHeader().uuid},
+    // assetB.GetAsset().asset_a_refs = {SoftReference<AssetA> {assetA.GetHeader().uuid},
-    //                                  SoftReference<AssetA> {assetAA.GetHeader().uuid}};
+    //                                   SoftReference<AssetA> {assetAA.GetHeader().uuid}};
 
     const eastl::vector<std::byte> test = assetB.Save();
 
@@ -112,13 +112,13 @@ TEST_F(AssetFixture, AssetBTests)
     EXPECT_EQ(assetB.GetHeader().version, versionB);
     EXPECT_EQ(assetB.GetHeader().version, assetB_dup.GetHeader().version);
 
-    //EXPECT_EQ(assetB.GetAsset().asset_a_ref, HardReference<AssetA> {assetA.GetHeader().uuid});
+    // EXPECT_EQ(assetB.GetAsset().asset_a_ref, HardReference<AssetA> {assetA.GetHeader().uuid});
-    //EXPECT_EQ(assetB.GetAsset().asset_a_ref, assetB_dup.GetAsset().asset_a_ref);
+    // EXPECT_EQ(assetB.GetAsset().asset_a_ref, assetB_dup.GetAsset().asset_a_ref);
 
-    //EXPECT_EQ(assetB.GetAsset().asset_a_refs,
+    // EXPECT_EQ(assetB.GetAsset().asset_a_refs,
-    //          (eastl::vector<SoftReference<AssetA>> {SoftReference<AssetA> {assetA.GetHeader().uuid},
+    //           (eastl::vector<SoftReference<AssetA>> {SoftReference<AssetA> {assetA.GetHeader().uuid},
-    //                                                 SoftReference<AssetA> {assetAA.GetHeader().uuid}}));
+    //                                                  SoftReference<AssetA> {assetAA.GetHeader().uuid}}));
-    //EXPECT_EQ(assetB.GetAsset().asset_a_refs, assetB_dup.GetAsset().asset_a_refs);
+    // EXPECT_EQ(assetB.GetAsset().asset_a_refs, assetB_dup.GetAsset().asset_a_refs);
 }
 
 /****************************************************************************************/
@@ -153,9 +153,9 @@ TEST_F(AssetFixture, AssetCTests)
     AssetB assetB;
     assetB.SetName(nameB);
     assetB.SetVersion(versionB);
-    //assetB.GetAsset().asset_a_ref = HardReference<AssetA> {assetA.GetHeader().uuid};
+    // assetB.GetAsset().asset_a_ref = HardReference<AssetA> {assetA.GetHeader().uuid};
-    //assetB.GetAsset().asset_a_refs = {SoftReference<AssetA> {assetA.GetHeader().uuid},
+    // assetB.GetAsset().asset_a_refs = {SoftReference<AssetA> {assetA.GetHeader().uuid},
-    //                                  SoftReference<AssetA> {assetAA.GetHeader().uuid}};
+    //                                   SoftReference<AssetA> {assetAA.GetHeader().uuid}};
 
     constexpr eastl::string_view nameC = "General";
     constexpr std::uint32_t versionC = 1;
@@ -163,11 +163,11 @@ TEST_F(AssetFixture, AssetCTests)
     AssetC assetC;
     assetC.SetName(nameC);
     assetC.SetVersion(versionC);
-    //assetC.GetAsset().inner_table->asset_a_ref = HardReference<AssetA> {assetA.GetHeader().uuid};
+    // assetC.GetAsset().inner_table->asset_a_ref = HardReference<AssetA> {assetA.GetHeader().uuid};
-    //assetC.GetAsset().inner_table->asset_a_refs = {HardReference<AssetA> {assetA.GetHeader().uuid},
+    // assetC.GetAsset().inner_table->asset_a_refs = {HardReference<AssetA> {assetA.GetHeader().uuid},
-    //                                               HardReference<AssetA> {assetAA.GetHeader().uuid}};
+    //                                                HardReference<AssetA> {assetAA.GetHeader().uuid}};
-    //assetC.GetAsset().asset_b_ref = HardReference<AssetB> {assetB.GetHeader().uuid};
+    // assetC.GetAsset().asset_b_ref = HardReference<AssetB> {assetB.GetHeader().uuid};
-    //assetC.GetAsset().asset_b_refs = {SoftReference<AssetB> {assetB.GetHeader().uuid}};
+    // assetC.GetAsset().asset_b_refs = {SoftReference<AssetB> {assetB.GetHeader().uuid}};
 
     const eastl::vector<std::byte> test = assetC.Save();
 
@@ -187,19 +187,19 @@ TEST_F(AssetFixture, AssetCTests)
     EXPECT_EQ(assetC.GetHeader().version, versionC);
     EXPECT_EQ(assetC.GetHeader().version, assetC_dup.GetHeader().version);
 
-    //EXPECT_EQ(assetC.GetAsset().asset_b_ref, HardReference<AssetB> {assetB.GetHeader().uuid});
+    // EXPECT_EQ(assetC.GetAsset().asset_b_ref, HardReference<AssetB> {assetB.GetHeader().uuid});
-    //EXPECT_EQ(assetC.GetAsset().asset_b_ref, assetC_dup.GetAsset().asset_b_ref);
+    // EXPECT_EQ(assetC.GetAsset().asset_b_ref, assetC_dup.GetAsset().asset_b_ref);
 
-    //EXPECT_EQ(assetC.GetAsset().asset_b_refs,
+    // EXPECT_EQ(assetC.GetAsset().asset_b_refs,
-    //          (eastl::vector<SoftReference<AssetB>> {SoftReference<AssetB> {assetB.GetHeader().uuid}}));
+    //           (eastl::vector<SoftReference<AssetB>> {SoftReference<AssetB> {assetB.GetHeader().uuid}}));
-    //EXPECT_EQ(assetC.GetAsset().asset_b_refs, assetC_dup.GetAsset().asset_b_refs);
+    // EXPECT_EQ(assetC.GetAsset().asset_b_refs, assetC_dup.GetAsset().asset_b_refs);
 
-    //EXPECT_EQ(assetC.GetAsset().inner_table->asset_a_ref, HardReference<AssetA> {assetA.GetHeader().uuid});
+    // EXPECT_EQ(assetC.GetAsset().inner_table->asset_a_ref, HardReference<AssetA> {assetA.GetHeader().uuid});
-    //EXPECT_EQ(assetC.GetAsset().inner_table->asset_a_ref, assetC_dup.GetAsset().inner_table->asset_a_ref);
+    // EXPECT_EQ(assetC.GetAsset().inner_table->asset_a_ref, assetC_dup.GetAsset().inner_table->asset_a_ref);
 
-    //EXPECT_EQ(assetC.GetAsset().inner_table->asset_a_refs,
+    // EXPECT_EQ(assetC.GetAsset().inner_table->asset_a_refs,
-    //          (eastl::vector<HardReference<AssetA>> {HardReference<AssetA> {assetA.GetHeader().uuid},
+    //           (eastl::vector<HardReference<AssetA>> {HardReference<AssetA> {assetA.GetHeader().uuid},
-    //                                                 HardReference<AssetA> {assetAA.GetHeader().uuid}}));
+    //                                                  HardReference<AssetA> {assetAA.GetHeader().uuid}}));
-    //EXPECT_EQ(assetC.GetAsset().inner_table->asset_a_refs, assetC_dup.GetAsset().inner_table->asset_a_refs);
+    // EXPECT_EQ(assetC.GetAsset().inner_table->asset_a_refs, assetC_dup.GetAsset().inner_table->asset_a_refs);
 }
 }   // namespace Bigfoot

Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetA.fbs

@@ -1,9 +1,13 @@
+include "Engine/Asset/Reference.fbs";
+
 namespace Flat.Bigfoot;
 
 table AssetA
 {
     health: uint = 0;
     mana: uint = 0;
+
+    ref_a: SoftReference (native_inline, native_type_template_arg: "::Bigfoot::AssetA");
 }
 
 root_type AssetA;

Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetA.hpp

@@ -6,10 +6,10 @@
  *********************************************************************/
 #ifndef BIGFOOT_ASSETSFORTESTING_ASSET_ASSETA_HPP
 #define BIGFOOT_ASSETSFORTESTING_ASSET_ASSETA_HPP
-#include <AssetsForTesting/Asset/AssetA_generated.hpp>
-
 #include <Engine/Asset/Asset.hpp>
 
+#include <AssetsForTesting/Asset/AssetA_generated.hpp>
+
 namespace Bigfoot
 {
 struct AssetATraits
@@ -30,7 +30,7 @@ class AssetA: public Asset<AssetATraits>
     AssetA(const AssetA& p_asset) = delete;
     AssetA(AssetA&& p_asset) = default;
 
-    ~AssetA() = default;
+    ~AssetA() override = default;
 
     AssetA& operator=(const AssetA& p_asset) = delete;
     AssetA& operator=(AssetA&& p_asset) = default;

Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetA_generated.hpp

@@ -13,6 +13,10 @@ static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
               FLATBUFFERS_VERSION_REVISION == 19,
              "Non-compatible flatbuffers version included");
 
+#include "System/UUID/UUID.hpp"
+#include "Engine/Asset/Reference.hpp"
+#include "Engine/Asset/Reference_generated.hpp"
+
 #include "EASTL/unique_ptr.h"
 #include "EASTL/string.h"
 #include "EASTL/vector.h"
@@ -33,6 +37,7 @@ struct AssetAT : public ::flatbuffers::NativeTable {
   }
   uint32_t health = 0;
   uint32_t mana = 0;
+  ::Bigfoot::SoftReference<::Bigfoot::AssetA> ref_a{};
 };
 
 struct AssetA FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
@@ -47,7 +52,8 @@ struct AssetA FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   }
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_HEALTH = 4,
-    VT_MANA = 6
+    VT_MANA = 6,
+    VT_REF_A = 8
   };
   uint32_t health() const {
     return GetField<uint32_t>(VT_HEALTH, 0);
@@ -55,11 +61,15 @@ struct AssetA FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   uint32_t mana() const {
     return GetField<uint32_t>(VT_MANA, 0);
   }
+  const Flat::Bigfoot::SoftReference *ref_a() const {
+    return GetStruct<const Flat::Bigfoot::SoftReference *>(VT_REF_A);
+  }
   template <bool B = false>
   bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint32_t>(verifier, VT_HEALTH, 4) &&
            VerifyField<uint32_t>(verifier, VT_MANA, 4) &&
+           VerifyField<Flat::Bigfoot::SoftReference>(verifier, VT_REF_A, 1) &&
            verifier.EndTable();
   }
   AssetAT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -77,6 +87,9 @@ struct AssetABuilder {
   void add_mana(uint32_t mana) {
     fbb_.AddElement<uint32_t>(AssetA::VT_MANA, mana, 0);
   }
+  void add_ref_a(const Flat::Bigfoot::SoftReference *ref_a) {
+    fbb_.AddStruct(AssetA::VT_REF_A, ref_a);
+  }
   explicit AssetABuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
@@ -91,8 +104,10 @@ struct AssetABuilder {
 inline ::flatbuffers::Offset<AssetA> CreateAssetA(
     ::flatbuffers::FlatBufferBuilder &_fbb,
     uint32_t health = 0,
-    uint32_t mana = 0) {
+    uint32_t mana = 0,
+    const Flat::Bigfoot::SoftReference *ref_a = nullptr) {
   AssetABuilder builder_(_fbb);
+  builder_.add_ref_a(ref_a);
   builder_.add_mana(mana);
   builder_.add_health(health);
   return builder_.Finish();
@@ -116,6 +131,7 @@ inline void AssetA::UnPackTo(AssetAT *_o, const ::flatbuffers::resolver_function
   (void)_resolver;
   { auto _e = health(); _o->health = _e; }
   { auto _e = mana(); _o->mana = _e; }
+  { auto _e = ref_a(); if (_e) _o->ref_a = ::flatbuffers::UnPackSoftReferenceAssetA(*_e); }
 }
 
 inline ::flatbuffers::Offset<AssetA> CreateAssetA(::flatbuffers::FlatBufferBuilder &_fbb, const AssetAT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
@@ -128,19 +144,25 @@ inline ::flatbuffers::Offset<AssetA> AssetA::Pack(::flatbuffers::FlatBufferBuild
   struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const AssetAT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
   auto _health = _o->health;
   auto _mana = _o->mana;
+  auto _ref_a = ::flatbuffers::PackSoftReferenceAssetA(_o->ref_a);
   return Flat::Bigfoot::CreateAssetA(
       _fbb,
       _health,
-      _mana);
+      _mana,
+      &_ref_a);
 }
 
 inline const ::flatbuffers::TypeTable *AssetATypeTable() {
   static const ::flatbuffers::TypeCode type_codes[] = {
     { ::flatbuffers::ET_UINT, 0, -1 },
-    { ::flatbuffers::ET_UINT, 0, -1 }
+    { ::flatbuffers::ET_UINT, 0, -1 },
+    { ::flatbuffers::ET_SEQUENCE, 0, 0 }
+  };
+  static const ::flatbuffers::TypeFunction type_refs[] = {
+    Flat::Bigfoot::SoftReferenceTypeTable
   };
   static const ::flatbuffers::TypeTable tt = {
-    ::flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, nullptr, nullptr
+    ::flatbuffers::ST_TABLE, 3, type_codes, type_refs, nullptr, nullptr, nullptr
   };
   return &tt;
 }

Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetB.fbs

@@ -1,9 +1,11 @@
-include "AssetsForTesting/Asset/AssetA.fbs";
+include "Engine/Asset/Reference.fbs";
 
 namespace Flat.Bigfoot;
 
 table AssetB
 {
+    ref_a: HardReference (native_inline, native_type_template_arg: "::Bigfoot::AssetA");
+    refs_a: [SoftReference] (native_inline, native_type_template_arg: "::Bigfoot::AssetA");
 }
 
 root_type AssetB;

Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetB.hpp

@@ -6,10 +6,10 @@
  *********************************************************************/
 #ifndef BIGFOOT_ASSETSFORTESTING_ASSET_ASSETB_HPP
 #define BIGFOOT_ASSETSFORTESTING_ASSET_ASSETB_HPP
-#include <AssetsForTesting/Asset/AssetB_generated.hpp>
-
 #include <Engine/Asset/Asset.hpp>
 
+#include <AssetsForTesting/Asset/AssetB_generated.hpp>
+
 namespace Bigfoot
 {
 struct AssetBTraits
@@ -30,7 +30,7 @@ class AssetB: public Asset<AssetBTraits>
     AssetB(const AssetB& p_asset) = delete;
     AssetB(AssetB&& p_asset) = default;
 
-    ~AssetB() = default;
+    ~AssetB() override = default;
 
     AssetB& operator=(const AssetB& p_asset) = delete;
     AssetB& operator=(AssetB&& p_asset) = default;

Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetB_generated.hpp

@@ -13,7 +13,9 @@ static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
               FLATBUFFERS_VERSION_REVISION == 19,
              "Non-compatible flatbuffers version included");
 
-#include "AssetsForTesting/Asset/AssetA_generated.hpp"
+#include "System/UUID/UUID.hpp"
+#include "Engine/Asset/Reference.hpp"
+#include "Engine/Asset/Reference_generated.hpp"
 
 #include "EASTL/unique_ptr.h"
 #include "EASTL/string.h"
@@ -33,6 +35,8 @@ struct AssetBT : public ::flatbuffers::NativeTable {
   static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
     return "Flat.Bigfoot.AssetBT";
   }
+  ::Bigfoot::HardReference<::Bigfoot::AssetA> ref_a{};
+  eastl::vector<::Bigfoot::SoftReference<::Bigfoot::AssetA>> refs_a{};
 };
 
 struct AssetB FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
@@ -45,9 +49,22 @@ struct AssetB FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
     return "Flat.Bigfoot.AssetB";
   }
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_REF_A = 4,
+    VT_REFS_A = 6
+  };
+  const Flat::Bigfoot::HardReference *ref_a() const {
+    return GetStruct<const Flat::Bigfoot::HardReference *>(VT_REF_A);
+  }
+  const ::flatbuffers::Vector<const Flat::Bigfoot::SoftReference *> *refs_a() const {
+    return GetPointer<const ::flatbuffers::Vector<const Flat::Bigfoot::SoftReference *> *>(VT_REFS_A);
+  }
   template <bool B = false>
   bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
+           VerifyField<Flat::Bigfoot::HardReference>(verifier, VT_REF_A, 1) &&
+           VerifyOffset(verifier, VT_REFS_A) &&
+           verifier.VerifyVector(refs_a()) &&
            verifier.EndTable();
   }
   AssetBT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -59,6 +76,12 @@ struct AssetBBuilder {
   typedef AssetB Table;
   ::flatbuffers::FlatBufferBuilder &fbb_;
   ::flatbuffers::uoffset_t start_;
+  void add_ref_a(const Flat::Bigfoot::HardReference *ref_a) {
+    fbb_.AddStruct(AssetB::VT_REF_A, ref_a);
+  }
+  void add_refs_a(::flatbuffers::Offset<::flatbuffers::Vector<const Flat::Bigfoot::SoftReference *>> refs_a) {
+    fbb_.AddOffset(AssetB::VT_REFS_A, refs_a);
+  }
   explicit AssetBBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
@@ -71,8 +94,12 @@ struct AssetBBuilder {
 };
 
 inline ::flatbuffers::Offset<AssetB> CreateAssetB(
-    ::flatbuffers::FlatBufferBuilder &_fbb) {
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    const Flat::Bigfoot::HardReference *ref_a = nullptr,
+    ::flatbuffers::Offset<::flatbuffers::Vector<const Flat::Bigfoot::SoftReference *>> refs_a = 0) {
   AssetBBuilder builder_(_fbb);
+  builder_.add_refs_a(refs_a);
+  builder_.add_ref_a(ref_a);
   return builder_.Finish();
 }
 
@@ -92,6 +119,8 @@ inline AssetBT *AssetB::UnPack(const ::flatbuffers::resolver_function_t *_resolv
 inline void AssetB::UnPackTo(AssetBT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
   (void)_o;
   (void)_resolver;
+  { auto _e = ref_a(); if (_e) _o->ref_a = ::flatbuffers::UnPackHardReferenceAssetA(*_e); }
+  { auto _e = refs_a(); if (_e) { _o->refs_a.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->refs_a[_i] = ::flatbuffers::UnPackSoftReferenceAssetA(*_e->Get(_i)); } } else { _o->refs_a.resize(0); } }
 }
 
 inline ::flatbuffers::Offset<AssetB> CreateAssetB(::flatbuffers::FlatBufferBuilder &_fbb, const AssetBT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
@@ -102,13 +131,25 @@ inline ::flatbuffers::Offset<AssetB> AssetB::Pack(::flatbuffers::FlatBufferBuild
   (void)_rehasher;
   (void)_o;
   struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const AssetBT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _ref_a = ::flatbuffers::PackHardReferenceAssetA(_o->ref_a);
+  auto _refs_a = _fbb.CreateVectorOfNativeStructs<Flat::Bigfoot::SoftReference, ::Bigfoot::SoftReference<::Bigfoot::AssetA>>(_o->refs_a.data(), _o->refs_a.size(), ::flatbuffers::PackSoftReferenceAssetA);
   return Flat::Bigfoot::CreateAssetB(
-      _fbb);
+      _fbb,
+      &_ref_a,
+      _refs_a);
 }
 
 inline const ::flatbuffers::TypeTable *AssetBTypeTable() {
+  static const ::flatbuffers::TypeCode type_codes[] = {
+    { ::flatbuffers::ET_SEQUENCE, 0, 0 },
+    { ::flatbuffers::ET_SEQUENCE, 1, 1 }
+  };
+  static const ::flatbuffers::TypeFunction type_refs[] = {
+    Flat::Bigfoot::HardReferenceTypeTable,
+    Flat::Bigfoot::SoftReferenceTypeTable
+  };
   static const ::flatbuffers::TypeTable tt = {
-    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
+    ::flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, nullptr
   };
   return &tt;
 }

Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetC.fbs

@@ -1,15 +1,19 @@
-include "AssetsForTesting/Asset/AssetA.fbs";
+include "Engine/Asset/Reference.fbs";
-include "AssetsForTesting/Asset/AssetB.fbs";
 
 namespace Flat.Bigfoot;
 
 table InnerTable
 {
+    asset_a_ref: HardReference (native_inline, native_type_template_arg: "::Bigfoot::AssetA");
+	asset_a_refs: [HardReference] (native_inline, native_type_template_arg: "::Bigfoot::AssetA");
 }
 
 table AssetC
 {
     inner_table: InnerTable (required);
+
+    asset_b_ref: HardReference (native_inline, native_type_template_arg: "::Bigfoot::AssetB");
+    asset_b_refs: [SoftReference] (native_inline, native_type_template_arg: "::Bigfoot::AssetB");
 }
 
 root_type AssetC;

Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetC.hpp

@@ -6,10 +6,10 @@
  *********************************************************************/
 #ifndef BIGFOOT_ASSETSFORTESTING_ASSET_ASSETC_HPP
 #define BIGFOOT_ASSETSFORTESTING_ASSET_ASSETC_HPP
-#include <AssetsForTesting/Asset/AssetC_generated.hpp>
-
 #include <Engine/Asset/Asset.hpp>
 
+#include <AssetsForTesting/Asset/AssetC_generated.hpp>
+
 namespace Bigfoot
 {
 struct AssetCTraits
@@ -33,7 +33,7 @@ class AssetC: public Asset<AssetCTraits>
     AssetC(const AssetC& p_asset) = delete;
     AssetC(AssetC&& p_asset) = default;
 
-    ~AssetC() = default;
+    ~AssetC() override = default;
 
     AssetC& operator=(const AssetC& p_asset) = delete;
     AssetC& operator=(AssetC&& p_asset) = default;

Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetC_generated.hpp

@@ -13,8 +13,9 @@ static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
               FLATBUFFERS_VERSION_REVISION == 19,
              "Non-compatible flatbuffers version included");
 
-#include "AssetsForTesting/Asset/AssetA_generated.hpp"
+#include "System/UUID/UUID.hpp"
-#include "AssetsForTesting/Asset/AssetB_generated.hpp"
+#include "Engine/Asset/Reference.hpp"
+#include "Engine/Asset/Reference_generated.hpp"
 
 #include "EASTL/unique_ptr.h"
 #include "EASTL/string.h"
@@ -40,6 +41,8 @@ struct InnerTableT : public ::flatbuffers::NativeTable {
   static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
     return "Flat.Bigfoot.InnerTableT";
   }
+  ::Bigfoot::HardReference<::Bigfoot::AssetA> asset_a_ref{};
+  eastl::vector<::Bigfoot::HardReference<::Bigfoot::AssetA>> asset_a_refs{};
 };
 
 struct InnerTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
@@ -52,9 +55,22 @@ struct InnerTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
     return "Flat.Bigfoot.InnerTable";
   }
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_ASSET_A_REF = 4,
+    VT_ASSET_A_REFS = 6
+  };
+  const Flat::Bigfoot::HardReference *asset_a_ref() const {
+    return GetStruct<const Flat::Bigfoot::HardReference *>(VT_ASSET_A_REF);
+  }
+  const ::flatbuffers::Vector<const Flat::Bigfoot::HardReference *> *asset_a_refs() const {
+    return GetPointer<const ::flatbuffers::Vector<const Flat::Bigfoot::HardReference *> *>(VT_ASSET_A_REFS);
+  }
   template <bool B = false>
   bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
+           VerifyField<Flat::Bigfoot::HardReference>(verifier, VT_ASSET_A_REF, 1) &&
+           VerifyOffset(verifier, VT_ASSET_A_REFS) &&
+           verifier.VerifyVector(asset_a_refs()) &&
            verifier.EndTable();
   }
   InnerTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -66,6 +82,12 @@ struct InnerTableBuilder {
   typedef InnerTable Table;
   ::flatbuffers::FlatBufferBuilder &fbb_;
   ::flatbuffers::uoffset_t start_;
+  void add_asset_a_ref(const Flat::Bigfoot::HardReference *asset_a_ref) {
+    fbb_.AddStruct(InnerTable::VT_ASSET_A_REF, asset_a_ref);
+  }
+  void add_asset_a_refs(::flatbuffers::Offset<::flatbuffers::Vector<const Flat::Bigfoot::HardReference *>> asset_a_refs) {
+    fbb_.AddOffset(InnerTable::VT_ASSET_A_REFS, asset_a_refs);
+  }
   explicit InnerTableBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
@@ -78,8 +100,12 @@ struct InnerTableBuilder {
 };
 
 inline ::flatbuffers::Offset<InnerTable> CreateInnerTable(
-    ::flatbuffers::FlatBufferBuilder &_fbb) {
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    const Flat::Bigfoot::HardReference *asset_a_ref = nullptr,
+    ::flatbuffers::Offset<::flatbuffers::Vector<const Flat::Bigfoot::HardReference *>> asset_a_refs = 0) {
   InnerTableBuilder builder_(_fbb);
+  builder_.add_asset_a_refs(asset_a_refs);
+  builder_.add_asset_a_ref(asset_a_ref);
   return builder_.Finish();
 }
 
@@ -96,6 +122,8 @@ struct AssetCT : public ::flatbuffers::NativeTable {
     return "Flat.Bigfoot.AssetCT";
   }
   eastl::unique_ptr<Flat::Bigfoot::InnerTableT> inner_table{};
+  ::Bigfoot::HardReference<::Bigfoot::AssetB> asset_b_ref{};
+  eastl::vector<::Bigfoot::SoftReference<::Bigfoot::AssetB>> asset_b_refs{};
   AssetCT() = default;
   AssetCT(const AssetCT &o);
   AssetCT(AssetCT&&) FLATBUFFERS_NOEXCEPT = default;
@@ -113,16 +141,27 @@ struct AssetC FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     return "Flat.Bigfoot.AssetC";
   }
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_INNER_TABLE = 4
+    VT_INNER_TABLE = 4,
+    VT_ASSET_B_REF = 6,
+    VT_ASSET_B_REFS = 8
   };
   const Flat::Bigfoot::InnerTable *inner_table() const {
     return GetPointer<const Flat::Bigfoot::InnerTable *>(VT_INNER_TABLE);
   }
+  const Flat::Bigfoot::HardReference *asset_b_ref() const {
+    return GetStruct<const Flat::Bigfoot::HardReference *>(VT_ASSET_B_REF);
+  }
+  const ::flatbuffers::Vector<const Flat::Bigfoot::SoftReference *> *asset_b_refs() const {
+    return GetPointer<const ::flatbuffers::Vector<const Flat::Bigfoot::SoftReference *> *>(VT_ASSET_B_REFS);
+  }
   template <bool B = false>
   bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffsetRequired(verifier, VT_INNER_TABLE) &&
            verifier.VerifyTable(inner_table()) &&
+           VerifyField<Flat::Bigfoot::HardReference>(verifier, VT_ASSET_B_REF, 1) &&
+           VerifyOffset(verifier, VT_ASSET_B_REFS) &&
+           verifier.VerifyVector(asset_b_refs()) &&
            verifier.EndTable();
   }
   AssetCT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -137,6 +176,12 @@ struct AssetCBuilder {
   void add_inner_table(::flatbuffers::Offset<Flat::Bigfoot::InnerTable> inner_table) {
     fbb_.AddOffset(AssetC::VT_INNER_TABLE, inner_table);
   }
+  void add_asset_b_ref(const Flat::Bigfoot::HardReference *asset_b_ref) {
+    fbb_.AddStruct(AssetC::VT_ASSET_B_REF, asset_b_ref);
+  }
+  void add_asset_b_refs(::flatbuffers::Offset<::flatbuffers::Vector<const Flat::Bigfoot::SoftReference *>> asset_b_refs) {
+    fbb_.AddOffset(AssetC::VT_ASSET_B_REFS, asset_b_refs);
+  }
   explicit AssetCBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
@@ -151,8 +196,12 @@ struct AssetCBuilder {
 
 inline ::flatbuffers::Offset<AssetC> CreateAssetC(
     ::flatbuffers::FlatBufferBuilder &_fbb,
-    ::flatbuffers::Offset<Flat::Bigfoot::InnerTable> inner_table = 0) {
+    ::flatbuffers::Offset<Flat::Bigfoot::InnerTable> inner_table = 0,
+    const Flat::Bigfoot::HardReference *asset_b_ref = nullptr,
+    ::flatbuffers::Offset<::flatbuffers::Vector<const Flat::Bigfoot::SoftReference *>> asset_b_refs = 0) {
   AssetCBuilder builder_(_fbb);
+  builder_.add_asset_b_refs(asset_b_refs);
+  builder_.add_asset_b_ref(asset_b_ref);
   builder_.add_inner_table(inner_table);
   return builder_.Finish();
 }
@@ -173,6 +222,8 @@ inline InnerTableT *InnerTable::UnPack(const ::flatbuffers::resolver_function_t
 inline void InnerTable::UnPackTo(InnerTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
   (void)_o;
   (void)_resolver;
+  { auto _e = asset_a_ref(); if (_e) _o->asset_a_ref = ::flatbuffers::UnPackHardReferenceAssetA(*_e); }
+  { auto _e = asset_a_refs(); if (_e) { _o->asset_a_refs.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->asset_a_refs[_i] = ::flatbuffers::UnPackHardReferenceAssetA(*_e->Get(_i)); } } else { _o->asset_a_refs.resize(0); } }
 }
 
 inline ::flatbuffers::Offset<InnerTable> CreateInnerTable(::flatbuffers::FlatBufferBuilder &_fbb, const InnerTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
@@ -183,16 +234,24 @@ inline ::flatbuffers::Offset<InnerTable> InnerTable::Pack(::flatbuffers::FlatBuf
   (void)_rehasher;
   (void)_o;
   struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const InnerTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _asset_a_ref = ::flatbuffers::PackHardReferenceAssetA(_o->asset_a_ref);
+  auto _asset_a_refs = _fbb.CreateVectorOfNativeStructs<Flat::Bigfoot::HardReference, ::Bigfoot::HardReference<::Bigfoot::AssetA>>(_o->asset_a_refs.data(), _o->asset_a_refs.size(), ::flatbuffers::PackHardReferenceAssetA);
   return Flat::Bigfoot::CreateInnerTable(
-      _fbb);
+      _fbb,
+      &_asset_a_ref,
+      _asset_a_refs);
 }
 
 inline AssetCT::AssetCT(const AssetCT &o)
-      : inner_table((o.inner_table) ? new Flat::Bigfoot::InnerTableT(*o.inner_table) : nullptr) {
+      : inner_table((o.inner_table) ? new Flat::Bigfoot::InnerTableT(*o.inner_table) : nullptr),
+        asset_b_ref(o.asset_b_ref),
+        asset_b_refs(o.asset_b_refs) {
 }
 
 inline AssetCT &AssetCT::operator=(AssetCT o) FLATBUFFERS_NOEXCEPT {
   std::swap(inner_table, o.inner_table);
+  std::swap(asset_b_ref, o.asset_b_ref);
+  std::swap(asset_b_refs, o.asset_b_refs);
   return *this;
 }
 
@@ -206,6 +265,8 @@ inline void AssetC::UnPackTo(AssetCT *_o, const ::flatbuffers::resolver_function
   (void)_o;
   (void)_resolver;
   { auto _e = inner_table(); if (_e) { if(_o->inner_table) { _e->UnPackTo(_o->inner_table.get(), _resolver); } else { _o->inner_table = eastl::unique_ptr<Flat::Bigfoot::InnerTableT>(_e->UnPack(_resolver)); } } else if (_o->inner_table) { _o->inner_table.reset(); } }
+  { auto _e = asset_b_ref(); if (_e) _o->asset_b_ref = ::flatbuffers::UnPackHardReferenceAssetB(*_e); }
+  { auto _e = asset_b_refs(); if (_e) { _o->asset_b_refs.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->asset_b_refs[_i] = ::flatbuffers::UnPackSoftReferenceAssetB(*_e->Get(_i)); } } else { _o->asset_b_refs.resize(0); } }
 }
 
 inline ::flatbuffers::Offset<AssetC> CreateAssetC(::flatbuffers::FlatBufferBuilder &_fbb, const AssetCT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
@@ -217,27 +278,42 @@ inline ::flatbuffers::Offset<AssetC> AssetC::Pack(::flatbuffers::FlatBufferBuild
   (void)_o;
   struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const AssetCT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
   auto _inner_table = _o->inner_table ? CreateInnerTable(_fbb, _o->inner_table.get(), _rehasher) : 0;
+  auto _asset_b_ref = ::flatbuffers::PackHardReferenceAssetB(_o->asset_b_ref);
+  auto _asset_b_refs = _fbb.CreateVectorOfNativeStructs<Flat::Bigfoot::SoftReference, ::Bigfoot::SoftReference<::Bigfoot::AssetB>>(_o->asset_b_refs.data(), _o->asset_b_refs.size(), ::flatbuffers::PackSoftReferenceAssetB);
   return Flat::Bigfoot::CreateAssetC(
       _fbb,
-      _inner_table);
+      _inner_table,
+      &_asset_b_ref,
+      _asset_b_refs);
 }
 
 inline const ::flatbuffers::TypeTable *InnerTableTypeTable() {
+  static const ::flatbuffers::TypeCode type_codes[] = {
+    { ::flatbuffers::ET_SEQUENCE, 0, 0 },
+    { ::flatbuffers::ET_SEQUENCE, 1, 0 }
+  };
+  static const ::flatbuffers::TypeFunction type_refs[] = {
+    Flat::Bigfoot::HardReferenceTypeTable
+  };
   static const ::flatbuffers::TypeTable tt = {
-    ::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
+    ::flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, nullptr
   };
   return &tt;
 }
 
 inline const ::flatbuffers::TypeTable *AssetCTypeTable() {
   static const ::flatbuffers::TypeCode type_codes[] = {
-    { ::flatbuffers::ET_SEQUENCE, 0, 0 }
+    { ::flatbuffers::ET_SEQUENCE, 0, 0 },
+    { ::flatbuffers::ET_SEQUENCE, 0, 1 },
+    { ::flatbuffers::ET_SEQUENCE, 1, 2 }
   };
   static const ::flatbuffers::TypeFunction type_refs[] = {
-    Flat::Bigfoot::InnerTableTypeTable
+    Flat::Bigfoot::InnerTableTypeTable,
+    Flat::Bigfoot::HardReferenceTypeTable,
+    Flat::Bigfoot::SoftReferenceTypeTable
   };
   static const ::flatbuffers::TypeTable tt = {
-    ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, nullptr
+    ::flatbuffers::ST_TABLE, 3, type_codes, type_refs, nullptr, nullptr, nullptr
   };
   return &tt;
 }