flockbay 0.10.19 → 0.10.21

package/tools/unreal-mcp/upstream/MCPGameProject/Plugins/UnrealMCP/Source/UnrealMCP/Private/Commands/UnrealMCPEditorCommands.cpp

@@ -27,6 +27,8 @@
 #include "Components/StaticMeshComponent.h"
 #include "Materials/MaterialInterface.h"
 #include "Sound/SoundWave.h"
+#include "IImageWrapper.h"
+#include "IImageWrapperModule.h"
 #include "EditorSubsystem.h"
 #include "Subsystems/EditorActorSubsystem.h"
 #include "Engine/Blueprint.h"
@@ -49,6 +51,35 @@
 #include "Engine/EngineTypes.h"
 #include "GameFramework/PlayerController.h"
 #include "Camera/PlayerCameraManager.h"
+#include "Engine/LocalPlayer.h"
+#include "Engine/SceneCapture2D.h"
+#include "Components/SceneCaptureComponent2D.h"
+#include "Engine/TextureRenderTarget2D.h"
+
+static bool SavePngToFile(const FString& FilePath, int32 Width, int32 Height, const TArray<FColor>& Bitmap)
+{
+	IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper"));
+	TSharedPtr<IImageWrapper> Wrapper = ImageWrapperModule.CreateImageWrapper(EImageFormat::PNG);
+	if (!Wrapper.IsValid())
+	{
+		return false;
+	}
+
+	if (!Wrapper->SetRaw(Bitmap.GetData(), Bitmap.Num() * sizeof(FColor), Width, Height, ERGBFormat::BGRA, 8))
+	{
+		return false;
+	}
+
+	const TArray64<uint8>& Compressed = Wrapper->GetCompressed(100);
+	if (Compressed.Num() <= 0 || Compressed.Num() > MAX_int32)
+	{
+		return false;
+	}
+
+	TArray<uint8> Out;
+	Out.Append(Compressed.GetData(), static_cast<int32>(Compressed.Num()));
+	return FFileHelper::SaveArrayToFile(Out, *FilePath);
+}
 
 FUnrealMCPEditorCommands::FUnrealMCPEditorCommands()
 {
@@ -215,7 +246,7 @@ TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleSaveAll(const TSharedPtr
     }
 
     TArray<UPackage*> DirtyBefore;
-    FEditorFileUtils::GetDirtyPackages(DirtyBefore, /*bIncludeMapPackages=*/true, /*bIncludeContentPackages=*/true);
+    FEditorFileUtils::GetDirtyPackages(DirtyBefore);
 
     TSet<FString> DirtyBeforeNames;
     for (UPackage* Pkg : DirtyBefore)
@@ -235,7 +266,7 @@ TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleSaveAll(const TSharedPtr
     );
 
     TArray<UPackage*> DirtyAfter;
-    FEditorFileUtils::GetDirtyPackages(DirtyAfter, /*bIncludeMapPackages=*/true, /*bIncludeContentPackages=*/true);
+    FEditorFileUtils::GetDirtyPackages(DirtyAfter);
 
     TSet<FString> DirtyAfterNames;
     for (UPackage* Pkg : DirtyAfter)
@@ -289,8 +320,7 @@ TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleSaveAll(const TSharedPtr
         Details->SetArrayField(TEXT("stillDirtyPackages"), StillDirty);
 
         TSharedPtr<FJsonObject> ErrObj = FUnrealMCPCommonUtils::CreateErrorResponse(
-            TEXT("Some packages are still dirty after save_all. They may require manual Save As, source control checkout, or have save errors. Resolve in-editor and retry save_all."),
-        );
+            TEXT("Some packages are still dirty after save_all. They may require manual Save As, source control checkout, or have save errors. Resolve in-editor and retry save_all."));
         ErrObj->SetObjectField(TEXT("details"), Details);
         return ErrObj;
     }
@@ -2295,26 +2325,188 @@ TSharedPtr<FJsonObject> FUnrealMCPEditorCommands::HandleTakeScreenshot(const TSh
         FilePath += TEXT(".png");
     }
 
