BiomeRegistry.h

#pragma once
 
#include "mc/_HeaderOutputPredefine.h"
#include "mc/world/level/biome/components/vanilla/VanillaBiomeTypes.h"
 
// auto generated inclusion list
#include "mc/deps/core/utility/EnableNonOwnerReferences.h"
#include "mc/deps/core/utility/NonOwnerPointer.h"
#include "mc/deps/core/utility/pub_sub/Subscription.h"
#include "mc/platform/brstd/flat_set.h"
#include "mc/platform/brstd/function_ref.h"
#include "mc/util/IDType.h"
#include "mc/util/TagRegistry.h"
#include "mc/world/level/biome/registry/WellKnownBiomeTags.h"
 
// auto generated forward declare list
// clang-format off
class BaseGameVersion;
class Biome;
class HashedString;
class ILevelStorageManagerConnector;
class IWorldRegistriesProvider;
class LevelStorage;
class LinkedAssetValidator;
class ResourcePackManager;
class WellKnownTagID;
struct BiomeHashType;
struct BiomeIdType;
struct BiomeJsonDocumentGlue;
struct BiomeJsonDocumentGlueResolvedBiomeData;
struct BiomeTagIDType;
struct BiomeTagSetIDType;
struct DimensionType;
namespace cereal { struct ReflectionCtx; }
// clang-format on
 
class BiomeRegistry : public ::Bedrock::EnableNonOwnerReferences {
public:
    // BiomeRegistry inner types declare
    // clang-format off
    struct BiomeComparator;
    struct LoadedBiomeDocument;
    struct SeasonTextureRowSettings;
    // clang-format on
 
    // BiomeRegistry inner types define
    struct BiomeComparator {
    public:
        // BiomeComparator inner types define
        using is_transparent = void;
    };
 
    struct LoadedBiomeDocument {};
 
    struct SeasonTextureRowSettings {
    public:
        // member variables
        // NOLINTBEGIN
        ::ll::TypedStorage<4, 4, float> mTemperature;
        ::ll::TypedStorage<4, 4, float> mDownfall;
        ::ll::TypedStorage<4, 4, float> mFoliageSnow;
        // NOLINTEND
    };
 
    using BiomeNameLookupMap = ::std::unordered_map<uint64, ::std::unique_ptr<::Biome>>;
 
public:
    // member variables
    // NOLINTBEGIN
    ::ll::TypedStorage<8, 128, ::TagRegistry<::IDType<::BiomeTagIDType>, ::IDType<::BiomeTagSetIDType>>> mTagRegistry;
    ::ll::TypedStorage<8, 720, ::WellKnownBiomeTags const>                              mWellKnownBiomeTags;
    ::ll::TypedStorage<1, 1, bool>                                                      mSurfaceBuildersResolved;
    ::ll::TypedStorage<1, 1, bool>                                                      mClientInitialized;
    ::ll::TypedStorage<8, 64, ::std::unordered_map<uint64, ::std::unique_ptr<::Biome>>> mBiomesByName;
    ::ll::TypedStorage<
        8,
        24,
        ::brstd::flat_set<
            ::gsl::not_null<::Biome*>,
            ::BiomeRegistry::BiomeComparator,
            ::std::vector<::gsl::not_null<::Biome*>>>>
        mBiomesById;
    ::ll::TypedStorage<8, 24, ::std::vector<::std::pair<::BiomeIdType const, ::std::string const&>>>
                                                               mRemovedBiomesIdAndFullName;
    ::ll::TypedStorage<4, 4, uint>                             mNextCustomBiomeId;
    ::ll::TypedStorage<1, 1, ::std::atomic<bool>>              mClosedForRegistration;
    ::ll::TypedStorage<8, 8, ::Biome*>                         mEmptyBiome;
    ::ll::TypedStorage<8, 16, ::Bedrock::PubSub::Subscription> mOnSaveSubscription;
    ::ll::TypedStorage<8, 16, ::Bedrock::PubSub::Subscription> mOnLevelStorageManagerStartLeaveGameSubscription;
    ::ll::TypedStorage<8, 24, ::std::vector<::BiomeRegistry::SeasonTextureRowSettings>> mSeasonTextureRowSettings;
    // NOLINTEND
 
public:
    // virtual functions
    // NOLINTBEGIN
    virtual ~BiomeRegistry() /*override*/;
    // NOLINTEND
 
public:
    // member functions
    // NOLINTBEGIN
    MCAPI BiomeRegistry();
 
    MCAPI void _forEachExistingBiomeAndRemovedBiome(
        ::brstd::function_ref<void(::BiomeIdType, ::std::string const&)> callback
    ) const;
 
    MCAPI ::Biome& _register(::std::string_view name, ::BiomeIdType id);
 
