diff --git a/Bigfoot/Sources/Engine/Include/Engine/Asset/Asset.hpp b/Bigfoot/Sources/Engine/Include/Engine/Asset/Asset.hpp index 01618c3..31eff7e 100644 --- a/Bigfoot/Sources/Engine/Include/Engine/Asset/Asset.hpp +++ b/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() { diff --git a/Bigfoot/Sources/Engine/Include/Engine/Asset/AssetHelper.hpp b/Bigfoot/Sources/Engine/Include/Engine/Asset/AssetHelper.hpp index d7496ab..c4aa601 100644 --- a/Bigfoot/Sources/Engine/Include/Engine/Asset/AssetHelper.hpp +++ b/Bigfoot/Sources/Engine/Include/Engine/Asset/AssetHelper.hpp @@ -9,7 +9,7 @@ #include #include -#define ASSET_CONTAINER(AssetName, AssetType) \ +#define ASSET_CONTAINER(AssetName, AssetType) \ namespace Bigfoot \ { \ AssetContainer g_containerFor##AssetName; \ diff --git a/Bigfoot/Sources/Engine/Include/Engine/Asset/Reference.fbs b/Bigfoot/Sources/Engine/Include/Engine/Asset/Reference.fbs new file mode 100644 index 0000000..2b69919 --- /dev/null +++ b/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; +} \ 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 94d7c9c..e4952f5 100644 --- a/Bigfoot/Sources/Engine/Include/Engine/Asset/Reference.hpp +++ b/Bigfoot/Sources/Engine/Include/Engine/Asset/Reference.hpp @@ -82,7 +82,7 @@ class HardReference private: void Acquire() { - if (AssetContainer* assetContainer = g_assetLibrary.Get() ; assetContainer && m_uuid) + if (AssetContainer* assetContainer = g_assetLibrary.Get(); assetContainer && m_uuid) { if (!m_slotKey.Valid()) { diff --git a/Bigfoot/Sources/Engine/Include/Engine/Asset/Reference_generated.hpp b/Bigfoot/Sources/Engine/Include/Engine/Asset/Reference_generated.hpp new file mode 100644 index 0000000..1d28c7e --- /dev/null +++ b/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_ diff --git a/Bigfoot/Tests/Engine/Asset/Asset.cpp b/Bigfoot/Tests/Engine/Asset/Asset.cpp index ee6cbc1..53976d7 100644 --- a/Bigfoot/Tests/Engine/Asset/Asset.cpp +++ b/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.GetHeader().uuid}; - //assetB.GetAsset().asset_a_refs = {SoftReference {assetA.GetHeader().uuid}, - // SoftReference {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(); @@ -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.GetHeader().uuid}); - //EXPECT_EQ(assetB.GetAsset().asset_a_ref, assetB_dup.GetAsset().asset_a_ref); + // 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> {SoftReference {assetA.GetHeader().uuid}, - // SoftReference {assetAA.GetHeader().uuid}})); - //EXPECT_EQ(assetB.GetAsset().asset_a_refs, assetB_dup.GetAsset().asset_a_refs); + // EXPECT_EQ(assetB.GetAsset().asset_a_refs, + // (eastl::vector> {SoftReference {assetA.GetHeader().uuid}, + // SoftReference {assetAA.GetHeader().uuid}})); + // 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.GetHeader().uuid}; - //assetB.GetAsset().asset_a_refs = {SoftReference {assetA.GetHeader().uuid}, - // SoftReference {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; @@ -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.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}}; + // 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(); @@ -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.GetHeader().uuid}); - //EXPECT_EQ(assetC.GetAsset().asset_b_ref, assetC_dup.GetAsset().asset_b_ref); + // 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> {SoftReference {assetB.GetHeader().uuid}})); - //EXPECT_EQ(assetC.GetAsset().asset_b_refs, assetC_dup.GetAsset().asset_b_refs); + // EXPECT_EQ(assetC.GetAsset().asset_b_refs, + // (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, 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_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> {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); + // EXPECT_EQ(assetC.GetAsset().inner_table->asset_a_refs, + // (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); } } // namespace Bigfoot diff --git a/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetA.fbs b/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetA.fbs index 5dcd580..3f12528 100644 --- a/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetA.fbs +++ b/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; \ No newline at end of file diff --git a/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetA.hpp b/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetA.hpp index 5d56027..7d172f2 100644 --- a/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetA.hpp +++ b/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 - #include +#include + namespace Bigfoot { struct AssetATraits @@ -30,7 +30,7 @@ class AssetA: public Asset 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; diff --git a/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetA_generated.hpp b/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetA_generated.hpp index 22cf352..adff89d 100644 --- a/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetA_generated.hpp +++ b/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(VT_HEALTH, 0); @@ -55,11 +61,15 @@ struct AssetA FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { uint32_t mana() const { return GetField(VT_MANA, 0); } + const Flat::Bigfoot::SoftReference *ref_a() const { + return GetStruct(VT_REF_A); + } template bool Verify(::flatbuffers::VerifierTemplate &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_HEALTH, 4) && VerifyField(verifier, VT_MANA, 4) && + VerifyField(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(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 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 CreateAssetA(::flatbuffers::FlatBufferBuilder &_fbb, const AssetAT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { @@ -128,19 +144,25 @@ inline ::flatbuffers::Offset 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; } diff --git a/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetB.fbs b/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetB.fbs index 22ab30d..5026764 100644 --- a/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetB.fbs +++ b/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; \ No newline at end of file diff --git a/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetB.hpp b/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetB.hpp index 7aef595..4df701d 100644 --- a/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetB.hpp +++ b/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 - #include +#include + namespace Bigfoot { struct AssetBTraits @@ -30,7 +30,7 @@ class AssetB: public Asset 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; diff --git a/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetB_generated.hpp b/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetB_generated.hpp index 0971e31..8c620f5 100644 --- a/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetB_generated.hpp +++ b/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(VT_REF_A); + } + const ::flatbuffers::Vector *refs_a() const { + return GetPointer *>(VT_REFS_A); + } template bool Verify(::flatbuffers::VerifierTemplate &verifier) const { return VerifyTableStart(verifier) && + VerifyField(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> 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 CreateAssetB( - ::flatbuffers::FlatBufferBuilder &_fbb) { + ::flatbuffers::FlatBufferBuilder &_fbb, + const Flat::Bigfoot::HardReference *ref_a = nullptr, + ::flatbuffers::Offset<::flatbuffers::Vector> 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 CreateAssetB(::flatbuffers::FlatBufferBuilder &_fbb, const AssetBT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { @@ -102,13 +131,25 @@ 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 _ref_a = ::flatbuffers::PackHardReferenceAssetA(_o->ref_a); + auto _refs_a = _fbb.CreateVectorOfNativeStructs>(_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; } diff --git a/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetC.fbs b/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetC.fbs index 7374f65..cae5c61 100644 --- a/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetC.fbs +++ b/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetC.fbs @@ -1,15 +1,19 @@ -include "AssetsForTesting/Asset/AssetA.fbs"; -include "AssetsForTesting/Asset/AssetB.fbs"; +include "Engine/Asset/Reference.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; \ No newline at end of file diff --git a/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetC.hpp b/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetC.hpp index 36953d8..5b8557c 100644 --- a/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetC.hpp +++ b/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 - #include +#include + namespace Bigfoot { struct AssetCTraits @@ -33,7 +33,7 @@ class AssetC: public Asset 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; diff --git a/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetC_generated.hpp b/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetC_generated.hpp index 6f60966..e5a57cf 100644 --- a/Bigfoot/Tests/Misc/AssetsForTesting/Include/AssetsForTesting/Asset/AssetC_generated.hpp +++ b/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 "AssetsForTesting/Asset/AssetB_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" @@ -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(VT_ASSET_A_REF); + } + 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) && + 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> 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 CreateInnerTable( - ::flatbuffers::FlatBufferBuilder &_fbb) { + ::flatbuffers::FlatBufferBuilder &_fbb, + 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); return builder_.Finish(); } @@ -96,6 +122,8 @@ struct AssetCT : public ::flatbuffers::NativeTable { return "Flat.Bigfoot.AssetCT"; } eastl::unique_ptr 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(VT_INNER_TABLE); } + 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); + } 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) && + 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 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> 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 CreateAssetC( ::flatbuffers::FlatBufferBuilder &_fbb, - ::flatbuffers::Offset inner_table = 0) { + ::flatbuffers::Offset inner_table = 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); 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 CreateInnerTable(::flatbuffers::FlatBufferBuilder &_fbb, const InnerTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { @@ -183,16 +234,24 @@ 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::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); + _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(_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 CreateAssetC(::flatbuffers::FlatBufferBuilder &_fbb, const AssetCT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { @@ -217,27 +278,42 @@ 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::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); + _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; }