coplaydev--unity-mcp
wehub-resource-sync
1913 行
77 KiB
C#
1913 行
77 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Xml;
|
|
using MCPForUnity.Editor.Helpers;
|
|
using MCPForUnity.Runtime.Helpers;
|
|
using Newtonsoft.Json.Linq;
|
|
using UnityEditor;
|
|
using UnityEngine;
|
|
using UnityEngine.UIElements;
|
|
|
|
namespace MCPForUnity.Editor.Tools
|
|
{
|
|
[McpForUnityTool("manage_ui", AutoRegister = false, Group = "ui")]
|
|
public static class ManageUI
|
|
{
|
|
private static readonly HashSet<string> ValidExtensions = new(StringComparer.OrdinalIgnoreCase)
|
|
{
|
|
".uxml", ".uss"
|
|
};
|
|
|
|
// UTF-8 without BOM — UI Builder in Unity 6 can fail to open UXML files with a BOM.
|
|
private static readonly Encoding Utf8NoBom = new UTF8Encoding(false);
|
|
|
|
static ManageUI()
|
|
{
|
|
EditorApplication.quitting += CleanupRenderTextures;
|
|
AssemblyReloadEvents.beforeAssemblyReload += CleanupRenderTextures;
|
|
}
|
|
|
|
private static void CleanupRenderTextures()
|
|
{
|
|
foreach (var kvp in s_panelRTs)
|
|
{
|
|
if (kvp.Value == null) continue;
|
|
string assetPath = AssetDatabase.GetAssetPath(kvp.Value);
|
|
kvp.Value.Release();
|
|
if (!string.IsNullOrEmpty(assetPath))
|
|
AssetDatabase.DeleteAsset(assetPath);
|
|
else
|
|
UnityEngine.Object.DestroyImmediate(kvp.Value);
|
|
}
|
|
s_panelRTs.Clear();
|
|
}
|
|
|
|
public static object HandleCommand(JObject @params)
|
|
{
|
|
string action = @params["action"]?.ToString()?.ToLowerInvariant();
|
|
if (string.IsNullOrEmpty(action))
|
|
{
|
|
return new ErrorResponse("Action is required");
|
|
}
|
|
|
|
try
|
|
{
|
|
switch (action)
|
|
{
|
|
case "ping":
|
|
return new SuccessResponse("pong", new { tool = "manage_ui" });
|
|
|
|
case "create":
|
|
return CreateFile(@params);
|
|
|
|
case "read":
|
|
return ReadFile(@params);
|
|
|
|
case "update":
|
|
return UpdateFile(@params);
|
|
|
|
case "attach_ui_document":
|
|
return AttachUIDocument(@params);
|
|
|
|
case "create_panel_settings":
|
|
return CreatePanelSettings(@params);
|
|
|
|
case "update_panel_settings":
|
|
return UpdatePanelSettings(@params);
|
|
|
|
case "get_visual_tree":
|
|
return GetVisualTree(@params);
|
|
|
|
case "render_ui":
|
|
return RenderUI(@params);
|
|
|
|
case "link_stylesheet":
|
|
return LinkStylesheet(@params);
|
|
|
|
case "delete":
|
|
return DeleteFile(@params);
|
|
|
|
case "list":
|
|
return ListUIAssets(@params);
|
|
|
|
case "detach_ui_document":
|
|
return DetachUIDocument(@params);
|
|
|
|
case "modify_visual_element":
|
|
return ModifyVisualElement(@params);
|
|
|
|
default:
|
|
return new ErrorResponse($"Unknown action: {action}");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return new ErrorResponse(ex.Message, new { stackTrace = ex.StackTrace });
|
|
}
|
|
}
|
|
|
|
private static string ValidatePath(string path, out string error)
|
|
{
|
|
error = null;
|
|
if (string.IsNullOrEmpty(path))
|
|
{
|
|
error = "'path' parameter is required.";
|
|
return null;
|
|
}
|
|
|
|
path = AssetPathUtility.SanitizeAssetPath(path);
|
|
if (path == null)
|
|
{
|
|
error = "Invalid path: contains traversal sequences.";
|
|
return null;
|
|
}
|
|
|
|
string ext = Path.GetExtension(path);
|
|
if (!ValidExtensions.Contains(ext))
|
|
{
|
|
error = $"Invalid file extension '{ext}'. Must be .uxml or .uss.";
|
|
return null;
|
|
}
|
|
|
|
return path;
|
|
}
|
|
|
|
private static object CreateFile(JObject @params)
|
|
{
|
|
var p = new ToolParams(@params);
|
|
string path = ValidatePath(p.Get("path"), out string pathError);
|
|
if (pathError != null) return new ErrorResponse(pathError);
|
|
|
|
string contents;
|
|
try
|
|
{
|
|
contents = GetDecodedContents(p);
|
|
}
|
|
catch (ArgumentException ex)
|
|
{
|
|
return new ErrorResponse(ex.Message);
|
|
}
|
|
|
|
if (contents == null)
|
|
{
|
|
return new ErrorResponse("'contents' parameter is required for create.");
|
|
}
|
|
|
|
string fullPath = Path.Combine(Application.dataPath,
|
|
path.Substring("Assets/".Length));
|
|
fullPath = fullPath.Replace('/', Path.DirectorySeparatorChar);
|
|
|
|
if (File.Exists(fullPath))
|
|
{
|
|
return new ErrorResponse($"File already exists at {path}. Use 'update' action to overwrite.");
|
|
}
|
|
|
|
string dir = Path.GetDirectoryName(fullPath);
|
|
if (!string.IsNullOrEmpty(dir) && !Directory.Exists(dir))
|
|
{
|
|
Directory.CreateDirectory(dir);
|
|
}
|
|
|
|
bool isUxml = path.EndsWith(".uxml", StringComparison.OrdinalIgnoreCase);
|
|
var validationWarnings = new List<string>();
|
|
|
|
if (isUxml)
|
|
{
|
|
string xmlError = ValidateUxmlContent(contents, validationWarnings);
|
|
if (xmlError != null)
|
|
{
|
|
return new ErrorResponse($"UXML validation failed — file was NOT written. {xmlError}");
|
|
}
|
|
contents = EnsureEditorExtensionMode(contents);
|
|
}
|
|
|
|
File.WriteAllText(fullPath, contents, Utf8NoBom);
|
|
AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate);
|
|
|
|
if (isUxml)
|
|
{
|
|
ValidateUxmlPostImport(path, validationWarnings);
|
|
}
|
|
|
|
string ext = Path.GetExtension(path).TrimStart('.');
|
|
if (validationWarnings.Count > 0)
|
|
{
|
|
return new SuccessResponse(
|
|
$"Created {ext} file at {path} with {validationWarnings.Count} warning(s)",
|
|
new { path, validationWarnings });
|
|
}
|
|
|
|
return new SuccessResponse($"Created {ext} file at {path}",
|
|
new { path });
|
|
}
|
|
|
|
private static object ReadFile(JObject @params)
|
|
{
|
|
var p = new ToolParams(@params);
|
|
string path = ValidatePath(p.Get("path"), out string pathError);
|
|
if (pathError != null) return new ErrorResponse(pathError);
|
|
|
|
string fullPath = Path.Combine(Application.dataPath,
|
|
path.Substring("Assets/".Length));
|
|
fullPath = fullPath.Replace('/', Path.DirectorySeparatorChar);
|
|
|
|
if (!File.Exists(fullPath))
|
|
{
|
|
return new ErrorResponse($"File not found: {path}");
|
|
}
|
|
|
|
string contents = File.ReadAllText(fullPath, Encoding.UTF8);
|
|
string encoded = Convert.ToBase64String(Encoding.UTF8.GetBytes(contents));
|
|
|
|
return new SuccessResponse($"Read {Path.GetExtension(path).TrimStart('.')} file at {path}",
|
|
new
|
|
{
|
|
path,
|
|
contents,
|
|
encodedContents = encoded,
|
|
contentsEncoded = true,
|
|
lengthBytes = Encoding.UTF8.GetByteCount(contents)
|
|
});
|
|
}
|
|
|
|
private static object UpdateFile(JObject @params)
|
|
{
|
|
var p = new ToolParams(@params);
|
|
string path = ValidatePath(p.Get("path"), out string pathError);
|
|
if (pathError != null) return new ErrorResponse(pathError);
|
|
|
|
string contents;
|
|
try
|
|
{
|
|
contents = GetDecodedContents(p);
|
|
}
|
|
catch (ArgumentException ex)
|
|
{
|
|
return new ErrorResponse(ex.Message);
|
|
}
|
|
|
|
if (contents == null)
|
|
{
|
|
return new ErrorResponse("'contents' parameter is required for update.");
|
|
}
|
|
|
|
string fullPath = Path.Combine(Application.dataPath,
|
|
path.Substring("Assets/".Length));
|
|
fullPath = fullPath.Replace('/', Path.DirectorySeparatorChar);
|
|
|
|
if (!File.Exists(fullPath))
|
|
{
|
|
return new ErrorResponse($"File not found: {path}. Use 'create' action for new files.");
|
|
}
|
|
|
|
bool isUxml = path.EndsWith(".uxml", StringComparison.OrdinalIgnoreCase);
|
|
var validationWarnings = new List<string>();
|
|
|
|
if (isUxml)
|
|
{
|
|
string xmlError = ValidateUxmlContent(contents, validationWarnings);
|
|
if (xmlError != null)
|
|
{
|
|
return new ErrorResponse($"UXML validation failed — file was NOT updated. {xmlError}");
|
|
}
|
|
contents = EnsureEditorExtensionMode(contents);
|
|
}
|
|
|
|
File.WriteAllText(fullPath, contents, Utf8NoBom);
|
|
AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate);
|
|
|
|
if (isUxml)
|
|
{
|
|
ValidateUxmlPostImport(path, validationWarnings);
|
|
}
|
|
|
|
string ext = Path.GetExtension(path).TrimStart('.');
|
|
if (validationWarnings.Count > 0)
|
|
{
|
|
return new SuccessResponse(
|
|
$"Updated {ext} file at {path} with {validationWarnings.Count} warning(s)",
|
|
new { path, validationWarnings });
|
|
}
|
|
|
|
return new SuccessResponse($"Updated {ext} file at {path}",
|
|
new { path });
|
|
}
|
|
|
|
private static object AttachUIDocument(JObject @params)
|
|
{
|
|
var p = new ToolParams(@params);
|
|
|
|
var targetResult = p.GetRequired("target");
|
|
var targetError = targetResult.GetOrError(out string target);
|
|
if (targetError != null) return targetError;
|
|
|
|
var sourceResult = p.GetRequired("source_asset");
|
|
var sourceError = sourceResult.GetOrError(out string sourceAssetPath);
|
|
if (sourceError != null) return sourceError;
|
|
|
|
sourceAssetPath = AssetPathUtility.SanitizeAssetPath(sourceAssetPath);
|
|
if (sourceAssetPath == null)
|
|
{
|
|
return new ErrorResponse("Invalid source_asset path.");
|
|
}
|
|
|
|
// Find the GameObject
|
|
var goInstruction = new JObject { ["find"] = target };
|
|
GameObject go = ObjectResolver.Resolve(goInstruction, typeof(GameObject)) as GameObject;
|
|
if (go == null)
|
|
{
|
|
return new ErrorResponse($"Could not find target GameObject: {target}");
|
|
}
|
|
|
|
// Load the VisualTreeAsset
|
|
var vta = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(sourceAssetPath);
|
|
if (vta == null)
|
|
{
|
|
return new ErrorResponse($"Could not load VisualTreeAsset at: {sourceAssetPath}");
|
|
}
|
|
|
|
// Load or create PanelSettings
|
|
string panelSettingsPath = p.Get("panel_settings") ?? p.Get("panelSettings");
|
|
PanelSettings panelSettings = null;
|
|
|
|
if (!string.IsNullOrEmpty(panelSettingsPath))
|
|
{
|
|
panelSettingsPath = AssetPathUtility.SanitizeAssetPath(panelSettingsPath);
|
|
if (panelSettingsPath != null)
|
|
{
|
|
panelSettings = AssetDatabase.LoadAssetAtPath<PanelSettings>(panelSettingsPath);
|
|
}
|
|
if (panelSettings == null)
|
|
{
|
|
return new ErrorResponse($"Could not load PanelSettings at: {panelSettingsPath}");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Find existing or create default PanelSettings
|
|
string[] guids = AssetDatabase.FindAssets("t:PanelSettings");
|
|
if (guids.Length > 0)
|
|
{
|
|
string existingPath = AssetDatabase.GUIDToAssetPath(guids[0]);
|
|
panelSettings = AssetDatabase.LoadAssetAtPath<PanelSettings>(existingPath);
|
|
}
|
|
|
|
if (panelSettings == null)
|
|
{
|
|
panelSettings = CreateDefaultPanelSettings("Assets/UI/DefaultPanelSettings.asset");
|
|
if (panelSettings == null)
|
|
{
|
|
return new ErrorResponse("Failed to create default PanelSettings.");
|
|
}
|
|
}
|
|
}
|
|
|
|
Undo.RecordObject(go, "Attach UIDocument");
|
|
|
|
// Add or get UIDocument component
|
|
var uiDoc = go.GetComponent<UIDocument>();
|
|
if (uiDoc == null)
|
|
{
|
|
uiDoc = Undo.AddComponent<UIDocument>(go);
|
|
}
|
|
|
|
uiDoc.visualTreeAsset = vta;
|
|
uiDoc.panelSettings = panelSettings;
|
|
|
|
int sortOrder = p.GetInt("sort_order") ?? 0;
|
|
uiDoc.sortingOrder = sortOrder;
|
|
|
|
EditorUtility.SetDirty(go);
|
|
|
|
return new SuccessResponse($"Attached UIDocument to {go.name}",
|
|
new
|
|
{
|
|
gameObject = go.name,
|
|
sourceAsset = sourceAssetPath,
|
|
panelSettings = AssetDatabase.GetAssetPath(panelSettings),
|
|
sortOrder
|
|
});
|
|
}
|
|
|
|
private static object CreatePanelSettings(JObject @params)
|
|
{
|
|
var p = new ToolParams(@params);
|
|
|
|
var pathResult = p.GetRequired("path");
|
|
var pathError = pathResult.GetOrError(out string path);
|
|
if (pathError != null) return pathError;
|
|
|
|
path = AssetPathUtility.SanitizeAssetPath(path);
|
|
if (path == null)
|
|
{
|
|
return new ErrorResponse("Invalid path: contains traversal sequences.");
|
|
}
|
|
|
|
if (!path.EndsWith(".asset", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
path += ".asset";
|
|
}
|
|
|
|
if (AssetDatabase.LoadAssetAtPath<PanelSettings>(path) != null)
|
|
{
|
|
return new ErrorResponse($"PanelSettings already exists at {path}");
|
|
}
|
|
|
|
var ps = CreateDefaultPanelSettings(path);
|
|
if (ps == null)
|
|
{
|
|
return new ErrorResponse("Failed to create PanelSettings asset.");
|
|
}
|
|
|
|
// Apply any settings passed as a flat dict
|
|
JToken settingsToken = p.GetRaw("settings");
|
|
var changes = new List<string>();
|
|
if (settingsToken is JObject settingsObj)
|
|
{
|
|
ApplyPanelSettingsProperties(ps, settingsObj, changes);
|
|
}
|
|
else
|
|
{
|
|
// Legacy: support top-level scale_mode / reference_resolution
|
|
string scaleMode = p.Get("scale_mode");
|
|
if (!string.IsNullOrEmpty(scaleMode))
|
|
{
|
|
if (Enum.TryParse<PanelScaleMode>(scaleMode, true, out var mode))
|
|
{
|
|
ps.scaleMode = mode;
|
|
changes.Add("scaleMode");
|
|
}
|
|
}
|
|
|
|
JToken refResToken = p.GetRaw("reference_resolution");
|
|
if (refResToken is JObject refRes)
|
|
{
|
|
int w = refRes["width"]?.ToObject<int>() ?? 1920;
|
|
int h = refRes["height"]?.ToObject<int>() ?? 1080;
|
|
ps.referenceResolution = new Vector2Int(w, h);
|
|
changes.Add("referenceResolution");
|
|
}
|
|
}
|
|
|
|
EditorUtility.SetDirty(ps);
|
|
AssetDatabase.SaveAssets();
|
|
|
|
return new SuccessResponse($"Created PanelSettings at {path}",
|
|
new { path, applied = changes });
|
|
}
|
|
|
|
private static object UpdatePanelSettings(JObject @params)
|
|
{
|
|
var p = new ToolParams(@params);
|
|
|
|
var pathResult = p.GetRequired("path");
|
|
var pathError = pathResult.GetOrError(out string path);
|
|
if (pathError != null) return pathError;
|
|
|
|
path = AssetPathUtility.SanitizeAssetPath(path);
|
|
if (path == null)
|
|
return new ErrorResponse("Invalid path: contains traversal sequences.");
|
|
|
|
if (!path.EndsWith(".asset", StringComparison.OrdinalIgnoreCase))
|
|
path += ".asset";
|
|
|
|
var ps = AssetDatabase.LoadAssetAtPath<PanelSettings>(path);
|
|
if (ps == null)
|
|
return new ErrorResponse($"No PanelSettings found at {path}");
|
|
|
|
JToken settingsToken = p.GetRaw("settings");
|
|
if (settingsToken is not JObject settingsObj || settingsObj.Count == 0)
|
|
return new ErrorResponse("'settings' dict is required with at least one property to update.");
|
|
|
|
var changes = new List<string>();
|
|
ApplyPanelSettingsProperties(ps, settingsObj, changes);
|
|
|
|
if (changes.Count == 0)
|
|
return new ErrorResponse("No recognised properties were applied. Check the key names.");
|
|
|
|
EditorUtility.SetDirty(ps);
|
|
AssetDatabase.SaveAssets();
|
|
|
|
return new SuccessResponse($"Updated PanelSettings at {path}",
|
|
new { path, applied = changes });
|
|
}
|
|
|
|
private static PanelSettings CreateDefaultPanelSettings(string path)
|
|
{
|
|
string dir = Path.GetDirectoryName(path);
|
|
if (!string.IsNullOrEmpty(dir))
|
|
{
|
|
EnsureFolderExists(dir);
|
|
}
|
|
|
|
var ps = ScriptableObject.CreateInstance<PanelSettings>();
|
|
AssetDatabase.CreateAsset(ps, path);
|
|
AssetDatabase.SaveAssets();
|
|
return ps;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Generic, data-driven applicator for PanelSettings properties.
|
|
/// Accepts a flat JObject where each key maps to a PanelSettings property.
|
|
/// Recognised keys (case-insensitive matching via snake_case/camelCase):
|
|
/// scaleMode, referenceResolution, screenMatchMode, match,
|
|
/// referenceDpi, fallbackDpi, sortingOrder, targetDisplay,
|
|
/// clearColor, colorClearValue, clearDepthStencil,
|
|
/// themeStyleSheet, dynamicAtlasSettings.
|
|
/// </summary>
|
|
private static void ApplyPanelSettingsProperties(PanelSettings ps, JObject settings, List<string> changes)
|
|
{
|
|
foreach (var prop in settings)
|
|
{
|
|
string key = NormalizeKey(prop.Key);
|
|
JToken val = prop.Value;
|
|
|
|
switch (key)
|
|
{
|
|
// ── Enum properties ─────────────────────────────────────
|
|
case "scalemode":
|
|
if (TryParseEnum<PanelScaleMode>(val, out var sm)) { ps.scaleMode = sm; changes.Add("scaleMode"); }
|
|
break;
|
|
|
|
case "screenmatchmode":
|
|
if (TryParseEnum<PanelScreenMatchMode>(val, out var smm)) { ps.screenMatchMode = smm; changes.Add("screenMatchMode"); }
|
|
break;
|
|
|
|
// ── Numeric properties ──────────────────────────────────
|
|
case "match":
|
|
if (TryFloat(val, out float matchVal)) { ps.match = Mathf.Clamp01(matchVal); changes.Add("match"); }
|
|
break;
|
|
|
|
case "referencedpi":
|
|
if (TryFloat(val, out float refDpi)) { ps.referenceDpi = refDpi; changes.Add("referenceDpi"); }
|
|
break;
|
|
|
|
case "fallbackdpi":
|
|
if (TryFloat(val, out float fbDpi)) { ps.fallbackDpi = fbDpi; changes.Add("fallbackDpi"); }
|
|
break;
|
|
|
|
case "sortingorder":
|
|
if (TryInt(val, out int so)) { ps.sortingOrder = so; changes.Add("sortingOrder"); }
|
|
break;
|
|
|
|
case "targetdisplay":
|
|
if (TryInt(val, out int td)) { ps.targetDisplay = td; changes.Add("targetDisplay"); }
|
|
break;
|
|
|
|
// ── Bool properties ──────────────────────────────────────
|
|
case "clearcolor":
|
|
ps.clearColor = ParamCoercion.CoerceBool(val, false);
|
|
changes.Add("clearColor");
|
|
break;
|
|
|
|
case "cleardepthstencil":
|
|
ps.clearDepthStencil = ParamCoercion.CoerceBool(val, false);
|
|
changes.Add("clearDepthStencil");
|
|
break;
|
|
|
|
// ── Composite properties ────────────────────────────────
|
|
case "referenceresolution":
|
|
if (val is JObject resObj)
|
|
{
|
|
int w = resObj["width"]?.ToObject<int>() ?? ps.referenceResolution.x;
|
|
int h = resObj["height"]?.ToObject<int>() ?? ps.referenceResolution.y;
|
|
ps.referenceResolution = new Vector2Int(w, h);
|
|
changes.Add("referenceResolution");
|
|
}
|
|
break;
|
|
|
|
case "colorclearvalue":
|
|
if (TryParseColor(val, out Color clr)) { ps.colorClearValue = clr; changes.Add("colorClearValue"); }
|
|
break;
|
|
|
|
case "dynamicatlassettings":
|
|
if (val is JObject daObj) { ApplyDynamicAtlasSettings(ps, daObj, changes); }
|
|
break;
|
|
|
|
// ── Asset reference properties ──────────────────────────
|
|
case "themestylesheet":
|
|
{
|
|
string tsPath = val?.ToString();
|
|
if (!string.IsNullOrEmpty(tsPath))
|
|
{
|
|
var ts = AssetDatabase.LoadAssetAtPath<ThemeStyleSheet>(tsPath);
|
|
if (ts != null) { ps.themeStyleSheet = ts; changes.Add("themeStyleSheet"); }
|
|
}
|
|
break;
|
|
}
|
|
|
|
// unknown keys are silently ignored
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void ApplyDynamicAtlasSettings(PanelSettings ps, JObject da, List<string> changes)
|
|
{
|
|
var daCopy = ps.dynamicAtlasSettings;
|
|
|
|
if (da["minAtlasSize"] != null && TryInt(da["minAtlasSize"], out int minSize))
|
|
daCopy.minAtlasSize = minSize;
|
|
if (da["maxAtlasSize"] != null && TryInt(da["maxAtlasSize"], out int maxSize))
|
|
daCopy.maxAtlasSize = maxSize;
|
|
if (da["maxSubTextureSize"] != null && TryInt(da["maxSubTextureSize"], out int maxSub))
|
|
daCopy.maxSubTextureSize = maxSub;
|
|
if (da["activeFilters"] != null && TryParseEnum<DynamicAtlasFilters>(da["activeFilters"], out var af))
|
|
daCopy.activeFilters = af;
|
|
|
|
ps.dynamicAtlasSettings = daCopy;
|
|
changes.Add("dynamicAtlasSettings");
|
|
}
|
|
|
|
// ── Tiny helpers to keep the switch compact ─────────────────────────
|
|
|
|
private static string NormalizeKey(string key)
|
|
{
|
|
// Strip underscores and lowercase so "scale_mode", "scaleMode", "ScaleMode"
|
|
// all match the same case label.
|
|
return key.Replace("_", "").ToLowerInvariant();
|
|
}
|
|
|
|
private static bool TryParseEnum<T>(JToken token, out T result) where T : struct, Enum
|
|
{
|
|
result = default;
|
|
string s = token?.ToString();
|
|
return !string.IsNullOrEmpty(s) && Enum.TryParse(s, true, out result);
|
|
}
|
|
|
|
private static bool TryFloat(JToken token, out float result)
|
|
{
|
|
result = 0f;
|
|
if (token == null) return false;
|
|
if (token.Type == JTokenType.Float || token.Type == JTokenType.Integer)
|
|
{
|
|
result = token.ToObject<float>();
|
|
return true;
|
|
}
|
|
return float.TryParse(token.ToString(), out result);
|
|
}
|
|
|
|
private static bool TryInt(JToken token, out int result)
|
|
{
|
|
result = 0;
|
|
if (token == null) return false;
|
|
if (token.Type == JTokenType.Integer)
|
|
{
|
|
result = token.ToObject<int>();
|
|
return true;
|
|
}
|
|
return int.TryParse(token.ToString(), out result);
|
|
}
|
|
|
|
private static bool TryParseColor(JToken token, out Color color)
|
|
{
|
|
color = Color.clear;
|
|
if (token == null) return false;
|
|
|
|
// Accept "#RRGGBB", "#RRGGBBAA", or {r,g,b,a} object
|
|
if (token.Type == JTokenType.String)
|
|
{
|
|
return ColorUtility.TryParseHtmlString(token.ToString(), out color);
|
|
}
|
|
|
|
if (token is JObject cObj)
|
|
{
|
|
color = new Color(
|
|
cObj["r"]?.ToObject<float>() ?? 0f,
|
|
cObj["g"]?.ToObject<float>() ?? 0f,
|
|
cObj["b"]?.ToObject<float>() ?? 0f,
|
|
cObj["a"]?.ToObject<float>() ?? 1f
|
|
);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static void EnsureFolderExists(string assetFolderPath)
|
|
{
|
|
if (AssetDatabase.IsValidFolder(assetFolderPath))
|
|
return;
|
|
|
|
string[] parts = assetFolderPath.Replace('\\', '/').Split('/');
|
|
string current = parts[0]; // "Assets"
|
|
for (int i = 1; i < parts.Length; i++)
|
|
{
|
|
string next = current + "/" + parts[i];
|
|
if (!AssetDatabase.IsValidFolder(next))
|
|
{
|
|
AssetDatabase.CreateFolder(current, parts[i]);
|
|
}
|
|
current = next;
|
|
}
|
|
}
|
|
|
|
private static object GetVisualTree(JObject @params)
|
|
{
|
|
var p = new ToolParams(@params);
|
|
|
|
var targetResult = p.GetRequired("target");
|
|
var targetError = targetResult.GetOrError(out string target);
|
|
if (targetError != null) return targetError;
|
|
|
|
int maxDepth = p.GetInt("max_depth") ?? 10;
|
|
|
|
var goInstruction = new JObject { ["find"] = target };
|
|
GameObject go = ObjectResolver.Resolve(goInstruction, typeof(GameObject)) as GameObject;
|
|
if (go == null)
|
|
{
|
|
return new ErrorResponse($"Could not find target GameObject: {target}");
|
|
}
|
|
|
|
var uiDoc = go.GetComponent<UIDocument>();
|
|
if (uiDoc == null)
|
|
{
|
|
return new ErrorResponse($"GameObject {go.name} has no UIDocument component.");
|
|
}
|
|
|
|
var root = uiDoc.rootVisualElement;
|
|
if (root == null)
|
|
{
|
|
return new SuccessResponse($"UIDocument on {go.name} has no visual tree (not yet built).",
|
|
new
|
|
{
|
|
gameObject = go.name,
|
|
sourceAsset = uiDoc.visualTreeAsset != null
|
|
? AssetDatabase.GetAssetPath(uiDoc.visualTreeAsset)
|
|
: null,
|
|
tree = (object)null
|
|
});
|
|
}
|
|
|
|
var tree = SerializeVisualElement(root, 0, maxDepth);
|
|
|
|
return new SuccessResponse($"Visual tree for UIDocument on {go.name}",
|
|
new
|
|
{
|
|
gameObject = go.name,
|
|
sourceAsset = uiDoc.visualTreeAsset != null
|
|
? AssetDatabase.GetAssetPath(uiDoc.visualTreeAsset)
|
|
: null,
|
|
tree
|
|
});
|
|
}
|
|
|
|
private static object SerializeVisualElement(VisualElement element, int depth, int maxDepth)
|
|
{
|
|
var result = new Dictionary<string, object>
|
|
{
|
|
["type"] = element.GetType().Name,
|
|
["name"] = element.name ?? "",
|
|
["classes"] = new List<string>(element.GetClasses()),
|
|
};
|
|
|
|
// Include basic computed style info
|
|
var style = new Dictionary<string, object>();
|
|
var resolved = element.resolvedStyle;
|
|
|
|
if (resolved.width > 0) style["width"] = resolved.width;
|
|
if (resolved.height > 0) style["height"] = resolved.height;
|
|
if (resolved.color != Color.clear)
|
|
style["color"] = ColorToHex(resolved.color);
|
|
if (resolved.backgroundColor != Color.clear)
|
|
style["backgroundColor"] = ColorToHex(resolved.backgroundColor);
|
|
if (resolved.fontSize > 0) style["fontSize"] = resolved.fontSize;
|
|
|
|
if (style.Count > 0)
|
|
result["resolvedStyle"] = style;
|
|
|
|
// Include text content for labels/buttons
|
|
if (element is TextElement textEl && !string.IsNullOrEmpty(textEl.text))
|
|
{
|
|
result["text"] = textEl.text;
|
|
}
|
|
|
|
// Serialize children
|
|
if (depth < maxDepth && element.childCount > 0)
|
|
{
|
|
var children = new List<object>();
|
|
foreach (var child in element.Children())
|
|
{
|
|
children.Add(SerializeVisualElement(child, depth + 1, maxDepth));
|
|
}
|
|
result["children"] = children;
|
|
}
|
|
else if (element.childCount > 0)
|
|
{
|
|
result["childCount"] = element.childCount;
|
|
result["truncated"] = true;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// ---- Render UI ----
|
|
|
|
// Persistent RenderTextures keyed by PanelSettings instance ID so the panel
|
|
// renders into them automatically every frame.
|
|
private static readonly Dictionary<int, RenderTexture> s_panelRTs = new();
|
|
|
|
// Play-mode coroutine capture state. Only one capture is in-flight at a
|
|
// time; concurrent render_ui calls while a capture is pending are rejected
|
|
// with an explicit error.
|
|
private static Texture2D s_pendingCaptureTex;
|
|
private static bool s_pendingCaptureDone;
|
|
private static bool s_pendingCaptureStarted;
|
|
|
|
private static object RenderUI(JObject @params)
|
|
{
|
|
var p = new ToolParams(@params);
|
|
|
|
string target = p.Get("target");
|
|
string uxmlPath = p.Get("path");
|
|
int width = p.GetInt("width") ?? 1920;
|
|
int height = p.GetInt("height") ?? 1080;
|
|
bool includeImage = p.GetBool("include_image") || p.GetBool("includeImage");
|
|
int maxResolution = p.GetInt("max_resolution") ?? p.GetInt("maxResolution") ?? 640;
|
|
string fileName = p.Get("file_name") ?? p.Get("fileName");
|
|
string outputFolderOverride = p.Get("output_folder") ?? p.Get("outputFolder");
|
|
|
|
if (string.IsNullOrEmpty(target) && string.IsNullOrEmpty(uxmlPath))
|
|
{
|
|
return new ErrorResponse("Either 'target' (GameObject with UIDocument) or 'path' (UXML asset path) is required.");
|
|
}
|
|
|
|
string resolvedFolderSpec = ScreenshotPreferences.Resolve(outputFolderOverride);
|
|
string resolvedFolderAbs;
|
|
try
|
|
{
|
|
resolvedFolderAbs = ScreenshotUtility.ResolveFolderAbsolute(resolvedFolderSpec);
|
|
}
|
|
catch (InvalidOperationException ex)
|
|
{
|
|
return new ErrorResponse(ex.Message);
|
|
}
|
|
|
|
// ── Play-mode capture via ScreenCapture coroutine ──────────────────────
|
|
// PanelSettings.targetTexture is read in the same frame it is assigned,
|
|
// so the RT is always blank in a synchronous tool call. In play mode we
|
|
// dispatch a WaitForEndOfFrame coroutine that uses ScreenCapture, which
|
|
// captures the fully-composited game view (including UI Toolkit overlays).
|
|
// First call: queues the capture and returns "pending".
|
|
// Second call: result is ready – save PNG and return data.
|
|
if (Application.isPlaying)
|
|
{
|
|
// Build the output paths (used by both the pending and ready branches)
|
|
string resolvedPlayName = string.IsNullOrWhiteSpace(fileName)
|
|
? $"ui-render-{DateTime.Now:yyyyMMdd-HHmmss}.png"
|
|
: fileName.Trim();
|
|
if (!resolvedPlayName.EndsWith(".png", StringComparison.OrdinalIgnoreCase))
|
|
resolvedPlayName += ".png";
|
|
|
|
Directory.CreateDirectory(resolvedFolderAbs);
|
|
string playFullPath = Path.Combine(resolvedFolderAbs, resolvedPlayName).Replace('\\', '/');
|
|
playFullPath = EnsureUniqueFilePath(playFullPath);
|
|
string playProjectRelPath = ScreenshotUtility.ToProjectRelativePath(playFullPath);
|
|
|
|
// ── Case 1: capture is ready ──────────────────────────────────────
|
|
if (s_pendingCaptureDone && s_pendingCaptureTex != null)
|
|
{
|
|
var captureTex = s_pendingCaptureTex;
|
|
s_pendingCaptureDone = false;
|
|
s_pendingCaptureTex = null;
|
|
|
|
int captureW = captureTex.width;
|
|
int captureH = captureTex.height;
|
|
byte[] capturePng = captureTex.EncodeToPNG();
|
|
UnityEngine.Object.DestroyImmediate(captureTex);
|
|
|
|
File.WriteAllBytes(playFullPath, capturePng);
|
|
if (ScreenshotUtility.IsUnderAssets(playProjectRelPath))
|
|
AssetDatabase.ImportAsset(playProjectRelPath, ImportAssetOptions.ForceSynchronousImport);
|
|
|
|
var playData = new Dictionary<string, object>
|
|
{
|
|
{ "path", playProjectRelPath },
|
|
{ "fullPath", playFullPath },
|
|
{ "width", captureW },
|
|
{ "height", captureH },
|
|
{ "hasContent", true },
|
|
};
|
|
|
|
if (!string.IsNullOrEmpty(target)) playData["gameObject"] = target;
|
|
if (!string.IsNullOrEmpty(uxmlPath)) playData["sourceAsset"] = uxmlPath;
|
|
|
|
if (includeImage)
|
|
{
|
|
int targetMax = maxResolution > 0 ? maxResolution : 640;
|
|
Texture2D downscaled = null;
|
|
try
|
|
{
|
|
var fullTex = new Texture2D(captureW, captureH, TextureFormat.RGBA32, false);
|
|
fullTex.LoadImage(capturePng);
|
|
if (captureW > targetMax || captureH > targetMax)
|
|
{
|
|
downscaled = ScreenshotUtility.DownscaleTexture(fullTex, targetMax);
|
|
playData["imageBase64"] = Convert.ToBase64String(downscaled.EncodeToPNG());
|
|
playData["imageWidth"] = downscaled.width;
|
|
playData["imageHeight"] = downscaled.height;
|
|
}
|
|
else
|
|
{
|
|
playData["imageBase64"] = Convert.ToBase64String(capturePng);
|
|
playData["imageWidth"] = captureW;
|
|
playData["imageHeight"] = captureH;
|
|
}
|
|
UnityEngine.Object.DestroyImmediate(fullTex);
|
|
}
|
|
finally
|
|
{
|
|
if (downscaled != null) UnityEngine.Object.DestroyImmediate(downscaled);
|
|
}
|
|
}
|
|
|
|
return new SuccessResponse($"UI render saved to '{playProjectRelPath}'.", playData);
|
|
}
|
|
|
|
// ── Case 2: start a new capture ───────────────────────────────────
|
|
// Only one capture in flight at a time. If one is already pending,
|
|
// reject rather than silently overwriting the state.
|
|
if (s_pendingCaptureStarted)
|
|
{
|
|
return new ErrorResponse(
|
|
"Cannot capture: another capture is already in progress.",
|
|
new { retry_after_ms = 100, reason = "capture_in_progress" });
|
|
}
|
|
|
|
s_pendingCaptureDone = false;
|
|
s_pendingCaptureTex = null;
|
|
s_pendingCaptureStarted = true;
|
|
ScreenshotCapturer.Begin(1, tex =>
|
|
{
|
|
s_pendingCaptureTex = tex;
|
|
s_pendingCaptureDone = true;
|
|
s_pendingCaptureStarted = false;
|
|
});
|
|
|
|
return new SuccessResponse(
|
|
"Play-mode screenshot capture queued (WaitForEndOfFrame). Call render_ui again to retrieve the rendered image.",
|
|
new Dictionary<string, object>
|
|
{
|
|
{ "pending", true },
|
|
{ "gameObject", (object)target ?? uxmlPath },
|
|
{ "note", "A screen capture was scheduled for the end of this frame. Call render_ui once more to get the result." }
|
|
});
|
|
}
|
|
// ── End play-mode branch ────────────────────────────────────────────────
|
|
|
|
// Resolve UIDocument
|
|
UIDocument uiDoc = null;
|
|
GameObject tempGo = null;
|
|
PanelSettings tempPs = null;
|
|
|
|
try
|
|
{
|
|
if (!string.IsNullOrEmpty(target))
|
|
{
|
|
var goInstruction = new JObject { ["find"] = target };
|
|
GameObject go = ObjectResolver.Resolve(goInstruction, typeof(GameObject)) as GameObject;
|
|
if (go == null)
|
|
return new ErrorResponse($"Could not find target GameObject: {target}");
|
|
|
|
uiDoc = go.GetComponent<UIDocument>();
|
|
if (uiDoc == null)
|
|
return new ErrorResponse($"GameObject '{go.name}' has no UIDocument component.");
|
|
}
|
|
else
|
|
{
|
|
uxmlPath = AssetPathUtility.SanitizeAssetPath(uxmlPath);
|
|
if (uxmlPath == null)
|
|
return new ErrorResponse("Invalid UXML path.");
|
|
|
|
var vta = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(uxmlPath);
|
|
if (vta == null)
|
|
return new ErrorResponse($"Could not load VisualTreeAsset at: {uxmlPath}");
|
|
|
|
tempGo = new GameObject("__MCP_UI_Render_Temp__");
|
|
tempGo.hideFlags = HideFlags.HideAndDontSave;
|
|
uiDoc = tempGo.AddComponent<UIDocument>();
|
|
|
|
string[] guids = AssetDatabase.FindAssets("t:PanelSettings");
|
|
PanelSettings ps = null;
|
|
if (guids.Length > 0)
|
|
ps = AssetDatabase.LoadAssetAtPath<PanelSettings>(AssetDatabase.GUIDToAssetPath(guids[0]));
|
|
if (ps == null)
|
|
{
|
|
ps = CreateDefaultPanelSettings("Assets/UI/DefaultPanelSettings.asset");
|
|
tempPs = ps;
|
|
}
|
|
|
|
uiDoc.panelSettings = ps;
|
|
uiDoc.visualTreeAsset = vta;
|
|
}
|
|
|
|
if (uiDoc.panelSettings == null)
|
|
return new ErrorResponse("UIDocument has no PanelSettings assigned.");
|
|
|
|
var panelSettings = uiDoc.panelSettings;
|
|
int psId = panelSettings.GetInstanceIDCompat();
|
|
|
|
// Check if we already have a persistent RT assigned to this PanelSettings.
|
|
// If the RT exists and its size matches, the panel has been rendering into it.
|
|
// If not, create one and assign it — content will be available on the next call.
|
|
// Look up from our cache rather than panelSettings.targetTexture,
|
|
// because we set targetTexture = null after each successful read
|
|
// to restore on-screen rendering. The RT itself stays alive in s_panelRTs.
|
|
bool rtJustAssigned = false;
|
|
RenderTexture rt = null;
|
|
|
|
if (s_panelRTs.TryGetValue(psId, out var cachedRt) && cachedRt != null)
|
|
{
|
|
if (cachedRt.width == width && cachedRt.height == height)
|
|
{
|
|
rt = cachedRt;
|
|
// Re-attach if it was detached after the previous read
|
|
if (panelSettings.targetTexture != rt)
|
|
{
|
|
panelSettings.targetTexture = rt;
|
|
rtJustAssigned = true;
|
|
|
|
uiDoc.rootVisualElement?.MarkDirtyRepaint();
|
|
EditorUtility.SetDirty(panelSettings);
|
|
UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
|
|
Canvas.ForceUpdateCanvases();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Size changed — release the old RT
|
|
panelSettings.targetTexture = null;
|
|
string oldPath = AssetDatabase.GetAssetPath(cachedRt);
|
|
cachedRt.Release();
|
|
if (!string.IsNullOrEmpty(oldPath))
|
|
AssetDatabase.DeleteAsset(oldPath);
|
|
else
|
|
UnityEngine.Object.DestroyImmediate(cachedRt);
|
|
s_panelRTs.Remove(psId);
|
|
}
|
|
}
|
|
|
|
if (rt == null)
|
|
{
|
|
// Create RT as an asset so PanelSettings can serialize the reference properly
|
|
rt = new RenderTexture(width, height, 32, RenderTextureFormat.ARGB32);
|
|
rt.name = $"MCP_UI_Render_{psId}";
|
|
rt.Create();
|
|
|
|
string rtFolder = "Assets/UI";
|
|
if (!AssetDatabase.IsValidFolder(rtFolder))
|
|
AssetDatabase.CreateFolder("Assets", "UI");
|
|
string rtAssetPath = $"{rtFolder}/RT_MCP_UI_Render_{psId}.renderTexture";
|
|
AssetDatabase.CreateAsset(rt, rtAssetPath);
|
|
AssetDatabase.SaveAssets();
|
|
|
|
panelSettings.targetTexture = rt;
|
|
s_panelRTs[psId] = rt;
|
|
rtJustAssigned = true;
|
|
|
|
// Mark dirty and force editor repaint so the panel renders into the RT
|
|
uiDoc.rootVisualElement?.MarkDirtyRepaint();
|
|
EditorUtility.SetDirty(panelSettings);
|
|
UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
|
|
|
|
// Force a synchronous layout + repaint pass
|
|
Canvas.ForceUpdateCanvases();
|
|
}
|
|
|
|
// Read pixels from the RT
|
|
RenderTexture prevActive = RenderTexture.active;
|
|
RenderTexture.active = rt;
|
|
var tex = new Texture2D(width, height, TextureFormat.RGBA32, false);
|
|
tex.ReadPixels(new Rect(0, 0, width, height), 0, 0);
|
|
tex.Apply();
|
|
RenderTexture.active = prevActive;
|
|
|
|
// Restore targetTexture to null so the UI renders back to the
|
|
// actual display / camera. The RT stays cached in s_panelRTs
|
|
// and will be re-attached on the next render_ui call.
|
|
if (!rtJustAssigned)
|
|
{
|
|
panelSettings.targetTexture = null;
|
|
EditorUtility.SetDirty(panelSettings);
|
|
}
|
|
|
|
// Check if any content was rendered
|
|
bool hasContent = false;
|
|
var pixels = tex.GetPixels32();
|
|
for (int i = 0; i < pixels.Length; i += Mathf.Max(1, pixels.Length / 100))
|
|
{
|
|
if (pixels[i].a > 0) { hasContent = true; break; }
|
|
}
|
|
|
|
// Save to Screenshots folder
|
|
string resolvedName = string.IsNullOrWhiteSpace(fileName)
|
|
? $"ui-render-{DateTime.Now:yyyyMMdd-HHmmss}.png"
|
|
: fileName.Trim();
|
|
if (!resolvedName.EndsWith(".png", StringComparison.OrdinalIgnoreCase))
|
|
resolvedName += ".png";
|
|
|
|
Directory.CreateDirectory(resolvedFolderAbs);
|
|
string fullPath = Path.Combine(resolvedFolderAbs, resolvedName).Replace('\\', '/');
|
|
fullPath = EnsureUniqueFilePath(fullPath);
|
|
|
|
byte[] png = tex.EncodeToPNG();
|
|
File.WriteAllBytes(fullPath, png);
|
|
|
|
string projectRelPath = ScreenshotUtility.ToProjectRelativePath(fullPath);
|
|
if (ScreenshotUtility.IsUnderAssets(projectRelPath))
|
|
AssetDatabase.ImportAsset(projectRelPath, ImportAssetOptions.ForceSynchronousImport);
|
|
|
|
var data = new Dictionary<string, object>
|
|
{
|
|
{ "path", projectRelPath },
|
|
{ "fullPath", fullPath },
|
|
{ "width", width },
|
|
{ "height", height },
|
|
{ "hasContent", hasContent },
|
|
};
|
|
|
|
if (rtJustAssigned)
|
|
data["note"] = "RenderTexture was just assigned to PanelSettings. Call render_ui again to capture the rendered UI.";
|
|
|
|
if (!string.IsNullOrEmpty(target))
|
|
data["gameObject"] = target;
|
|
if (!string.IsNullOrEmpty(uxmlPath))
|
|
data["sourceAsset"] = uxmlPath;
|
|
|
|
if (includeImage)
|
|
{
|
|
int targetMax = maxResolution > 0 ? maxResolution : 640;
|
|
Texture2D downscaled = null;
|
|
try
|
|
{
|
|
if (width > targetMax || height > targetMax)
|
|
{
|
|
downscaled = ScreenshotUtility.DownscaleTexture(tex, targetMax);
|
|
data["imageBase64"] = Convert.ToBase64String(downscaled.EncodeToPNG());
|
|
data["imageWidth"] = downscaled.width;
|
|
data["imageHeight"] = downscaled.height;
|
|
}
|
|
else
|
|
{
|
|
data["imageBase64"] = Convert.ToBase64String(png);
|
|
data["imageWidth"] = width;
|
|
data["imageHeight"] = height;
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
if (downscaled != null) UnityEngine.Object.DestroyImmediate(downscaled);
|
|
}
|
|
}
|
|
|
|
UnityEngine.Object.DestroyImmediate(tex);
|
|
|
|
string msg = hasContent
|
|
? $"UI rendered to '{projectRelPath}'."
|
|
: rtJustAssigned
|
|
? $"RenderTexture assigned to PanelSettings. Call render_ui again to capture the rendered content."
|
|
: $"UI render saved to '{projectRelPath}' (no visible content detected).";
|
|
|
|
return new SuccessResponse(msg, data);
|
|
}
|
|
finally
|
|
{
|
|
if (tempGo != null) UnityEngine.Object.DestroyImmediate(tempGo);
|
|
if (tempPs != null)
|
|
{
|
|
string tempPsPath = AssetDatabase.GetAssetPath(tempPs);
|
|
if (!string.IsNullOrEmpty(tempPsPath))
|
|
AssetDatabase.DeleteAsset(tempPsPath);
|
|
else
|
|
UnityEngine.Object.DestroyImmediate(tempPs, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
// ---- Link Stylesheet ----
|
|
|
|
private static object LinkStylesheet(JObject @params)
|
|
{
|
|
var p = new ToolParams(@params);
|
|
|
|
string uxmlPathRaw = p.Get("path");
|
|
string uxmlPath = ValidatePath(uxmlPathRaw, out string pathError);
|
|
if (pathError != null) return new ErrorResponse(pathError);
|
|
|
|
// Validate the UXML path is actually a .uxml
|
|
if (!uxmlPath.EndsWith(".uxml", StringComparison.OrdinalIgnoreCase))
|
|
return new ErrorResponse("'path' must point to a .uxml file.");
|
|
|
|
string stylesheetPath = p.Get("stylesheet");
|
|
if (string.IsNullOrEmpty(stylesheetPath))
|
|
return new ErrorResponse("'stylesheet' parameter is required.");
|
|
|
|
stylesheetPath = AssetPathUtility.SanitizeAssetPath(stylesheetPath);
|
|
if (stylesheetPath == null)
|
|
return new ErrorResponse("Invalid stylesheet path: contains traversal sequences.");
|
|
|
|
if (!stylesheetPath.EndsWith(".uss", StringComparison.OrdinalIgnoreCase))
|
|
return new ErrorResponse("'stylesheet' must point to a .uss file.");
|
|
|
|
// Read the UXML file
|
|
string fullPath = Path.Combine(Application.dataPath,
|
|
uxmlPath.Substring("Assets/".Length)).Replace('/', Path.DirectorySeparatorChar);
|
|
|
|
if (!File.Exists(fullPath))
|
|
return new ErrorResponse($"UXML file not found: {uxmlPath}");
|
|
|
|
string content = File.ReadAllText(fullPath, Encoding.UTF8);
|
|
|
|
// Check if stylesheet is already linked
|
|
if (content.Contains($"src=\"{stylesheetPath}\"") ||
|
|
content.Contains($"src=\"project://database/{stylesheetPath}\""))
|
|
{
|
|
return new SuccessResponse($"Stylesheet already linked in '{uxmlPath}'.",
|
|
new { path = uxmlPath, stylesheet = stylesheetPath, alreadyLinked = true });
|
|
}
|
|
|
|
// Find the insertion point (after the opening <ui:UXML ...> or <UXML ...> tag)
|
|
int insertIdx = FindUxmlBodyStart(content);
|
|
if (insertIdx < 0)
|
|
return new ErrorResponse("Could not find insertion point. Ensure UXML has a root <ui:UXML> or <UXML> element.");
|
|
|
|
string styleTag = $"\n <ui:Style src=\"project://database/{stylesheetPath}\" />";
|
|
content = content.Insert(insertIdx, styleTag);
|
|
|
|
File.WriteAllText(fullPath, content, Utf8NoBom);
|
|
AssetDatabase.ImportAsset(uxmlPath, ImportAssetOptions.ForceUpdate);
|
|
|
|
return new SuccessResponse($"Linked stylesheet '{stylesheetPath}' to '{uxmlPath}'.",
|
|
new { path = uxmlPath, stylesheet = stylesheetPath });
|
|
}
|
|
|
|
// ---- Delete ----
|
|
|
|
private static object DeleteFile(JObject @params)
|
|
{
|
|
var p = new ToolParams(@params);
|
|
string path = ValidatePath(p.Get("path"), out string pathError);
|
|
if (pathError != null) return new ErrorResponse(pathError);
|
|
|
|
string fullPath = Path.Combine(Application.dataPath,
|
|
path.Substring("Assets/".Length));
|
|
fullPath = fullPath.Replace('/', Path.DirectorySeparatorChar);
|
|
|
|
if (!File.Exists(fullPath))
|
|
{
|
|
return new ErrorResponse($"File not found: {path}");
|
|
}
|
|
|
|
try
|
|
{
|
|
bool success = AssetDatabase.DeleteAsset(path);
|
|
if (!success)
|
|
{
|
|
return new ErrorResponse($"Failed to delete file through AssetDatabase: '{path}'");
|
|
}
|
|
|
|
// Fallback: if file still exists after AssetDatabase.DeleteAsset
|
|
if (File.Exists(fullPath))
|
|
{
|
|
File.Delete(fullPath);
|
|
}
|
|
|
|
return new SuccessResponse($"Deleted {Path.GetExtension(path).TrimStart('.')} file at {path}",
|
|
new { path });
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return new ErrorResponse($"Failed to delete '{path}': {e.Message}");
|
|
}
|
|
}
|
|
|
|
// ---- List UI Assets ----
|
|
|
|
private static object ListUIAssets(JObject @params)
|
|
{
|
|
var p = new ToolParams(@params);
|
|
string scope = p.Get("path") ?? "Assets";
|
|
string filterType = p.Get("filter_type") ?? p.Get("filterType");
|
|
int pageSize = p.GetInt("page_size") ?? p.GetInt("pageSize") ?? 50;
|
|
int pageNumber = p.GetInt("page_number") ?? p.GetInt("pageNumber") ?? 1;
|
|
|
|
scope = AssetPathUtility.SanitizeAssetPath(scope);
|
|
if (scope == null)
|
|
{
|
|
return new ErrorResponse("Invalid path: contains traversal sequences.");
|
|
}
|
|
|
|
string[] folderScope = AssetDatabase.IsValidFolder(scope)
|
|
? new[] { scope }
|
|
: null;
|
|
|
|
// Find UXML and USS assets based on filter
|
|
var allAssets = new List<object>();
|
|
|
|
bool includeUxml = string.IsNullOrEmpty(filterType) ||
|
|
filterType.Equals("uxml", StringComparison.OrdinalIgnoreCase) ||
|
|
filterType.Equals("VisualTreeAsset", StringComparison.OrdinalIgnoreCase);
|
|
bool includeUss = string.IsNullOrEmpty(filterType) ||
|
|
filterType.Equals("uss", StringComparison.OrdinalIgnoreCase) ||
|
|
filterType.Equals("StyleSheet", StringComparison.OrdinalIgnoreCase);
|
|
bool includePanelSettings = string.IsNullOrEmpty(filterType) ||
|
|
filterType.Equals("PanelSettings", StringComparison.OrdinalIgnoreCase);
|
|
|
|
if (includeUxml)
|
|
{
|
|
string[] guids = AssetDatabase.FindAssets("t:VisualTreeAsset", folderScope);
|
|
foreach (string guid in guids)
|
|
{
|
|
string assetPath = AssetDatabase.GUIDToAssetPath(guid);
|
|
if (!string.IsNullOrEmpty(assetPath))
|
|
{
|
|
allAssets.Add(new Dictionary<string, object>
|
|
{
|
|
["path"] = assetPath,
|
|
["type"] = "uxml",
|
|
["name"] = Path.GetFileName(assetPath),
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
if (includeUss)
|
|
{
|
|
string[] guids = AssetDatabase.FindAssets("t:StyleSheet", folderScope);
|
|
foreach (string guid in guids)
|
|
{
|
|
string assetPath = AssetDatabase.GUIDToAssetPath(guid);
|
|
if (!string.IsNullOrEmpty(assetPath))
|
|
{
|
|
allAssets.Add(new Dictionary<string, object>
|
|
{
|
|
["path"] = assetPath,
|
|
["type"] = "uss",
|
|
["name"] = Path.GetFileName(assetPath),
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
if (includePanelSettings)
|
|
{
|
|
string[] guids = AssetDatabase.FindAssets("t:PanelSettings", folderScope);
|
|
foreach (string guid in guids)
|
|
{
|
|
string assetPath = AssetDatabase.GUIDToAssetPath(guid);
|
|
if (!string.IsNullOrEmpty(assetPath))
|
|
{
|
|
allAssets.Add(new Dictionary<string, object>
|
|
{
|
|
["path"] = assetPath,
|
|
["type"] = "PanelSettings",
|
|
["name"] = Path.GetFileName(assetPath),
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
int total = allAssets.Count;
|
|
int startIndex = (pageNumber - 1) * pageSize;
|
|
var paged = allAssets.Skip(startIndex).Take(pageSize).ToList();
|
|
|
|
return new SuccessResponse(
|
|
$"Found {total} UI asset(s). Returning page {pageNumber} ({paged.Count} items).",
|
|
new
|
|
{
|
|
total,
|
|
pageSize,
|
|
pageNumber,
|
|
assets = paged,
|
|
});
|
|
}
|
|
|
|
// ---- Detach UIDocument ----
|
|
|
|
private static object DetachUIDocument(JObject @params)
|
|
{
|
|
var p = new ToolParams(@params);
|
|
|
|
var targetResult = p.GetRequired("target");
|
|
var targetError = targetResult.GetOrError(out string target);
|
|
if (targetError != null) return targetError;
|
|
|
|
var goInstruction = new JObject { ["find"] = target };
|
|
GameObject go = ObjectResolver.Resolve(goInstruction, typeof(GameObject)) as GameObject;
|
|
if (go == null)
|
|
{
|
|
return new ErrorResponse($"Could not find target GameObject: {target}");
|
|
}
|
|
|
|
var uiDoc = go.GetComponent<UIDocument>();
|
|
if (uiDoc == null)
|
|
{
|
|
return new ErrorResponse($"GameObject '{go.name}' has no UIDocument component.");
|
|
}
|
|
|
|
string sourceAsset = uiDoc.visualTreeAsset != null
|
|
? AssetDatabase.GetAssetPath(uiDoc.visualTreeAsset)
|
|
: null;
|
|
|
|
Undo.DestroyObjectImmediate(uiDoc);
|
|
EditorUtility.SetDirty(go);
|
|
|
|
return new SuccessResponse($"Removed UIDocument from {go.name}",
|
|
new
|
|
{
|
|
gameObject = go.name,
|
|
removedSourceAsset = sourceAsset,
|
|
});
|
|
}
|
|
|
|
// ---- Modify Visual Element ----
|
|
|
|
private static object ModifyVisualElement(JObject @params)
|
|
{
|
|
var p = new ToolParams(@params);
|
|
|
|
var targetResult = p.GetRequired("target");
|
|
var targetError = targetResult.GetOrError(out string target);
|
|
if (targetError != null) return targetError;
|
|
|
|
string elementName = p.Get("element_name") ?? p.Get("elementName");
|
|
if (string.IsNullOrEmpty(elementName))
|
|
{
|
|
return new ErrorResponse("'element_name' parameter is required.");
|
|
}
|
|
|
|
var goInstruction = new JObject { ["find"] = target };
|
|
GameObject go = ObjectResolver.Resolve(goInstruction, typeof(GameObject)) as GameObject;
|
|
if (go == null)
|
|
{
|
|
return new ErrorResponse($"Could not find target GameObject: {target}");
|
|
}
|
|
|
|
var uiDoc = go.GetComponent<UIDocument>();
|
|
if (uiDoc == null)
|
|
{
|
|
return new ErrorResponse($"GameObject '{go.name}' has no UIDocument component.");
|
|
}
|
|
|
|
var root = uiDoc.rootVisualElement;
|
|
if (root == null)
|
|
{
|
|
return new ErrorResponse($"UIDocument on {go.name} has no visual tree (not yet built).");
|
|
}
|
|
|
|
// Find the target element by name
|
|
var element = root.Q(elementName);
|
|
if (element == null)
|
|
{
|
|
return new ErrorResponse($"Visual element with name '{elementName}' not found in the visual tree.");
|
|
}
|
|
|
|
var modifications = new List<string>();
|
|
|
|
// Set text content (Label, Button, etc.)
|
|
string text = p.Get("text");
|
|
if (text != null && element is TextElement textEl)
|
|
{
|
|
textEl.text = text;
|
|
modifications.Add($"text='{text}'");
|
|
}
|
|
else if (text != null)
|
|
{
|
|
return new ErrorResponse($"Element '{elementName}' ({element.GetType().Name}) does not support text content.");
|
|
}
|
|
|
|
// Add CSS classes
|
|
JToken addClassesToken = p.GetRaw("add_classes") ?? p.GetRaw("addClasses");
|
|
if (addClassesToken is JArray addArr)
|
|
{
|
|
foreach (var cls in addArr)
|
|
{
|
|
string className = cls.ToString();
|
|
if (!element.ClassListContains(className))
|
|
{
|
|
element.AddToClassList(className);
|
|
modifications.Add($"+class '{className}'");
|
|
}
|
|
}
|
|
}
|
|
|
|
// Remove CSS classes
|
|
JToken removeClassesToken = p.GetRaw("remove_classes") ?? p.GetRaw("removeClasses");
|
|
if (removeClassesToken is JArray removeArr)
|
|
{
|
|
foreach (var cls in removeArr)
|
|
{
|
|
string className = cls.ToString();
|
|
if (element.ClassListContains(className))
|
|
{
|
|
element.RemoveFromClassList(className);
|
|
modifications.Add($"-class '{className}'");
|
|
}
|
|
}
|
|
}
|
|
|
|
// Toggle CSS classes
|
|
JToken toggleClassesToken = p.GetRaw("toggle_classes") ?? p.GetRaw("toggleClasses");
|
|
if (toggleClassesToken is JArray toggleArr)
|
|
{
|
|
foreach (var cls in toggleArr)
|
|
{
|
|
string className = cls.ToString();
|
|
element.ToggleInClassList(className);
|
|
modifications.Add($"~class '{className}'");
|
|
}
|
|
}
|
|
|
|
// Set inline styles
|
|
JToken styleToken = p.GetRaw("style") ?? p.GetRaw("inline_style") ?? p.GetRaw("inlineStyle");
|
|
if (styleToken is JObject styleObj)
|
|
{
|
|
ApplyInlineStyles(element, styleObj, modifications);
|
|
}
|
|
|
|
// Set enabled/disabled
|
|
bool? enabled = p.GetNullableBool("enabled");
|
|
if (enabled.HasValue)
|
|
{
|
|
element.SetEnabled(enabled.Value);
|
|
modifications.Add($"enabled={enabled.Value}");
|
|
}
|
|
|
|
// Set visibility
|
|
string visibility = p.Get("visible");
|
|
if (visibility != null)
|
|
{
|
|
bool isVisible = visibility.Equals("true", StringComparison.OrdinalIgnoreCase) ||
|
|
visibility == "1";
|
|
element.style.display = isVisible ? DisplayStyle.Flex : DisplayStyle.None;
|
|
modifications.Add($"visible={isVisible}");
|
|
}
|
|
|
|
// Set tooltip
|
|
string tooltip = p.Get("tooltip");
|
|
if (tooltip != null)
|
|
{
|
|
element.tooltip = tooltip;
|
|
modifications.Add($"tooltip='{tooltip}'");
|
|
}
|
|
|
|
// Filter out [skipped] entries so they don't count as real modifications
|
|
var applied = modifications.Where(m => !m.StartsWith("[skipped]")).ToList();
|
|
var skipped = modifications.Where(m => m.StartsWith("[skipped]")).ToList();
|
|
|
|
if (applied.Count == 0)
|
|
{
|
|
string msg = skipped.Count > 0
|
|
? $"No modifications applied. Skipped unsupported styles: {string.Join(", ", skipped)}"
|
|
: "No modifications specified. Provide at least one of: text, add_classes, remove_classes, toggle_classes, style, enabled, visible, tooltip.";
|
|
return new ErrorResponse(msg);
|
|
}
|
|
|
|
var responseData = new Dictionary<string, object>
|
|
{
|
|
{ "gameObject", go.name },
|
|
{ "elementName", elementName },
|
|
{ "elementType", element.GetType().Name },
|
|
{ "modifications", applied },
|
|
{ "currentClasses", new List<string>(element.GetClasses()) },
|
|
};
|
|
if (skipped.Count > 0)
|
|
responseData["skipped"] = skipped;
|
|
|
|
return new SuccessResponse(
|
|
$"Modified element '{elementName}' on {go.name}: {string.Join(", ", applied)}",
|
|
responseData);
|
|
}
|
|
|
|
private static void ApplyInlineStyles(VisualElement element, JObject styleObj, List<string> modifications)
|
|
{
|
|
foreach (var prop in styleObj)
|
|
{
|
|
string key = prop.Key;
|
|
JToken val = prop.Value;
|
|
|
|
switch (key.ToLowerInvariant())
|
|
{
|
|
case "backgroundcolor":
|
|
case "background-color":
|
|
if (ColorUtility.TryParseHtmlString(val.ToString(), out Color bgColor))
|
|
{
|
|
element.style.backgroundColor = bgColor;
|
|
modifications.Add($"backgroundColor={val}");
|
|
}
|
|
break;
|
|
|
|
case "color":
|
|
if (ColorUtility.TryParseHtmlString(val.ToString(), out Color fgColor))
|
|
{
|
|
element.style.color = fgColor;
|
|
modifications.Add($"color={val}");
|
|
}
|
|
break;
|
|
|
|
case "fontsize":
|
|
case "font-size":
|
|
element.style.fontSize = val.ToObject<float>();
|
|
modifications.Add($"fontSize={val}");
|
|
break;
|
|
|
|
case "width":
|
|
element.style.width = val.ToObject<float>();
|
|
modifications.Add($"width={val}");
|
|
break;
|
|
|
|
case "height":
|
|
element.style.height = val.ToObject<float>();
|
|
modifications.Add($"height={val}");
|
|
break;
|
|
|
|
case "opacity":
|
|
element.style.opacity = val.ToObject<float>();
|
|
modifications.Add($"opacity={val}");
|
|
break;
|
|
|
|
case "display":
|
|
if (Enum.TryParse<DisplayStyle>(val.ToString(), true, out var display))
|
|
{
|
|
element.style.display = display;
|
|
modifications.Add($"display={val}");
|
|
}
|
|
break;
|
|
|
|
case "visibility":
|
|
if (Enum.TryParse<Visibility>(val.ToString(), true, out var vis))
|
|
{
|
|
element.style.visibility = vis;
|
|
modifications.Add($"visibility={val}");
|
|
}
|
|
break;
|
|
|
|
case "flexgrow":
|
|
case "flex-grow":
|
|
element.style.flexGrow = val.ToObject<float>();
|
|
modifications.Add($"flexGrow={val}");
|
|
break;
|
|
|
|
case "flexshrink":
|
|
case "flex-shrink":
|
|
element.style.flexShrink = val.ToObject<float>();
|
|
modifications.Add($"flexShrink={val}");
|
|
break;
|
|
|
|
case "marginleft":
|
|
case "margin-left":
|
|
element.style.marginLeft = val.ToObject<float>();
|
|
modifications.Add($"marginLeft={val}");
|
|
break;
|
|
|
|
case "marginright":
|
|
case "margin-right":
|
|
element.style.marginRight = val.ToObject<float>();
|
|
modifications.Add($"marginRight={val}");
|
|
break;
|
|
|
|
case "margintop":
|
|
case "margin-top":
|
|
element.style.marginTop = val.ToObject<float>();
|
|
modifications.Add($"marginTop={val}");
|
|
break;
|
|
|
|
case "marginbottom":
|
|
case "margin-bottom":
|
|
element.style.marginBottom = val.ToObject<float>();
|
|
modifications.Add($"marginBottom={val}");
|
|
break;
|
|
|
|
case "paddingleft":
|
|
case "padding-left":
|
|
element.style.paddingLeft = val.ToObject<float>();
|
|
modifications.Add($"paddingLeft={val}");
|
|
break;
|
|
|
|
case "paddingright":
|
|
case "padding-right":
|
|
element.style.paddingRight = val.ToObject<float>();
|
|
modifications.Add($"paddingRight={val}");
|
|
break;
|
|
|
|
case "paddingtop":
|
|
case "padding-top":
|
|
element.style.paddingTop = val.ToObject<float>();
|
|
modifications.Add($"paddingTop={val}");
|
|
break;
|
|
|
|
case "paddingbottom":
|
|
case "padding-bottom":
|
|
element.style.paddingBottom = val.ToObject<float>();
|
|
modifications.Add($"paddingBottom={val}");
|
|
break;
|
|
|
|
case "borderradius":
|
|
case "border-radius":
|
|
float radius = val.ToObject<float>();
|
|
element.style.borderTopLeftRadius = radius;
|
|
element.style.borderTopRightRadius = radius;
|
|
element.style.borderBottomLeftRadius = radius;
|
|
element.style.borderBottomRightRadius = radius;
|
|
modifications.Add($"borderRadius={val}");
|
|
break;
|
|
|
|
default:
|
|
modifications.Add($"[skipped] {key} (unsupported inline style)");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static bool? GetNullableBool(this ToolParams p, string key)
|
|
{
|
|
var raw = p.GetRaw(key);
|
|
if (raw == null) return null;
|
|
if (raw.Type == JTokenType.Boolean) return raw.ToObject<bool>();
|
|
string s = raw.ToString();
|
|
if (bool.TryParse(s, out bool result)) return result;
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Finds the index right after the closing '>' of the root UXML element opening tag.
|
|
/// Returns -1 if not found or if the root tag is self-closing.
|
|
/// </summary>
|
|
private static int FindUxmlBodyStart(string content)
|
|
{
|
|
int searchFrom = 0;
|
|
while (true)
|
|
{
|
|
int idx = content.IndexOf("<ui:UXML", searchFrom, StringComparison.OrdinalIgnoreCase);
|
|
if (idx < 0)
|
|
idx = content.IndexOf("<UXML", searchFrom, StringComparison.OrdinalIgnoreCase);
|
|
if (idx < 0)
|
|
return -1;
|
|
|
|
// Skip matches inside XML comments (<!-- ... -->)
|
|
int commentStart = content.LastIndexOf("<!--", idx, StringComparison.Ordinal);
|
|
if (commentStart >= 0)
|
|
{
|
|
int commentEnd = content.IndexOf("-->", commentStart + 4, StringComparison.Ordinal);
|
|
if (commentEnd >= 0 && commentEnd + 3 > idx)
|
|
{
|
|
searchFrom = commentEnd + 3;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
int closeTag = content.IndexOf('>', idx);
|
|
if (closeTag < 0) return -1;
|
|
// Self-closing tag cannot have children
|
|
if (closeTag > 0 && content[closeTag - 1] == '/') return -1;
|
|
|
|
return closeTag + 1;
|
|
}
|
|
}
|
|
|
|
// ---- Helpers ----
|
|
|
|
private static string EnsureUniqueFilePath(string path)
|
|
{
|
|
if (!File.Exists(path)) return path;
|
|
string dir = Path.GetDirectoryName(path) ?? string.Empty;
|
|
string baseName = Path.GetFileNameWithoutExtension(path);
|
|
string ext = Path.GetExtension(path);
|
|
int counter = 1;
|
|
string candidate;
|
|
do
|
|
{
|
|
candidate = Path.Combine(dir, $"{baseName}-{counter}{ext}").Replace('\\', '/');
|
|
counter++;
|
|
} while (File.Exists(candidate));
|
|
return candidate;
|
|
}
|
|
|
|
private static string ColorToHex(Color c)
|
|
{
|
|
return $"#{ColorUtility.ToHtmlStringRGBA(c)}";
|
|
}
|
|
|
|
private static string GetDecodedContents(ToolParams p)
|
|
{
|
|
bool isEncoded = p.GetBool("contents_encoded") || p.GetBool("contentsEncoded");
|
|
|
|
if (isEncoded)
|
|
{
|
|
string encoded = p.Get("encoded_contents") ?? p.Get("encodedContents");
|
|
if (!string.IsNullOrEmpty(encoded))
|
|
{
|
|
try
|
|
{
|
|
return Encoding.UTF8.GetString(Convert.FromBase64String(encoded));
|
|
}
|
|
catch (FormatException ex)
|
|
{
|
|
throw new ArgumentException(
|
|
"Parameter 'encodedContents' must be valid base64 when 'contentsEncoded' is true.",
|
|
ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
return p.Get("contents");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Validates UXML content before writing to disk.
|
|
/// Returns null if valid, or an error message if malformed.
|
|
/// Populates warnings list with non-fatal issues.
|
|
/// Uses XmlParserContext to pre-declare common UXML namespace prefixes
|
|
/// (ui, uie, engine, editor) since Unity's parser is more lenient than System.Xml.
|
|
/// </summary>
|
|
|
|
/// <summary>
|
|
/// Ensures the root UXML element has editor-extension-mode attribute.
|
|
/// UI Builder requires this to open the file. Injects "False" if missing.
|
|
/// </summary>
|
|
private static string EnsureEditorExtensionMode(string contents)
|
|
{
|
|
if (contents.Contains("editor-extension-mode"))
|
|
return contents;
|
|
|
|
int idx = contents.IndexOf("<ui:UXML", StringComparison.Ordinal);
|
|
if (idx < 0)
|
|
idx = contents.IndexOf("<UXML", StringComparison.Ordinal);
|
|
if (idx < 0)
|
|
return contents;
|
|
|
|
int closeTag = contents.IndexOf('>', idx);
|
|
if (closeTag < 0)
|
|
return contents;
|
|
|
|
bool selfClosing = contents[closeTag - 1] == '/';
|
|
int insertPos = selfClosing ? closeTag - 1 : closeTag;
|
|
|
|
return contents.Substring(0, insertPos)
|
|
+ " editor-extension-mode=\"False\""
|
|
+ contents.Substring(insertPos);
|
|
}
|
|
|
|
private static string ValidateUxmlContent(string contents, List<string> warnings)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(contents))
|
|
return "UXML content is empty.";
|
|
|
|
var nt = new NameTable();
|
|
var nsMgr = new XmlNamespaceManager(nt);
|
|
nsMgr.AddNamespace("ui", "UnityEngine.UIElements");
|
|
nsMgr.AddNamespace("uie", "UnityEditor.UIElements");
|
|
nsMgr.AddNamespace("engine", "UnityEngine.UIElements");
|
|
nsMgr.AddNamespace("editor", "UnityEditor.UIElements");
|
|
var ctx = new XmlParserContext(nt, nsMgr, null, XmlSpace.Default);
|
|
|
|
string rootLocalName = null;
|
|
try
|
|
{
|
|
using (var reader = XmlReader.Create(new StringReader(contents), null, ctx))
|
|
{
|
|
while (reader.Read())
|
|
{
|
|
if (reader.NodeType == XmlNodeType.Element && rootLocalName == null)
|
|
rootLocalName = reader.LocalName;
|
|
}
|
|
}
|
|
}
|
|
catch (XmlException ex)
|
|
{
|
|
return $"Malformed XML at line {ex.LineNumber}, position {ex.LinePosition}: {ex.Message}";
|
|
}
|
|
|
|
if (rootLocalName == null)
|
|
return "UXML content has no root element.";
|
|
|
|
if (rootLocalName != "UXML")
|
|
warnings.Add($"Root element is <{rootLocalName}>, expected <UXML> or <ui:UXML>.");
|
|
|
|
if (!contents.Contains("UnityEngine.UIElements"))
|
|
{
|
|
warnings.Add("Missing namespace declaration xmlns:ui=\"UnityEngine.UIElements\". " +
|
|
"UI Builder may fail to open this file.");
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Validates a UXML asset after import by attempting to load it as a VisualTreeAsset.
|
|
/// </summary>
|
|
private static void ValidateUxmlPostImport(string assetPath, List<string> warnings)
|
|
{
|
|
var asset = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(assetPath);
|
|
if (asset == null)
|
|
{
|
|
warnings.Add("Unity failed to parse the UXML file. " +
|
|
"The file was written but UI Builder will not be able to open it. " +
|
|
"Check the console for details.");
|
|
}
|
|
}
|
|
}
|
|
}
|