Update to version 1.4.3. Added the ability to specify the recursion depth. Added a new function GetDataByClassADAM.

Author: Pavreally

Plugins/AsyncDataAssetManager/AsyncDataAssetManager.uplugin

@@ -1,7 +1,7 @@
 {
 	"FileVersion": 3,
 	"Version": 1,
-	"VersionName": "1.4.2",
+	"VersionName": "1.4.3",
 	"FriendlyName": "Async Data Asset Manager",
 	"Description": "Asynchronous management of data assets.",
 	"Category": "Async Technologies",

Plugins/AsyncDataAssetManager/Content/DemoFiles/B_GameMode_DemoADAM.uasset

@@ -179,3 +179,28 @@ void UAsyncDataAssetManagerSubsystem::FindNestedAssetsRecursive(void* Container,
 		}
 	}
 }
+
+TArray<TSoftObjectPtr<UPrimaryDataAsset>> UAsyncDataAssetManagerSubsystem::GetDataByClassADAM(TSubclassOf<UPrimaryDataAsset> DataAssetClass, FName Tag, bool bIgnoreTag)
+{
+	TArray<TSoftObjectPtr<UPrimaryDataAsset>> SortedPrimaryDataAsset;
+
+	if (!DataAssetClass)
+	{
+		UE_LOG(LogTemp, Warning, TEXT("ADAM (GetDataByClass): DataAssetClass is nullptr!"));
+
+		return SortedPrimaryDataAsset;
+	}
+
+	for (const FMemoryADAM& Data : DataADAM)
+	{
+		if (Data.MemoryReference.IsValid() && Data.SoftReference->GetClass()->IsChildOf(DataAssetClass))
+		{
+			if (bIgnoreTag || Data.Tag == Tag)
+			{
+				SortedPrimaryDataAsset.Add(Data.SoftReference);
+			}
+		}
+	}
+
+	return SortedPrimaryDataAsset;
+}

Plugins/AsyncDataAssetManager/Source/AsyncDataAssetManager/Private/ADAMS_Getters.cpp

@@ -6,7 +6,7 @@
 #include "Engine/DataAsset.h"
 #include "AsyncTechnologiesSettings.h"
 
-void UAsyncDataAssetManagerSubsystem::RecursiveLoad(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, FName Tag, bool NotifyAfterFullLoaded)
+void UAsyncDataAssetManagerSubsystem::RecursiveLoad(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, FName Tag, bool NotifyAfterFullLoaded, int32 RecursiveDepthLoading)
 {
 	if (PrimaryDataAsset.IsNull())
 	{
@@ -15,6 +15,9 @@ void UAsyncDataAssetManagerSubsystem::RecursiveLoad(TSoftObjectPtr<UPrimaryDataA
 		return;
 	}
 
+	if (RecursiveDepthLoading == 0)
+		return;
+
 	UPrimaryDataAsset* Asset = PrimaryDataAsset.Get();
 
 	if (!Asset)
@@ -37,6 +40,9 @@ void UAsyncDataAssetManagerSubsystem::RecursiveLoad(TSoftObjectPtr<UPrimaryDataA
 		return;
 	}
 
+	// Compute depth to pass children. If RecursiveDepthLoading == -1 -> keep -1 (infinite), else decrease by 1
+	int32 ChildDepth = (RecursiveDepthLoading == -1) ? -1 : (RecursiveDepthLoading - 1);
+
 	for (TSoftObjectPtr<UPrimaryDataAsset>& NestedAsset : NestedAssets)
 	{
 		// Calling asynchronous loading
@@ -53,11 +59,11 @@ void UAsyncDataAssetManagerSubsystem::RecursiveLoad(TSoftObjectPtr<UPrimaryDataA
 				continue;
 			}
 
-			AddToADAM(NestedAsset, Tag, true);
+			AddToADAM(NestedAsset, Tag, ChildDepth);
 		}
 		else
 		{
-			AddAllToADAM(NestedAsset, Tag, true);
+			AddAllToADAM(NestedAsset, Tag, ChildDepth);
 		}
 	}
 }