    MCAPI void _save(::LevelStorage& levelStorage) const;
 
#ifdef LL_PLAT_C
    MCAPI
        uint64 assignSeasonTextureRow(::BiomeRegistry::SeasonTextureRowSettings const& desiredSettings, uint64 maxSize);
#endif
 
    MCAPI bool biomeAddTag(::Biome& biome, ::HashedString tag);
 
    MCAPI ::std::vector<::std::string> const biomeGetTags(::Biome const& biome) const;
 
    MCAPI bool biomeHasTag(::Biome const& biome, ::HashedString const& id) const;
 
    MCAPI bool biomeHasTag(::Biome const& biome, uint64 tagHash) const;
 
    MCFOLD bool biomeHasTag(::Biome const& biome, ::IDType<::BiomeTagIDType> const& tagID) const;
 
    MCFOLD bool biomeHasTag(::Biome const& biome, ::WellKnownTagID const& tagID) const;
 
    MCFOLD void forEachBiome(::brstd::function_ref<void(::Biome const&)> callback) const;
 
    MCFOLD void forEachNonConstBiome(::brstd::function_ref<void(::Biome&)> callback);
 
    MCAPI ::std::vector<::Biome const*> getBiomesInDimension(::DimensionType type) const;
 
#ifdef LL_PLAT_C
    MCFOLD ::std::vector<::BiomeRegistry::SeasonTextureRowSettings> const& getSeasonTextureRowSettings() const;
 
    MCFOLD ::std::vector<::BiomeRegistry::SeasonTextureRowSettings>& getSeasonTextureRowSettings();
#endif
 
    MCFOLD ::TagRegistry<::IDType<::BiomeTagIDType>, ::IDType<::BiomeTagSetIDType>> const& getTagRegistry() const;
 
#ifdef LL_PLAT_C
    MCFOLD ::TagRegistry<::IDType<::BiomeTagIDType>, ::IDType<::BiomeTagSetIDType>>& getTagRegistry();
#endif
 
    MCAPI void initServerFromPacks(
        ::IWorldRegistriesProvider& worldRegistries,
        ::Bedrock::NonOwnerPointer<::LinkedAssetValidator>,
        ::std::unordered_map<::std::string, ::std::unique_ptr<::BiomeJsonDocumentGlueResolvedBiomeData>>&
            biomeIdToResolvedData
    );
 
    MCAPI void
    initializeWithLevelStorageManagerConnector(::ILevelStorageManagerConnector& levelStorageManagerConnector);
 
    MCAPI bool isRegistrationFinished() const;
 
    MCAPI void loadAllBiomeDocuments(
        ::ResourcePackManager const&                       loader,
        ::cereal::ReflectionCtx&                           ctx,
        ::Bedrock::NonOwnerPointer<::LinkedAssetValidator> linkedAssetValidator,
        ::BaseGameVersion const&                           baseGameVersion,
        ::BiomeJsonDocumentGlue&                           biomeJsonDocumentGlue,
        ::std::unordered_map<::std::string, ::std::unique_ptr<::BiomeJsonDocumentGlueResolvedBiomeData>>&
             biomeIdToResolvedData,
        bool betaApis
    );
 
    MCAPI void loadBiomeData(::LevelStorage const& levelStorage);
 
    MCAPI void loadBiomeTable(::LevelStorage const& levelStorage);
 
#ifdef LL_PLAT_C
    MCAPI ::Biome const* lookupByHash(::HashedString const& hash) const;
#endif
 
    MCFOLD ::Biome const* lookupByHashId(::BiomeHashType id) const;
 
    MCFOLD ::Biome* lookupByHashId(::BiomeHashType id);
 
    MCFOLD ::Biome const* lookupById(::BiomeIdType id) const;
 
    MCFOLD ::Biome* lookupById(::BiomeIdType id);
 
    MCFOLD ::Biome const* lookupByName(::std::string const& name) const;
 
    MCFOLD ::Biome* lookupByName(::std::string const& name);
 
    MCAPI ::Biome& registerBiomeWithExplicitId(::std::string_view name, ::BiomeIdType id);
 
    MCAPI ::Biome& registerCustomBiome(::std::string_view name);
 
    MCAPI void registrationFinished();
 
    MCAPI void removeFailedToLoadBiomes();
 
    MCAPI void saveBiomeTable(::LevelStorage& levelStorage) const;
    // NOLINTEND
 
public:
    // constructor thunks
    // NOLINTBEGIN
    MCAPI void* $ctor();
    // NOLINTEND
 
public:
    // destructor thunk
    // NOLINTBEGIN
    MCAPI void $dtor();
    // NOLINTEND
 
public:
    // vftables
    // NOLINTBEGIN
    MCNAPI static void** $vftable();
    // NOLINTEND
};