Initial Commit

Source/Simulore_Tirsova/PreloadSubsystem.cpp

@@ -0,0 +1,121 @@
+#include "PreloadSubsystem.h"
+#include "AssetRegistry/AssetRegistryModule.h"
+#include "Engine/AssetManager.h"
+
+void UPreloadSubsystem::StartPreload(const TArray<FString>& ContentPaths)
+{
+	if (bIsPreloading)
+	{
+		UE_LOG(LogTemp, Warning, TEXT("PreloadSubsystem: Already preloading, ignoring request."));
+		return;
+	}
+
+	IAssetRegistry& AssetRegistry = FModuleManager::LoadModuleChecked<FAssetRegistryModule>("AssetRegistry").Get();
+
+	PendingAssets.Empty();
+
+	for (const FString& Path : ContentPaths)
+	{
+		TArray<FAssetData> FoundAssets;
+		AssetRegistry.GetAssetsByPath(FName(*Path), FoundAssets, /*bRecursive=*/ true);
+
+		for (const FAssetData& Asset : FoundAssets)
+		{
+			PendingAssets.Add(Asset.GetSoftObjectPath());
+		}
+
+		UE_LOG(LogTemp, Log, TEXT("PreloadSubsystem: Found %d assets in '%s'"), FoundAssets.Num(), *Path);
+	}
+
+	BeginAsyncLoad();
+}
+
+void UPreloadSubsystem::PreloadAssets(const TArray<FSoftObjectPath>& Assets)
+{
+	if (bIsPreloading)
+	{
+		UE_LOG(LogTemp, Warning, TEXT("PreloadSubsystem: Already preloading, ignoring request."));
+		return;
+	}
+
+	PendingAssets = Assets;
+	BeginAsyncLoad();
+}
+
+void UPreloadSubsystem::BeginAsyncLoad()
+{
+	TotalAssets = PendingAssets.Num();
+
+	if (TotalAssets == 0)
+	{
+		UE_LOG(LogTemp, Warning, TEXT("PreloadSubsystem: No assets to preload."));
+		OnPreloadComplete.Broadcast();
+		return;
+	}
+
+	UE_LOG(LogTemp, Log, TEXT("PreloadSubsystem: Starting async load of %d assets..."), TotalAssets);
+	bIsPreloading = true;
+
+	FStreamableManager& Manager = UAssetManager::GetStreamableManager();
+	StreamableHandle = Manager.RequestAsyncLoad(
+		PendingAssets,
+		FStreamableDelegate::CreateUObject(this, &UPreloadSubsystem::OnAssetsLoaded),
+		FStreamableManager::DefaultAsyncLoadPriority,
+		false, // bManageActiveHandle
+		false, // bStartStalled
+		TEXT("PreloadSubsystem")
+	);
+
+	// Tick progress until complete
+	TickerHandle = FTSTicker::GetCoreTicker().AddTicker(
+		FTickerDelegate::CreateUObject(this, &UPreloadSubsystem::TickProgress),
+		0.05f // 20 updates per second
+	);
+}
+
+bool UPreloadSubsystem::TickProgress(float DeltaTime)
+{
+	if (!bIsPreloading)
+	{
+		return false; // stop ticking
+	}
+
+	OnPreloadProgress.Broadcast(GetProgress());
+	return true; // keep ticking
+}
+
+void UPreloadSubsystem::OnAssetsLoaded()
+{
+	UE_LOG(LogTemp, Log, TEXT("PreloadSubsystem: All %d assets loaded."), TotalAssets);
+
+	bIsPreloading = false;
+
+	if (TickerHandle.IsValid())
+	{
+		FTSTicker::GetCoreTicker().RemoveTicker(TickerHandle);
+		TickerHandle.Reset();
+	}
+
+	OnPreloadProgress.Broadcast(1.0f);
+	OnPreloadComplete.Broadcast();
+}
+
+float UPreloadSubsystem::GetProgress() const
+{
+	if (!bIsPreloading || !StreamableHandle.IsValid())
+	{
+		return bIsPreloading ? 0.0f : 1.0f;
+	}
+
+	return StreamableHandle->GetProgress();
+}
+
+int32 UPreloadSubsystem::GetTotalAssetCount() const
+{
+	return TotalAssets;
+}
+
+bool UPreloadSubsystem::IsPreloading() const
+{
+	return bIsPreloading;
+}