Plugins/AsyncDataAssetManager/Source/AsyncDataAssetManager/Private/ADAMS_Handlers.cpp

@@ -6,7 +6,7 @@
 #include "Engine/DataAsset.h"
 #include "AsyncTechnologiesSettings.h"
 
-void UAsyncDataAssetManagerSubsystem::LoadADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, FTagADAM Tag, bool RecursiveLoading, TSoftObjectPtr<UPrimaryDataAsset>& ReturnPrimaryDataAsset)
+void UAsyncDataAssetManagerSubsystem::LoadADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, FTagADAM Tag, int32 RecursiveDepthLoading, TSoftObjectPtr<UPrimaryDataAsset>& ReturnPrimaryDataAsset)
 {
 	if (PrimaryDataAsset.IsNull())
 	{
@@ -26,14 +26,19 @@ void UAsyncDataAssetManagerSubsystem::LoadADAM(TSoftObjectPtr<UPrimaryDataAsset>
 		return;
 	}
 
+	if (RecursiveDepthLoading < -1)
+	{
+		RecursiveDepthLoading = FMath::Max(RecursiveDepthLoading, -1);
+	}
+
 	// Add in array ADAM and async load. In this case, a load notification occurs after each file is loaded.
-	AddToADAM(PrimaryDataAsset, GetTagNameFromStruct(Tag), RecursiveLoading);
+	AddToADAM(PrimaryDataAsset, GetTagNameFromStruct(Tag), RecursiveDepthLoading);
 
 	// Return the value of a soft link
 	ReturnPrimaryDataAsset = PrimaryDataAsset;
 }
 
-void UAsyncDataAssetManagerSubsystem::LoadArrayADAM(TArray<TSoftObjectPtr<UPrimaryDataAsset>> PrimaryDataAssets, FTagADAM Tag, bool NotifyAfterFullLoaded, bool RecursiveLoading, TArray<TSoftObjectPtr<UPrimaryDataAsset>>& ReturnPrimaryDataAssets)
+void UAsyncDataAssetManagerSubsystem::LoadArrayADAM(TArray<TSoftObjectPtr<UPrimaryDataAsset>> PrimaryDataAssets, FTagADAM Tag, bool NotifyAfterFullLoaded, int32 RecursiveDepthLoading, TArray<TSoftObjectPtr<UPrimaryDataAsset>>& ReturnPrimaryDataAssets)
 {
 	if (PrimaryDataAssets.IsEmpty())
 	{
@@ -51,6 +56,11 @@ void UAsyncDataAssetManagerSubsystem::LoadArrayADAM(TArray<TSoftObjectPtr<UPrima
 		QueueCounterADAM.Add(TagName, 0);
 	}
 
+	if (RecursiveDepthLoading < -1)
+	{
+		RecursiveDepthLoading = FMath::Max(RecursiveDepthLoading, -1);
+	}
+
 	// Invoking asynchronous loading of each data asset.
 	for (TSoftObjectPtr<UPrimaryDataAsset>& DataAsset : PrimaryDataAssets)
 	{
@@ -68,19 +78,19 @@ void UAsyncDataAssetManagerSubsystem::LoadArrayADAM(TArray<TSoftObjectPtr<UPrima
 		// Add in array ADAM and async load
 		if (!NotifyAfterFullLoaded)
 		{
-			AddToADAM(DataAsset, TagName, RecursiveLoading);
+			AddToADAM(DataAsset, TagName, RecursiveDepthLoading);
 		}
 		else
 		{
-			AddAllToADAM(DataAsset, TagName, RecursiveLoading);
+			AddAllToADAM(DataAsset, TagName, RecursiveDepthLoading);
 		}
 	}
 
 	// Return an array of soft links
 	ReturnPrimaryDataAssets = PrimaryDataAssets;
 }
 
-void UAsyncDataAssetManagerSubsystem::AddToADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, FName Tag, bool RecursiveLoading)
+void UAsyncDataAssetManagerSubsystem::AddToADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, FName Tag, int32 RecursiveDepthLoading)
 {
 	// Add Queue
 	FString DataAssetName = PrimaryDataAsset.GetAssetName();
@@ -97,7 +107,7 @@ void UAsyncDataAssetManagerSubsystem::AddToADAM(TSoftObjectPtr<UPrimaryDataAsset
 	&UAsyncDataAssetManagerSubsystem::OnLoaded,
 	PrimaryDataAsset,
 	Tag,
-	RecursiveLoading);
+	RecursiveDepthLoading);
 
 	// Determine whether the descriptor will be declared and stored
 	TSharedPtr<FStreamableHandle> DataAssetHandle = StreamableManager.RequestAsyncLoad(PrimaryDataAsset.ToSoftObjectPath(),	Delegate);
@@ -109,7 +119,7 @@ void UAsyncDataAssetManagerSubsystem::AddToADAM(TSoftObjectPtr<UPrimaryDataAsset
 	}
 }
 
