Fix and GUI update

Author: Scriptwonder

MCPForUnity/Editor/Tools/Cameras/CameraControl.cs

@@ -244,17 +244,17 @@ internal static object ForceCamera(JObject @params)
 
             try
             {
-                // ICinemachineCamera interface
-                var icmInterface = cmCamera.GetType().GetInterface("ICinemachineCamera")
-                                ?? cmCamera.GetType().GetInterface("Unity.Cinemachine.ICinemachineCamera");
-
+                // CM3 signature: SetCameraOverride(int overrideId, int priority,
+                //   ICinemachineCamera camA, ICinemachineCamera camB, float weightB, float deltaTime)
+                // -1 for overrideId creates a new override; same cam for A+B with weight=1 = instant switch
                 _overrideId = (int)method.Invoke(brain, new object[]
                 {
-                    _overrideId >= 0 ? _overrideId : 0,
-                    cmCamera, // overrideCamera
-                    cmCamera, // fromCamera (blend from current)
-                    0f,       // blend time = instant
-                    -1f       // timeout = permanent
+                    _overrideId >= 0 ? _overrideId : -1,
+                    999,      // high priority to win over all others
+                    cmCamera, // camA (at weight=0)
+                    cmCamera, // camB (at weight=1) — same camera = no blend
+                    1f,       // weightB = fully on camB
+                    -1f       // deltaTime = use default
                 });
             }
             catch (Exception ex)

MCPForUnity/Editor/Tools/Cameras/ManageCamera.cs

@@ -59,6 +59,20 @@ public static object HandleCommand(JObject @params)
 
                     case "list_cameras":
                         return CameraControl.ListCameras(@params);
+
+                    case "screenshot":
+                    case "screenshot_multiview":
+                    {
+                        // Delegate to ManageScene's screenshot infrastructure
+                        var shotParams = new JObject(@params);
+                        shotParams["action"] = "screenshot";
+                        if (action == "screenshot_multiview")
+                        {
+                            shotParams["batch"] = "surround";
+                            shotParams["includeImage"] = true;
+                        }
+                        return ManageScene.HandleCommand(shotParams);
+                    }
                 }
 
                 // Tier 2: Cinemachine-only actions
@@ -104,7 +118,8 @@ public static object HandleCommand(JObject @params)
                     default:
                         return new ErrorResponse(
                             $"Unknown action: '{action}'. Valid actions: ping, create_camera, set_target, "
-                            + "set_lens, set_priority, list_cameras, ensure_brain, get_brain_status, "
+                            + "set_lens, set_priority, list_cameras, screenshot, screenshot_multiview, "
+                            + "ensure_brain, get_brain_status, "
                             + "set_body, set_aim, set_noise, add_extension, remove_extension, "
                             + "set_blend, force_camera, release_override.");
                 }

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

@@ -319,7 +319,7 @@ private VisualElement CreateToolRow(ToolMetadata tool)
                 row.Add(parametersLabel);
             }
 
-            if (IsManageSceneTool(tool))
+            if (IsManageSceneTool(tool) || IsManageCameraTool(tool))
             {
                 row.Add(CreateManageSceneActions());
             }
@@ -734,6 +734,8 @@ private static Label CreateTag(string text)
 
         private static bool IsManageSceneTool(ToolMetadata tool) => string.Equals(tool?.Name, "manage_scene", StringComparison.OrdinalIgnoreCase);
 
+        private static bool IsManageCameraTool(ToolMetadata tool) => string.Equals(tool?.Name, "manage_camera", StringComparison.OrdinalIgnoreCase);
+
         private static bool IsBatchExecuteTool(ToolMetadata tool) => string.Equals(tool?.Name, "batch_execute", StringComparison.OrdinalIgnoreCase);
 
         private static bool IsBuiltIn(ToolMetadata tool) => tool?.IsBuiltIn ?? false;

Server/src/cli/commands/camera.py

@@ -469,3 +469,68 @@ def release_override():
     config = get_config()
     result = run_command(config, "manage_camera", {"action": "release_override"})
     format_output(result, config)