-    // Get the active viewport
+    FString Source = TEXT("auto");
+    if (Params->TryGetStringField(TEXT("source"), Source))
+    {
+        Source = Source.TrimStartAndEnd().ToLower();
+        if (Source.IsEmpty())
+        {
+            Source = TEXT("auto");
+        }
+    }
+
+    double WidthNum = 0.0;
+    double HeightNum = 0.0;
+    int32 RequestedWidth = 0;
+    int32 RequestedHeight = 0;
+    if (Params->TryGetNumberField(TEXT("width"), WidthNum))
+    {
+        RequestedWidth = static_cast<int32>(WidthNum);
+    }
+    else if (Params->TryGetNumberField(TEXT("resX"), WidthNum))
+    {
+        RequestedWidth = static_cast<int32>(WidthNum);
+    }
+
+    if (Params->TryGetNumberField(TEXT("height"), HeightNum))
+    {
+        RequestedHeight = static_cast<int32>(HeightNum);
+    }
+    else if (Params->TryGetNumberField(TEXT("resY"), HeightNum))
+    {
+        RequestedHeight = static_cast<int32>(HeightNum);
+    }
+
+    const bool bPieRunning = (GEditor && GEditor->PlayWorld);
+    const bool bWantsPie = (Source == TEXT("pie"));
+    const bool bWantsEditor = (Source == TEXT("editor"));
+    const bool bAuto = (Source == TEXT("auto"));
+    if (!bWantsPie && !bWantsEditor && !bAuto)
+    {
+        return FUnrealMCPCommonUtils::CreateErrorResponse(FString::Printf(TEXT("Invalid screenshot source: %s (expected: auto|pie|editor)"), *Source));
+    }
+
+    const bool bUsePieCapture = bWantsPie || (bAuto && bPieRunning);
+    if (bUsePieCapture)
+    {
+        if (!bPieRunning)
+        {
+            return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("PIE is not running (PlayWorld is null)."));
+        }
+
+        UWorld* PlayWorld = GEditor->PlayWorld;
+        APlayerController* PC = PlayWorld ? PlayWorld->GetFirstPlayerController() : nullptr;
+        if (!PC)
+        {
+            return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to find PlayerController in PlayWorld."));
+        }
+
+        APlayerCameraManager* PCM = PC->PlayerCameraManager;
+        if (!PCM)
+        {
+            return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to find PlayerCameraManager (PlayerController.PlayerCameraManager is null)."));
+        }
+
+        int32 Width = RequestedWidth;
+        int32 Height = RequestedHeight;
+        if (Width <= 0 || Height <= 0)
+        {
+            if (ULocalPlayer* LocalPlayer = PC->GetLocalPlayer())
+            {
+                if (LocalPlayer->ViewportClient && LocalPlayer->ViewportClient->Viewport)
+                {
+                    const FIntPoint ViewSize = LocalPlayer->ViewportClient->Viewport->GetSizeXY();
+                    if (ViewSize.X > 0 && ViewSize.Y > 0)
+                    {
+                        if (Width <= 0)
+                        {
+                            Width = ViewSize.X;
+                        }
+                        if (Height <= 0)
+                        {
+                            Height = ViewSize.Y;
+                        }
+                    }
+                }
+            }
+        }
+
+        if (Width <= 0 || Height <= 0)
+        {
+            Width = 1280;
+            Height = 720;
+        }
+
+        const FVector CamLocation = PCM->GetCameraLocation();
+        const FRotator CamRotation = PCM->GetCameraRotation();
+
+        FActorSpawnParameters SpawnParams;
+        SpawnParams.ObjectFlags |= RF_Transient;
+        SpawnParams.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
+
+        ASceneCapture2D* CaptureActor = PlayWorld->SpawnActor<ASceneCapture2D>(ASceneCapture2D::StaticClass(), CamLocation, CamRotation, SpawnParams);
+        if (!CaptureActor)
+        {
+            return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to spawn ASceneCapture2D for PIE screenshot capture."));
+        }
+
+        USceneCaptureComponent2D* CaptureComp = CaptureActor->GetCaptureComponent2D();
+        if (!CaptureComp)
+        {
+            CaptureActor->Destroy();
+            return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to get SceneCaptureComponent2D from ASceneCapture2D."));
+        }
+
+        UTextureRenderTarget2D* RenderTarget = NewObject<UTextureRenderTarget2D>(CaptureComp);
+        if (!RenderTarget)
+        {
+            CaptureActor->Destroy();
+            return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to create UTextureRenderTarget2D."));
+        }
+        RenderTarget->InitCustomFormat(Width, Height, PF_B8G8R8A8, /*bForceLinearGamma*/ false);
+        RenderTarget->ClearColor = FLinearColor::Black;
+        RenderTarget->UpdateResourceImmediate(true);
+
+        CaptureComp->TextureTarget = RenderTarget;
+        CaptureComp->bCaptureEveryFrame = false;
+        CaptureComp->bCaptureOnMovement = false;
+        CaptureComp->CaptureSource = ESceneCaptureSource::SCS_FinalColorLDR;
+        CaptureComp->FOVAngle = PCM->GetFOVAngle();
+
+        CaptureComp->CaptureScene();
+
+        FTextureRenderTargetResource* RenderResource = RenderTarget->GameThread_GetRenderTargetResource();
+        if (!RenderResource)
+        {
+            CaptureActor->Destroy();
+            return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to get render target resource for PIE screenshot capture."));
+        }
+
+        TArray<FColor> Bitmap;
+        if (!RenderResource->ReadPixels(Bitmap))
+        {
+            CaptureActor->Destroy();
+            return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to read pixels from PIE render target."));
+        }
+
+        CaptureActor->Destroy();
+
+        if (!SavePngToFile(FilePath, Width, Height, Bitmap))
+        {
+            return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to save screenshot PNG to disk."));
+        }
+
+        TSharedPtr<FJsonObject> ResultObj = MakeShared<FJsonObject>();
+        ResultObj->SetStringField(TEXT("filepath"), FilePath);
+        ResultObj->SetStringField(TEXT("source"), TEXT("pie"));
+        ResultObj->SetNumberField(TEXT("width"), Width);
+        ResultObj->SetNumberField(TEXT("height"), Height);
+        return ResultObj;
+    }
+
+    // Editor viewport screenshot (can be stale if the OS window is not focused; prefer PIE capture when playing).
     if (GEditor && GEditor->GetActiveViewport())
     {
+        GEditor->RedrawAllViewports(/*bInvalidateHitProxies*/ true);
+
         FViewport* Viewport = GEditor->GetActiveViewport();
+        const FIntPoint ViewSize = Viewport->GetSizeXY();
         TArray<FColor> Bitmap;
-        FIntRect ViewportRect(0, 0, Viewport->GetSizeXY().X, Viewport->GetSizeXY().Y);
-        
+        FIntRect ViewportRect(0, 0, ViewSize.X, ViewSize.Y);
+
         if (Viewport->ReadPixels(Bitmap, FReadSurfaceDataFlags(), ViewportRect))
         {
-            TArray<uint8> CompressedBitmap;
-            FImageUtils::CompressImageArray(Viewport->GetSizeXY().X, Viewport->GetSizeXY().Y, Bitmap, CompressedBitmap);
-            
-            if (FFileHelper::SaveArrayToFile(CompressedBitmap, *FilePath))
+            if (SavePngToFile(FilePath, ViewSize.X, ViewSize.Y, Bitmap))
             {
                 TSharedPtr<FJsonObject> ResultObj = MakeShared<FJsonObject>();
                 ResultObj->SetStringField(TEXT("filepath"), FilePath);
+                ResultObj->SetStringField(TEXT("source"), TEXT("editor"));
+                ResultObj->SetNumberField(TEXT("width"), ViewSize.X);
+                ResultObj->SetNumberField(TEXT("height"), ViewSize.Y);
                 return ResultObj;
             }
         }
     }
-    
-    return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to take screenshot"));
+
+    return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Failed to take screenshot."));
 } 

package/tools/unreal-mcp/upstream/MCPGameProject/Plugins/UnrealMCP/Source/UnrealMCP/UnrealMCP.Build.cs

@@ -45,6 +45,7 @@ public class UnrealMCP : ModuleRules
 				"EditorScriptingUtilities",
 				"EditorSubsystem",
 				"Landscape",
+				"ImageWrapper",
 				"Slate",
 				"SlateCore",
 				"MessageLog",