-void UAsyncDataAssetManagerSubsystem::AddAllToADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, FName Tag, bool RecursiveLoading)
+void UAsyncDataAssetManagerSubsystem::AddAllToADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, FName Tag, int32 RecursiveDepthLoading)
 {
 	FStreamableManager& StreamableManager = UAssetManager::GetStreamableManager();
 	// Create a delegate
@@ -118,7 +128,7 @@ void UAsyncDataAssetManagerSubsystem::AddAllToADAM(TSoftObjectPtr<UPrimaryDataAs
 	&UAsyncDataAssetManagerSubsystem::OnAllLoaded,
 	PrimaryDataAsset,
 	Tag,
-	RecursiveLoading);
+	RecursiveDepthLoading);
 
 	// Determine whether the descriptor will be declared and stored
 	TSharedPtr<FStreamableHandle> DataAssetHandle = StreamableManager.RequestAsyncLoad(PrimaryDataAsset.ToSoftObjectPath(),	Delegate);
@@ -172,7 +182,7 @@ void UAsyncDataAssetManagerSubsystem::FastLoadADAM(TSoftObjectPtr<UPrimaryDataAs
 			&UAsyncDataAssetManagerSubsystem::OnLoaded,
 			PrimaryDataAsset,
 			Tag,
-			false);
+			0);
 
 	// This handle is not stored in memory
 	TSharedPtr<FStreamableHandle> DataAssetHandle = StreamableManager.RequestAsyncLoad(PrimaryDataAsset.ToSoftObjectPath(),	Delegate);

Plugins/AsyncDataAssetManager/Source/AsyncDataAssetManager/Private/ADAMS_Loading.cpp

@@ -35,7 +35,7 @@ void UAsyncDataAssetManagerSubsystem::Deinitialize()
 #pragma endregion SUBSYSTEM
 
 #pragma region CALL_DELEGATE