+
+
+# =============================================================================
+# Capture
+# =============================================================================
+
+@camera.command("screenshot")
+@click.option("--camera-ref", default=None, help="Camera to capture from (name/path/ID).")
+@click.option("--file-name", default=None, help="Output file name.")
+@click.option("--super-size", type=int, default=None, help="Supersize multiplier.")
+@click.option("--include-image/--no-include-image", default=None, help="Return inline base64 PNG.")
+@click.option("--max-resolution", type=int, default=None, help="Max resolution for inline image.")
+@click.option("--batch", default=None, type=click.Choice(["surround", "orbit"]),
+              help="Batch capture mode.")
+@click.option("--look-at", default=None, help="Target to aim at (name/path/ID or [x,y,z]).")
+@handle_unity_errors
+def screenshot(camera_ref, file_name, super_size, include_image, max_resolution, batch, look_at):
+    """Capture a screenshot from a camera.
+
+    \b
+    Examples:
+        unity-mcp camera screenshot
+        unity-mcp camera screenshot --camera-ref "CM FollowCam" --include-image --max-resolution 512
+        unity-mcp camera screenshot --batch surround --look-at Player
+    """
+    config = get_config()
+    params: dict[str, Any] = {"action": "screenshot"}
+    if camera_ref:
+        params["camera"] = camera_ref
+    if file_name:
+        params["fileName"] = file_name
+    if super_size is not None:
+        params["superSize"] = super_size
+    if include_image is not None:
+        params["includeImage"] = include_image
+    if max_resolution is not None:
+        params["maxResolution"] = max_resolution
+    if batch:
+        params["batch"] = batch
+    if look_at:
+        params["lookAt"] = look_at
+    result = run_command(config, "manage_camera", params)
+    format_output(result, config)
+
+
+@camera.command("screenshot-multiview")
+@click.option("--max-resolution", type=int, default=None, help="Max resolution per tile.")
+@click.option("--look-at", default=None, help="Center target for the multiview capture.")
+@handle_unity_errors
+def screenshot_multiview(max_resolution, look_at):
+    """Capture a 6-angle contact sheet around the scene.
+
+    \b
+    Examples:
+        unity-mcp camera screenshot-multiview
+        unity-mcp camera screenshot-multiview --look-at Player --max-resolution 480
+    """
+    config = get_config()
+    params: dict[str, Any] = {"action": "screenshot_multiview"}
+    if max_resolution is not None:
+        params["maxResolution"] = max_resolution
+    if look_at:
+        params["lookAt"] = look_at
+    result = run_command(config, "manage_camera", params)
+    format_output(result, config)

Server/src/services/tools/manage_camera.py

@@ -1,10 +1,13 @@
+import json
 from typing import Annotated, Any, Literal
 
 from fastmcp import Context
-from mcp.types import ToolAnnotations
+from fastmcp.server.server import ToolResult
+from mcp.types import ToolAnnotations, TextContent, ImageContent
 
 from services.registry import mcp_for_unity_tool
 from services.tools import get_unity_instance_from_context
+from services.tools.utils import coerce_int, coerce_bool, normalize_vector3
 from transport.unity_transport import send_with_unity_instance
 from transport.legacy.unity_connection import async_send_command_with_retry
 
@@ -24,7 +27,57 @@
     "set_blend", "force_camera", "release_override", "list_cameras",
 ]
 
