unreal-engine-mcp-server 0.4.7 → 0.5.0

package/plugins/McpAutomationBridge/Config/FilterPlugin.ini

@@ -0,0 +1,8 @@
+[FilterPlugin]
+; This section lists additional files which will be packaged along with your plugin. Paths should be listed relative to the root plugin directory, and
+; may include "...", "*", and "?" wildcards to match directories, files, and individual characters respectively.
+;
+; Examples:
+;    /README.txt
+;    /Extras/...
+;    /Binaries/ThirdParty/*.dll

package/plugins/McpAutomationBridge/McpAutomationBridge.uplugin

@@ -0,0 +1,64 @@
+{
+  "FileVersion": 3,
+  "Version": 1,
+  "VersionName": "0.1.0",
+  "FriendlyName": "MCP Automation Bridge",
+  "Description": "Editor-side bridge that accepts elevated automation requests from the Unreal MCP server.",
+  "Category": "Automation",
+  "CreatedBy": "unreal-engine-mcp-server",
+  "CreatedByURL": "https://github.com/ChiR24/Unreal_mcp",
+  "DocsURL": "",
+  "MarketplaceURL": "",
+  "SupportURL": "",
+  "CanContainContent": false,
+  "IsBetaVersion": true,
+  "IsExperimentalVersion": true,
+  "EnabledByDefault": true,
+  "SupportsUEBuildSystem": true,
+  "Modules": [
+    {
+      "Name": "McpAutomationBridge",
+      "Type": "Editor",
+      "LoadingPhase": "Default"
+    }
+  ],
+  "BlacklistPlatforms": [],
+  "Plugins": [
+    {
+      "Name": "EditorScriptingUtilities",
+      "Enabled": true
+    },
+    {
+      "Name": "LevelSequenceEditor",
+      "Enabled": true
+    },
+    {
+      "Name": "Niagara",
+      "Enabled": true
+    },
+    {
+      "Name": "ControlRig",
+      "Enabled": true
+    },
+    {
+      "Name": "ProceduralMeshComponent",
+      "Enabled": true
+    },
+    {
+      "Name": "Interchange",
+      "Enabled": true
+    },
+    {
+      "Name": "InterchangeOpenUSD",
+      "Enabled": true
+    },
+    {
+      "Name": "DataValidation",
+      "Enabled": true
+    },
+    {
+      "Name": "EnhancedInput",
+      "Enabled": true
+    }
+  ]
+}

package/plugins/McpAutomationBridge/Source/McpAutomationBridge/McpAutomationBridge.Build.cs

@@ -0,0 +1,189 @@
+using UnrealBuildTool;
+using System;
+using System.IO;
+using System.Collections.Generic;
+
+public class McpAutomationBridge : ModuleRules
+{
+    /// <summary>
+    /// Configures build rules, dependencies, and compile-time feature definitions for the McpAutomationBridge module based on the provided build target.
+    /// </summary>
+    /// <param name="Target">Build target settings used to determine platform, configuration, and whether editor-only dependencies and feature flags should be enabled.</param>
+    public McpAutomationBridge(ReadOnlyTargetRules Target) : base(Target)
+    {
+        PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
+
+        PublicDependencyModuleNames.AddRange(new string[]
+        {
+            "Core","CoreUObject","Engine","Json","JsonUtilities",
+            "LevelSequence", "MovieScene", "MovieSceneTracks"
+        });
+
+        if (Target.bBuildEditor)
+        {
+            // Editor-only Public Dependencies
+            PublicDependencyModuleNames.AddRange(new string[] 
+            { 
+                "LevelSequenceEditor", "Sequencer", "MovieSceneTools", "Niagara", "NiagaraEditor", "UnrealEd",
+                "WorldPartitionEditor", "DataLayerEditor", "EnhancedInput", "InputEditor"
+            });
+
+            PrivateDependencyModuleNames.AddRange(new string[]
+            {
+                "ApplicationCore","Slate","SlateCore","Projects","InputCore","DeveloperSettings","Settings","EngineSettings",
+                "Sockets","Networking","EditorSubsystem","EditorScriptingUtilities","BlueprintGraph",
+                "Kismet","KismetCompiler","AssetRegistry","AssetTools","MaterialEditor","SourceControl",
+                "AudioEditor", "DataValidation", "NiagaraEditor"
+            });
+
+            PrivateDependencyModuleNames.AddRange(new string[]
+            {
+                "Landscape","LandscapeEditor","LandscapeEditorUtilities","Foliage","FoliageEdit",
+                "AnimGraph","AnimationBlueprintLibrary","Persona","ToolMenus","EditorWidgets","PropertyEditor","LevelEditor",
+                "ControlRig","ControlRigDeveloper","ControlRigEditor","UMG","UMGEditor","ProceduralMeshComponent","MergeActors",
+                "BehaviorTreeEditor", "RenderCore", "RHI", "AutomationController", "GameplayDebugger", "TraceLog", "TraceAnalysis", "AIModule", "AIGraph",
+                "MeshUtilities", "MaterialUtilities"
+            });
+
+            // Ensure editor builds expose full Blueprint graph editing APIs.
+            PublicDefinitions.Add("MCP_HAS_K2NODE_HEADERS=1");
+            PublicDefinitions.Add("MCP_HAS_EDGRAPH_SCHEMA_K2=1");
+
+            // --- Feature Detection Logic ---
+
+            string EngineDir = Path.GetFullPath(Target.RelativeEnginePath);
+            
+            // 1. SubobjectData Detection
+            // UE 5.7 renamed/moved this to SubobjectDataInterface in Editor/
+            bool bHasSubobjectDataInterface = Directory.Exists(Path.Combine(EngineDir, "Source", "Editor", "SubobjectDataInterface"));
+            
+            if (bHasSubobjectDataInterface)
+            {
+                PrivateDependencyModuleNames.Add("SubobjectDataInterface");
+                PublicDefinitions.Add("MCP_HAS_SUBOBJECT_DATA_SUBSYSTEM=1");
+            }
+            else
+            {
+                // Fallback for older versions
+                if (!PrivateDependencyModuleNames.Contains("SubobjectData"))
+                {
+                    PrivateDependencyModuleNames.Add("SubobjectData");
+                }
+                PublicDefinitions.Add("MCP_HAS_SUBOBJECT_DATA_SUBSYSTEM=1");
+            }
+
+            // 2. WorldPartition Support Detection
+            // Detect whether UWorldPartition supports ForEachDataLayerInstance
+            bool bHasWPForEach = false;
+            try
+            {
+                // In UE 5.7, ForEachDataLayerInstance moved to DataLayerManager.h
+                string WPHeader = Path.Combine(EngineDir, "Source", "Runtime", "Engine", "Public", "WorldPartition", "DataLayer", "DataLayerManager.h");
+                if (!File.Exists(WPHeader))
+                {
+                    // Fallback to old location for older engines
+                    WPHeader = Path.Combine(EngineDir, "Source", "Runtime", "Engine", "Public", "WorldPartition", "WorldPartition.h");
+                }
+
+                if (File.Exists(WPHeader))
+                {
+                    string Content = File.ReadAllText(WPHeader);
+                    if (Content.Contains("ForEachDataLayerInstance("))
+                    {
+                        bHasWPForEach = true;
+                    }
+                }
+            }
+            catch {}
+
+            PublicDefinitions.Add(bHasWPForEach ? "MCP_HAS_WP_FOR_EACH_DATALAYER=1" : "MCP_HAS_WP_FOR_EACH_DATALAYER=0");
+
+            // Ensure Win64 debug builds emit Edit-and-Continue friendly debug info
+            if (Target.Platform == UnrealTargetPlatform.Win64 && Target.Configuration == UnrealTargetConfiguration.Debug)
+            {
+                PublicDefinitions.Add("MCP_ENABLE_EDIT_AND_CONTINUE=1");
+            }
+
+            // Control Rig Factory Support
+            PublicDefinitions.Add("MCP_HAS_CONTROLRIG_FACTORY=1");
+        }
+        else
+        {
+            // Non-editor builds cannot rely on editor-only headers.
+            PublicDefinitions.Add("MCP_HAS_K2NODE_HEADERS=0");
+            PublicDefinitions.Add("MCP_HAS_EDGRAPH_SCHEMA_K2=0");
+            PublicDefinitions.Add("MCP_HAS_SUBOBJECT_DATA_SUBSYSTEM=0");
+            PublicDefinitions.Add("MCP_HAS_WP_FOR_EACH_DATALAYER=0");
+        }
+    }
+
+    /// <summary>
+    /// Determines whether a SubobjectData module or plugin exists under the given engine directory.
+    /// </summary>
+    /// <param name="EngineDir">Absolute path to the engine root directory to inspect.</param>
+    /// <returns>`true` if a SubobjectData directory is found in EngineDir/Source/Runtime/SubobjectData or anywhere under EngineDir/Plugins/Runtime; `false` if not found or if an error occurs.</returns>
+    private bool IsSubobjectDataAvailable(string EngineDir)
+    {
+        try
+        {
+            if (string.IsNullOrEmpty(EngineDir)) return false;
+            
+            // Check Runtime module
+            string RuntimeDir = Path.Combine(EngineDir, "Source", "Runtime", "SubobjectData");
+            if (Directory.Exists(RuntimeDir)) return true;
+
+            // Check Plugins
+            string PluginsDir = Path.Combine(EngineDir, "Plugins");
+            if (Directory.Exists(PluginsDir))
+            {
+                // Simple check for the folder in Runtime plugins
+                // A full recursive search might be slow, but we can check common locations or do a search
+                // The original code did a recursive search in Plugins/Runtime
+                string PluginsRuntime = Path.Combine(PluginsDir, "Runtime");
+                if (Directory.Exists(PluginsRuntime))
+                {
+                     var Found = Directory.GetDirectories(PluginsRuntime, "SubobjectData", SearchOption.AllDirectories);
+                     if (Found.Length > 0) return true;
+                }
+            }
+        }
+        catch {}
+        return false;
+    }
+
+    /// <summary>
+    /// Determines whether the current project contains a "SubobjectData" directory inside its Plugins folder by searching upward from the provided module directory for the project root (.uproject).
+    /// </summary>
+    /// <param name="ModuleDir">Path to the module directory used as the starting point to locate the project root.</param>
+    /// <returns>`true` if a "SubobjectData" directory is found under the project's Plugins directory, `false` otherwise.</returns>
+    private bool IsSubobjectDataInProject(string ModuleDir)
+    {
+        try
+        {
+            // Find project root by looking for .uproject
+            string ProjectRoot = null;
+            DirectoryInfo Dir = new DirectoryInfo(ModuleDir);
+            while (Dir != null)
+            {
+                if (Dir.GetFiles("*.uproject").Length > 0) 
+                { 
+                    ProjectRoot = Dir.FullName; 
+                    break; 
+                }
+                Dir = Dir.Parent;
+            }
+
+            if (!string.IsNullOrEmpty(ProjectRoot))
+            {
+                string ProjPlugins = Path.Combine(ProjectRoot, "Plugins");
+                if (Directory.Exists(ProjPlugins))
+                {
+                    var Found = Directory.GetDirectories(ProjPlugins, "SubobjectData", SearchOption.AllDirectories);
+                    if (Found.Length > 0) return true;
+                }
+            }
+        }
+        catch {}
+        return false;
+    }
+}

package/plugins/McpAutomationBridge/Source/McpAutomationBridge/Private/McpAutomationBridgeGlobals.cpp

@@ -0,0 +1,22 @@
+#include "McpAutomationBridgeGlobals.h"
+
+TMap<FString, TArray<TPair<FString, TSharedPtr<FMcpBridgeWebSocket>>>>
+    GBlueprintExistsInflight;
+TMap<FString, TArray<TPair<FString, TSharedPtr<FMcpBridgeWebSocket>>>>
+    GBlueprintCreateInflight;
+TMap<FString, double> GBlueprintCreateInflightTs;
+FCriticalSection GBlueprintCreateMutex;
+double GBlueprintCreateStaleTimeoutSec = 60.0;
+TSet<FString> GBlueprintBusySet;
+TMap<FString, TSharedPtr<FJsonObject>> GBlueprintRegistry;
+
+TMap<FString, TSharedPtr<FJsonObject>> GSequenceRegistry;
+FString GCurrentSequencePath;
+
+TMap<FString, TSharedPtr<FJsonObject>> GNiagaraRegistry;
+
+// Recent asset save tracking (throttle across plugin to avoid frequent
+// SavePackage calls)
+TMap<FString, double> GRecentAssetSaveTs;
+FCriticalSection GRecentAssetSaveMutex;
+double GRecentAssetSaveThrottleSeconds = 0.5;

package/plugins/McpAutomationBridge/Source/McpAutomationBridge/Private/McpAutomationBridgeGlobals.h

@@ -0,0 +1,30 @@
+// Shared globals for McpAutomationBridge plugin
+#pragma once
+
+#include "CoreMinimal.h"
+#include "HAL/CriticalSection.h"
+
+extern TMap<FString,
+            TArray<TPair<FString, TSharedPtr<class FMcpBridgeWebSocket>>>>
+    GBlueprintExistsInflight;
+extern TMap<FString,
+            TArray<TPair<FString, TSharedPtr<class FMcpBridgeWebSocket>>>>
+    GBlueprintCreateInflight;
+extern TMap<FString, double> GBlueprintCreateInflightTs;
+extern FCriticalSection GBlueprintCreateMutex;
+extern double GBlueprintCreateStaleTimeoutSec;
+extern TSet<FString> GBlueprintBusySet;
+extern TMap<FString, TSharedPtr<FJsonObject>> GBlueprintRegistry;
+
+extern TMap<FString, TSharedPtr<FJsonObject>> GSequenceRegistry;
+extern FString GCurrentSequencePath;
+
+// Lightweight registry used for created Niagara systems when running in
+// fast-mode or when native Niagara factories are not available. Tests and
+// higher-level tooling may rely on a plugin-side record of created
+// Niagara assets even when on-disk creation is not possible.
+extern TMap<FString, TSharedPtr<FJsonObject>> GNiagaraRegistry;
+
+extern TMap<FString, double> GRecentAssetSaveTs;
+extern FCriticalSection GRecentAssetSaveMutex;
+extern double GRecentAssetSaveThrottleSeconds;