-void UAsyncDataAssetManagerSubsystem::OnLoaded(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, FName Tag, bool RecursiveLoading)
+void UAsyncDataAssetManagerSubsystem::OnLoaded(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, FName Tag, int32 RecursiveDepthLoading)
 {
 	UPrimaryDataAsset* LoadedObject =	PrimaryDataAsset.Get();
 
@@ -47,11 +47,11 @@ void UAsyncDataAssetManagerSubsystem::OnLoaded(TSoftObjectPtr<UPrimaryDataAsset>
 	}
 
 	// Inform the FOnLoadedADAM subsystem delegate that the loading is complete
-	OnLoadedADAM.Broadcast(LoadedObject, PrimaryDataAsset, Tag, RecursiveLoading);
+	OnLoadedADAM.Broadcast(LoadedObject, PrimaryDataAsset, Tag, RecursiveDepthLoading);
 
-	if (RecursiveLoading && FindNestedAssets(LoadedObject).Num() != 0)
+	if (RecursiveDepthLoading != 0 && FindNestedAssets(LoadedObject).Num() != 0)
 	{
-		RecursiveLoad(PrimaryDataAsset, Tag, false);
+		RecursiveLoad(PrimaryDataAsset, Tag, false, RecursiveDepthLoading);
 	}
 
 	if (EnableLog)
@@ -63,7 +63,7 @@ void UAsyncDataAssetManagerSubsystem::OnLoaded(TSoftObjectPtr<UPrimaryDataAsset>
 	QueueADAM.Remove(PrimaryDataAsset.GetAssetName());
 }
 
-void UAsyncDataAssetManagerSubsystem::OnAllLoaded(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, FName Tag, bool RecursiveLoading)
+void UAsyncDataAssetManagerSubsystem::OnAllLoaded(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, FName Tag, int32 RecursiveDepthLoading)
 {
 	UPrimaryDataAsset* LoadedObject =	PrimaryDataAsset.Get();
 
@@ -74,9 +74,9 @@ void UAsyncDataAssetManagerSubsystem::OnAllLoaded(TSoftObjectPtr<UPrimaryDataAss
 		return;
 	}
 
-	if (RecursiveLoading && FindNestedAssets(LoadedObject).Num() != 0)
+	if (RecursiveDepthLoading != 0 && FindNestedAssets(LoadedObject).Num() != 0)
 	{
-		RecursiveLoad(PrimaryDataAsset, Tag, true);
+		RecursiveLoad(PrimaryDataAsset, Tag, true, RecursiveDepthLoading);
 	}
 
 	if (EnableLog)

Plugins/AsyncDataAssetManager/Source/AsyncDataAssetManager/Private/AsyncDataAssetManagerSubsystem.cpp

@@ -115,7 +115,7 @@ class ASYNCDATAASSETMANAGER_API UAsyncDataAssetManagerSubsystem : public UGameIn
 	//~End USubsystem
 
 #pragma region DELEGATES
-	DECLARE_DYNAMIC_MULTICAST_DELEGATE_FourParams(FOnLoadedADAM, UPrimaryDataAsset*, LoadedObject, TSoftObjectPtr<UPrimaryDataAsset>, LoadedPrimaryDataAsset, FName, LoadedTag, bool, RecursiveLoading);
+	DECLARE_DYNAMIC_MULTICAST_DELEGATE_FourParams(FOnLoadedADAM, UPrimaryDataAsset*, LoadedObject, TSoftObjectPtr<UPrimaryDataAsset>, LoadedPrimaryDataAsset, FName, LoadedTag, int32, RecursiveDepthLoading);
 
 	// Indicates that the load is complete
 	UPROPERTY(BlueprintAssignable, Category = "ADAM Subsystem")
@@ -144,30 +144,30 @@ class ASYNCDATAASSETMANAGER_API UAsyncDataAssetManagerSubsystem : public UGameIn
 	 * Async loading of a Data Asset and storing it in memory.
 	 * @param PrimaryDataAsset Soft link to data asset.
 	 * @param Tag Designed for data grouping.
-	 * @param RecursiveLoading Support for recursion. During loading, the function will check for nested Data Assets and attempt to load them. Warning! This option may require more performance and processing time.
+	 * @param RecursiveDepthLoading Recursion support and depth. If the value is set to '0', recursion will be disabled. If set to '-1', recursion will be infinite.
 	 * @return ReturnPrimaryDataAsset - Returns the same data asset as that specified in the first parameter.
 	 */
 	UFUNCTION(BlueprintCallable, Category = "ADAM Subsystem")
 	void LoadADAM(
 			TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset,
-			FTagADAM Tag, 
-			bool RecursiveLoading, 
+			FTagADAM Tag,
+			int32 RecursiveDepthLoading,
 			TSoftObjectPtr<UPrimaryDataAsset>& ReturnPrimaryDataAsset);
 
 	/**
 	 * Async loading of an array of Data Asset and storing each element in memory.
 	 * @param PrimaryDataAssets Soft link to data assets.
 	 * @param Tag Designed for data grouping.
 	 * @param NotifyAfterFullLoaded If true, the "OnAllLoaded" event will notify you when all data in the array has been fully loaded. The ADAM system will ignore duplicate checks (to prevent accidental unloading of necessary data through another thread), so all Data Asset duplicates will be controlled by the engine's base system.
-	 * @param RecursiveLoading Support for recursion. During loading, the function will check for nested Data Assets and attempt to load them. Warning! This option may require more performance and processing time.
+	 * @param RecursiveDepthLoading Recursion support and depth. If the value is set to '0', recursion will be disabled. If set to '-1', recursion will be infinite.
 	 * @result ReturnPrimaryDataAssets - Returns the same data asset as that specified in the first parameter.
 	 */
 	UFUNCTION(BlueprintCallable, Category = "ADAM Subsystem")
 	void LoadArrayADAM(
 			TArray<TSoftObjectPtr<UPrimaryDataAsset>> PrimaryDataAssets, 
-			FTagADAM Tag, 
+			FTagADAM Tag,
 			bool NotifyAfterFullLoaded,
-			bool RecursiveLoading, 
+			int32 RecursiveDepthLoading,
 			TArray<TSoftObjectPtr<UPrimaryDataAsset>>& ReturnPrimaryDataAssets);
 
 	/**
@@ -238,7 +238,18 @@ class ASYNCDATAASSETMANAGER_API UAsyncDataAssetManagerSubsystem : public UGameIn
 	 */
 	UFUNCTION(BlueprintCallable, Category = "ADAM Subsystem")
 	int32 GetIndexDataADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset);
-	
+
+	/**
+	 * Selects a data array from the shared storage based on the specified class and tag.
+	 * 
+	 * @param DataAssetClass The data asset class to filter by.
+	 * @param Tag The tag to filter the data assets.
+	 * @param bIgnoreTag If true, the tag will not be checked.
+	 * @return Returns an array of data assets that match the specified class and tag.
+	 */
+	UFUNCTION(BlueprintCallable, Category = "ADAM Subsystem")
+	TArray<TSoftObjectPtr<UPrimaryDataAsset>> GetDataByClassADAM(TSubclassOf<UPrimaryDataAsset> DataAssetClass, FName Tag, bool bIgnoreTag = true);
+
 #pragma endregion BLUEPRINT_FUNCTIONS
 
 protected:
@@ -283,10 +294,10 @@ class ASYNCDATAASSETMANAGER_API UAsyncDataAssetManagerSubsystem : public UGameIn
 	 * 
 	 * @param PrimaryDataAsset Soft link to data asset.
 	 * @param Tag Designed for data grouping.
-	 * @param RecursiveLoading Support for recursion. During loading, the function will check for nested Data Assets and attempt to load them. Warning! This option may require more performance and processing time.
+	 * @param RecursiveDepthLoading Recursion support and depth. If the value is set to '0', recursion will be disabled. If set to '-1', recursion will be infinite.
 	 */
 	UFUNCTION()
-	void AddToADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, FName Tag, bool RecursiveLoading);
+	void AddToADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, FName Tag, int32 RecursiveDepthLoading);
 
 	/**
 	 * Multiple asynchronous loading with completion notification
@@ -299,40 +310,38 @@ class ASYNCDATAASSETMANAGER_API UAsyncDataAssetManagerSubsystem : public UGameIn
 	 * 
 	 * @param PrimaryDataAsset Soft link to data asset.
 	 * @param Tag Designed for data grouping.
-	 * @param RecursiveLoading Support for recursion. During loading, the function will check for nested Data Assets and attempt to load them. Warning! This option may require more performance and processing time.
+	 * @param RecursiveDepthLoading Recursion support and depth. If the value is set to '0', recursion will be disabled. If set to '-1', recursion will be infinite.
 	 */
 	UFUNCTION()