-ALL_ACTIONS = SETUP_ACTIONS + CREATION_ACTIONS + CONFIGURATION_ACTIONS + EXTENSION_ACTIONS + CONTROL_ACTIONS
+CAPTURE_ACTIONS = ["screenshot", "screenshot_multiview"]
+
+ALL_ACTIONS = SETUP_ACTIONS + CREATION_ACTIONS + CONFIGURATION_ACTIONS + EXTENSION_ACTIONS + CONTROL_ACTIONS + CAPTURE_ACTIONS
+
+
+def _extract_images(response: dict[str, Any], action: str) -> ToolResult | None:
+    """If the Unity response contains inline base64 images, return a ToolResult
+    with TextContent + ImageContent blocks. Returns None for normal text-only responses."""
+    if not isinstance(response, dict) or not response.get("success"):
+        return None
+
+    data = response.get("data")
+    if not isinstance(data, dict):
+        return None
+
+    # Batch images (surround/orbit mode) — multiple screenshots in one response
+    screenshots = data.get("screenshots")
+    if screenshots and isinstance(screenshots, list):
+        blocks: list[TextContent | ImageContent] = []
+        summary_screenshots = []
+        for s in screenshots:
+            summary_screenshots.append({k: v for k, v in s.items() if k != "imageBase64"})
+        text_result = {
+            "success": True,
+            "message": response.get("message", ""),
+            "data": {
+                "sceneCenter": data.get("sceneCenter"),
+                "sceneRadius": data.get("sceneRadius"),
+                "screenshots": summary_screenshots,
+            },
+        }
+        blocks.append(TextContent(type="text", text=json.dumps(text_result)))
+        for s in screenshots:
+            b64 = s.get("imageBase64")
+            if b64:
+                blocks.append(TextContent(type="text", text=f"[Angle: {s.get('angle', '?')}]"))
+                blocks.append(ImageContent(type="image", data=b64, mimeType="image/png"))
+        return ToolResult(content=blocks)
+
+    # Single image (include_image or positioned capture) or contact sheet
+    image_b64 = data.get("imageBase64")
+    if not image_b64:
+        return None
+    text_data = {k: v for k, v in data.items() if k != "imageBase64"}
+    text_result = {"success": True, "message": response.get("message", ""), "data": text_data}
+    return ToolResult(
+        content=[
+            TextContent(type="text", text=json.dumps(text_result)),
+            ImageContent(type="image", data=image_b64, mimeType="image/png"),
+        ],
+    )
 
 
 @mcp_for_unity_tool(
@@ -55,7 +108,12 @@
         "- set_blend: Configure default blend (style: Cut/EaseInOut/Linear/etc., duration)\n"
         "- force_camera: Override Brain to use specific camera\n"
         "- release_override: Release camera override\n"
-        "- list_cameras: List all cameras with status\n"
+        "- list_cameras: List all cameras with status\n\n"
+        "CAPTURE:\n"
+        "- screenshot: Capture from a camera. Supports include_image=true for inline base64 PNG, "
+        "batch='surround' for 6-angle contact sheet, batch='orbit' for configurable grid, "
+        "look_at/view_position for positioned capture.\n"
+        "- screenshot_multiview: Shorthand for screenshot with batch='surround' and include_image=true."
     ),
     annotations=ToolAnnotations(
         title="Manage Camera",
@@ -74,7 +132,34 @@ async def manage_camera(
         dict[str, Any] | str | None,
         "Action-specific parameters (dict or JSON string).",
     ] = None,
-) -> dict[str, Any]:
+    # --- screenshot params ---
+    screenshot_file_name: Annotated[str | None,
+        "Screenshot file name (optional). Defaults to timestamp."] = None,
+    screenshot_super_size: Annotated[int | str | None,
+        "Screenshot supersize multiplier (integer >= 1)."] = None,
+    camera: Annotated[str | None,
+        "Camera to capture from (name, path, or instance ID). Defaults to Camera.main."] = None,
+    include_image: Annotated[bool | str | None,
+        "If true, return screenshot as inline base64 PNG. Default false."] = None,
+    max_resolution: Annotated[int | str | None,
+        "Max resolution (longest edge px) for inline image. Default 640."] = None,
+    batch: Annotated[str | None,
+        "Batch capture mode: 'surround' (6 angles) or 'orbit' (configurable grid)."] = None,
+    look_at: Annotated[str | int | list[float] | None,
+        "Target to aim camera at. GameObject name/path/ID or [x,y,z]."] = None,
+    view_position: Annotated[list[float] | str | None,
+        "World position [x,y,z] to place camera for positioned capture."] = None,
+    view_rotation: Annotated[list[float] | str | None,
+        "Euler rotation [x,y,z] for camera. Overrides look_at if both provided."] = None,
+    orbit_angles: Annotated[int | str | None,
+        "Number of azimuth samples for batch='orbit' (default 8, max 36)."] = None,
+    orbit_elevations: Annotated[list[float] | str | None,
+        "Elevation angles in degrees for batch='orbit' (default [0, 30, -15])."] = None,
+    orbit_distance: Annotated[float | str | None,
+        "Camera distance from target for batch='orbit' (default auto)."] = None,
+    orbit_fov: Annotated[float | str | None,
+        "Camera FOV in degrees for batch='orbit' (default 60)."] = None,
+) -> dict[str, Any] | ToolResult:
     """Unified camera management tool (Unity Camera + Cinemachine)."""
 
     action_normalized = action.lower()
