774 lines
30 KiB
C#
774 lines
30 KiB
C#
#if UNITY_EDITOR
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using Newtonsoft.Json.Linq;
|
|
using TMPro;
|
|
using UnityEditor;
|
|
using UnityEngine;
|
|
using UnityEngine.UI;
|
|
|
|
namespace XGame.EditorTools
|
|
{
|
|
public class ValidationResult
|
|
{
|
|
public bool Ok = true;
|
|
public readonly List<string> Errors = new List<string>();
|
|
public readonly List<string> Warnings = new List<string>();
|
|
}
|
|
|
|
public static class JsonUIPrefabBuilder
|
|
{
|
|
// Doc/UIPrefabCreater 位于仓库根（Unity 工程目录 Client/ 的上一级），
|
|
// 不能用相对路径（Unity 工作目录是工程目录），需基于 dataPath 解析为绝对路径。
|
|
private const string JsonRootRelative = "Doc/UIPrefabCreater";
|
|
private const string TextureRoot = "Assets/Game/Art/UI/Texture";
|
|
private static readonly int[] RequiredRefResolution = { 2048, 1024 };
|
|
|
|
// 解析 JSON 根目录绝对路径：优先 仓库根/Doc/UIPrefabCreater，回退 工程根/Doc/UIPrefabCreater
|
|
private static string ResolveJsonRoot()
|
|
{
|
|
// Application.dataPath = <repo>/Client/Assets
|
|
string projectDir = Directory.GetParent(Application.dataPath).FullName; // <repo>/Client
|
|
string repoDir = Directory.GetParent(projectDir)?.FullName ?? projectDir; // <repo>
|
|
string atRepo = Path.Combine(repoDir, JsonRootRelative);
|
|
if (Directory.Exists(atRepo))
|
|
{
|
|
return atRepo;
|
|
}
|
|
string atProject = Path.Combine(projectDir, JsonRootRelative);
|
|
return atProject;
|
|
}
|
|
|
|
public static string ResolveDefaultJsonRoot()
|
|
{
|
|
return ResolveJsonRoot();
|
|
}
|
|
|
|
// 已识别但本期未实现的组件：遇到只告警、不报错（让 LoginPanelControls.json 仍能通过）
|
|
private static readonly HashSet<string> KnownUnimplemented = new HashSet<string>
|
|
{
|
|
"Toggle", "TMP_InputField", "RotationAnimation"
|
|
};
|
|
|
|
[MenuItem("Tools/UI/Generate Prefab From JSON...")]
|
|
public static void GenerateOne()
|
|
{
|
|
string path = EditorUtility.OpenFilePanel("选择 UI JSON", ResolveJsonRoot(), "json");
|
|
if (string.IsNullOrEmpty(path))
|
|
{
|
|
return;
|
|
}
|
|
string output = BuildFromJsonFile(path);
|
|
if (!string.IsNullOrEmpty(output))
|
|
{
|
|
Debug.Log("[UIGen] 生成成功: " + output);
|
|
}
|
|
}
|
|
|
|
[MenuItem("Tools/UI/Generate All Prefabs From JSON")]
|
|
public static void GenerateAll()
|
|
{
|
|
IReadOnlyList<string> outputs = BuildAll(ResolveJsonRoot());
|
|
Debug.Log("[UIGen] 批量生成完成，成功 " + outputs.Count + " 个。");
|
|
}
|
|
|
|
public static void BuildGameLobbyFromCommandLine()
|
|
{
|
|
string jsonPath = Path.Combine(ResolveJsonRoot(), "GameLobbyControls.json");
|
|
string output = BuildFromJsonFile(jsonPath);
|
|
if (string.IsNullOrEmpty(output))
|
|
{
|
|
throw new Exception("[UIGen] GameLobbyControls.json build failed.");
|
|
}
|
|
}
|
|
|
|
public static void BuildMatchWaitingFromCommandLine()
|
|
{
|
|
string jsonPath = Path.Combine(ResolveJsonRoot(), "MatchWaitingControls.json");
|
|
string output = BuildFromJsonFile(jsonPath);
|
|
if (string.IsNullOrEmpty(output))
|
|
{
|
|
throw new Exception("[UIGen] MatchWaitingControls.json build failed.");
|
|
}
|
|
}
|
|
|
|
public static void BuildAllFromCommandLine()
|
|
{
|
|
string jsonRoot = GetCommandLineValue("-uiJsonRoot");
|
|
if (string.IsNullOrEmpty(jsonRoot))
|
|
{
|
|
jsonRoot = ResolveJsonRoot();
|
|
}
|
|
else if (!Path.IsPathRooted(jsonRoot))
|
|
{
|
|
string projectDir = Directory.GetParent(Application.dataPath).FullName;
|
|
string repoDir = Directory.GetParent(projectDir)?.FullName ?? projectDir;
|
|
jsonRoot = Path.Combine(repoDir, jsonRoot);
|
|
}
|
|
|
|
IReadOnlyList<string> outputs = BuildAll(jsonRoot);
|
|
if (outputs.Count == 0)
|
|
{
|
|
throw new Exception("[UIGen] no prefab was built.");
|
|
}
|
|
}
|
|
|
|
public static ValidationResult Validate(string jsonPath)
|
|
{
|
|
ValidationResult vr = new ValidationResult();
|
|
if (!File.Exists(jsonPath))
|
|
{
|
|
Fail(vr, "文件不存在: " + jsonPath);
|
|
return vr;
|
|
}
|
|
|
|
JObject root;
|
|
try
|
|
{
|
|
root = JObject.Parse(File.ReadAllText(jsonPath));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Fail(vr, "JSON 解析失败: " + ex.Message);
|
|
return vr;
|
|
}
|
|
|
|
foreach (string field in new[] { "schemaVersion", "prefabName", "prefabPath", "canvas", "assets", "nodes" })
|
|
{
|
|
if (root[field] == null)
|
|
{
|
|
Fail(vr, "缺少顶层字段: " + field);
|
|
}
|
|
}
|
|
if (!vr.Ok)
|
|
{
|
|
return vr;
|
|
}
|
|
|
|
string prefabName = (string)root["prefabName"];
|
|
string prefabPath = (string)root["prefabPath"];
|
|
if (!prefabPath.Replace("\\", "/").StartsWith("Assets/"))
|
|
{
|
|
Fail(vr, "prefabPath 必须位于 Assets/ 下: " + prefabPath);
|
|
}
|
|
|
|
JToken refRes = root["canvas"]?["canvasScaler"]?["referenceResolution"];
|
|
if (refRes == null || (int)refRes[0] != RequiredRefResolution[0] || (int)refRes[1] != RequiredRefResolution[1])
|
|
{
|
|
Fail(vr, "referenceResolution 必须为 [2048, 1024]");
|
|
}
|
|
|
|
JArray nodes = root["nodes"] as JArray;
|
|
if (nodes == null || nodes.Count == 0)
|
|
{
|
|
Fail(vr, "nodes 为空");
|
|
return vr;
|
|
}
|
|
|
|
HashSet<string> names = new HashSet<string>();
|
|
List<string> roots = new List<string>();
|
|
foreach (JToken node in nodes)
|
|
{
|
|
string name = (string)node["name"];
|
|
if (string.IsNullOrEmpty(name))
|
|
{
|
|
Fail(vr, "存在无 name 的节点");
|
|
continue;
|
|
}
|
|
if (!names.Add(name))
|
|
{
|
|
Fail(vr, "节点名重复: " + name);
|
|
}
|
|
if (node["rect"] == null)
|
|
{
|
|
Fail(vr, "节点缺少 rect: " + name);
|
|
}
|
|
if (node["parent"] == null || node["parent"].Type == JTokenType.Null)
|
|
{
|
|
roots.Add(name);
|
|
}
|
|
}
|
|
foreach (JToken node in nodes)
|
|
{
|
|
JToken parent = node["parent"];
|
|
if (parent != null && parent.Type != JTokenType.Null && !names.Contains((string)parent))
|
|
{
|
|
Fail(vr, "父节点不存在: " + (string)parent + " (来自 " + (string)node["name"] + ")");
|
|
}
|
|
}
|
|
if (roots.Count != 1)
|
|
{
|
|
Fail(vr, "根节点数量必须为 1，实际 " + roots.Count);
|
|
}
|
|
else if (roots[0] != prefabName)
|
|
{
|
|
Fail(vr, "prefabName 必须与根节点名一致: " + prefabName + " vs " + roots[0]);
|
|
}
|
|
|
|
foreach (string b in EnumStrings(root["bindings"]))
|
|
{
|
|
if (!names.Contains(b))
|
|
{
|
|
Fail(vr, "bindings 节点不存在: " + b);
|
|
}
|
|
}
|
|
foreach (JToken ev in (root["events"] as JArray) ?? new JArray())
|
|
{
|
|
string n = (string)ev["node"];
|
|
if (!names.Contains(n))
|
|
{
|
|
Fail(vr, "events 节点不存在: " + n);
|
|
}
|
|
}
|
|
return vr;
|
|
}
|
|
|
|
public static string BuildFromJsonFile(string jsonPath)
|
|
{
|
|
ValidationResult vr = Validate(jsonPath);
|
|
foreach (string w in vr.Warnings)
|
|
{
|
|
Debug.LogWarning("[UIGen] " + Path.GetFileName(jsonPath) + ": " + w);
|
|
}
|
|
if (!vr.Ok)
|
|
{
|
|
foreach (string e in vr.Errors)
|
|
{
|
|
Debug.LogError("[UIGen] " + Path.GetFileName(jsonPath) + ": " + e);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
JObject root = JObject.Parse(File.ReadAllText(jsonPath));
|
|
string prefabName = (string)root["prefabName"];
|
|
string prefabPath = (string)root["prefabPath"];
|
|
JArray nodes = (JArray)root["nodes"];
|
|
|
|
GameObject rootGo = null;
|
|
try
|
|
{
|
|
Dictionary<string, GameObject> map = new Dictionary<string, GameObject>();
|
|
List<Action> deferred = new List<Action>();
|
|
|
|
foreach (JToken node in nodes)
|
|
{
|
|
string name = (string)node["name"];
|
|
string parentName = node["parent"]?.Type == JTokenType.Null ? null : (string)node["parent"];
|
|
|
|
GameObject go = new GameObject(name, typeof(RectTransform));
|
|
map[name] = go;
|
|
if (parentName == null)
|
|
{
|
|
rootGo = go;
|
|
}
|
|
else if (map.TryGetValue(parentName, out GameObject parentGo))
|
|
{
|
|
go.transform.SetParent(parentGo.transform, false);
|
|
}
|
|
|
|
ApplyRect(go.GetComponent<RectTransform>(), node["rect"] as JObject);
|
|
bool active = node["active"] == null || (bool)node["active"];
|
|
|
|
foreach (JToken comp in (node["components"] as JArray) ?? new JArray())
|
|
{
|
|
ApplyComponent(go, comp as JObject, map, deferred, Path.GetFileName(jsonPath));
|
|
}
|
|
go.SetActive(active);
|
|
}
|
|
|
|
foreach (Action a in deferred)
|
|
{
|
|
a();
|
|
}
|
|
|
|
string dir = Path.GetDirectoryName(prefabPath);
|
|
if (!AssetDatabase.IsValidFolder(dir))
|
|
{
|
|
Directory.CreateDirectory(dir);
|
|
AssetDatabase.Refresh();
|
|
}
|
|
|
|
GameObject saved = PrefabUtility.SaveAsPrefabAsset(rootGo, prefabPath);
|
|
AssetDatabase.SaveAssets();
|
|
AssetDatabase.Refresh();
|
|
Debug.Log("[UIGen] " + prefabName + " 生成完成 -> " + prefabPath);
|
|
return saved == null ? null : prefabPath;
|
|
}
|
|
finally
|
|
{
|
|
if (rootGo != null)
|
|
{
|
|
UnityEngine.Object.DestroyImmediate(rootGo);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static IReadOnlyList<string> BuildAll(string jsonRoot)
|
|
{
|
|
List<string> outputs = new List<string>();
|
|
int failed = 0;
|
|
if (!Directory.Exists(jsonRoot))
|
|
{
|
|
Debug.LogError("[UIGen] JSON 目录不存在: " + jsonRoot);
|
|
return outputs;
|
|
}
|
|
foreach (string file in Directory.GetFiles(jsonRoot, "*.json", SearchOption.AllDirectories))
|
|
{
|
|
// 只处理含 prefabName/nodes 的 UI 描述文件，跳过其它 json
|
|
string text;
|
|
try { text = File.ReadAllText(file); } catch { continue; }
|
|
if (!text.Contains("\"prefabName\"") || !text.Contains("\"nodes\""))
|
|
{
|
|
Debug.Log("[UIGen] 跳过非 UI JSON: " + file);
|
|
continue;
|
|
}
|
|
string output = BuildFromJsonFile(file);
|
|
if (string.IsNullOrEmpty(output))
|
|
{
|
|
failed++;
|
|
}
|
|
else
|
|
{
|
|
outputs.Add(output);
|
|
}
|
|
}
|
|
Debug.Log("[UIGen] BuildAll 完成 Success:" + outputs.Count + " Failed:" + failed);
|
|
return outputs;
|
|
}
|
|
|
|
public static IReadOnlyList<string> BuildChanged(string jsonRoot, string reason, bool force = false)
|
|
{
|
|
List<string> outputs = new List<string>();
|
|
int skipped = 0;
|
|
int failed = 0;
|
|
if (!Directory.Exists(jsonRoot))
|
|
{
|
|
Debug.LogError("[UIGen] JSON 目录不存在: " + jsonRoot);
|
|
return outputs;
|
|
}
|
|
|
|
foreach (string file in Directory.GetFiles(jsonRoot, "*.json", SearchOption.AllDirectories))
|
|
{
|
|
if (!TryReadUiJson(file, out JObject root))
|
|
{
|
|
skipped++;
|
|
continue;
|
|
}
|
|
|
|
string prefabPath = (string)root["prefabPath"];
|
|
if (!force && !IsJsonNewerThanPrefab(file, prefabPath))
|
|
{
|
|
skipped++;
|
|
continue;
|
|
}
|
|
|
|
string output = BuildFromJsonFile(file);
|
|
if (string.IsNullOrEmpty(output))
|
|
{
|
|
failed++;
|
|
}
|
|
else
|
|
{
|
|
outputs.Add(output);
|
|
Debug.Log("[UIGen:" + reason + "] " + Path.GetFileName(file) + " -> " + output);
|
|
}
|
|
}
|
|
|
|
if (outputs.Count > 0 || failed > 0)
|
|
{
|
|
Debug.Log("[UIGen:" + reason + "] BuildChanged 完成 Success:" + outputs.Count + " Failed:" + failed + " Skipped:" + skipped);
|
|
}
|
|
return outputs;
|
|
}
|
|
|
|
private static bool TryReadUiJson(string file, out JObject root)
|
|
{
|
|
root = null;
|
|
try
|
|
{
|
|
string text = File.ReadAllText(file);
|
|
if (!text.Contains("\"prefabName\"") || !text.Contains("\"nodes\""))
|
|
{
|
|
return false;
|
|
}
|
|
root = JObject.Parse(text);
|
|
return root["prefabName"] != null && root["prefabPath"] != null && root["nodes"] != null;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private static bool IsJsonNewerThanPrefab(string jsonPath, string prefabPath)
|
|
{
|
|
if (string.IsNullOrEmpty(prefabPath))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
string normalizedPrefabPath = prefabPath.Replace("\\", "/");
|
|
string fullPrefabPath = Path.IsPathRooted(normalizedPrefabPath)
|
|
? normalizedPrefabPath
|
|
: Path.Combine(Directory.GetParent(Application.dataPath).FullName, normalizedPrefabPath);
|
|
if (!File.Exists(fullPrefabPath))
|
|
{
|
|
return true;
|
|
}
|
|
return File.GetLastWriteTimeUtc(jsonPath) > File.GetLastWriteTimeUtc(fullPrefabPath).AddMilliseconds(100);
|
|
}
|
|
|
|
// ---------- RectTransform ----------
|
|
private static void ApplyRect(RectTransform rt, JObject rect)
|
|
{
|
|
if (rect == null)
|
|
{
|
|
return;
|
|
}
|
|
rt.anchorMin = ToVec2(rect["anchorMin"], new Vector2(0, 0));
|
|
rt.anchorMax = ToVec2(rect["anchorMax"], new Vector2(1, 1));
|
|
rt.pivot = ToVec2(rect["pivot"], new Vector2(0.5f, 0.5f));
|
|
if (rect["offsetMin"] != null && rect["offsetMax"] != null)
|
|
{
|
|
rt.offsetMin = ToVec2(rect["offsetMin"], Vector2.zero);
|
|
rt.offsetMax = ToVec2(rect["offsetMax"], Vector2.zero);
|
|
}
|
|
else
|
|
{
|
|
rt.sizeDelta = ToVec2(rect["sizeDelta"], Vector2.zero);
|
|
rt.anchoredPosition = ToVec2(rect["anchoredPosition"], Vector2.zero);
|
|
}
|
|
}
|
|
|
|
// 用 Unity 重载的 == 判空，避免 C# ?? 在 Unity 对象上的“假 null”陷阱
|
|
private static T GetOrAdd<T>(GameObject go) where T : Component
|
|
{
|
|
T c = go.GetComponent<T>();
|
|
if (c == null)
|
|
{
|
|
c = go.AddComponent<T>();
|
|
}
|
|
return c;
|
|
}
|
|
|
|
// ---------- 组件 ----------
|
|
private static void ApplyComponent(GameObject go, JObject comp, Dictionary<string, GameObject> map, List<Action> deferred, string fileName)
|
|
{
|
|
if (comp == null)
|
|
{
|
|
return;
|
|
}
|
|
string type = (string)comp["type"];
|
|
switch (type)
|
|
{
|
|
case "Canvas":
|
|
{
|
|
Canvas c = GetOrAdd<Canvas>(go);
|
|
c.renderMode = RenderMode.ScreenSpaceOverlay;
|
|
if (comp["sortingOrder"] != null) c.sortingOrder = (int)comp["sortingOrder"];
|
|
break;
|
|
}
|
|
case "CanvasScaler":
|
|
{
|
|
CanvasScaler cs = GetOrAdd<CanvasScaler>(go);
|
|
cs.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize;
|
|
cs.referenceResolution = ToVec2(comp["referenceResolution"], new Vector2(2048, 1024));
|
|
cs.screenMatchMode = CanvasScaler.ScreenMatchMode.MatchWidthOrHeight;
|
|
cs.matchWidthOrHeight = comp["matchWidthOrHeight"] != null ? (float)comp["matchWidthOrHeight"] : 0.5f;
|
|
break;
|
|
}
|
|
case "GraphicRaycaster":
|
|
GetOrAdd<GraphicRaycaster>(go);
|
|
break;
|
|
case "CanvasGroup":
|
|
{
|
|
CanvasGroup cg = GetOrAdd<CanvasGroup>(go);
|
|
if (comp["alpha"] != null) cg.alpha = (float)comp["alpha"];
|
|
if (comp["interactable"] != null) cg.interactable = (bool)comp["interactable"];
|
|
if (comp["blocksRaycasts"] != null) cg.blocksRaycasts = (bool)comp["blocksRaycasts"];
|
|
break;
|
|
}
|
|
case "Image":
|
|
{
|
|
Image img = GetOrAdd<Image>(go);
|
|
string spriteName = (string)comp["sprite"];
|
|
Sprite sprite = ResolveSprite(spriteName, fileName);
|
|
img.sprite = sprite;
|
|
img.type = string.Equals((string)comp["imageType"], "Sliced", StringComparison.OrdinalIgnoreCase) ? Image.Type.Sliced : Image.Type.Simple;
|
|
if (comp["preserveAspect"] != null) img.preserveAspect = (bool)comp["preserveAspect"];
|
|
img.raycastTarget = comp["raycastTarget"] == null || (bool)comp["raycastTarget"];
|
|
img.color = ParseColor((string)comp["color"], Color.white);
|
|
break;
|
|
}
|
|
case "TextMeshProUGUI":
|
|
{
|
|
TextMeshProUGUI t = GetOrAdd<TextMeshProUGUI>(go);
|
|
t.text = (string)comp["text"] ?? string.Empty;
|
|
if (comp["fontSize"] != null) t.fontSize = (float)comp["fontSize"];
|
|
t.fontStyle = string.Equals((string)comp["fontStyle"], "Bold", StringComparison.OrdinalIgnoreCase) ? FontStyles.Bold : FontStyles.Normal;
|
|
t.alignment = ParseAlignment((string)comp["alignment"]);
|
|
t.color = ParseColor((string)comp["color"], Color.white);
|
|
t.raycastTarget = comp["raycastTarget"] != null && (bool)comp["raycastTarget"];
|
|
break;
|
|
}
|
|
case "Button":
|
|
{
|
|
Button btn = GetOrAdd<Button>(go);
|
|
Image target = go.GetComponent<Image>();
|
|
if (target != null) btn.targetGraphic = target;
|
|
if (string.Equals((string)comp["transition"], "SpriteSwap", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
btn.transition = Selectable.Transition.SpriteSwap;
|
|
SpriteState state = btn.spriteState;
|
|
state.highlightedSprite = ResolveSprite((string)comp["spriteHighlighted"], fileName);
|
|
state.pressedSprite = ResolveSprite((string)comp["spritePressed"], fileName);
|
|
state.disabledSprite = ResolveSprite((string)comp["spriteDisabled"], fileName);
|
|
btn.spriteState = state;
|
|
}
|
|
else
|
|
{
|
|
btn.transition = Selectable.Transition.ColorTint;
|
|
}
|
|
// onClick 仅作事件标记，不在 Prefab 写死回调
|
|
break;
|
|
}
|
|
case "Shadow":
|
|
{
|
|
Shadow shadow = GetOrAdd<Shadow>(go);
|
|
shadow.effectColor = ParseColor((string)comp["effectColor"], new Color(0.06f, 0.12f, 0.2f, 0.75f));
|
|
shadow.effectDistance = ToVec2(comp["effectDistance"], new Vector2(1f, -1f));
|
|
if (comp["useGraphicAlpha"] != null) shadow.useGraphicAlpha = (bool)comp["useGraphicAlpha"];
|
|
break;
|
|
}
|
|
case "Outline":
|
|
{
|
|
Outline outline = GetOrAdd<Outline>(go);
|
|
outline.effectColor = ParseColor((string)comp["effectColor"], new Color(0.06f, 0.12f, 0.2f, 0.75f));
|
|
outline.effectDistance = ToVec2(comp["effectDistance"], new Vector2(1f, -1f));
|
|
if (comp["useGraphicAlpha"] != null) outline.useGraphicAlpha = (bool)comp["useGraphicAlpha"];
|
|
break;
|
|
}
|
|
case "ScrollRect":
|
|
{
|
|
ScrollRect sr = GetOrAdd<ScrollRect>(go);
|
|
sr.horizontal = comp["horizontal"] != null && (bool)comp["horizontal"];
|
|
sr.vertical = comp["vertical"] == null || (bool)comp["vertical"];
|
|
string viewportName = (string)comp["viewport"];
|
|
string contentName = (string)comp["content"];
|
|
deferred.Add(() =>
|
|
{
|
|
if (!string.IsNullOrEmpty(viewportName) && map.TryGetValue(viewportName, out GameObject vp))
|
|
sr.viewport = vp.GetComponent<RectTransform>();
|
|
if (!string.IsNullOrEmpty(contentName) && map.TryGetValue(contentName, out GameObject ct))
|
|
sr.content = ct.GetComponent<RectTransform>();
|
|
});
|
|
break;
|
|
}
|
|
case "RectMask2D":
|
|
GetOrAdd<RectMask2D>(go);
|
|
break;
|
|
case "Mask":
|
|
{
|
|
GetOrAdd<Image>(go);
|
|
Mask m = GetOrAdd<Mask>(go);
|
|
if (comp["showMaskGraphic"] != null) m.showMaskGraphic = (bool)comp["showMaskGraphic"];
|
|
break;
|
|
}
|
|
case "VerticalLayoutGroup":
|
|
{
|
|
VerticalLayoutGroup v = GetOrAdd<VerticalLayoutGroup>(go);
|
|
if (comp["spacing"] != null) v.spacing = (float)comp["spacing"];
|
|
v.padding = ParsePadding(comp["padding"]);
|
|
v.childAlignment = ParseAnchor((string)comp["childAlignment"]);
|
|
if (comp["childControlWidth"] != null) v.childControlWidth = (bool)comp["childControlWidth"];
|
|
if (comp["childControlHeight"] != null) v.childControlHeight = (bool)comp["childControlHeight"];
|
|
if (comp["childForceExpandWidth"] != null) v.childForceExpandWidth = (bool)comp["childForceExpandWidth"];
|
|
if (comp["childForceExpandHeight"] != null) v.childForceExpandHeight = (bool)comp["childForceExpandHeight"];
|
|
break;
|
|
}
|
|
case "ContentSizeFitter":
|
|
{
|
|
ContentSizeFitter f = GetOrAdd<ContentSizeFitter>(go);
|
|
f.verticalFit = ParseFit((string)comp["verticalFit"]);
|
|
f.horizontalFit = ParseFit((string)comp["horizontalFit"]);
|
|
break;
|
|
}
|
|
case "LayoutElement":
|
|
{
|
|
LayoutElement le = GetOrAdd<LayoutElement>(go);
|
|
if (comp["minHeight"] != null) le.minHeight = (float)comp["minHeight"];
|
|
if (comp["minWidth"] != null) le.minWidth = (float)comp["minWidth"];
|
|
if (comp["preferredHeight"] != null) le.preferredHeight = (float)comp["preferredHeight"];
|
|
if (comp["preferredWidth"] != null) le.preferredWidth = (float)comp["preferredWidth"];
|
|
break;
|
|
}
|
|
case "MonoBehaviour":
|
|
{
|
|
string typeName = (string)comp["typeName"];
|
|
deferred.Add(() =>
|
|
{
|
|
Type componentType = FindComponentType(typeName);
|
|
if (componentType == null)
|
|
{
|
|
Debug.LogWarning("[UIGen] " + fileName + ": 找不到脚本组件: " + typeName + " (" + go.name + ")");
|
|
}
|
|
else if (go.GetComponent(componentType) == null)
|
|
{
|
|
go.AddComponent(componentType);
|
|
}
|
|
});
|
|
break;
|
|
}
|
|
default:
|
|
if (KnownUnimplemented.Contains(type))
|
|
Debug.LogWarning("[UIGen] " + fileName + ": 组件未实现，已跳过: " + type + " (" + go.name + ")");
|
|
else
|
|
Debug.LogWarning("[UIGen] " + fileName + ": 未知组件类型: " + type + " (" + go.name + ")");
|
|
break;
|
|
}
|
|
}
|
|
|
|
// ---------- 资源/解析辅助 ----------
|
|
private static Type FindComponentType(string typeName)
|
|
{
|
|
if (string.IsNullOrEmpty(typeName))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
Type type = Type.GetType(typeName);
|
|
if (type != null && typeof(Component).IsAssignableFrom(type))
|
|
{
|
|
return type;
|
|
}
|
|
|
|
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
|
|
{
|
|
type = assembly.GetType(typeName);
|
|
if (type != null && typeof(Component).IsAssignableFrom(type))
|
|
{
|
|
return type;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static Sprite ResolveSprite(string spriteName, string fileName)
|
|
{
|
|
if (string.IsNullOrEmpty(spriteName))
|
|
{
|
|
return null;
|
|
}
|
|
string[] guids = AssetDatabase.FindAssets(spriteName, new[] { TextureRoot });
|
|
foreach (string guid in guids)
|
|
{
|
|
string path = AssetDatabase.GUIDToAssetPath(guid);
|
|
if (!string.Equals(Path.GetFileNameWithoutExtension(path), spriteName, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
continue;
|
|
}
|
|
Sprite sprite = AssetDatabase.LoadAssetAtPath<Sprite>(path);
|
|
if (sprite != null)
|
|
{
|
|
return sprite;
|
|
}
|
|
Debug.LogWarning("[UIGen] " + fileName + ": 贴图存在但非 Sprite 类型，回退纯色: " + spriteName + " (" + path + ")");
|
|
return null;
|
|
}
|
|
Debug.LogWarning("[UIGen] " + fileName + ": 找不到 Sprite，回退纯色: " + spriteName);
|
|
return null;
|
|
}
|
|
|
|
private static Color ParseColor(string hex, Color fallback)
|
|
{
|
|
if (!string.IsNullOrEmpty(hex) && ColorUtility.TryParseHtmlString(hex, out Color c))
|
|
{
|
|
return c;
|
|
}
|
|
return fallback;
|
|
}
|
|
|
|
private static Vector2 ToVec2(JToken arr, Vector2 fallback)
|
|
{
|
|
if (arr is JArray a && a.Count >= 2)
|
|
{
|
|
return new Vector2((float)a[0], (float)a[1]);
|
|
}
|
|
return fallback;
|
|
}
|
|
|
|
private static RectOffset ParsePadding(JToken token)
|
|
{
|
|
if (token is JArray a && a.Count >= 4)
|
|
{
|
|
return new RectOffset((int)a[0], (int)a[1], (int)a[2], (int)a[3]);
|
|
}
|
|
return new RectOffset(0, 0, 0, 0);
|
|
}
|
|
|
|
private static TextAlignmentOptions ParseAlignment(string a)
|
|
{
|
|
switch (a)
|
|
{
|
|
case "Left": return TextAlignmentOptions.Left;
|
|
case "Right": return TextAlignmentOptions.Right;
|
|
default: return TextAlignmentOptions.Center;
|
|
}
|
|
}
|
|
|
|
private static TextAnchor ParseAnchor(string a)
|
|
{
|
|
switch (a)
|
|
{
|
|
case "UpperLeft": return TextAnchor.UpperLeft;
|
|
case "UpperCenter": return TextAnchor.UpperCenter;
|
|
case "MiddleCenter": return TextAnchor.MiddleCenter;
|
|
default: return TextAnchor.UpperCenter;
|
|
}
|
|
}
|
|
|
|
private static ContentSizeFitter.FitMode ParseFit(string f)
|
|
{
|
|
switch (f)
|
|
{
|
|
case "PreferredSize": return ContentSizeFitter.FitMode.PreferredSize;
|
|
case "MinSize": return ContentSizeFitter.FitMode.MinSize;
|
|
default: return ContentSizeFitter.FitMode.Unconstrained;
|
|
}
|
|
}
|
|
|
|
private static IEnumerable<string> EnumStrings(JToken token)
|
|
{
|
|
if (token is JArray a)
|
|
{
|
|
foreach (JToken t in a)
|
|
{
|
|
yield return (string)t;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void Fail(ValidationResult vr, string msg)
|
|
{
|
|
vr.Ok = false;
|
|
vr.Errors.Add(msg);
|
|
}
|
|
|
|
private static string GetCommandLineValue(string key)
|
|
{
|
|
string[] args = Environment.GetCommandLineArgs();
|
|
for (int i = 0; i < args.Length - 1; i++)
|
|
{
|
|
if (string.Equals(args[i], key, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
return args[i + 1];
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
#endif
|