-	void AddAllToADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, FName Tag, bool RecursiveLoading);
+	void AddAllToADAM(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, FName Tag, int32 RecursiveDepthLoading);
 
 	/**
 	* Delegate notification after loading Data Asset into ADAM subsystem
 	* 
 	* @param PrimaryDataAsset Soft link to data asset.
 	* @param Tag Designed for data grouping.
-	* @param RecursiveLoading Support for recursion. During loading, the function will check for nested Data Assets and attempt to load them. Warning! This option may require more performance and processing time.
+	* @param RecursiveDepthLoading Recursion support and depth. If the value is set to '0', recursion will be disabled. If set to '-1', recursion will be infinite.
 	* 
-	* LoadedObject - the loaded data asset object.
 	* PrimaryDataAsset - a soft link with a generic suffix.
 	* Tag - a given tag for grouping data.
-	* RecursiveLoading - whether the recursive option was selected during loading.
+	* RecursiveDepthLoading - whether the recursive option was selected during loading.
 	*/
 	UFUNCTION()
-	void OnLoaded(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, FName Tag, bool RecursiveLoading);
+	void OnLoaded(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, FName Tag, int32 RecursiveDepthLoading);
 
 	/**
 	 * Delegate notification after full loading Data Asset into ADAM subsystem
 	 * 
 	 * @param PrimaryDataAsset Soft link to data asset.
 	 * @param Tag Designed for data grouping.
-	 * @param RecursiveLoading Support for recursion. During loading, the function will check for nested Data Assets and attempt to load them. Warning! This option may require more performance and processing time.
+	 * @param RecursiveDepthLoading Recursion support and depth. If the value is set to '0', recursion will be disabled. If set to '-1', recursion will be infinite.
 	 * 
-	 * LoadedObject - the loaded data asset object.
 	 * PrimaryDataAsset - a soft link with a generic suffix.
 	 * Tag - a given tag for grouping data.
-	 * RecursiveLoading - whether the recursive option was selected during loading.
+	 * RecursiveDepthLoading - whether the recursive option was selected during loading.
 	 */
 	UFUNCTION()