@@ -86,6 +171,7 @@ async def manage_camera(
             "Configuration": CONFIGURATION_ACTIONS,
             "Extensions": EXTENSION_ACTIONS,
             "Control": CONTROL_ACTIONS,
+            "Capture": CAPTURE_ACTIONS,
         }
         category_list = "; ".join(
             f"{cat}: {', '.join(actions)}" for cat, actions in categories.items()
@@ -108,6 +194,64 @@ async def manage_camera(
     if search_method is not None:
         params_dict["searchMethod"] = search_method
 
+    # Screenshot params — only relevant for screenshot/screenshot_multiview actions
+    if action_normalized in CAPTURE_ACTIONS:
+        if screenshot_file_name:
+            params_dict["fileName"] = screenshot_file_name
+        coerced_super_size = coerce_int(screenshot_super_size, default=None)
+        if coerced_super_size is not None:
+            params_dict["superSize"] = coerced_super_size
+        if camera:
+            params_dict["camera"] = camera
+        coerced_include_image = coerce_bool(include_image, default=None)
+        if coerced_include_image is not None:
+            params_dict["includeImage"] = coerced_include_image
+        coerced_max_resolution = coerce_int(max_resolution, default=None)
+        if coerced_max_resolution is not None:
+            if coerced_max_resolution <= 0:
+                return {"success": False, "message": "max_resolution must be a positive integer."}
+            params_dict["maxResolution"] = coerced_max_resolution
+        if batch:
+            params_dict["batch"] = batch
+        if look_at is not None:
+            params_dict["lookAt"] = look_at
+
+        # Orbit params
+        coerced_orbit_angles = coerce_int(orbit_angles, default=None)
+        if coerced_orbit_angles is not None:
+            params_dict["orbitAngles"] = coerced_orbit_angles
+        if orbit_elevations is not None:
+            if isinstance(orbit_elevations, str):
+                try:
+                    orbit_elevations = json.loads(orbit_elevations)
+                except (ValueError, TypeError):
+                    return {"success": False, "message": "orbit_elevations must be a JSON array of floats."}
+            if not isinstance(orbit_elevations, list) or not all(
+                isinstance(v, (int, float)) for v in orbit_elevations
+            ):
+                return {"success": False, "message": "orbit_elevations must be a list of numbers."}
+            params_dict["orbitElevations"] = orbit_elevations
+        if orbit_distance is not None:
+            try:
+                params_dict["orbitDistance"] = float(orbit_distance)
+            except (ValueError, TypeError):
+                return {"success": False, "message": "orbit_distance must be a number."}
+        if orbit_fov is not None:
+            try:
+                params_dict["orbitFov"] = float(orbit_fov)
+            except (ValueError, TypeError):
+                return {"success": False, "message": "orbit_fov must be a number."}
+        if view_position is not None:
+            vec, err = normalize_vector3(view_position, "view_position")
+            if err:
+                return {"success": False, "message": err}
+            params_dict["viewPosition"] = vec
+        if view_rotation is not None:
+            vec, err = normalize_vector3(view_rotation, "view_rotation")
+            if err:
+                return {"success": False, "message": err}
+            params_dict["viewRotation"] = vec
+
     params_dict = {k: v for k, v in params_dict.items() if v is not None}
 
     result = await send_with_unity_instance(
@@ -117,4 +261,13 @@ async def manage_camera(
         params_dict,
     )
 
-    return result if isinstance(result, dict) else {"success": False, "message": str(result)}
+    if not isinstance(result, dict):
+        return {"success": False, "message": str(result)}
+
+    # For capture actions, check for inline images to return as ImageContent
+    if action_normalized in CAPTURE_ACTIONS:
+        image_result = _extract_images(result, "screenshot")
+        if image_result is not None:
+            return image_result
+
+    return result