Source/Simulore_Tirsova/PreloadSubsystem.h

@@ -0,0 +1,70 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Subsystems/GameInstanceSubsystem.h"
+#include "Engine/StreamableManager.h"
+#include "PreloadSubsystem.generated.h"
+
+DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnPreloadComplete);
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnPreloadProgress, float, Progress);
+
+/**
+ * Preloads assets before level transition to prevent streaming pop-in.
+ *
+ * Usage from Blueprint:
+ *   1. Get this subsystem from GameInstance
+ *   2. Bind OnPreloadComplete / OnPreloadProgress
+ *   3. Call StartPreload with content paths to scan
+ *   4. Poll GetProgress() for loading bar
+ *   5. On complete, open your target level
+ */
+UCLASS()
+class SIMULORE_TIRSOVA_API UPreloadSubsystem : public UGameInstanceSubsystem
+{
+	GENERATED_BODY()
+
+public:
+	/**
+	 * Preload all assets found in the given content directory paths (recursive).
+	 * Example paths: "/Game/ArchVis", "/Game/CollaborativeViewer"
+	 */
+	UFUNCTION(BlueprintCallable, Category = "Preload")
+	void StartPreload(const TArray<FString>& ContentPaths);
+
+	/**
+	 * Preload specific assets by soft object path.
+	 * Useful when you know exactly which heavy assets to load.
+	 */
+	UFUNCTION(BlueprintCallable, Category = "Preload")
+	void PreloadAssets(const TArray<FSoftObjectPath>& Assets);
+
+	/** Current loading progress 0.0 to 1.0. Poll this from your loading widget. */
+	UFUNCTION(BlueprintCallable, BlueprintPure, Category = "Preload")
+	float GetProgress() const;
+
+	/** Number of assets being loaded. */
+	UFUNCTION(BlueprintCallable, BlueprintPure, Category = "Preload")
+	int32 GetTotalAssetCount() const;
+
+	UFUNCTION(BlueprintCallable, BlueprintPure, Category = "Preload")
+	bool IsPreloading() const;
+
+	/** Fires when all assets finish loading. */
+	UPROPERTY(BlueprintAssignable, Category = "Preload")
+	FOnPreloadComplete OnPreloadComplete;
+
+	/** Fires each frame with current progress. Bind to update your loading bar. */
+	UPROPERTY(BlueprintAssignable, Category = "Preload")
+	FOnPreloadProgress OnPreloadProgress;
+
+private:
+	void BeginAsyncLoad();
+	void OnAssetsLoaded();
+	bool TickProgress(float DeltaTime);
+
+	TSharedPtr<FStreamableHandle> StreamableHandle;
+	TArray<FSoftObjectPath> PendingAssets;
+	FTSTicker::FDelegateHandle TickerHandle;
+	int32 TotalAssets = 0;
+	bool bIsPreloading = false;
+};

Source/Simulore_Tirsova/Simulore_Tirsova.Build.cs

@@ -0,0 +1,16 @@
+using UnrealBuildTool;
+
+public class Simulore_Tirsova : ModuleRules
+{
+	public Simulore_Tirsova(ReadOnlyTargetRules Target) : base(Target)
+	{
+		PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
+
+		PrivateDependencyModuleNames.AddRange(new string[]
+		{
+			"Core",
+			"CoreUObject",
+			"Engine"
+		});
+	}
+}

Source/Simulore_Tirsova/Simulore_Tirsova.cpp

@@ -0,0 +1,4 @@
+#include "CoreTypes.h"
+#include "Modules/ModuleManager.h"
+
+IMPLEMENT_PRIMARY_GAME_MODULE(FDefaultModuleImpl, Simulore_Tirsova, "Simulore_Tirsova");