-	void OnAllLoaded(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, FName Tag, bool RecursiveLoading);
+	void OnAllLoaded(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, FName Tag, int32 RecursiveDepthLoading);
 
 	/**
 	 * Remove Data Asset from the ADAM array and asynchronously unload it.
@@ -350,5 +359,5 @@ class ASYNCDATAASSETMANAGER_API UAsyncDataAssetManagerSubsystem : public UGameIn
 	 * @param NotifyAfterFullLoaded If true, the "OnAllLoaded" event will notify you when all data in the array has been fully loaded. The ADAM system will ignore duplicate checks (to prevent accidental unloading of necessary data through another thread), so all Data Asset duplicates will be controlled by the engine's base system.
 	 */
 	UFUNCTION()
-	void RecursiveLoad(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, FName Tag, bool NotifyAfterFullLoaded);
+	void RecursiveLoad(TSoftObjectPtr<UPrimaryDataAsset> PrimaryDataAsset, FName Tag, bool NotifyAfterFullLoaded, int32 RecursiveDepthLoading);
 };

Plugins/AsyncDataAssetManager/Source/AsyncDataAssetManager/Public/AsyncDataAssetManagerSubsystem.h

@@ -9,10 +9,10 @@ ADAM is a plugin for Unreal Engine 5 that adds a subsystem for asynchronous load
 > The plugin has been pre-packaged only for Win64 and Android.
 
 ## Latest Updates
-`Version 1.4.2`
+`Version 1.4.3`
 - Build version for Unreal Engine 5.6.0+
-- Refactored the method for searching nested data assets.
-- Structures and arrays of structures are now checked during recursive data asset loading.
+- Improved recursive loading option. The function parameters of `LoadADAM` and `LoadArrayADAM` have been updated. Added the ability to specify the recursion depth, allowing data to be loaded only up to a defined level of nesting.
+- `New` Added a new function `GetDataByClassADAM`. This function retrieves a filtered list of loaded data assets from ADAM’s internal memory based on class and tag. (For example, this can be useful when working with deeply nested assets required for data retrieval.)
 
 ## What it's for
 - Load and unload Data Assets asynchronously using simple functions.
@@ -41,6 +41,7 @@ An interactive step-by-step tutorial on how to use ADAM can be found in the file
 ![Window Manager](./_Misc/Tutorial/Tutorial_1.jpg)
 ![Window Manager](./_Misc/Tutorial/Tutorial_2.jpg)
 ![Window Manager](./_Misc/Tutorial/Tutorial_3.jpg)
+![Window Manager](./_Misc/Tutorial/Tutorial_4.jpg)
 
 ## (C++) Documentaion
 All sources contain self-documenting code.