Add new plugins, refactor exp, introduce stat forge to replace GAS

Plugins/PSOFunctionLibrary/Source/PSOFunctions/PSOFunctions.Build.cs

@@ -0,0 +1,55 @@
+// Copyright (c) 2025 Danielel. All rights reserved.
+
+using UnrealBuildTool;
+
+public class PSOFunctions : ModuleRules
+{
+	public PSOFunctions(ReadOnlyTargetRules Target) : base(Target)
+	{
+		PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
+		
+		PublicIncludePaths.AddRange(
+			new string[] {
+				// ... add public include paths required here ...
+			}
+			);
+				
+		
+		PrivateIncludePaths.AddRange(
+			new string[] {
+				// ... add other private include paths required here ...
+			}
+			);
+			
+		
+		PublicDependencyModuleNames.AddRange(
+			new string[]
+			{
+				"Core",
+				// ... add other public dependencies that you statically link with here ...
+			}
+			);
+			
+		
+		PrivateDependencyModuleNames.AddRange(
+			new string[]
+			{
+				"Core",
+				"CoreUObject",
+				"Engine",
+				"Slate",
+				"SlateCore",
+                "RenderCore"
+				// ... add private dependencies that you statically link with here ...	
+			}
+			);
+		
+		
+		DynamicallyLoadedModuleNames.AddRange(
+			new string[]
+			{
+				// ... add any modules that your module loads dynamically here ...
+			}
+			);
+	}
+}

Plugins/PSOFunctionLibrary/Source/PSOFunctions/Private/PSOFunctions.cpp

@@ -0,0 +1,20 @@
+// Copyright (c) 2025 Danielel. All rights reserved.
+
+#include "PSOFunctions.h"
+
+#define LOCTEXT_NAMESPACE "FPSOFunctionsModule"
+
+void FPSOFunctionsModule::StartupModule()
+{
+	// This code will execute after your module is loaded into memory; the exact timing is specified in the .uplugin file per-module
+}
+
+void FPSOFunctionsModule::ShutdownModule()
+{
+	// This function may be called during shutdown to clean up your module.  For modules that support dynamic reloading,
+	// we call this function before unloading the module.
+}
+
+#undef LOCTEXT_NAMESPACE
+	
+IMPLEMENT_MODULE(FPSOFunctionsModule, PSOFunctions)

Plugins/PSOFunctionLibrary/Source/PSOFunctions/Private/ShaderPipeline.cpp

@@ -0,0 +1,46 @@
+// Copyright (c) 2025 Danielel. All rights reserved.
+
+#include "ShaderPipeline.h"
+#include "ShaderPipelineCache.h"
+#include "RenderResource.h"
+
+
+void UShaderPipeline::SetBatchModeFast()
+{
+	FShaderPipelineCache::SetBatchMode(FShaderPipelineCache::BatchMode::Fast);
+}
+
+void UShaderPipeline::SetBatchModeBackground()
+{
+	FShaderPipelineCache::SetBatchMode(FShaderPipelineCache::BatchMode::Background);
+}
+
+void UShaderPipeline::SetBatchModePrecompile()
+{
+	FShaderPipelineCache::SetBatchMode(FShaderPipelineCache::BatchMode::Precompile);
+}
+
+void UShaderPipeline::PauseBatching()
+{
+	FShaderPipelineCache::PauseBatching();
+}
+
+void UShaderPipeline::ResumeBatching()
+{
+	FShaderPipelineCache::ResumeBatching();
+}
+
+bool UShaderPipeline::IsPrecompiling()
+{
+	return FShaderPipelineCache::IsPrecompiling();
+}
+
+int UShaderPipeline::NumPrecompilesRemaining()
+{
+	return FShaderPipelineCache::NumPrecompilesRemaining();
+}
+
+bool UShaderPipeline::IsBatchingPaused()
+{
+	return FShaderPipelineCache::IsBatchingPaused();
+}

Plugins/PSOFunctionLibrary/Source/PSOFunctions/Public/PSOFunctions.h

@@ -0,0 +1,15 @@
+// Copyright (c) 2025 Danielel. All rights reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Modules/ModuleManager.h"
+
+class FPSOFunctionsModule : public IModuleInterface
+{
+public:
+
+	/** IModuleInterface implementation */
+	virtual void StartupModule() override;
+	virtual void ShutdownModule() override;
+};

Plugins/PSOFunctionLibrary/Source/PSOFunctions/Public/ShaderPipeline.h

@@ -0,0 +1,51 @@
+// Copyright (c) 2025 Danielel. All rights reserved.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Kismet/BlueprintFunctionLibrary.h"
+#include "ShaderPipelineCache.h"
+
+#include "ShaderPipeline.generated.h"
+
+/**
+ * 
+ */
+UCLASS()
+class PSOFUNCTIONS_API UShaderPipeline : public UBlueprintFunctionLibrary
+{
+	GENERATED_BODY()
+	
+public:
+
+	
+
+	UFUNCTION(BlueprintCallable, Category = "PSO precompile", meta = (ToolTip = "Sets the precompilation batching mode to Fast"))
+	static void SetBatchModeFast();
+
+	UFUNCTION(BlueprintCallable, Category = "PSO precompile", meta = (ToolTip = "Sets the precompilation batching mode to Background"))
+	static void SetBatchModeBackground();
+
+	UFUNCTION(BlueprintCallable, Category = "PSO precompile", meta = (ToolTip = "Sets the precompilation batching mode to Precompile"))
+	static void SetBatchModePrecompile();
+
+	/** Pauses precompilation batching. */
+	UFUNCTION(BlueprintCallable, Category = "PSO precompile", meta = (ToolTip = "Pauses precompilation batching"))
+	static void PauseBatching();
+
+	/** Resumes precompilation batching. */
+	UFUNCTION(BlueprintCallable, Category = "PSO precompile", meta = (ToolTip = "Resumes precompilation batching"))
+	static void ResumeBatching();
+
+	/** true if pipeline cache(s) are precompiling. */
+	UFUNCTION(BlueprintCallable, Category = "PSO precompile", BlueprintPure, meta = (ToolTip = "True if pipeline cache(s) are precompiling"))
+	static bool IsPrecompiling();
+
+	/** Returns the number of pipelines waiting for precompilation of the current PSOFC task.
+		if there are multiple PSOFCs pending this will return a minimum value of 1. It may increase as subsequent caches are processed.*/
+	UFUNCTION(BlueprintCallable, Category = "PSO precompile", BlueprintPure, meta = (ToolTip = "Returns the number of pipelines waiting for precompilation of the current PSOFC task. If there are multiple PSOFCs pending this will return a minimum value of 1. It may increase as subsequent caches are processed."))
+	static int NumPrecompilesRemaining();
+
+	UFUNCTION(BlueprintCallable, Category = "PSO precompile", BlueprintPure, meta = (ToolTip = "Returns if the precompilation batching is paused"))
+	static bool IsBatchingPaused();
+};