Update to version 1.4.2. Refactored the method for searching nested data assets. Structures and arrays of structures are now checked during recursive data asset loading.

Author: Pavreally

Plugins/AsyncDataAssetManager/AsyncDataAssetManager.uplugin

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

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

@@ -88,67 +88,94 @@ int32 UAsyncDataAssetManagerSubsystem::GetIndexDataADAM(TSoftObjectPtr<UPrimaryD
 TArray<TSoftObjectPtr<UPrimaryDataAsset>> UAsyncDataAssetManagerSubsystem::FindNestedAssets(UPrimaryDataAsset* DataAsset)
 {
 	TArray<TSoftObjectPtr<UPrimaryDataAsset>> NestedAssets;
-
 	if (!DataAsset)
 	{
 		UE_LOG(LogTemp, Warning, TEXT("ADAM (Recursive Load): Received a null value."));
 
 		return NestedAssets;
 	}
 
-	// Storage of unique asset names for duplicate control.
-	TArray<FString> UniqueAssetNames;
+	// Use a set for faster unique checks
+	TSet<FString> UniqueAssetNames;
+
+	// Start recursion from the DataAsset itself
+	FindNestedAssetsRecursive(DataAsset, DataAsset->GetClass(), NestedAssets, UniqueAssetNames);
 
-	// Use reflection to search for nested Data Assets
-	for (TFieldIterator<FProperty> PropIterator(DataAsset->GetClass()); PropIterator; ++PropIterator)
+	if (EnableLog && NestedAssets.Num() == 0)
 	{
-		const FProperty* Prop = *PropIterator;
+		UE_LOG(LogTemp, Display, TEXT("ADAM (Recursive data): Iteration is complete. All nested data is loaded!"));
+	}
+
+	return NestedAssets;
+}
+
+void UAsyncDataAssetManagerSubsystem::FindNestedAssetsRecursive(void* Container, UStruct* Struct, TArray<TSoftObjectPtr<UPrimaryDataAsset>>& OutNestedAssets, TSet<FString>& UniqueAssetNames)
+{
+	if (!Container || !Struct) 
+		return;
 
-		// Look for properties of type TSoftObjectPtr<UPrimaryDataAsset>
+	// Iterate over all properties in the struct/class
+	for (TFieldIterator<FProperty> PropIterator(Struct); PropIterator; ++PropIterator)
+	{
+		const FProperty* Prop = *PropIterator;
+		// Handle soft object properties (TSoftObjectPtr<UPrimaryDataAsset>)
 		if (const FSoftObjectProperty* SoftObjectProperty = CastField<FSoftObjectProperty>(Prop))
 		{
 			if (SoftObjectProperty->PropertyClass->IsChildOf(UPrimaryDataAsset::StaticClass()))
 			{
-				TSoftObjectPtr<UPrimaryDataAsset> ChildAsset = *SoftObjectProperty->ContainerPtrToValuePtr<TSoftObjectPtr<UPrimaryDataAsset>>(DataAsset);
+				TSoftObjectPtr<UPrimaryDataAsset> ChildAsset = *SoftObjectProperty->ContainerPtrToValuePtr<TSoftObjectPtr<UPrimaryDataAsset>>(Container);
 				FString ChildAssetName = ChildAsset.GetAssetName();
-				// Filtering and adding data
 				if (!ChildAssetName.IsEmpty() && !UniqueAssetNames.Contains(ChildAssetName))
 				{
-					UniqueAssetNames.AddUnique(ChildAssetName);
-					NestedAssets.Add(ChildAsset);
+					UniqueAssetNames.Add(ChildAssetName);
+					OutNestedAssets.Add(ChildAsset);
 				}
 			}
 		}
-
-		// If the array of soft references
-		if (const FArrayProperty* ArrayProp = CastField<FArrayProperty>(Prop))
+		// Handle struct properties (recurse into the struct)
+		else if (const FStructProperty* StructProperty = CastField<FStructProperty>(Prop))
+		{
+			void* StructData = StructProperty->ContainerPtrToValuePtr<void>(Container);
+			if (StructData)
+			{
+				FindNestedAssetsRecursive(StructData, StructProperty->Struct, OutNestedAssets, UniqueAssetNames);
+			}
+		}
+		// Handle array properties
+		else if (const FArrayProperty* ArrayProp = CastField<FArrayProperty>(Prop))
 		{
-			if (const FSoftObjectProperty* InnerSoftObjectProperty = CastField<FSoftObjectProperty>(ArrayProp->Inner))
+			FScriptArrayHelper ArrayHelper(ArrayProp, ArrayProp->ContainerPtrToValuePtr<void>(Container));
+			// Check inner property type
+			const FProperty* InnerProp = ArrayProp->Inner;
+			// If inner is soft object ptr
+			if (const FSoftObjectProperty* InnerSoftObjectProperty = CastField<FSoftObjectProperty>(InnerProp))
 			{
 				if (InnerSoftObjectProperty->PropertyClass->IsChildOf(UPrimaryDataAsset::StaticClass()))
 				{
-					FScriptArrayHelper ArrayHelper(ArrayProp, ArrayProp->ContainerPtrToValuePtr<void>(DataAsset));
-
 					for (int32 i = 0; i < ArrayHelper.Num(); ++i)
 					{
 						TSoftObjectPtr<UPrimaryDataAsset> ChildAsset = *reinterpret_cast<TSoftObjectPtr<UPrimaryDataAsset>*>(ArrayHelper.GetRawPtr(i));
 						FString ChildAssetName = ChildAsset.GetAssetName();
-						// Filtering and adding data
 						if (!ChildAssetName.IsEmpty() && !UniqueAssetNames.Contains(ChildAssetName))
 						{
-							UniqueAssetNames.AddUnique(ChildAssetName);
-							NestedAssets.Add(ChildAsset);
+							UniqueAssetNames.Add(ChildAssetName);
+							OutNestedAssets.Add(ChildAsset);
 						}
 					}
 				}
 			}
+			// If inner is struct, recurse on each array element
+			else if (const FStructProperty* InnerStructProperty = CastField<FStructProperty>(InnerProp))
+			{
+				for (int32 i = 0; i < ArrayHelper.Num(); ++i)
+				{
+					void* ElementData = ArrayHelper.GetRawPtr(i);
+					if (ElementData)
+					{
+						FindNestedAssetsRecursive(ElementData, InnerStructProperty->Struct, OutNestedAssets, UniqueAssetNames);
+					}
+				}
+			}
 		}
 	}
-
-	if (EnableLog && NestedAssets.Num() == 0)
-	{
-		UE_LOG(LogTemp, Display, TEXT("ADAM (Recursive data): Iteration is complete. All nested data is loaded!"));
-	}
-
-	return NestedAssets;
 }

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

@@ -253,10 +253,20 @@ class ASYNCDATAASSETMANAGER_API UAsyncDataAssetManagerSubsystem : public UGameIn
 	UPROPERTY()
 	TMap<FName, int32> QueueCounterADAM;
 
-	// Function for searching nested data assets
+	// Searching nested data assets
 	UFUNCTION()
 	TArray<TSoftObjectPtr<UPrimaryDataAsset>> FindNestedAssets(UPrimaryDataAsset* DataAsset);
 
+	/**
+	 * Recursive function for searching nested data assets.
+	 * 
+	 * @param Container Pointer to the memory of the struct or object instance being inspected.
+	 * @param Struct Reflection metadata describing the type of the container (UStruct or UClass).
+	 * @param OutNestedAssets Array to collect discovered nested PrimaryDataAssets.
+	 * @param UniqueAssetNames Set of asset names used to prevent duplicates when collecting assets.
+	 */
+	void FindNestedAssetsRecursive(void* Container, UStruct* Struct, TArray<TSoftObjectPtr<UPrimaryDataAsset>>& OutNestedAssets, TSet<FString>& UniqueAssetNames);
+
 	/**
 	 * Add data to the main DataADAM array
 	 * @param PrimaryDataAsset Soft link to data asset.

README.md

@@ -9,14 +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.1`
-- Build version for Unreal Engine 5.6.0
-- Code refactoring and decomposition.
-- Improving code security.
-- Cleaning up the chaos in the DemoFiles folder after the latest patch and putting things in order.
-- Redesign of the data asset loading tag system. Tags in the ADAM subsystem functions are now universal — this means that for each data asset package, you can choose which approach to use: a regular `FName` for complex tags (e.g., level names) or fixed tags like `FGameplayTag` for centralized management (so you don’t have to keep everything written down). Both approaches can be used at the same time, since the main storage supports both tag types as `FName`. However, only one tag type can be used per data asset package.
-- Redesign of the data asset unloading tag system in the `UnloadAllTagsADAM` function. For convenience, the tag selection has been expanded to three. You can fill in and specify all the tag types you need to unload at once.
-- Correction for the `UnloadAllTagsADAM` function — now it is also possible to bulk unload from memory only data assets with the tag "None".
+`Version 1.4.2`
+- 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.
 
 ## What it's for
 - Load and unload Data Assets asynchronously using simple functions.
@@ -28,7 +24,7 @@ ADAM is a plugin for Unreal Engine 5 that adds a subsystem for asynchronous load
 - Additional duplicate checking ensures that there are no additional references to resources in memory and that they are retained by the standard system.
 - Supports bulk asynchronous loading of unique Data Assets.
 - This subsystem enables recursive data loading. If you load a single DataAsset that includes multiple nested Data Assets, all of them will be loaded and filtered to avoid duplicates in memory.
-- Group your uploaded DataAssets using tags so that they can be unloaded at the right moment <i>(for example, this can be useful if you are uploading DataAssets in parts and want to unload them without affecting other necessary data still stored in memory)</i>.
+- Group your uploaded DataAssets using tags so that they can be unloaded at the right moment <i>(for example, this can be useful if you are uploading DataAssets in parts and want to unload them without affecting other necessary data still stored in memory)</i>. You can also choose which approach to use: a regular `FName` for complex tags (e.g., level names) or fixed tags like `FGameplayTag` for centralized management (so you don’t have to keep everything written down).
 - Supports asynchronous loading without memory retention <i>(e.g., if you need to immediately access data and then free up memory)</i>.
 - Single notification for bulk data load. The `OnAllLoadedADAM` delegate notifies when all Data Assets have been loaded simultaneously. It only functions if the `NotifyAfterFullLoaded` option is enabled, which is supported exclusively by the `LoadArrayADAM` method.
 - Disableable debug logs allow you to monitor the entire asynchronous data management process. Plugin settings are located in `Project Settings > Plugins > Async Technologies - ADAM`.