File size: 5,468 Bytes
7fd553e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 | // Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
#include "Engine/AssetManager.h"
#include "LyraAssetManagerStartupJob.h"
#include "Templates/SubclassOf.h"
#include "LyraAssetManager.generated.h"
#define UE_API LYRAGAME_API
class UPrimaryDataAsset;
class ULyraGameData;
class ULyraPawnData;
struct FLyraBundles
{
static const FName Equipped;
};
/**
* ULyraAssetManager
*
* Game implementation of the asset manager that overrides functionality and stores game-specific types.
* It is expected that most games will want to override AssetManager as it provides a good place for game-specific loading logic.
* This class is used by setting 'AssetManagerClassName' in DefaultEngine.ini.
*/
UCLASS(MinimalAPI, Config = Game)
class ULyraAssetManager : public UAssetManager
{
GENERATED_BODY()
public:
UE_API ULyraAssetManager();
// Returns the AssetManager singleton object.
static UE_API ULyraAssetManager& Get();
// Returns the asset referenced by a TSoftObjectPtr. This will synchronously load the asset if it's not already loaded.
template<typename AssetType>
static AssetType* GetAsset(const TSoftObjectPtr<AssetType>& AssetPointer, bool bKeepInMemory = true);
// Returns the subclass referenced by a TSoftClassPtr. This will synchronously load the asset if it's not already loaded.
template<typename AssetType>
static TSubclassOf<AssetType> GetSubclass(const TSoftClassPtr<AssetType>& AssetPointer, bool bKeepInMemory = true);
// Logs all assets currently loaded and tracked by the asset manager.
static UE_API void DumpLoadedAssets();
UE_API const ULyraGameData& GetGameData();
UE_API const ULyraPawnData* GetDefaultPawnData() const;
protected:
template <typename GameDataClass>
const GameDataClass& GetOrLoadTypedGameData(const TSoftObjectPtr<GameDataClass>& DataPath)
{
if (TObjectPtr<UPrimaryDataAsset> const * pResult = GameDataMap.Find(GameDataClass::StaticClass()))
{
return *CastChecked<GameDataClass>(*pResult);
}
// Does a blocking load if needed
return *CastChecked<const GameDataClass>(LoadGameDataOfClass(GameDataClass::StaticClass(), DataPath, GameDataClass::StaticClass()->GetFName()));
}
static UE_API UObject* SynchronousLoadAsset(const FSoftObjectPath& AssetPath);
static UE_API bool ShouldLogAssetLoads();
// Thread safe way of adding a loaded asset to keep in memory.
UE_API void AddLoadedAsset(const UObject* Asset);
//~UAssetManager interface
UE_API virtual void StartInitialLoading() override;
#if WITH_EDITOR
UE_API virtual void PreBeginPIE(bool bStartSimulate) override;
#endif
//~End of UAssetManager interface
UE_API UPrimaryDataAsset* LoadGameDataOfClass(TSubclassOf<UPrimaryDataAsset> DataClass, const TSoftObjectPtr<UPrimaryDataAsset>& DataClassPath, FPrimaryAssetType PrimaryAssetType);
protected:
// Global game data asset to use.
UPROPERTY(Config)
TSoftObjectPtr<ULyraGameData> LyraGameDataPath;
// Loaded version of the game data
UPROPERTY(Transient)
TMap<TObjectPtr<UClass>, TObjectPtr<UPrimaryDataAsset>> GameDataMap;
// Pawn data used when spawning player pawns if there isn't one set on the player state.
UPROPERTY(Config)
TSoftObjectPtr<ULyraPawnData> DefaultPawnData;
private:
// Flushes the StartupJobs array. Processes all startup work.
UE_API void DoAllStartupJobs();
// Sets up the ability system
UE_API void InitializeGameplayCueManager();
// Called periodically during loads, could be used to feed the status to a loading screen
UE_API void UpdateInitialGameContentLoadPercent(float GameContentPercent);
// The list of tasks to execute on startup. Used to track startup progress.
TArray<FLyraAssetManagerStartupJob> StartupJobs;
private:
// Assets loaded and tracked by the asset manager.
UPROPERTY()
TSet<TObjectPtr<const UObject>> LoadedAssets;
// Used for a scope lock when modifying the list of load assets.
FCriticalSection LoadedAssetsCritical;
};
template<typename AssetType>
AssetType* ULyraAssetManager::GetAsset(const TSoftObjectPtr<AssetType>& AssetPointer, bool bKeepInMemory)
{
AssetType* LoadedAsset = nullptr;
const FSoftObjectPath& AssetPath = AssetPointer.ToSoftObjectPath();
if (AssetPath.IsValid())
{
LoadedAsset = AssetPointer.Get();
if (!LoadedAsset)
{
LoadedAsset = Cast<AssetType>(SynchronousLoadAsset(AssetPath));
ensureAlwaysMsgf(LoadedAsset, TEXT("Failed to load asset [%s]"), *AssetPointer.ToString());
}
if (LoadedAsset && bKeepInMemory)
{
// Added to loaded asset list.
Get().AddLoadedAsset(Cast<UObject>(LoadedAsset));
}
}
return LoadedAsset;
}
template<typename AssetType>
TSubclassOf<AssetType> ULyraAssetManager::GetSubclass(const TSoftClassPtr<AssetType>& AssetPointer, bool bKeepInMemory)
{
TSubclassOf<AssetType> LoadedSubclass;
const FSoftObjectPath& AssetPath = AssetPointer.ToSoftObjectPath();
if (AssetPath.IsValid())
{
LoadedSubclass = AssetPointer.Get();
if (!LoadedSubclass)
{
LoadedSubclass = Cast<UClass>(SynchronousLoadAsset(AssetPath));
ensureAlwaysMsgf(LoadedSubclass, TEXT("Failed to load asset class [%s]"), *AssetPointer.ToString());
}
if (LoadedSubclass && bKeepInMemory)
{
// Added to loaded asset list.
Get().AddLoadedAsset(Cast<UObject>(LoadedSubclass));
}
}
return LoadedSubclass;
}
#undef UE_API
|