@@ -0,0 +1,803 @@
using System ;
using System.Collections.Generic ;
using System.Linq ;
using System.Threading.Tasks ;
using MCPForUnity.Editor.Clients ;
using MCPForUnity.Editor.Constants ;
using MCPForUnity.Editor.Helpers ;
using MCPForUnity.Editor.Models ;
using MCPForUnity.Editor.Services ;
using MCPForUnity.Editor.Services.Transport ;
using MCPForUnity.Editor.Tools ;
using UnityEditor ;
using UnityEditor.UIElements ;
using UnityEngine.UIElements ;
namespace MCPForUnity.Editor.Windows.Components.Tools
{
/// <summary>
/// Controller for the Tools section inside the MCP for Unity editor window.
/// Provides discovery, filtering, and per-tool enablement toggles.
/// Tools are grouped by their Group property (core first, then alphabetical).
/// </summary>
public class McpToolsSection
{
private readonly Dictionary < string , Toggle > toolToggleMap = new ( ) ;
private Toggle projectScopedToolsToggle ;
private Label summaryLabel ;
private Label noteLabel ;
private Button enableAllButton ;
private Button disableAllButton ;
private Button rescanButton ;
private Button reconfigureButton ;
private VisualElement categoryContainer ;
private List < ToolMetadata > allTools = new ( ) ;
private readonly Dictionary < string , Toggle > groupToggleMap = new ( ) ;
private readonly List < ( Foldout foldout , string title , List < ToolMetadata > tools ) > foldoutEntries = new ( ) ;
/// <summary>Human-friendly names for tool groups shown in the UI.</summary>
private static readonly Dictionary < string , string > GroupDisplayNames = new ( StringComparer . OrdinalIgnoreCase )
{
{ "core" , "Core Tools" } ,
{ "vfx" , "VFX & Shaders" } ,
{ "animation" , "Animation" } ,
{ "ui" , "UI Toolkit" } ,
{ "scripting_ext" , "Scripting Extensions" } ,
{ "testing" , "Testing" } ,
{ "probuilder" , "ProBuilder — Experimental" } ,
{ "profiling" , "Profiling & Frame Debugger" } ,
} ;
public VisualElement Root { get ; }
public McpToolsSection ( VisualElement root )
{
Root = root ;
CacheUIElements ( ) ;
RegisterCallbacks ( ) ;
}
private void CacheUIElements ( )
{
projectScopedToolsToggle = Root . Q < Toggle > ( "project-scoped-tools-toggle" ) ;
summaryLabel = Root . Q < Label > ( "tools-summary" ) ;
noteLabel = Root . Q < Label > ( "tools-note" ) ;
enableAllButton = Root . Q < Button > ( "enable-all-button" ) ;
disableAllButton = Root . Q < Button > ( "disable-all-button" ) ;
rescanButton = Root . Q < Button > ( "rescan-button" ) ;
reconfigureButton = Root . Q < Button > ( "reconfigure-button" ) ;
categoryContainer = Root . Q < VisualElement > ( "tool-category-container" ) ;
}
private void RegisterCallbacks ( )
{
if ( projectScopedToolsToggle ! = null )
{
projectScopedToolsToggle . value = EditorPrefs . GetBool (
EditorPrefKeys . ProjectScopedToolsLocalHttp ,
false
) ;
projectScopedToolsToggle . tooltip = "When enabled, register project-scoped tools with HTTP Local and stdio transports. Allows per-project tool customization." ;
projectScopedToolsToggle . RegisterValueChangedCallback ( evt = >
{
EditorPrefs . SetBool ( EditorPrefKeys . ProjectScopedToolsLocalHttp , evt . newValue ) ;
} ) ;
}
if ( enableAllButton ! = null )
{
enableAllButton . AddToClassList ( "tool-action-button" ) ;
enableAllButton . style . marginRight = 4 ;
enableAllButton . clicked + = ( ) = > SetAllToolsState ( true ) ;
}
if ( disableAllButton ! = null )
{
disableAllButton . AddToClassList ( "tool-action-button" ) ;
disableAllButton . style . marginRight = 4 ;
disableAllButton . clicked + = ( ) = > SetAllToolsState ( false ) ;
}
if ( rescanButton ! = null )
{
rescanButton . AddToClassList ( "tool-action-button" ) ;
rescanButton . clicked + = ( ) = >
{
McpLog . Info ( "Rescanning MCP tools from the editor window." ) ;
MCPServiceLocator . ToolDiscovery . InvalidateCache ( ) ;
Refresh ( ) ;
} ;
}
if ( reconfigureButton ! = null )
{
reconfigureButton . AddToClassList ( "tool-action-button" ) ;
reconfigureButton . clicked + = OnReconfigureClientsClicked ;
}
}
/// <summary>
/// Rebuilds the tool list and synchronises toggle states.
/// Tools are displayed in group-based foldouts: core first, then other
/// groups alphabetically. Custom (non-built-in) tools appear in a
/// separate "Custom Tools" foldout at the bottom.
/// </summary>
public void Refresh ( )
{
toolToggleMap . Clear ( ) ;
groupToggleMap . Clear ( ) ;
foldoutEntries . Clear ( ) ;
categoryContainer ? . Clear ( ) ;
var service = MCPServiceLocator . ToolDiscovery ;
allTools = service . DiscoverAllTools ( )
. OrderBy ( tool = > tool . Name , StringComparer . OrdinalIgnoreCase )
. ToList ( ) ;
bool hasTools = allTools . Count > 0 ;
enableAllButton ? . SetEnabled ( hasTools ) ;
disableAllButton ? . SetEnabled ( hasTools ) ;
if ( noteLabel ! = null )
{
noteLabel . style . display = hasTools ? DisplayStyle . Flex : DisplayStyle . None ;
if ( hasTools )
{
bool isHttp = EditorConfigurationCache . Instance . UseHttpTransport ;
noteLabel . text = isHttp
? "Changes apply after reconnecting or re-registering tools."
: "Stdio mode: toggles sync at startup. After changing toggles, ask the AI to run manage_tools with action 'sync' to refresh." ;
}
}
if ( ! hasTools )
{
AddInfoLabel ( "No MCP tools found. Add classes decorated with [McpForUnityTool] to expose tools." ) ;
UpdateSummary ( ) ;
return ;
}
// Partition into built-in and custom
var builtInTools = allTools . Where ( IsBuiltIn ) . ToList ( ) ;
var customTools = allTools . Where ( tool = > ! IsBuiltIn ( tool ) ) . ToList ( ) ;
// Group built-in tools by their Group property
var grouped = builtInTools
. GroupBy ( t = > t . Group ? ? "core" )
. ToDictionary ( g = > g . Key , g = > g . OrderBy ( t = > t . Name , StringComparer . OrdinalIgnoreCase ) . ToList ( ) ) ;
// Render "core" first, then remaining groups alphabetically
if ( grouped . TryGetValue ( "core" , out var coreTools ) )
{
BuildCategory ( GetGroupDisplayName ( "core" ) , "group-core" , coreTools ) ;
grouped . Remove ( "core" ) ;
}
foreach ( var kvp in grouped . OrderBy ( k = > k . Key , StringComparer . OrdinalIgnoreCase ) )
{
BuildCategory ( GetGroupDisplayName ( kvp . Key ) , $"group-{kvp.Key}" , kvp . Value ) ;
}
// Custom tools at the bottom
if ( customTools . Count > 0 )
{
BuildCategory ( "Custom Tools" , "custom" , customTools ) ;
}
UpdateSummary ( ) ;
}
private static string GetGroupDisplayName ( string group )
{
if ( GroupDisplayNames . TryGetValue ( group , out var displayName ) )
return displayName ;
// Fallback: capitalize first letter
return string . IsNullOrEmpty ( group )
? "Other"
: char . ToUpper ( group [ 0 ] ) + group . Substring ( 1 ) ;
}
private void BuildCategory ( string title , string prefsSuffix , IEnumerable < ToolMetadata > tools )
{
var toolList = tools . ToList ( ) ;
if ( toolList . Count = = 0 )
{
return ;
}
bool isExperimental = string . Equals ( prefsSuffix , "group-probuilder" , StringComparison . OrdinalIgnoreCase ) ;
int enabledCount = toolList . Count ( t = > MCPServiceLocator . ToolDiscovery . IsToolEnabled ( t . Name ) ) ;
// Default foldout state: core is open, others collapsed
bool defaultOpen = prefsSuffix = = "group-core" ;
var foldout = new Foldout
{
text = $"{title} ({enabledCount}/{toolList.Count})" ,
value = EditorPrefs . GetBool ( EditorPrefKeys . ToolFoldoutStatePrefix + prefsSuffix , defaultOpen )
} ;
foldout . RegisterValueChangedCallback ( evt = >
{
if ( evt . target ! = foldout ) return ;
EditorPrefs . SetBool ( EditorPrefKeys . ToolFoldoutStatePrefix + prefsSuffix , evt . newValue ) ;
} ) ;
// Add a checkbox into the foldout header to toggle all tools in this group
bool allEnabled = enabledCount = = toolList . Count ;
var groupCheckbox = new Toggle { value = allEnabled } ;
groupCheckbox . AddToClassList ( "group-header-checkbox" ) ;
groupCheckbox . tooltip = $"Toggle all tools in \" { title } \ " on or off." ;
// Prevent the click from propagating to the foldout expand/collapse toggle
groupCheckbox . RegisterCallback < ClickEvent > ( evt = > evt . StopPropagation ( ) ) ;
groupCheckbox . RegisterValueChangedCallback ( evt = >
{
evt . StopPropagation ( ) ;
SetGroupToolsState ( toolList , evt . newValue , foldout , title ) ;
} ) ;
// Insert the checkbox into the foldout's own header toggle element
foldout . Q < Toggle > ( ) ? . Add ( groupCheckbox ) ;
groupToggleMap [ prefsSuffix ] = groupCheckbox ;
foreach ( var tool in toolList )
{
foldout . Add ( CreateToolRow ( tool ) ) ;
}
if ( isExperimental )
{
var warning = new HelpBox (
"ProBuilder support is experimental. Mesh editing operations may produce " +
"unexpected results on complex topologies. Always save your scene before " +
"performing destructive operations." ,
HelpBoxMessageType . Warning ) ;
warning . style . marginTop = 4 ;
warning . style . marginBottom = 2 ;
foldout . Insert ( 0 , warning ) ;
}
foldoutEntries . Add ( ( foldout , title , toolList ) ) ;
categoryContainer ? . Add ( foldout ) ;
}
private VisualElement CreateToolRow ( ToolMetadata tool )
{
var row = new VisualElement ( ) ;
row . AddToClassList ( "tool-item" ) ;
var header = new VisualElement ( ) ;
header . AddToClassList ( "tool-item-header" ) ;
var toggle = new Toggle ( tool . Name )
{
value = MCPServiceLocator . ToolDiscovery . IsToolEnabled ( tool . Name )
} ;
toggle . AddToClassList ( "tool-item-toggle" ) ;
toggle . tooltip = string . IsNullOrWhiteSpace ( tool . Description ) ? tool . Name : tool . Description ;
toggle . RegisterValueChangedCallback ( evt = >
{
HandleToggleChange ( tool , evt . newValue ) ;
} ) ;
toolToggleMap [ tool . Name ] = toggle ;
header . Add ( toggle ) ;
var tagsContainer = new VisualElement ( ) ;
tagsContainer . AddToClassList ( "tool-tags" ) ;
bool defaultEnabled = tool . AutoRegister | | tool . IsBuiltIn ;
tagsContainer . Add ( CreateTag ( defaultEnabled ? "On by default" : "Off by default" ) ) ;
tagsContainer . Add ( CreateTag ( tool . StructuredOutput ? "Structured output" : "Free-form" ) ) ;
if ( tool . RequiresPolling )
{
tagsContainer . Add ( CreateTag ( $"Polling: {tool.PollAction}" ) ) ;
}
header . Add ( tagsContainer ) ;
row . Add ( header ) ;
// Skip auto-generated placeholder descriptions like "Tool: find_gameobjects"
if ( ! string . IsNullOrWhiteSpace ( tool . Description )
& & ! tool . Description . StartsWith ( "Tool: " , StringComparison . OrdinalIgnoreCase ) )
{
var description = new Label ( tool . Description ) ;
description . AddToClassList ( "tool-item-description" ) ;
row . Add ( description ) ;
}
if ( tool . Parameters ! = null & & tool . Parameters . Count > 0 )
{
var paramSummary = string . Join ( ", " , tool . Parameters . Select ( p = >
$"{p.Name}{(p.Required ? string.Empty : " ( optional ) ")}: {p.Type}" ) ) ;
var parametersLabel = new Label ( paramSummary ) ;
parametersLabel . AddToClassList ( "tool-parameters" ) ;
row . Add ( parametersLabel ) ;
}
if ( IsManageCameraTool ( tool ) )
{
row . Add ( CreateManageSceneActions ( ) ) ;
}
if ( IsBatchExecuteTool ( tool ) )
{
row . Add ( CreateBatchExecuteSettings ( ) ) ;
}
return row ;
}
private void HandleToggleChange (
ToolMetadata tool ,
bool enabled ,
bool updateSummary = true ,
bool reregisterTools = true )
{
MCPServiceLocator . ToolDiscovery . SetToolEnabled ( tool . Name , enabled ) ;
if ( updateSummary )
{
UpdateSummary ( ) ;
UpdateFoldoutHeaders ( ) ;
SyncGroupToggles ( ) ;
}
if ( reregisterTools )
{
// Trigger tool reregistration with connected MCP server
ReregisterToolsAsync ( ) ;
}
}
private void ReregisterToolsAsync ( )
{
// Fire and forget - don't block UI thread
var transportManager = MCPServiceLocator . TransportManager ;
var client = transportManager . GetClient ( TransportMode . Http ) ;
if ( client = = null | | ! client . IsConnected )
{
return ;
}
_ = Task . Run ( async ( ) = >
{
try
{
await client . ReregisterToolsAsync ( ) . ConfigureAwait ( false ) ;
}
catch ( Exception ex )
{
McpLog . Warn ( $"Failed to reregister tools: {ex}" ) ;
}
} ) ;
}
private void SetAllToolsState ( bool enabled )
{
bool hasChanges = false ;
foreach ( var tool in allTools )
{
if ( ! toolToggleMap . TryGetValue ( tool . Name , out var toggle ) )
{
bool currentEnabled = MCPServiceLocator . ToolDiscovery . IsToolEnabled ( tool . Name ) ;
if ( currentEnabled ! = enabled )
{
MCPServiceLocator . ToolDiscovery . SetToolEnabled ( tool . Name , enabled ) ;
hasChanges = true ;
}
continue ;
}
if ( toggle . value = = enabled )
{
continue ;
}
toggle . SetValueWithoutNotify ( enabled ) ;
HandleToggleChange ( tool , enabled , updateSummary : false , reregisterTools : false ) ;
hasChanges = true ;
}
UpdateSummary ( ) ;
UpdateFoldoutHeaders ( ) ;
SyncGroupToggles ( ) ;
if ( hasChanges )
{
// Trigger a single reregistration after bulk change
ReregisterToolsAsync ( ) ;
}
}
private void SetGroupToolsState ( List < ToolMetadata > groupTools , bool enabled , Foldout foldout , string title )
{
bool hasChanges = false ;
foreach ( var tool in groupTools )
{
if ( toolToggleMap . TryGetValue ( tool . Name , out var toggle ) )
{
if ( toggle . value ! = enabled )
{
toggle . SetValueWithoutNotify ( enabled ) ;
HandleToggleChange ( tool , enabled , updateSummary : false , reregisterTools : false ) ;
hasChanges = true ;
}
}
else
{
bool currentEnabled = MCPServiceLocator . ToolDiscovery . IsToolEnabled ( tool . Name ) ;
if ( currentEnabled ! = enabled )
{
MCPServiceLocator . ToolDiscovery . SetToolEnabled ( tool . Name , enabled ) ;
hasChanges = true ;
}
}
}
// Update the foldout header count
int enabledCount = groupTools . Count ( t = > MCPServiceLocator . ToolDiscovery . IsToolEnabled ( t . Name ) ) ;
foldout . text = $"{title} ({enabledCount}/{groupTools.Count})" ;
// Sync global group toggles after group change
SyncGroupToggles ( ) ;
UpdateSummary ( ) ;
if ( hasChanges )
{
ReregisterToolsAsync ( ) ;
}
}
/// <summary>
/// Synchronises group toggle checkmarks with actual tool states.
/// Called after individual tool toggles change so the group toggle
/// stays accurate.
/// </summary>
private void SyncGroupToggles ( )
{
// We need the grouped tool lists to check states.
var builtInTools = allTools . Where ( IsBuiltIn ) . ToList ( ) ;
var grouped = builtInTools
. GroupBy ( t = > t . Group ? ? "core" )
. ToDictionary ( g = > g . Key , g = > g . ToList ( ) ) ;
var customTools = allTools . Where ( t = > ! IsBuiltIn ( t ) ) . ToList ( ) ;
foreach ( var kvp in groupToggleMap )
{
List < ToolMetadata > groupTools ;
if ( kvp . Key = = "custom" )
{
groupTools = customTools ;
}
else
{
string groupKey = kvp . Key . StartsWith ( "group-" ) ? kvp . Key . Substring ( 6 ) : kvp . Key ;
if ( ! grouped . TryGetValue ( groupKey , out groupTools ) )
continue ;
}
bool allEnabled = groupTools . All ( t = > MCPServiceLocator . ToolDiscovery . IsToolEnabled ( t . Name ) ) ;
kvp . Value . SetValueWithoutNotify ( allEnabled ) ;
}
}
private void OnReconfigureClientsClicked ( )
{
try
{
// Re-register tools with the server (HTTP mode)
ReregisterToolsAsync ( ) ;
// Reconfigure all already-configured clients.
// For CLI-based clients Configure() is a toggle (unregister if
// configured, register if not), so we call it twice: first to
// unregister, then to re-register with the updated tool set.
var clients = MCPServiceLocator . Client . GetAllClients ( ) ;
int success = 0 ;
int skipped = 0 ;
var messages = new List < string > ( ) ;
foreach ( var client in clients )
{
try
{
client . CheckStatus ( attemptAutoRewrite : false ) ;
if ( client . Status ! = McpStatus . Configured )
{
skipped + + ;
continue ;
}
if ( client is ClaudeCliMcpConfigurator )
{
// Toggle off (unregister), then toggle on (register)
MCPServiceLocator . Client . ConfigureClient ( client ) ;
MCPServiceLocator . Client . ConfigureClient ( client ) ;
}
else
{
// JSON-file clients: rewrite is idempotent
MCPServiceLocator . Client . ConfigureClient ( client ) ;
}
success + + ;
messages . Add ( $"✓ {client.DisplayName}: Reconfigured" ) ;
}
catch ( Exception ex )
{
messages . Add ( $"⚠ {client.DisplayName}: {ex.Message}" ) ;
}
}
string header = $"Reconfigured {success} client(s), skipped {skipped}." ;
string body = messages . Count > 0
? header + "\n\n" + string . Join ( "\n" , messages )
: header ;
EditorUtility . DisplayDialog ( "Reconfigure Clients" , body , "OK" ) ;
}
catch ( Exception ex )
{
EditorUtility . DisplayDialog ( "Reconfigure Failed" , ex . Message , "OK" ) ;
McpLog . Error ( $"Reconfigure failed: {ex.Message}" ) ;
}
}
private void UpdateSummary ( )
{
if ( summaryLabel = = null )
{
return ;
}
if ( allTools . Count = = 0 )
{
summaryLabel . text = "No MCP tools discovered." ;
return ;
}
int enabledCount = allTools . Count ( tool = > MCPServiceLocator . ToolDiscovery . IsToolEnabled ( tool . Name ) ) ;
summaryLabel . text = $"{enabledCount} of {allTools.Count} tools will register with connected clients." ;
}
private void UpdateFoldoutHeaders ( )
{
foreach ( var ( foldout , title , tools ) in foldoutEntries )
{
int enabledCount = tools . Count ( t = > MCPServiceLocator . ToolDiscovery . IsToolEnabled ( t . Name ) ) ;
foldout . text = $"{title} ({enabledCount}/{tools.Count})" ;
}
}
private void AddInfoLabel ( string message )
{
var label = new Label ( message ) ;
label . AddToClassList ( "help-text" ) ;
categoryContainer ? . Add ( label ) ;
}
private VisualElement CreateManageSceneActions ( )
{
var actions = new VisualElement ( ) ;
actions . AddToClassList ( "tool-item-actions" ) ;
var gameViewButton = new Button ( OnManageSceneScreenshotClicked )
{
text = "Game View"
} ;
gameViewButton . AddToClassList ( "tool-action-button" ) ;
gameViewButton . style . marginTop = 4 ;
gameViewButton . tooltip = "Capture a game camera screenshot. Default: Assets/Screenshots (configurable in Advanced)." ;
var sceneViewButton = new Button ( OnSceneViewScreenshotClicked )
{
text = "Scene View"
} ;
sceneViewButton . AddToClassList ( "tool-action-button" ) ;
sceneViewButton . style . marginTop = 4 ;
sceneViewButton . style . marginLeft = 4 ;
sceneViewButton . tooltip = "Capture the active Scene View viewport. Default: Assets/Screenshots (configurable in Advanced)." ;
var multiviewButton = new Button ( OnManageSceneMultiviewClicked )
{
text = "Multiview"
} ;
multiviewButton . AddToClassList ( "tool-action-button" ) ;
multiviewButton . style . marginTop = 4 ;
multiviewButton . style . marginLeft = 4 ;
multiviewButton . tooltip = "Capture a 6-angle contact sheet around the scene centre. Default: Assets/Screenshots (configurable in Advanced)." ;
var captureLabel = new Label ( "Capture:" ) ;
captureLabel . style . marginTop = 6 ;
captureLabel . style . unityFontStyleAndWeight = UnityEngine . FontStyle . Normal ;
var row = new VisualElement ( ) ;
row . style . flexDirection = FlexDirection . Row ;
row . style . flexWrap = Wrap . Wrap ;
row . Add ( gameViewButton ) ;
row . Add ( sceneViewButton ) ;
row . Add ( multiviewButton ) ;
actions . Add ( captureLabel ) ;
actions . Add ( row ) ;
return actions ;
}
private VisualElement CreateBatchExecuteSettings ( )
{
var container = new VisualElement ( ) ;
container . AddToClassList ( "tool-item-actions" ) ;
container . style . flexDirection = FlexDirection . Row ;
container . style . alignItems = Align . Center ;
container . style . marginTop = 4 ;
var label = new Label ( "Max commands per batch:" ) ;
label . style . marginRight = 8 ;
label . style . unityFontStyleAndWeight = UnityEngine . FontStyle . Normal ;
container . Add ( label ) ;
int currentValue = EditorPrefs . GetInt (
EditorPrefKeys . BatchExecuteMaxCommands ,
BatchExecute . DefaultMaxCommandsPerBatch
) ;
var field = new IntegerField
{
value = Math . Clamp ( currentValue , 1 , BatchExecute . AbsoluteMaxCommandsPerBatch ) ,
style = { width = 60 }
} ;
field . tooltip = $"Number of commands allowed per batch_execute call (1– ;
field . RegisterValueChangedCallback ( evt = >
{
int clamped = Math . Clamp ( evt . newValue , 1 , BatchExecute . AbsoluteMaxCommandsPerBatch ) ;
if ( clamped ! = evt . newValue )
{
field . SetValueWithoutNotify ( clamped ) ;
}
EditorPrefs . SetInt ( EditorPrefKeys . BatchExecuteMaxCommands , clamped ) ;
} ) ;
container . Add ( field ) ;
var hint = new Label ( $"(max {BatchExecute.AbsoluteMaxCommandsPerBatch})" ) ;
hint . style . marginLeft = 4 ;
hint . style . color = new UnityEngine . Color ( 0.5f , 0.5f , 0.5f ) ;
hint . style . fontSize = 10 ;
container . Add ( hint ) ;
return container ;
}
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 void OnSceneViewScreenshotClicked ( )
{
try
{
var response = ManageScene . ExecuteSceneViewScreenshot ( ) ;
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 ( "Scene View screenshot capture requested." ) ;
}
}
catch ( Exception ex )
{
McpLog . Error ( $"Failed to capture Scene View screenshot: {ex.Message}" ) ;
}
}
private void OnManageSceneMultiviewClicked ( )
{
try
{
var response = ManageScene . ExecuteMultiviewScreenshot ( ) ;
if ( response is SuccessResponse success )
{
// The data object is an anonymous type with imageBase64 — serialize to extract it
var json = Newtonsoft . Json . Linq . JObject . FromObject ( success . Data ) ;
string base64 = json [ "imageBase64" ] ? . ToString ( ) ;
if ( ! string . IsNullOrEmpty ( base64 ) )
{
string folderSpec = MCPForUnity . Editor . Helpers . ScreenshotPreferences . Resolve ( null ) ;
string folder ;
try
{
folder = MCPForUnity . Runtime . Helpers . ScreenshotUtility . ResolveFolderAbsolute ( folderSpec ) ;
}
catch ( System . InvalidOperationException ex )
{
McpLog . Error ( ex . Message ) ;
return ;
}
if ( ! System . IO . Directory . Exists ( folder ) )
System . IO . Directory . CreateDirectory ( folder ) ;
string fileName = $"Multiview_{System.DateTime.Now:yyyyMMdd_HHmmss}.png" ;
string filePath = System . IO . Path . Combine ( folder , fileName ) ;
System . IO . File . WriteAllBytes ( filePath , Convert . FromBase64String ( base64 ) ) ;
// Import only when the file landed under Assets/.
string projectRoot = System . IO . Path . GetFullPath ( System . IO . Path . Combine ( UnityEngine . Application . dataPath , ".." ) ) . Replace ( '\\' , '/' ) ;
string normalizedFile = filePath . Replace ( '\\' , '/' ) ;
string normalizedRoot = projectRoot . EndsWith ( "/" ) ? projectRoot : projectRoot + "/" ;
string projectRelative = normalizedFile . StartsWith ( normalizedRoot , System . StringComparison . OrdinalIgnoreCase )
? normalizedFile . Substring ( normalizedRoot . Length )
: normalizedFile ;
if ( MCPForUnity . Runtime . Helpers . ScreenshotUtility . IsUnderAssets ( projectRelative ) )
AssetDatabase . ImportAsset ( projectRelative , ImportAssetOptions . ForceSynchronousImport ) ;
McpLog . Info ( $"Multiview contact sheet saved to {projectRelative}" ) ;
}
else
{
McpLog . Info ( success . Message ? ? "Multiview capture completed." ) ;
}
}
else if ( response is ErrorResponse error & & ! string . IsNullOrWhiteSpace ( error . Error ) )
{
McpLog . Error ( error . Error ) ;
}
}
catch ( Exception ex )
{
McpLog . Error ( $"Failed to capture multiview: {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 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 ;
}
}
wehub-resource-sync