diff --git a/Bigfoot/Sources/Engine/Include/Engine/Asset/AssetContainer.hpp b/Bigfoot/Sources/Engine/Include/Engine/Asset/AssetContainer.hpp index e69de29..ba6d270 100644 --- a/Bigfoot/Sources/Engine/Include/Engine/Asset/AssetContainer.hpp +++ b/Bigfoot/Sources/Engine/Include/Engine/Asset/AssetContainer.hpp @@ -0,0 +1,91 @@ +/********************************************************************* + * \file AssetContainer.hpp + * + * \author Romain BOULLARD + * \date May 2026 + *********************************************************************/ +#ifndef BIGFOOT_ENGINE_ASSETCONTAINER_HPP +#define BIGFOOT_ENGINE_ASSETCONTAINER_HPP +#include + +#include + +#include + +#include + +namespace Bigfoot +{ +template +class AssetContainer +{ + public: + AssetContainer() + { + CRITICAL_ASSERT(EngineAssertHandler, !ms_instance, "Asset container already exists!"); + ms_instance = this; + } + + AssetContainer(const AssetContainer&) = delete; + AssetContainer& operator=(const AssetContainer&) = delete; + + ~AssetContainer() = default; + + struct Entry + { + std::uint32_t m_hardRefCount = 0; + std::uint32_t m_softRefCount = 0; + }; + + void IncrementHardRefCount(const UUID& p_uuid) + { + ++m_entries[p_uuid].m_hardRefCount; + } + + void DecrementHardRefCount(const UUID& p_uuid) + { + if (m_entries.contains(p_uuid)) + { + --m_entries.at(p_uuid).m_hardRefCount; + } + } + + void IncrementSoftRefCount(const UUID& p_uuid) + { + ++m_entries[p_uuid].m_softRefCount; + } + + void DecrementSoftRefCount(const UUID& p_uuid) + { + if (m_entries.contains(p_uuid)) + { + --m_entries.at(p_uuid).m_softRefCount; + } + } + + [[nodiscard]] + std::uint32_t HardRefCount(const UUID& p_uuid) const + { + return m_entries.contains(p_uuid) ? m_entries.at(p_uuid).m_hardRefCount : 0; + } + + [[nodiscard]] + std::uint32_t SoftRefCount(const UUID& p_uuid) const + { + return m_entries.contains(p_uuid) ? m_entries.at(p_uuid).m_softRefCount : 0; + } + + [[nodiscard]] + static AssetContainer& Get() + { + return *ms_instance; + } + + private: + ankerl::unordered_dense::segmented_map m_entries; + + inline static constinit AssetContainer* ms_instance = nullptr; +}; +} // namespace Bigfoot + +#endif diff --git a/Bigfoot/Sources/Engine/Include/Engine/Asset/AssetHelper.hpp b/Bigfoot/Sources/Engine/Include/Engine/Asset/AssetHelper.hpp new file mode 100644 index 0000000..dc7f3ad --- /dev/null +++ b/Bigfoot/Sources/Engine/Include/Engine/Asset/AssetHelper.hpp @@ -0,0 +1,74 @@ +/********************************************************************* + * \file AssetHelper.hpp + * + * \author Romain BOULLARD + * \date April 2026 + *********************************************************************/ +#ifndef BIGFOOT_ENGINE_ASSETHELPER_HPP +#define BIGFOOT_ENGINE_ASSETHELPER_HPP +#include +#include +#include + +#define ASSET_SOFT_REF_DECL(AssetName, AssetType) \ + namespace flatbuffers \ + { \ + Flat::Bigfoot::SoftReference PackSoftReference##AssetName(const Bigfoot::SoftReference& p_softRef); \ + Bigfoot::SoftReference UnPackSoftReference##AssetName(const Flat::Bigfoot::SoftReference& p_softRef); \ + } + +#define ASSET_HARD_REF_DECL(AssetName, AssetType) \ + namespace flatbuffers \ + { \ + Flat::Bigfoot::HardReference PackHardReference##AssetName(const Bigfoot::HardReference& p_hardRef); \ + Bigfoot::HardReference UnPackHardReference##AssetName(const Flat::Bigfoot::HardReference& p_hardRef); \ + } + +#define ASSET_CONTAINER(AssetName, AssetType) \ + namespace Bigfoot \ + { \ + inline AssetContainer g_##AssetName##Container; \ + } + +#define ASSET_REF_DECL(AssetName, AssetType) \ + ASSET_SOFT_REF_DECL(AssetName, AssetType) \ + ASSET_HARD_REF_DECL(AssetName, AssetType) + +#define ASSET_DECL(AssetName, AssetType) \ + ASSET_REF_DECL(AssetName, AssetType) \ + ASSET_CONTAINER(AssetName, AssetType) + +/****************************************************************************************/ + +#define ASSET_SOFT_REF_IMPL(AssetName, AssetType) \ + namespace flatbuffers \ + { \ + Flat::Bigfoot::SoftReference PackSoftReference##AssetName(const Bigfoot::SoftReference& p_softRef) \ + { \ + return {flatbuffers::Pack(p_softRef.GetUUID())}; \ + } \ + Bigfoot::SoftReference UnPackSoftReference##AssetName(const Flat::Bigfoot::SoftReference& p_softRef) \ + { \ + return {flatbuffers::UnPack(p_softRef.uuid())}; \ + } \ + } + +#define ASSET_HARD_REF_IMPL(AssetName, AssetType) \ + namespace flatbuffers \ + { \ + Flat::Bigfoot::HardReference PackHardReference##AssetName(const Bigfoot::HardReference& p_softRef) \ + { \ + return {flatbuffers::Pack(p_softRef.GetUUID())}; \ + } \ + Bigfoot::HardReference UnPackHardReference##AssetName(const Flat::Bigfoot::HardReference& p_softRef) \ + { \ + return {flatbuffers::UnPack(p_softRef.uuid())}; \ + } \ + } + +#define ASSET_REF_IMPL(AssetName, AssetType) \ + ASSET_SOFT_REF_IMPL(AssetName, AssetType) \ + ASSET_HARD_REF_IMPL(AssetName, AssetType) + +#define ASSET_IMPL(AssetName, AssetType) ASSET_REF_IMPL(AssetName, AssetType) +#endif diff --git a/Bigfoot/Sources/Engine/Include/Engine/Asset/Reference.fbs b/Bigfoot/Sources/Engine/Include/Engine/Asset/Reference.fbs index 1c96e1c..4529a78 100644 --- a/Bigfoot/Sources/Engine/Include/Engine/Asset/Reference.fbs +++ b/Bigfoot/Sources/Engine/Include/Engine/Asset/Reference.fbs @@ -4,12 +4,12 @@ include "System/UUID/UUID.fbs"; namespace Flat.Bigfoot; -struct HardRef +struct HardReference { uuid:UUID; } -struct SoftRef +struct SoftReference { uuid:UUID; } \ No newline at end of file diff --git a/Bigfoot/Sources/Engine/Include/Engine/Asset/Reference.hpp b/Bigfoot/Sources/Engine/Include/Engine/Asset/Reference.hpp index 1e023e0..23e4d0a 100644 --- a/Bigfoot/Sources/Engine/Include/Engine/Asset/Reference.hpp +++ b/Bigfoot/Sources/Engine/Include/Engine/Asset/Reference.hpp @@ -6,23 +6,35 @@ *********************************************************************/ #ifndef BIGFOOT_ENGINE_REFERENCE_HPP #define BIGFOOT_ENGINE_REFERENCE_HPP +#include #include +#include + namespace Bigfoot { template -class HardRef +class HardReference { public: - HardRef() = default; + HardReference() = default; - HardRef(const UUID& p_uuid): + HardReference(const UUID& p_uuid): m_uuid(p_uuid) { + Acquire(); } - HardRef(const HardRef& p_ref) = default; - HardRef(HardRef&& p_ref) = default; + HardReference(const HardReference& p_ref): + m_uuid(p_ref.m_uuid) + { + Acquire(); + } + + HardReference(HardReference&& p_ref) noexcept: + m_uuid(std::exchange(p_ref.m_uuid, UUID::NULL_UUID)) + { + } [[nodiscard]] const UUID& GetUUID() const @@ -30,34 +42,80 @@ class HardRef return m_uuid; } - ~HardRef() = default; + ~HardReference() + { + Release(); + } - HardRef& operator=(const HardRef& p_ref) = default; - HardRef& operator=(HardRef&& p_ref) = default; + HardReference& operator=(const HardReference& p_ref) + { + if (this != &p_ref) + { + Release(); + m_uuid = p_ref.m_uuid; + Acquire(); + } + return *this; + } + + HardReference& operator=(HardReference&& p_ref) noexcept + { + if (this != &p_ref) + { + Release(); + m_uuid = std::exchange(p_ref.m_uuid, UUID::NULL_UUID); + } + return *this; + } [[nodiscard]] - bool operator==(const HardRef& p_ref) const + bool operator==(const HardReference& p_ref) const { return m_uuid == p_ref.m_uuid; } private: + void Acquire() + { + if (m_uuid) + { + AssetContainer::Get().IncrementHardRefCount(m_uuid); + } + } + + void Release() + { + if (m_uuid) + { + AssetContainer::Get().DecrementHardRefCount(m_uuid); + } + } + UUID m_uuid = UUID::NULL_UUID; }; template -class SoftRef +class SoftReference { public: - SoftRef() = default; + SoftReference() = default; - SoftRef(const UUID& p_uuid): + SoftReference(const UUID& p_uuid): m_uuid(p_uuid) { + Acquire(); } - SoftRef(const SoftRef& p_ref) = default; - SoftRef(SoftRef&& p_ref) = default; + SoftReference(const SoftReference& p_ref): + m_uuid(p_ref.m_uuid) + { + Acquire(); + } + + SoftReference(SoftReference&& p_ref) noexcept: + m_uuid(std::exchange(p_ref.m_uuid, UUID::NULL_UUID)) + { + } [[nodiscard]] const UUID& GetUUID() const @@ -65,73 +123,56 @@ class SoftRef return m_uuid; } - ~SoftRef() = default; + ~SoftReference() + { + Release(); + } - SoftRef& operator=(const SoftRef& p_ref) = default; - SoftRef& operator=(SoftRef&& p_ref) = default; + SoftReference& operator=(const SoftReference& p_ref) + { + if (this != &p_ref) + { + Release(); + m_uuid = p_ref.m_uuid; + Acquire(); + } + return *this; + } + + SoftReference& operator=(SoftReference&& p_ref) noexcept + { + if (this != &p_ref) + { + Release(); + m_uuid = std::exchange(p_ref.m_uuid, UUID::NULL_UUID); + } + return *this; + } [[nodiscard]] - bool operator==(const SoftRef& p_ref) const + bool operator==(const SoftReference& p_ref) const { return m_uuid == p_ref.m_uuid; } private: + void Acquire() + { + if (m_uuid) + { + AssetContainer::Get().IncrementSoftRefCount(m_uuid); + } + } + + void Release() + { + if (m_uuid) + { + AssetContainer::Get().DecrementSoftRefCount(m_uuid); + } + } + UUID m_uuid = UUID::NULL_UUID; }; } // namespace Bigfoot - -#define ASSET_SOFT_REF_DECL(AssetName, AssetType) \ - namespace flatbuffers \ - { \ - Flat::Bigfoot::SoftRef PackSoftRef##AssetName(const Bigfoot::SoftRef& p_softRef); \ - Bigfoot::SoftRef UnPackSoftRef##AssetName(const Flat::Bigfoot::SoftRef& p_softRef); \ - } - -#define ASSET_HARD_REF_DECL(AssetName, AssetType) \ - namespace flatbuffers \ - { \ - Flat::Bigfoot::HardRef PackHardRef##AssetName(const Bigfoot::HardRef& p_hardRef); \ - Bigfoot::HardRef UnPackHardRef##AssetName(const Flat::Bigfoot::HardRef& p_hardRef); \ - } - -#define ASSET_REF_DECL(AssetName, AssetType) \ - ASSET_SOFT_REF_DECL(AssetName, AssetType) \ - ASSET_HARD_REF_DECL(AssetName, AssetType) - -#define ASSET_DECL(AssetName, AssetType) ASSET_REF_DECL(AssetName, AssetType) - -/****************************************************************************************/ - -#define ASSET_SOFT_REF_IMPL(AssetName, AssetType) \ - namespace flatbuffers \ - { \ - Flat::Bigfoot::SoftRef PackSoftRef##AssetName(const Bigfoot::SoftRef& p_softRef) \ - { \ - return {flatbuffers::Pack(p_softRef.GetUUID())}; \ - } \ - Bigfoot::SoftRef UnPackSoftRef##AssetName(const Flat::Bigfoot::SoftRef& p_softRef) \ - { \ - return {flatbuffers::UnPack(p_softRef.uuid())}; \ - } \ - } - -#define ASSET_HARD_REF_IMPL(AssetName, AssetType) \ - namespace flatbuffers \ - { \ - Flat::Bigfoot::HardRef PackHardRef##AssetName(const Bigfoot::HardRef& p_softRef) \ - { \ - return {flatbuffers::Pack(p_softRef.GetUUID())}; \ - } \ - Bigfoot::HardRef UnPackHardRef##AssetName(const Flat::Bigfoot::HardRef& p_softRef) \ - { \ - return {flatbuffers::UnPack(p_softRef.uuid())}; \ - } \ - } - -#define ASSET_REF_IMPL(AssetName, AssetType) \ - ASSET_SOFT_REF_IMPL(AssetName, AssetType) \ - ASSET_HARD_REF_IMPL(AssetName, AssetType) - -#define ASSET_IMPL(AssetName, AssetType) ASSET_REF_IMPL(AssetName, AssetType) #endif diff --git a/Bigfoot/Sources/Engine/Include/Engine/Asset/Reference_generated.hpp b/Bigfoot/Sources/Engine/Include/Engine/Asset/Reference_generated.hpp index d210a01..8128d52 100644 --- a/Bigfoot/Sources/Engine/Include/Engine/Asset/Reference_generated.hpp +++ b/Bigfoot/Sources/Engine/Include/Engine/Asset/Reference_generated.hpp @@ -25,71 +25,71 @@ static_assert(FLATBUFFERS_VERSION_MAJOR == 25 && namespace Flat { namespace Bigfoot { -struct HardRef; +struct HardReference; -struct SoftRef; +struct SoftReference; -inline const ::flatbuffers::TypeTable *HardRefTypeTable(); +inline const ::flatbuffers::TypeTable *HardReferenceTypeTable(); -inline const ::flatbuffers::TypeTable *SoftRefTypeTable(); +inline const ::flatbuffers::TypeTable *SoftReferenceTypeTable(); -FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) HardRef FLATBUFFERS_FINAL_CLASS { +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) HardReference FLATBUFFERS_FINAL_CLASS { private: Flat::Bigfoot::UUID uuid_; public: struct Traits; static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return HardRefTypeTable(); + return HardReferenceTypeTable(); } static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() { - return "Flat.Bigfoot.HardRef"; + return "Flat.Bigfoot.HardReference"; } - HardRef() + HardReference() : uuid_() { } - HardRef(const Flat::Bigfoot::UUID &_uuid) + HardReference(const Flat::Bigfoot::UUID &_uuid) : uuid_(_uuid) { } const Flat::Bigfoot::UUID &uuid() const { return uuid_; } }; -FLATBUFFERS_STRUCT_END(HardRef, 16); +FLATBUFFERS_STRUCT_END(HardReference, 16); -struct HardRef::Traits { - using type = HardRef; +struct HardReference::Traits { + using type = HardReference; }; -FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) SoftRef FLATBUFFERS_FINAL_CLASS { +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) SoftReference FLATBUFFERS_FINAL_CLASS { private: Flat::Bigfoot::UUID uuid_; public: struct Traits; static const ::flatbuffers::TypeTable *MiniReflectTypeTable() { - return SoftRefTypeTable(); + return SoftReferenceTypeTable(); } static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() { - return "Flat.Bigfoot.SoftRef"; + return "Flat.Bigfoot.SoftReference"; } - SoftRef() + SoftReference() : uuid_() { } - SoftRef(const Flat::Bigfoot::UUID &_uuid) + SoftReference(const Flat::Bigfoot::UUID &_uuid) : uuid_(_uuid) { } const Flat::Bigfoot::UUID &uuid() const { return uuid_; } }; -FLATBUFFERS_STRUCT_END(SoftRef, 16); +FLATBUFFERS_STRUCT_END(SoftReference, 16); -struct SoftRef::Traits { - using type = SoftRef; +struct SoftReference::Traits { + using type = SoftReference; }; -inline const ::flatbuffers::TypeTable *HardRefTypeTable() { +inline const ::flatbuffers::TypeTable *HardReferenceTypeTable() { static const ::flatbuffers::TypeCode type_codes[] = { { ::flatbuffers::ET_SEQUENCE, 0, 0 } }; @@ -103,7 +103,7 @@ inline const ::flatbuffers::TypeTable *HardRefTypeTable() { return &tt; } -inline const ::flatbuffers::TypeTable *SoftRefTypeTable() { +inline const ::flatbuffers::TypeTable *SoftReferenceTypeTable() { static const ::flatbuffers::TypeCode type_codes[] = { { ::flatbuffers::ET_SEQUENCE, 0, 0 } }; diff --git a/Bigfoot/Tests/Engine/Asset/Asset.cpp b/Bigfoot/Tests/Engine/Asset/Asset.cpp index a10316b..c0d4b11 100644 --- a/Bigfoot/Tests/Engine/Asset/Asset.cpp +++ b/Bigfoot/Tests/Engine/Asset/Asset.cpp @@ -106,9 +106,9 @@ TEST_F(AssetFixture, AssetBTests) AssetB assetB; assetB.SetName(nameB); assetB.SetVersion(versionB); - assetB.GetAsset().asset_a_ref = HardRef {assetA.GetHeader().uuid}; - assetB.GetAsset().asset_a_refs = {SoftRef {assetA.GetHeader().uuid}, - SoftRef {assetAA.GetHeader().uuid}}; + assetB.GetAsset().asset_a_ref = HardReference {assetA.GetHeader().uuid}; + assetB.GetAsset().asset_a_refs = {SoftReference {assetA.GetHeader().uuid}, + SoftReference {assetAA.GetHeader().uuid}}; const eastl::vector test = assetB.Save(); @@ -128,12 +128,12 @@ 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, HardRef {assetA.GetHeader().uuid}); + EXPECT_EQ(assetB.GetAsset().asset_a_ref, HardReference {assetA.GetHeader().uuid}); EXPECT_EQ(assetB.GetAsset().asset_a_ref, assetB_dup.GetAsset().asset_a_ref); EXPECT_EQ(assetB.GetAsset().asset_a_refs, - (eastl::vector> {SoftRef {assetA.GetHeader().uuid}, - SoftRef {assetAA.GetHeader().uuid}})); + (eastl::vector> {SoftReference {assetA.GetHeader().uuid}, + SoftReference {assetAA.GetHeader().uuid}})); EXPECT_EQ(assetB.GetAsset().asset_a_refs, assetB_dup.GetAsset().asset_a_refs); } @@ -169,9 +169,9 @@ TEST_F(AssetFixture, AssetCTests) AssetB assetB; assetB.SetName(nameB); assetB.SetVersion(versionB); - assetB.GetAsset().asset_a_ref = HardRef {assetA.GetHeader().uuid}; - assetB.GetAsset().asset_a_refs = {SoftRef {assetA.GetHeader().uuid}, - SoftRef {assetAA.GetHeader().uuid}}; + assetB.GetAsset().asset_a_ref = HardReference {assetA.GetHeader().uuid}; + assetB.GetAsset().asset_a_refs = {SoftReference {assetA.GetHeader().uuid}, + SoftReference {assetAA.GetHeader().uuid}}; constexpr eastl::string_view nameC = "General"; constexpr std::uint32_t versionC = 1; @@ -179,11 +179,11 @@ TEST_F(AssetFixture, AssetCTests) AssetC assetC; assetC.SetName(nameC); assetC.SetVersion(versionC); - assetC.GetAsset().inner_table->asset_a_ref = HardRef {assetA.GetHeader().uuid}; - assetC.GetAsset().inner_table->asset_a_refs = {HardRef {assetA.GetHeader().uuid}, - HardRef {assetAA.GetHeader().uuid}}; - assetC.GetAsset().asset_b_ref = HardRef {assetB.GetHeader().uuid}; - assetC.GetAsset().asset_b_refs = {SoftRef {assetB.GetHeader().uuid}}; + assetC.GetAsset().inner_table->asset_a_ref = HardReference {assetA.GetHeader().uuid}; + assetC.GetAsset().inner_table->asset_a_refs = {HardReference {assetA.GetHeader().uuid}, + HardReference {assetAA.GetHeader().uuid}}; + assetC.GetAsset().asset_b_ref = HardReference {assetB.GetHeader().uuid}; + assetC.GetAsset().asset_b_refs = {SoftReference {assetB.GetHeader().uuid}}; const eastl::vector test = assetC.Save(); @@ -203,23 +203,21 @@ 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, HardRef {assetB.GetHeader().uuid}); + EXPECT_EQ(assetC.GetAsset().asset_b_ref, HardReference {assetB.GetHeader().uuid}); EXPECT_EQ(assetC.GetAsset().asset_b_ref, assetC_dup.GetAsset().asset_b_ref); EXPECT_EQ(assetC.GetAsset().asset_b_refs, - (eastl::vector> {SoftRef {assetB.GetHeader().uuid}})); + (eastl::vector> {SoftReference {assetB.GetHeader().uuid}})); EXPECT_EQ(assetC.GetAsset().asset_b_refs, assetC_dup.GetAsset().asset_b_refs); - EXPECT_EQ(assetC.GetAsset().inner_table->asset_a_ref, HardRef {assetA.GetHeader().uuid}); + EXPECT_EQ(assetC.GetAsset().inner_table->asset_a_ref, HardReference {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_refs, - (eastl::vector> {HardRef {assetA.GetHeader().uuid}, - HardRef {assetAA.GetHeader().uuid}})); + (eastl::vector> {HardReference {assetA.GetHeader().uuid}, + HardReference {assetAA.GetHeader().uuid}})); EXPECT_EQ(assetC.GetAsset().inner_table->asset_a_refs, assetC_dup.GetAsset().inner_table->asset_a_refs); } -TEST_F(AssetFixture, MiniReflect) -{ -} +TEST_F(AssetFixture, MiniReflect) { } } // namespace Bigfoot diff --git a/Bigfoot/Tests/Engine/Asset/AssetContainer.cpp b/Bigfoot/Tests/Engine/Asset/AssetContainer.cpp deleted file mode 100644 index e69de29..0000000 diff --git a/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetA_fwd.hpp b/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetA_fwd.hpp index 5d58e5f..b00de9d 100644 --- a/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetA_fwd.hpp +++ b/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetA_fwd.hpp @@ -6,7 +6,7 @@ *********************************************************************/ #ifndef BIGFOOT_ENGINE_ASSETA_FWD_HPP #define BIGFOOT_ENGINE_ASSETA_FWD_HPP -#include +#include namespace Bigfoot { diff --git a/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetB.fbs b/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetB.fbs index 869c303..7819e1c 100644 --- a/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetB.fbs +++ b/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetB.fbs @@ -8,8 +8,8 @@ namespace Flat.Bigfoot; table AssetB { - asset_a_ref: Flat.Bigfoot.HardRef (native_type: "::Bigfoot::HardRef<::Bigfoot::AssetA>", native_inline, native_type_pack_name: "HardRefAssetA"); - asset_a_refs: [Flat.Bigfoot.SoftRef] (native_type: "::Bigfoot::SoftRef<::Bigfoot::AssetA>", native_inline, native_type_pack_name: "SoftRefAssetA"); + asset_a_ref: Flat.Bigfoot.HardReference (native_type: "::Bigfoot::HardReference<::Bigfoot::AssetA>", native_inline, native_type_pack_name: "HardReferenceAssetA"); + asset_a_refs: [Flat.Bigfoot.SoftReference] (native_type: "::Bigfoot::SoftReference<::Bigfoot::AssetA>", native_inline, native_type_pack_name: "SoftReferenceAssetA"); } root_type AssetB; \ No newline at end of file diff --git a/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetB_fwd.hpp b/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetB_fwd.hpp index 5171d6e..d9d102d 100644 --- a/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetB_fwd.hpp +++ b/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetB_fwd.hpp @@ -6,7 +6,7 @@ *********************************************************************/ #ifndef BIGFOOT_ENGINE_ASSETB_FWD_HPP #define BIGFOOT_ENGINE_ASSETB_FWD_HPP -#include +#include namespace Bigfoot { diff --git a/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetB_generated.hpp b/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetB_generated.hpp index 9d1b01a..96d8cef 100644 --- a/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetB_generated.hpp +++ b/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetB_generated.hpp @@ -39,8 +39,8 @@ struct AssetBT : public ::flatbuffers::NativeTable { static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() { return "Flat.Bigfoot.AssetBT"; } - ::Bigfoot::HardRef<::Bigfoot::AssetA> asset_a_ref{}; - eastl::vector<::Bigfoot::SoftRef<::Bigfoot::AssetA>> asset_a_refs{}; + ::Bigfoot::HardReference<::Bigfoot::AssetA> asset_a_ref{}; + eastl::vector<::Bigfoot::SoftReference<::Bigfoot::AssetA>> asset_a_refs{}; }; struct AssetB FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { @@ -57,16 +57,16 @@ struct AssetB FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { VT_ASSET_A_REF = 4, VT_ASSET_A_REFS = 6 }; - const Flat::Bigfoot::HardRef *asset_a_ref() const { - return GetStruct(VT_ASSET_A_REF); + const Flat::Bigfoot::HardReference *asset_a_ref() const { + return GetStruct(VT_ASSET_A_REF); } - const ::flatbuffers::Vector *asset_a_refs() const { - return GetPointer *>(VT_ASSET_A_REFS); + const ::flatbuffers::Vector *asset_a_refs() const { + return GetPointer *>(VT_ASSET_A_REFS); } template bool Verify(::flatbuffers::VerifierTemplate &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_ASSET_A_REF, 1) && + VerifyField(verifier, VT_ASSET_A_REF, 1) && VerifyOffset(verifier, VT_ASSET_A_REFS) && verifier.VerifyVector(asset_a_refs()) && verifier.EndTable(); @@ -80,10 +80,10 @@ struct AssetBBuilder { typedef AssetB Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; - void add_asset_a_ref(const Flat::Bigfoot::HardRef *asset_a_ref) { + void add_asset_a_ref(const Flat::Bigfoot::HardReference *asset_a_ref) { fbb_.AddStruct(AssetB::VT_ASSET_A_REF, asset_a_ref); } - void add_asset_a_refs(::flatbuffers::Offset<::flatbuffers::Vector> asset_a_refs) { + void add_asset_a_refs(::flatbuffers::Offset<::flatbuffers::Vector> asset_a_refs) { fbb_.AddOffset(AssetB::VT_ASSET_A_REFS, asset_a_refs); } explicit AssetBBuilder(::flatbuffers::FlatBufferBuilder &_fbb) @@ -99,8 +99,8 @@ struct AssetBBuilder { inline ::flatbuffers::Offset CreateAssetB( ::flatbuffers::FlatBufferBuilder &_fbb, - const Flat::Bigfoot::HardRef *asset_a_ref = nullptr, - ::flatbuffers::Offset<::flatbuffers::Vector> asset_a_refs = 0) { + const Flat::Bigfoot::HardReference *asset_a_ref = nullptr, + ::flatbuffers::Offset<::flatbuffers::Vector> asset_a_refs = 0) { AssetBBuilder builder_(_fbb); builder_.add_asset_a_refs(asset_a_refs); builder_.add_asset_a_ref(asset_a_ref); @@ -123,8 +123,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 = asset_a_ref(); if (_e) _o->asset_a_ref = ::flatbuffers::UnPackHardRefAssetA(*_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::UnPackSoftRefAssetA(*_e->Get(_i)); } } else { _o->asset_a_refs.resize(0); } } + { 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::UnPackSoftReferenceAssetA(*_e->Get(_i)); } } else { _o->asset_a_refs.resize(0); } } } inline ::flatbuffers::Offset CreateAssetB(::flatbuffers::FlatBufferBuilder &_fbb, const AssetBT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { @@ -135,8 +135,8 @@ inline ::flatbuffers::Offset 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 _asset_a_ref = ::flatbuffers::PackHardRefAssetA(_o->asset_a_ref); - auto _asset_a_refs = _fbb.CreateVectorOfNativeStructs>(_o->asset_a_refs.data(), _o->asset_a_refs.size(), ::flatbuffers::PackSoftRefAssetA); + auto _asset_a_ref = ::flatbuffers::PackHardReferenceAssetA(_o->asset_a_ref); + auto _asset_a_refs = _fbb.CreateVectorOfNativeStructs>(_o->asset_a_refs.data(), _o->asset_a_refs.size(), ::flatbuffers::PackSoftReferenceAssetA); return Flat::Bigfoot::CreateAssetB( _fbb, &_asset_a_ref, @@ -149,8 +149,8 @@ inline const ::flatbuffers::TypeTable *AssetBTypeTable() { { ::flatbuffers::ET_SEQUENCE, 1, 1 } }; static const ::flatbuffers::TypeFunction type_refs[] = { - Flat::Bigfoot::HardRefTypeTable, - Flat::Bigfoot::SoftRefTypeTable + Flat::Bigfoot::HardReferenceTypeTable, + Flat::Bigfoot::SoftReferenceTypeTable }; static const ::flatbuffers::TypeTable tt = { ::flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, nullptr diff --git a/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetC.fbs b/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetC.fbs index 9e2da2b..9106333 100644 --- a/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetC.fbs +++ b/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetC.fbs @@ -9,16 +9,16 @@ namespace Flat.Bigfoot; table InnerTable { - asset_a_ref: Flat.Bigfoot.HardRef (native_type: "::Bigfoot::HardRef<::Bigfoot::AssetA>", native_inline, native_type_pack_name: "HardRefAssetA"); - asset_a_refs: [Flat.Bigfoot.HardRef] (native_type: "::Bigfoot::HardRef<::Bigfoot::AssetA>", native_inline, native_type_pack_name: "HardRefAssetA"); + asset_a_ref: Flat.Bigfoot.HardReference (native_type: "::Bigfoot::HardReference<::Bigfoot::AssetA>", native_inline, native_type_pack_name: "HardReferenceAssetA"); + asset_a_refs: [Flat.Bigfoot.HardReference] (native_type: "::Bigfoot::HardReference<::Bigfoot::AssetA>", native_inline, native_type_pack_name: "HardReferenceAssetA"); } table AssetC { inner_table: InnerTable (required); - asset_b_ref: Flat.Bigfoot.HardRef (native_type: "::Bigfoot::HardRef<::Bigfoot::AssetB>", native_inline, native_type_pack_name: "HardRefAssetB"); - asset_b_refs: [Flat.Bigfoot.SoftRef] (native_type: "::Bigfoot::SoftRef<::Bigfoot::AssetB>", native_inline, native_type_pack_name: "SoftRefAssetB"); + asset_b_ref: Flat.Bigfoot.HardReference (native_type: "::Bigfoot::HardReference<::Bigfoot::AssetB>", native_inline, native_type_pack_name: "HardReferenceAssetB"); + asset_b_refs: [Flat.Bigfoot.SoftReference] (native_type: "::Bigfoot::SoftReference<::Bigfoot::AssetB>", native_inline, native_type_pack_name: "SoftReferenceAssetB"); } root_type AssetC; \ No newline at end of file diff --git a/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetC_fwd.hpp b/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetC_fwd.hpp index 3f71b53..ac699e3 100644 --- a/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetC_fwd.hpp +++ b/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetC_fwd.hpp @@ -6,7 +6,7 @@ *********************************************************************/ #ifndef BIGFOOT_ENGINE_ASSETC_FWD_HPP #define BIGFOOT_ENGINE_ASSETC_FWD_HPP -#include +#include namespace Bigfoot { diff --git a/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetC_generated.hpp b/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetC_generated.hpp index 294c371..d34da2d 100644 --- a/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetC_generated.hpp +++ b/Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetC_generated.hpp @@ -47,8 +47,8 @@ struct InnerTableT : public ::flatbuffers::NativeTable { static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() { return "Flat.Bigfoot.InnerTableT"; } - ::Bigfoot::HardRef<::Bigfoot::AssetA> asset_a_ref{}; - eastl::vector<::Bigfoot::HardRef<::Bigfoot::AssetA>> asset_a_refs{}; + ::Bigfoot::HardReference<::Bigfoot::AssetA> asset_a_ref{}; + eastl::vector<::Bigfoot::HardReference<::Bigfoot::AssetA>> asset_a_refs{}; }; struct InnerTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { @@ -65,16 +65,16 @@ struct InnerTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { VT_ASSET_A_REF = 4, VT_ASSET_A_REFS = 6 }; - const Flat::Bigfoot::HardRef *asset_a_ref() const { - return GetStruct(VT_ASSET_A_REF); + const Flat::Bigfoot::HardReference *asset_a_ref() const { + return GetStruct(VT_ASSET_A_REF); } - const ::flatbuffers::Vector *asset_a_refs() const { - return GetPointer *>(VT_ASSET_A_REFS); + const ::flatbuffers::Vector *asset_a_refs() const { + return GetPointer *>(VT_ASSET_A_REFS); } template bool Verify(::flatbuffers::VerifierTemplate &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_ASSET_A_REF, 1) && + VerifyField(verifier, VT_ASSET_A_REF, 1) && VerifyOffset(verifier, VT_ASSET_A_REFS) && verifier.VerifyVector(asset_a_refs()) && verifier.EndTable(); @@ -88,10 +88,10 @@ struct InnerTableBuilder { typedef InnerTable Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; - void add_asset_a_ref(const Flat::Bigfoot::HardRef *asset_a_ref) { + 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> asset_a_refs) { + void add_asset_a_refs(::flatbuffers::Offset<::flatbuffers::Vector> asset_a_refs) { fbb_.AddOffset(InnerTable::VT_ASSET_A_REFS, asset_a_refs); } explicit InnerTableBuilder(::flatbuffers::FlatBufferBuilder &_fbb) @@ -107,8 +107,8 @@ struct InnerTableBuilder { inline ::flatbuffers::Offset CreateInnerTable( ::flatbuffers::FlatBufferBuilder &_fbb, - const Flat::Bigfoot::HardRef *asset_a_ref = nullptr, - ::flatbuffers::Offset<::flatbuffers::Vector> asset_a_refs = 0) { + const Flat::Bigfoot::HardReference *asset_a_ref = nullptr, + ::flatbuffers::Offset<::flatbuffers::Vector> asset_a_refs = 0) { InnerTableBuilder builder_(_fbb); builder_.add_asset_a_refs(asset_a_refs); builder_.add_asset_a_ref(asset_a_ref); @@ -128,8 +128,8 @@ struct AssetCT : public ::flatbuffers::NativeTable { return "Flat.Bigfoot.AssetCT"; } eastl::unique_ptr inner_table{}; - ::Bigfoot::HardRef<::Bigfoot::AssetB> asset_b_ref{}; - eastl::vector<::Bigfoot::SoftRef<::Bigfoot::AssetB>> asset_b_refs{}; + ::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; @@ -154,18 +154,18 @@ struct AssetC FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { const Flat::Bigfoot::InnerTable *inner_table() const { return GetPointer(VT_INNER_TABLE); } - const Flat::Bigfoot::HardRef *asset_b_ref() const { - return GetStruct(VT_ASSET_B_REF); + const Flat::Bigfoot::HardReference *asset_b_ref() const { + return GetStruct(VT_ASSET_B_REF); } - const ::flatbuffers::Vector *asset_b_refs() const { - return GetPointer *>(VT_ASSET_B_REFS); + const ::flatbuffers::Vector *asset_b_refs() const { + return GetPointer *>(VT_ASSET_B_REFS); } template bool Verify(::flatbuffers::VerifierTemplate &verifier) const { return VerifyTableStart(verifier) && VerifyOffsetRequired(verifier, VT_INNER_TABLE) && verifier.VerifyTable(inner_table()) && - VerifyField(verifier, VT_ASSET_B_REF, 1) && + VerifyField(verifier, VT_ASSET_B_REF, 1) && VerifyOffset(verifier, VT_ASSET_B_REFS) && verifier.VerifyVector(asset_b_refs()) && verifier.EndTable(); @@ -182,10 +182,10 @@ struct AssetCBuilder { void add_inner_table(::flatbuffers::Offset inner_table) { fbb_.AddOffset(AssetC::VT_INNER_TABLE, inner_table); } - void add_asset_b_ref(const Flat::Bigfoot::HardRef *asset_b_ref) { + 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> asset_b_refs) { + void add_asset_b_refs(::flatbuffers::Offset<::flatbuffers::Vector> asset_b_refs) { fbb_.AddOffset(AssetC::VT_ASSET_B_REFS, asset_b_refs); } explicit AssetCBuilder(::flatbuffers::FlatBufferBuilder &_fbb) @@ -203,8 +203,8 @@ struct AssetCBuilder { inline ::flatbuffers::Offset CreateAssetC( ::flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::Offset inner_table = 0, - const Flat::Bigfoot::HardRef *asset_b_ref = nullptr, - ::flatbuffers::Offset<::flatbuffers::Vector> asset_b_refs = 0) { + const Flat::Bigfoot::HardReference *asset_b_ref = nullptr, + ::flatbuffers::Offset<::flatbuffers::Vector> asset_b_refs = 0) { AssetCBuilder builder_(_fbb); builder_.add_asset_b_refs(asset_b_refs); builder_.add_asset_b_ref(asset_b_ref); @@ -228,8 +228,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::UnPackHardRefAssetA(*_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::UnPackHardRefAssetA(*_e->Get(_i)); } } else { _o->asset_a_refs.resize(0); } } + { 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 CreateInnerTable(::flatbuffers::FlatBufferBuilder &_fbb, const InnerTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { @@ -240,8 +240,8 @@ inline ::flatbuffers::Offset 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::PackHardRefAssetA(_o->asset_a_ref); - auto _asset_a_refs = _fbb.CreateVectorOfNativeStructs>(_o->asset_a_refs.data(), _o->asset_a_refs.size(), ::flatbuffers::PackHardRefAssetA); + auto _asset_a_ref = ::flatbuffers::PackHardReferenceAssetA(_o->asset_a_ref); + auto _asset_a_refs = _fbb.CreateVectorOfNativeStructs>(_o->asset_a_refs.data(), _o->asset_a_refs.size(), ::flatbuffers::PackHardReferenceAssetA); return Flat::Bigfoot::CreateInnerTable( _fbb, &_asset_a_ref, @@ -271,8 +271,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(_e->UnPack(_resolver)); } } else if (_o->inner_table) { _o->inner_table.reset(); } } - { auto _e = asset_b_ref(); if (_e) _o->asset_b_ref = ::flatbuffers::UnPackHardRefAssetB(*_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::UnPackSoftRefAssetB(*_e->Get(_i)); } } else { _o->asset_b_refs.resize(0); } } + { 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 CreateAssetC(::flatbuffers::FlatBufferBuilder &_fbb, const AssetCT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { @@ -284,8 +284,8 @@ inline ::flatbuffers::Offset 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::PackHardRefAssetB(_o->asset_b_ref); - auto _asset_b_refs = _fbb.CreateVectorOfNativeStructs>(_o->asset_b_refs.data(), _o->asset_b_refs.size(), ::flatbuffers::PackSoftRefAssetB); + auto _asset_b_ref = ::flatbuffers::PackHardReferenceAssetB(_o->asset_b_ref); + auto _asset_b_refs = _fbb.CreateVectorOfNativeStructs>(_o->asset_b_refs.data(), _o->asset_b_refs.size(), ::flatbuffers::PackSoftReferenceAssetB); return Flat::Bigfoot::CreateAssetC( _fbb, _inner_table, @@ -299,7 +299,7 @@ inline const ::flatbuffers::TypeTable *InnerTableTypeTable() { { ::flatbuffers::ET_SEQUENCE, 1, 0 } }; static const ::flatbuffers::TypeFunction type_refs[] = { - Flat::Bigfoot::HardRefTypeTable + Flat::Bigfoot::HardReferenceTypeTable }; static const ::flatbuffers::TypeTable tt = { ::flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, nullptr @@ -315,8 +315,8 @@ inline const ::flatbuffers::TypeTable *AssetCTypeTable() { }; static const ::flatbuffers::TypeFunction type_refs[] = { Flat::Bigfoot::InnerTableTypeTable, - Flat::Bigfoot::HardRefTypeTable, - Flat::Bigfoot::SoftRefTypeTable + Flat::Bigfoot::HardReferenceTypeTable, + Flat::Bigfoot::SoftReferenceTypeTable }; static const ::flatbuffers::TypeTable tt = { ::flatbuffers::ST_TABLE, 3, type_codes, type_refs, nullptr, nullptr, nullptr