[FEATURE] Camera Capture

MCPForUnity/Editor/Tools/ManageScene.cs

@@ -3,6 +3,7 @@
 using System.IO;
 using System.Linq;
 using MCPForUnity.Editor.Helpers; // For Response class
+using MCPForUnity.Runtime.Helpers; // For ScreenshotUtility
 using Newtonsoft.Json.Linq;
 using UnityEditor;
 using UnityEditor.SceneManagement;
@@ -23,6 +24,8 @@ private sealed class SceneCommand
             public string name { get; set; } = string.Empty;
             public string path { get; set; } = string.Empty;
             public int? buildIndex { get; set; }
+            public string fileName { get; set; } = string.Empty;
+            public int? superSize { get; set; }
         }
 
         private static SceneCommand ToSceneCommand(JObject p)
@@ -42,7 +45,9 @@ private static SceneCommand ToSceneCommand(JObject p)
                 action = (p["action"]?.ToString() ?? string.Empty).Trim().ToLowerInvariant(),
                 name = p["name"]?.ToString() ?? string.Empty,
                 path = p["path"]?.ToString() ?? string.Empty,
-                buildIndex = BI(p["buildIndex"] ?? p["build_index"])
+                buildIndex = BI(p["buildIndex"] ?? p["build_index"]),
+                fileName = (p["fileName"] ?? p["filename"])?.ToString() ?? string.Empty,
+                superSize = BI(p["superSize"] ?? p["super_size"] ?? p["supersize"])
             };
         }
 
@@ -142,14 +147,26 @@ public static object HandleCommand(JObject @params)
                     return ga;
                 case "get_build_settings":
                     return GetBuildSettingsScenes();
+                case "screenshot":
+                    return CaptureScreenshot(cmd.fileName, cmd.superSize);
                 // Add cases for modifying build settings, additive loading, unloading etc.
                 default:
                     return new ErrorResponse(
-                        $"Unknown action: '{action}'. Valid actions: create, load, save, get_hierarchy, get_active, get_build_settings."
+                        $"Unknown action: '{action}'. Valid actions: create, load, save, get_hierarchy, get_active, get_build_settings, screenshot."
                     );
             }
         }
 
+        /// <summary>
+        /// Captures a screenshot to Assets/Screenshots and returns a response payload.
+        /// Public so the tools UI can reuse the same logic without duplicating parameters.
+        /// Available in both Edit Mode and Play Mode.
+        /// </summary>
+        public static object ExecuteScreenshot(string fileName = null, int? superSize = null)
+        {
+            return CaptureScreenshot(fileName, superSize);
+        }
+
         private static object CreateScene(string fullPath, string relativePath)
         {
             if (File.Exists(fullPath))
@@ -329,6 +346,55 @@ private static object SaveScene(string fullPath, string relativePath)
             }
         }
 
+        private static object CaptureScreenshot(string fileName, int? superSize)
+        {
+            try
+            {
+                int resolvedSuperSize = (superSize.HasValue && superSize.Value > 0) ? superSize.Value : 1;
+                ScreenshotCaptureResult result;
+
+                if (Application.isPlaying)
+                {
+                    result = ScreenshotUtility.CaptureToAssetsFolder(fileName, resolvedSuperSize, ensureUniqueFileName: true);
+                }
+                else
+                {
+                    // Edit Mode path: render from the best-guess camera using RenderTexture.
+                    Camera cam = Camera.main;
+                    if (cam == null)
+                    {
+                        var cams = UnityEngine.Object.FindObjectsOfType<Camera>();
+                        cam = cams.FirstOrDefault();
+                    }
+
+                    if (cam == null)
+                    {
+                        return new ErrorResponse("No camera found to capture screenshot in Edit Mode.");
+                    }
+
+                    result = ScreenshotUtility.CaptureFromCameraToAssetsFolder(cam, fileName, resolvedSuperSize, ensureUniqueFileName: true);
+                }
+
+                AssetDatabase.Refresh();
+
+                string message = $"Screenshot captured to '{result.AssetsRelativePath}' (full: {result.FullPath}).";
+
+                return new SuccessResponse(
+                    message,
+                    new
+                    {
+                        path = result.AssetsRelativePath,
+                        fullPath = result.FullPath,
+                        superSize = result.SuperSize,
+                    }
+                );
+            }
+            catch (Exception e)
+            {
+                return new ErrorResponse($"Error capturing screenshot: {e.Message}");
+            }
+        }
+
         private static object GetActiveSceneInfo()
         {
             try

MCPForUnity/Editor/Windows/Components/Tools/McpToolsSection.cs

@@ -4,6 +4,7 @@
 using MCPForUnity.Editor.Constants;
 using MCPForUnity.Editor.Helpers;
 using MCPForUnity.Editor.Services;
+using MCPForUnity.Editor.Tools;
 using UnityEditor;
 using UnityEngine.UIElements;
 
@@ -199,6 +200,11 @@ private VisualElement CreateToolRow(ToolMetadata tool)
                 row.Add(parametersLabel);
             }
 
+            if (IsManageSceneTool(tool))
+            {
+                row.Add(CreateManageSceneActions());
+            }
+
             return row;
         }
 
@@ -258,13 +264,56 @@ private void AddInfoLabel(string message)
             categoryContainer?.Add(label);
         }
 
+        private VisualElement CreateManageSceneActions()
+        {
+            var actions = new VisualElement();
+            actions.AddToClassList("tool-item-actions");
+
+            var screenshotButton = new Button(OnManageSceneScreenshotClicked)
+            {
+                text = "Capture Screenshot"
+            };
+            screenshotButton.AddToClassList("tool-action-button");
+            screenshotButton.style.marginTop = 4;
+            screenshotButton.tooltip = "Capture a screenshot to Assets/Screenshots via manage_scene.";
+
+            actions.Add(screenshotButton);
+            return actions;
+        }
+
+        private void OnManageSceneScreenshotClicked()
+        {
+            try
+            {
+                var response = ManageScene.ExecuteScreenshot();
+                if (response is SuccessResponse success && !string.IsNullOrWhiteSpace(success.Message))
+                {
+                    McpLog.Info(success.Message);
+                }
+                else if (response is ErrorResponse error && !string.IsNullOrWhiteSpace(error.Error))
+                {
+                    McpLog.Error(error.Error);
+                }
+                else
+                {
+                    McpLog.Info("Screenshot capture requested.");
+                }
+            }
+            catch (Exception ex)
+            {
+                McpLog.Error($"Failed to capture screenshot: {ex.Message}");
+            }
+        }
+
         private static Label CreateTag(string text)
         {
             var tag = new Label(text);
             tag.AddToClassList("tool-tag");
             return tag;
         }
 
+        private static bool IsManageSceneTool(ToolMetadata tool) => string.Equals(tool?.Name, "manage_scene", StringComparison.OrdinalIgnoreCase);
+
         private static bool IsBuiltIn(ToolMetadata tool) => tool?.IsBuiltIn ?? false;
     }
 }