【Unity编辑器扩展】(三)PSD转UGUI Prefab, 一键拼UI解放美术/程序(完结)

工具效果：

第一步，把psd图层转换为可编辑的节点树，并自动剖析UI范例、自动绑定UI子元素：

 第二步, 点击“天生UIForm"按钮天生UI预制体 (如有UI范例遗漏可在下拉菜单手动点选UI范例)：

 验证一键天生UI效果:


书接上回：【Unity编辑器扩展】(二)PSD转UGUI Prefab, 图层剖析和碎图导出_psd导入unity_TopGames的博客-CSDN博客
先上总结：

工具包含的功能：
1. 支持UGUI和TextMeshProGUI并新增FillColor(纯色)共16种UI范例：
Button、TMP Button、 Dropdown、TMP Dropdown、FillColor、Image、InputField、TMP InputField、Mask、RawImage、Scroll View、Slider、Text、TMP Text、Toggle、TMP Toggle。
2. 支持自界说UI范例匹配词，支持扩展自界说剖析器Helper，易扩展。
3. 支持批量导出图片和单独导出某个图层图片，美术仅提供psd，无需切图。
4. 支持自动同步UI元素位置和文本字体、字号、行列间距、字体颜色。解放繁琐的手动调治流程。
5. 自动根据UI范例导出图片为Sprite、Texture2D范例，并支持选择导出后是否压缩图片，若UI需要9宫拉伸自动对Sprite设置9宫边界。
6. 支持编辑(手动调治层级或UI范例)，假如UI筹划师有遗漏标志范例，程序可手动点选范例，范例革新后工具自动绑定UI元素。
7. 支持编辑阶段预览psd图层、组。
8. 支持任意UI范例嵌套组合，psd图层层级导出为UI预制体后保持一致。

Aspose.PSD库虽然很强盛，但它究竟是离开PS的独立剖析库，对于PS的有些功能支持并不美满，好比图层殊效(如描边、浮雕、阴影等)，把单个图层转换为图片图层的殊效会丢失。对于文本图层，转换为图片后会有字体样式改变的标题。好比PS文本用的是宋体字体，转换为图片后酿成了默认的雅黑字体。
幸亏Aspose.PSD支持半个PS智能对象，为什么说是半个，由于Aspose.PSD完美支持PS智能对象图层，但是，通过Aspose.PSD把带有殊效的PS图层转换为智能对象后会丢失图层殊效。
为了办理这一标题，不得不对之前的筹划做出让步，写一个自动转换图层为智能对象的PS脚本，以制止筹划师手动转换会有遗漏。UI筹划师交付psd前通过脚本自动把所有文本图层和带有殊效的图层转换为智能对象。这样才能绕过Aspose.PSD导出图片丢失图层殊效的标题。
只管有了使用PS脚本这个小瑕疵，但相比让UI筹划师单独切图并手动标识各个切图位置巨细、字体字号颜色等，他们仍旧以为这是一个巨大的解放。同样，对于技能来说，也节流大量时间。纵然筹划师遗漏了UI范例标志，也可以通过下拉框选择图层的UI范例，仅需简单标志范例就可以一键天生UI预制体。
Aspose.PSD仍在每月一个版本更新迭代，等待功能美满，摆脱所有瑕疵。

PSD转UGUI功能/工作流及原理:

 一、PSD规范要求(UI筹划师)


由于UI大多属于复合型UI(如上图)，即由多种UI元素范例组合而成。比方，Dropdown(下拉菜单)，紧张由下拉框+下拉列表+下拉列表Item三个主体构成，而三个主体又是由其他多个UI元素构成。
UI是由一个或多个UI元素构成，因此多个元素之间必须有父子节点的关系。而PS图层中没有这种关系，只能通过组(Group)把多个图层包起来，而组本身是一个空图层。
比方一个Button，通常包含一个配景图和一个按钮文本。图层结构如下：

实际上UI筹划师原本也是需要用组来管理图层和切图的，这一规范并不是标题。紧张是UI范例标志，通过对图层定名以".范例"，工具通过对图层范例的辨认以及每种UI有单独的剖析Helper，最大程度上智能判定辨认UI元素范例，对于无迹可寻的元素仍旧需要筹划师手动标志UI范例。
比方Button剖析器(ButtonHelper), 会依次按范例查找图层, 可以最大化放宽对图层标志范例：

1. buttonBackground = LayerNode.FindSubLayerNode(GUIType.Background, GUIType.Image, GUIType.RawImage);
2. buttonText = LayerNode.FindSubLayerNode(GUIType.Button_Text, GUIType.Text, GUIType.TMPText);

复制代码

二、剖析规则设置


 支持设置文本图层和非文本图层的默认范例，比方文本图层默熟悉别为Text或TextMeshProGUI范例，普通图层默熟悉别为Image或RawImage范例。
UI Type: 主UI范例和子UI范例。支持的范例如下：

 UIPrefab: UI模板预制体。
TypeMatches：UI范例匹配名, 比方Button的匹配项有.bt，.btn，.button。图层名以这些字符末了就会被辨以为Button。
UIHelper: UI的剖析逻辑。差别的UI通过重写剖析方法对UI元素和对应PS图层进行绑定，以及天生终极的UI GameObject。
Comment：表明分析，用于一键导出分析文档给UI筹划师参考。
总的来说，规则设置文件是为了更机动宽松，可以自由自界说多个UI范例的别名。
以下是一键导出的文档内容：
   
  使用分析:
  单元素UI：即单个图层的UI，如Image、Text、单图Button，可以直接在图层定名末了加上".范例"来标志UI范例。
如"A.btn"表现按钮。

多元素UI: 对于多个图片构成的复合型UI，可以通过使用"组"包裹多个UI元素。在“组”定名末了加上".范例"来标志UI范例。
组里的图层定名后夹".范例"来标志为UI子元素范例。

各种UI范例支持任意组合：如一个组范例标志为Button，组内包含一个按钮配景图层，一个艺术字图层(非文本图层)，就可以构成一个按钮内带有艺术字图片的按钮。
  
  
  
  UI范例标识: 图层/组定名以'.范例'末了
  UI范例标识列表:
  Image: UI图片, Sprite精灵图,支持九宫拉伸
  范例标识: .img, .image,
  
  RawImage: Texture贴图, 不支持九宫拉伸
  范例标识: .rimg, .tex, .rawimg, .rawimage,
  
  Text: UGUI普通Text文本
  范例标识: .txt, .text, .label,
  
  TMPText: Text Mesh Pro, 增强版文本范例. 通常无需标注此范例，使用Text范例即可
  范例标识: .tmptxt, .tmptext, .tmplabel,
  
  Mask: 遮罩图，根据遮罩图alpha对可使地区肴杂
  范例标识: .msk, .mask,
  
  FillColor: 纯色直角矩形图，比方直角矩形纯色图层可以在Unity中设置颜色实现，无需导出纯色图片
  范例标识: .col, .color, .fillcolor,
  
  Background: 配景图,  如Button配景，Toggle配景、InputField配景、ScrollView等
  范例标识: .bg, .background, .panel,
  
  Button: 按钮, 通常包含按钮配景图、按钮文本
  范例标识: .bt, .btn, .button,
  
  TMPButton: 按钮(Text Mesh Pro)
  范例标识: .tmpbt, .tmpbtn, .tmpbutton,
  
  Button_Highlight: 按钮高亮时显示的按钮图片(当按钮为多种状态图切换时)
  范例标识: .onover, .light, .highlight,
  
  Button_Press: 按住按钮时显示的图片(当按钮为多种状态图切换时)
  范例标识: .press, .click, .touch,
  
  Button_Select: 选中按钮时显示的图片(当按钮为多种状态图切换时)
  范例标识: .select, .focus,
  
  Button_Disable: 禁用按钮时显示的图片(当按钮为多种状态图切换时)
  范例标识: .disable, .forbid,
  
  Button_Text: 按钮文本，必须是文本图层. 假如是艺术字图片可以标志为Image
  范例标识: .bttxt, .btlb, .bttext, .btlabel, .buttontext, .buttonlabel,
  
  Dropdown: 下拉菜单, 由下拉框、下拉列表(ScrollVIew)、Toggle范例的item构成
  范例标识: .dpd, .dropdown,
  
  TMPDropdown: 按钮(Text Mesh Pro)
  范例标识: .tmpdpd, .tmpdropdown,
  
  Dropdown_Label: 下拉框上显示的文本
  范例标识: .dpdlb, .dpdlabel, .dpdtxt, .dpdtext, .dropdowntext, .dropdownlabel, .dropdowntxt, .dropdownlb,
  
  Dropdown_Arrow: 下拉框箭头图标
  范例标识: .dpdicon, .dpdarrow, .arrow, .dropdownarrow,
  
  InputField: 文本输入框，通常由输入框配景图、提示文本、输入文本构成
  范例标识: .ipt, .input, .inputbox, .inputfield,
  
  TMPInputField: 文本输入框(Text Mesh Pro)
  范例标识: .tmpipt, .tmpinput, .tmpinputbox, .tmpinputfield,
  
  InputField_Placeholder: 输入框内的提示文本
  范例标识: .placeholder, .ipttips, .tips, .inputtips,
  
  InputField_Text: 输入框输入的文本(样式)
  范例标识: .ipttxt, .ipttext, .iptlb, .iptlabel, .inputtext, .inputlabel,
  
  Toggle: 单选框/复选框
  范例标识: .tg, .toggle, .checkbox,
  
  TMPToggle: 勾选框/单选框/复选框(Text Mesh Pro)
  范例标识: .tmptg, .tmptoggle, .tmpcheckbox,
  
  Toggle_Checkmark: 勾选框，勾选状态图标
  范例标识: .mark, .tgmark, .togglemark,
  
  Toggle_Label: 勾选框文本
  范例标识: .tglb, .tgtxt, .toggletext, .togglelabel,
  
  Slider: 滑动条/进度条，通常由配景图和填充条构成
  范例标识: .sld, .slider,
  
  Slider_Fill: 滑动条/进度条的填充条
  范例标识: .fill, .sldfill, .sliderfill,
  
  Slider_Handle: 滑动条的拖动滑块
  范例标识: .handle, .sldhandle, .sliderhandle,
  
  ScrollView: 滚动列表，通常由配景图、垂直/程度滚条配景图以及垂直/程度滚动条构成
  范例标识: .sv, .scrollview, .lst, .listview,
  
  ScrollView_Viewport: 滚动列表的视口遮罩图
  范例标识: .vpt, .viewport, .svmask, .lstmask, .listviewport, .scrollviewport,
  
  ScrollView_HorizontalBarBG: 滚动列表的程度滑动条配景图
  范例标识: .hbarbg, .hbarbackground, .hbarpanel,
  
  ScrollView_HorizontalBar: 滚动列表的程度滑动条
  范例标识: .hbar, .svhbar, .lsthbar,
  
  ScrollView_VerticalBarBG: 滚动列表的垂直滑动条配景图
  范例标识: .vbarbg, .vbarbackground, .vbarpanel,
  
  ScrollView_VerticalBar: 滚动列表的垂直滑动条
  范例标识: .vbar, .svvbar, .lstvbar,
   UGUI Parser代码：

1. #if UNITY_EDITOR
2. using Aspose.PSD.FileFormats.Psd.Layers.FillLayers;
3. using System;
4. using System.IO;
5. using System.Linq;
6. using System.Text;
7. using TMPro;
8. using UnityEditor;
9. using UnityEngine;
11. namespace UGF.EditorTools.Psd2UGUI
12. {
13.     public enum GUIType
14.     {
15.         Null = 0,
16.         Image,
17.         RawImage,
18.         Text,
19.         Button,
20.         Dropdown,
21.         InputField,
22.         Toggle,
23.         Slider,
24.         ScrollView,
25.         Mask,
26.         FillColor, //纯色填充
27.         TMPText,
28.         TMPButton,
29.         TMPDropdown,
30.         TMPInputField,
31.         TMPToggle,
33.         //UI的子类型, 以101开始。 0-100预留给UI类型, 新类型从尾部追加
34.         Background = 101, //通用背景
36.         //Button的子类型
37.         Button_Highlight,
38.         Button_Press,
39.         Button_Select,
40.         Button_Disable,
41.         Button_Text,
43.         //Dropdown/TMPDropdown的子类型
44.         Dropdown_Label,
45.         Dropdown_Arrow,
47.         //InputField/TMPInputField的子类型
48.         InputField_Placeholder,
49.         InputField_Text,
51.         //Toggle的子类型
52.         Toggle_Checkmark,
53.         Toggle_Label,
55.         //Slider的子类型
56.         Slider_Fill,
57.         Slider_Handle,
59.         //ScrollView的子类型
60.         ScrollView_Viewport, //列表可视区域的遮罩图
61.         ScrollView_HorizontalBarBG, //水平滑动栏背景
62.         ScrollView_HorizontalBar,//水平滑块
63.         ScrollView_VerticalBarBG, //垂直滑动栏背景
64.         ScrollView_VerticalBar, //垂直滑动块
65.     }
66.     [Serializable]
67.     public class UGUIParseRule
68.     {
69.         public GUIType UIType;
70.         public string[] TypeMatches; //类型匹配标识
71.         public GameObject UIPrefab; //UI模板
72.         public string UIHelper; //UIHelper类型全名
73.         public string Comment;//注释
74.     }
75.     [CustomEditor(typeof(UGUIParser))]
76.     public class UGUIParserEditor : Editor
77.     {
78.         private SerializedProperty readmeProperty;
80.         private void OnEnable()
81.         {
82.             readmeProperty = serializedObject.FindProperty("readmeDoc");
83.         }
84.         public override void OnInspectorGUI()
85.         {
86.             serializedObject.Update();
87.             if (GUILayout.Button("导出使用文档"))
88.             {
89.                 (target as UGUIParser).ExportReadmeDoc();
90.             }
91.             EditorGUILayout.LabelField("使用说明:");
92.             readmeProperty.stringValue = EditorGUILayout.TextArea(readmeProperty.stringValue, GUILayout.Height(100));
93.             serializedObject.ApplyModifiedProperties();
94.             base.OnInspectorGUI();
95.         }
96.     }
97.     [CreateAssetMenu(fileName = "Psd2UIFormConfig", menuName = "ScriptableObject/Psd2UIForm Config【Psd2UIForm工具配置】")]
98.     public class UGUIParser : ScriptableObject
99.     {
100.         public const int UITYPE_MAX = 100;
101.         [SerializeField] GUIType defaultTextType = GUIType.Text;
102.         [SerializeField] GUIType defaultImageType = GUIType.Image;
103.         [SerializeField] GameObject uiFormTemplate;
104.         [SerializeField] UGUIParseRule[] rules;
105.         [HideInInspector][SerializeField] string readmeDoc = "使用说明";
107.         public GUIType DefaultText => defaultTextType;
108.         public GUIType DefaultImage => defaultImageType;
109.         public GameObject UIFormTemplate => uiFormTemplate;
110.         private static UGUIParser mInstance = null;
111.         public static UGUIParser Instance
112.         {
113.             get
114.             {
115.                 if (mInstance == null)
116.                 {
117.                     var guid = AssetDatabase.FindAssets("t:UGUIParser").FirstOrDefault();
118.                     mInstance = AssetDatabase.LoadAssetAtPath<UGUIParser>(AssetDatabase.GUIDToAssetPath(guid));
119.                 }
120.                 return mInstance;
121.             }
122.         }
123.         public static bool IsMainUIType(GUIType tp)
124.         {
125.             return (int)tp <= UITYPE_MAX;
126.         }
127.         public Type GetHelperType(GUIType uiType)
128.         {
129.             if (uiType == GUIType.Null) return null;
130.             var rule = GetRule(uiType);
131.             if (rule == null || string.IsNullOrWhiteSpace(rule.UIHelper)) return null;
133.             return Type.GetType(rule.UIHelper);
134.         }
135.         public UGUIParseRule GetRule(GUIType uiType)
136.         {
137.             foreach (var rule in rules)
138.             {
139.                 if (rule.UIType == uiType) return rule;
140.             }
141.             return null;
142.         }
143.         /// <summary>
144.         /// 根据图层命名解析UI类型
145.         /// </summary>
146.         /// <param name="layer"></param>
147.         /// <param name="comType"></param>
148.         /// <returns></returns>
149.         public bool TryParse(PsdLayerNode layer, out UGUIParseRule result)
150.         {
151.             result = null;
152.             var layerName = layer.BindPsdLayer.Name;
153.             if (Path.HasExtension(layerName))
154.             {
155.                 var tpTag = Path.GetExtension(layerName).Substring(1).ToLower();
156.                 foreach (var rule in rules)
157.                 {
158.                     foreach (var item in rule.TypeMatches)
159.                     {
160.                         if (tpTag.CompareTo(item.ToLower()) == 0)
161.                         {
162.                             result = rule;
163.                             return true;
164.                         }
165.                     }
166.                 }
167.             }
169.             switch (layer.LayerType)
170.             {
171.                 case PsdLayerType.TextLayer:
172.                     result = rules.First(itm => itm.UIType == defaultTextType);
173.                     break;
174.                 case PsdLayerType.LayerGroup:
175.                     result = rules.First(itm => itm.UIType == GUIType.Null);
176.                     break;
177.                 default:
178.                     result = rules.First(itm => itm.UIType == defaultImageType);
179.                     break;
180.             }
181.             return result != null;
182.         }
184.         /// <summary>
185.         /// 根据图层大小和位置设置UI节点大小和位置
186.         /// </summary>
187.         /// <param name="layerNode"></param>
188.         /// <param name="uiNode"></param>
189.         /// <param name="pos">是否设置位置</param>
190.         public static void SetRectTransform(PsdLayerNode layerNode, UnityEngine.Component uiNode, bool pos = true, bool width = true, bool height = true, int extSize = 0)
191.         {
192.             if (uiNode != null && layerNode != null)
193.             {
194.                 var rect = layerNode.LayerRect;
195.                 var rectTransform = uiNode.GetComponent<RectTransform>();
196.                 if (width) rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, rect.size.x + extSize);
197.                 if (height) rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, rect.size.y + extSize);
198.                 if (pos)
199.                 {
200.                     rectTransform.position = rect.position + rectTransform.rect.size * (rectTransform.pivot - Vector2.one * 0.5f)*0.01f;
201.                 }
202.             }
203.         }
205.         /// <summary>
206.         /// 把LayerNode图片保存到本地并返回
207.         /// </summary>
208.         /// <param name="layerNode"></param>
209.         /// <returns></returns>
210.         public static Texture2D LayerNode2Texture(PsdLayerNode layerNode)
211.         {
212.             if (layerNode != null)
213.             {
214.                 var spAssetName = layerNode.ExportImageAsset(false);
215.                 var texture = AssetDatabase.LoadAssetAtPath<Texture2D>(spAssetName);
216.                 return texture;
217.             }
218.             return null;
219.         }
220.         /// <summary>
221.         /// 把LayerNode图片保存到本地并返回
222.         /// </summary>
223.         /// <param name="layerNode"></param>
224.         /// <param name="auto9Slice">若没有设置Sprite的九宫,是否自动计算并设置九宫</param>
225.         /// <returns></returns>
226.         public static Sprite LayerNode2Sprite(PsdLayerNode layerNode, bool auto9Slice = false)
227.         {
228.             if (layerNode != null)
229.             {
230.                 var spAssetName = layerNode.ExportImageAsset(true);
231.                 var sprite = AssetDatabase.LoadAssetAtPath<Sprite>(spAssetName);
232.                 if (sprite != null)
233.                 {
234.                     if (auto9Slice)
235.                     {
236.                         var spImpt = AssetImporter.GetAtPath(spAssetName) as TextureImporter;
237.                         var rawReadable = spImpt.isReadable;
238.                         if (!rawReadable)
239.                         {
240.                             spImpt.isReadable = true;
241.                             spImpt.SaveAndReimport();
242.                         }
243.                         if (spImpt.spriteBorder == Vector4.zero)
244.                         {
245.                             spImpt.spriteBorder = CalculateTexture9SliceBorder(sprite.texture, layerNode.BindPsdLayer.Opacity);
246.                             spImpt.isReadable = rawReadable;
247.                             spImpt.SaveAndReimport();
248.                         }
249.                     }
250.                     return sprite;
251.                 }
252.             }
253.             return null;
254.         }
255.         /// <summary>
256.         /// 自动计算贴图的 9宫 Border
257.         /// </summary>
258.         /// <param name="texture"></param>
259.         /// <param name="alphaThreshold">0-255</param>
260.         /// <returns></returns>
261.         public static Vector4 CalculateTexture9SliceBorder(Texture2D texture, byte alphaThreshold = 3)
262.         {
263.             int width = texture.width;
264.             int height = texture.height;
266.             Color32[] pixels = texture.GetPixels32();
267.             int minX = width;
268.             int minY = height;
269.             int maxX = 0;
270.             int maxY = 0;
272.             // 寻找不透明像素的最小和最大边界
273.             for (int y = 0; y < height; y++)
274.             {
275.                 for (int x = 0; x < width; x++)
276.                 {
277.                     int pixelIndex = y * width + x;
278.                     Color32 pixel = pixels[pixelIndex];
280.                     if (pixel.a >= alphaThreshold)
281.                     {
282.                         minX = Mathf.Min(minX, x);
283.                         minY = Mathf.Min(minY, y);
284.                         maxX = Mathf.Max(maxX, x);
285.                         maxY = Mathf.Max(maxY, y);
286.                     }
287.                 }
288.             }
290.             // 计算最优的borderSize
291.             int borderSizeX = (maxX - minX) / 3;
292.             int borderSizeY = (maxY - minY) / 3;
293.             int borderSize = Mathf.Min(borderSizeX, borderSizeY);
295.             // 根据边界和Border Size计算Nine Slice Border
296.             int left = minX + borderSize;
297.             int right = maxX - borderSize;
298.             int top = minY + borderSize;
299.             int bottom = maxY - borderSize;
301.             // 确保边界在纹理范围内
302.             left = Mathf.Clamp(left, 0, width - 1);
303.             right = Mathf.Clamp(right, 0, width - 1);
304.             top = Mathf.Clamp(top, 0, height - 1);
305.             bottom = Mathf.Clamp(bottom, 0, height - 1);
307.             return new Vector4(left, top, width - right, height - bottom);
308.         }
310.         /// <summary>
311.         /// 把PS的字体样式同步设置到UGUI Text
312.         /// </summary>
313.         /// <param name="txtLayer"></param>
314.         /// <param name="text"></param>
315.         public static void SetTextStyle(PsdLayerNode txtLayer, UnityEngine.UI.Text text)
316.         {
317.             if (text == null) return;
318.             text.gameObject.SetActive(txtLayer != null);
319.             if (txtLayer != null && txtLayer.ParseTextLayerInfo(out var str, out var size, out var charSpace, out float lineSpace, out var col, out var style, out var tmpStyle, out var fName))
320.             {
321.                 var tFont = FindFontAsset(fName);
322.                 if (tFont != null) text.font = tFont;
323.                 text.text = str;
324.                 text.fontSize = size;
325.                 text.fontStyle = style;
326.                 text.color = col;
327.                 text.lineSpacing = lineSpace;
328.             }
329.         }
330.         /// <summary>
331.         /// 把PS的字体样式同步设置到TextMeshProUGUI
332.         /// </summary>
333.         /// <param name="txtLayer"></param>
334.         /// <param name="text"></param>
335.         public static void SetTextStyle(PsdLayerNode txtLayer, TextMeshProUGUI text)
336.         {
337.             if (txtLayer != null && txtLayer.ParseTextLayerInfo(out var str, out var size, out var charSpace, out float lineSpace, out var col, out var style, out var tmpStyle, out var fName))
338.             {
339.                 var tFont = FindTMPFontAsset(fName);
340.                 if (tFont != null) text.font = tFont;
341.                 text.text = str;
342.                 text.fontSize = size;
343.                 text.fontStyle = tmpStyle;
344.                 text.color = col;
345.                 text.characterSpacing = charSpace;
346.                 text.lineSpacing = lineSpace;
347.             }
348.         }
349.         /// <summary>
350.         /// 根据字体名查找TMP_FontAsset
351.         /// </summary>
352.         /// <param name="fontName"></param>
353.         /// <returns></returns>
354.         public static TMP_FontAsset FindTMPFontAsset(string fontName)
355.         {
356.             var fontGuids = AssetDatabase.FindAssets("t:TMP_FontAsset");
357.             foreach (var guid in fontGuids)
358.             {
359.                 var fontPath = AssetDatabase.GUIDToAssetPath(guid);
360.                 var font = AssetDatabase.LoadAssetAtPath<TMP_FontAsset>(fontPath);
361.                 if (font != null && font.faceInfo.familyName == fontName)
362.                 {
363.                     return font;
364.                 }
365.             }
366.             return null;
367.         }
368.         /// <summary>
369.         /// 根据字体名查找Font Asset
370.         /// </summary>
371.         /// <param name="fontName"></param>
372.         /// <returns></returns>
373.         public static UnityEngine.Font FindFontAsset(string fontName)
374.         {
375.             var fontGuids = AssetDatabase.FindAssets("t:font");
376.             foreach (var guid in fontGuids)
377.             {
378.                 var fontPath = AssetDatabase.GUIDToAssetPath(guid);
379.                 var font = AssetImporter.GetAtPath(fontPath) as TrueTypeFontImporter;
380.                 if (font != null && font.fontTTFName == fontName)
381.                 {
382.                     return AssetDatabase.LoadAssetAtPath<UnityEngine.Font>(fontPath);
383.                 }
384.             }
385.             return null;
386.         }
388.         internal static UnityEngine.Color LayerNode2Color(PsdLayerNode fillColor, Color defaultColor)
389.         {
390.             if (fillColor != null && fillColor.BindPsdLayer is FillLayer fillLayer)
391.             {
392.                 var layerColor = fillLayer.GetPixel(fillLayer.Width / 2, fillLayer.Height / 2);
393.                 return new UnityEngine.Color(layerColor.R, layerColor.G, layerColor.B, fillLayer.Opacity) / (float)255;
394.             }
395.             return defaultColor;
396.         }
397.         /// <summary>
398.         /// 导出UI设计师使用规则文档
399.         /// </summary>
400.         /// <exception cref="NotImplementedException"></exception>
401.         internal void ExportReadmeDoc()
402.         {
403.             var exportDir = EditorUtility.SaveFolderPanel("选择文档导出路径", Application.dataPath, null);
404.             if (string.IsNullOrWhiteSpace(exportDir) || !Directory.Exists(exportDir))
405.             {
406.                 return;
407.             }
409.             var docFile = UtilityBuiltin.ResPath.GetCombinePath(exportDir, "Psd2UGUI设计师使用文档.doc");
410.             var strBuilder = new StringBuilder();
411.             strBuilder.AppendLine("使用说明:");
412.             strBuilder.AppendLine(this.readmeDoc);
413.             strBuilder.AppendLine(Environment.NewLine + Environment.NewLine);
414.             strBuilder.AppendLine("UI类型标识: 图层/组命名以'.类型'结尾");
415.             strBuilder.AppendLine("UI类型标识列表:");
417.             foreach (var rule in rules)
418.             {
419.                 if (rule.UIType == GUIType.Null) continue;
421.                 strBuilder.AppendLine($"{rule.UIType}: {rule.Comment}");
422.                 strBuilder.Append("类型标识: ");
423.                 foreach (var tag in rule.TypeMatches)
424.                 {
425.                     strBuilder.Append($".{tag}, ");
426.                 }
427.                 strBuilder.AppendLine();
428.                 strBuilder.AppendLine();
429.             }
431.             try
432.             {
433.                 File.WriteAllText(docFile, strBuilder.ToString(), System.Text.Encoding.UTF8);
434.                 EditorUtility.RevealInFinder(docFile);
435.             }
436.             catch (Exception e)
437.             {
438.                 Debug.LogException(e);
439.             }
441.         }
442.     }
443. }
444. #endif

复制代码

 三、PS脚本编写，一键转换殊效图层/文本图层为智能对象

为了辅助UI筹划师，制止手动转换智能对象会有遗漏，筹划师交付PSD文件前需要实行自动化脚本，把殊效图层/字体转为智能对象，这样纵然差别设备字库丢失也能保持字体原本样式。PS脚本是用js语言编写，没有代码提示是最大的停滞。幸亏没有复杂逻辑，只是遍历当前打开的psd文档图层，判断图层是否带有殊效或是否为文本图层，把符合条件的图层转换为智能对象:

1. // 判断图层是否包含特效
2. function hasLayerEffect(layer) {
3.     app.activeDocument.activeLayer = layer;
4.         var hasEffect = false;
5.         try {
6.                 var ref = new ActionReference();
7.                 var keyLayerEffects = app.charIDToTypeID( 'Lefx' );
8.                 ref.putProperty( app.charIDToTypeID( 'Prpr' ), keyLayerEffects );
9.                 ref.putEnumerated( app.charIDToTypeID( 'Lyr ' ), app.charIDToTypeID( 'Ordn' ), app.charIDToTypeID( 'Trgt' ) );
10.                 var desc = executeActionGet( ref );
11.                 if ( desc.hasKey( keyLayerEffects ) ) {
12.                         hasEffect = true;
13.                 }
14.         }catch(e) {
15.                 hasEffect = false;
16.         }
17.         return hasEffect;
18. }
20. function convertLayersToSmartObjects(layers)
21. {
22.     for (var i = layers.length - 1; i >= 0; i--)
23.     {
24.         var layer = layers[i];
25.         if (layer.typename === "LayerSet")
26.         {
27.                convertLayersToSmartObjects(layer.layers); // Recursively convert layers in layer sets
28.         }
29.         else
30.         {
31.              if (hasLayerEffect(layer)){
32.                 if(layer.kind === LayerKind.TEXT)convertToSmartObject(layer); // Convert layers with layer effects to smart objects
33.                 else layer.rasterize(RasterizeType.SHAPE);
34.              }
35.         }
36.     }
37. }
38. // 把图层转换为智能对象，功能等同右键图层->转为智能对象
39. function convertToSmartObject(layer) {
40.     app.activeDocument.activeLayer = layer;
41.     // 创建一个新的智能对象
42.     var idnewPlacedLayer = stringIDToTypeID("newPlacedLayer");
43.     executeAction(idnewPlacedLayer, undefined, DialogModes.NO);
44.    
45. }
46. // 导出处理后的PSD文件
47. function exportPSD() {
48.   var doc = app.activeDocument;
49.   var savePath = Folder.selectDialog("选择psd导出路径");
50.   if (savePath != null) {
51.     var saveOptions = new PhotoshopSaveOptions();
52.     saveOptions.embedColorProfile = true;
53.     saveOptions.alphaChannels = true;
55.     var saveFile = new File(savePath + "/" + doc.name);
56.     doc.saveAs(saveFile, saveOptions, true, Extension.LOWERCASE);
57.     alert("PSD已成功导出!");
58.   }
59. }
60. function convertAndExport(){
61.     convertLayersToSmartObjects (app.activeDocument.layers);
62.     //exportPSD();
63. }
64. app.activeDocument.suspendHistory("Convert2SmartObject", "convertAndExport();");
65. //~ convertLayersToSmartObjects (app.activeDocument.layers);

复制代码

四、Psd转UGUI编辑器


1. Unity中右键PSD文件把PS图层转换成节点，每个节点绑定一个对应图层。
2. 剖析UI筹划师为UI标志的范例，自动标识图层是否需要导出，自动绑定UI子元素。
3. 查漏补缺，对于没有标志范例而且没有精确辨认绑定的UI元素进行手动选择范例。

 编辑器根节点提供各项长期化生存设置，而且支持自动压缩图片。压缩方法可参考之前写过的压缩工具:【Unity编辑器扩展】包体优化神器,图片压缩,批量天生图集/图集变体,动画压缩_unity 图片压缩_TopGames的博客-CSDN博客
4. 剖析psd图层：重新剖析psd为节点树状图。
5. 导出Images：把编辑器下勾选的图层节点导出为图片资源。
6. 天生UIForm：把当前的节点树剖析天生为UI界面预制体。
Psd2UIForm编辑器代码：

1. #if UNITY_EDITOR
2. using Aspose.PSD.FileFormats.Psd;
3. using Aspose.PSD.FileFormats.Psd.Layers;
4. using Aspose.PSD.FileFormats.Psd.Layers.SmartObjects;
5. using Aspose.PSD.ImageLoadOptions;
6. using GameFramework;
7. using HarmonyLib;
8. using System;
9. using System.Collections.Generic;
10. using System.IO;
11. using System.Linq;
12. using System.Text;
13. using UnityEditor;
14. using UnityEditor.SceneManagement;
15. using UnityEngine;
16. using UnityGameFramework.Runtime;
18. namespace UGF.EditorTools.Psd2UGUI
19. {
20.     #region Crack
21.     [HarmonyPatch(typeof(System.Xml.XmlElement), nameof(System.Xml.XmlElement.InnerText), MethodType.Getter)]
22.     class CrackAspose
23.     {
24.         static void Postfix(ref string __result)
25.         {
26.             if (__result == "20220516")
27.             {
28.                 __result = "20500516";
29.             }
30.             //else if (__result == "20210827")
31.             //{
32.             //    __result = "20250827";
33.             //}
34.         }
35.     }
36.     #endregion
37.     [CustomEditor(typeof(Psd2UIFormConverter))]
38.     public class Psd2UIFormConverterInspector : UnityEditor.Editor
39.     {
40.         Psd2UIFormConverter targetLogic;
42.         GUIContent parsePsd2NodesBt;
43.         GUIContent exportUISpritesBt;
44.         GUIContent generateUIFormBt;
45.         GUILayoutOption btHeight;
46.         private void OnEnable()
47.         {
48.             btHeight = GUILayout.Height(30);
49.             targetLogic = target as Psd2UIFormConverter;
50.             parsePsd2NodesBt = new GUIContent("解析psd图层", "把psd图层解析为可编辑节点树");
51.             exportUISpritesBt = new GUIContent("导出Images", "导出勾选的psd图层为碎图");
52.             generateUIFormBt = new GUIContent("生成UIForm", "根据解析后的节点树生成UIForm Prefab");
53.             if (string.IsNullOrWhiteSpace(Psd2UIFormSettings.Instance.UIFormOutputDir))
54.             {
55.                 Debug.LogWarning($"UIForm输出路径为空!");
56.             }
57.         }
58.         private void OnDisable()
59.         {
60.             Psd2UIFormSettings.Save();
61.         }
62.         public override void OnInspectorGUI()
63.         {
64.             EditorGUILayout.BeginVertical("box");
65.             {
66.                 EditorGUILayout.BeginHorizontal();
67.                 {
68.                     EditorGUILayout.LabelField("自动压缩图片:", GUILayout.Width(150));
69.                     Psd2UIFormSettings.Instance.CompressImage = EditorGUILayout.Toggle(Psd2UIFormSettings.Instance.CompressImage);
70.                     EditorGUILayout.EndHorizontal();
71.                 }
72.                 EditorGUILayout.BeginHorizontal();
73.                 {
74.                     EditorGUILayout.LabelField("UI图片导出路径:", GUILayout.Width(150));
75.                     Psd2UIFormSettings.Instance.UIImagesOutputDir = EditorGUILayout.TextField(Psd2UIFormSettings.Instance.UIImagesOutputDir);
76.                     if (GUILayout.Button("选择路径", GUILayout.Width(80)))
77.                     {
78.                         var retPath = EditorUtility.OpenFolderPanel("选择导出路径", Psd2UIFormSettings.Instance.UIImagesOutputDir, null);
79.                         if (!string.IsNullOrWhiteSpace(retPath))
80.                         {
81.                             if (!retPath.StartsWith("Assets/"))
82.                             {
83.                                 retPath = Path.GetRelativePath(Directory.GetParent(Application.dataPath).FullName, retPath);
84.                             }
85.                             Psd2UIFormSettings.Instance.UIImagesOutputDir = retPath;
86.                             Psd2UIFormSettings.Save();
87.                         }
88.                         GUIUtility.ExitGUI();
89.                     }
90.                     EditorGUILayout.EndHorizontal();
91.                 }
93.                 EditorGUILayout.BeginHorizontal();
94.                 {
95.                     Psd2UIFormSettings.Instance.UseUIFormOutputDir = EditorGUILayout.ToggleLeft("使用UIForm导出路径:", Psd2UIFormSettings.Instance.UseUIFormOutputDir, GUILayout.Width(150));
96.                     EditorGUI.BeginDisabledGroup(!Psd2UIFormSettings.Instance.UseUIFormOutputDir);
97.                     {
98.                         Psd2UIFormSettings.Instance.UIFormOutputDir = EditorGUILayout.TextField(Psd2UIFormSettings.Instance.UIFormOutputDir);
99.                         if (GUILayout.Button("选择路径", GUILayout.Width(80)))
100.                         {
101.                             var retPath = EditorUtility.OpenFolderPanel("选择导出路径", Psd2UIFormSettings.Instance.UIFormOutputDir, null);
102.                             if (!string.IsNullOrWhiteSpace(retPath))
103.                             {
104.                                 if (!retPath.StartsWith("Assets/"))
105.                                 {
106.                                     retPath = Path.GetRelativePath(Directory.GetParent(Application.dataPath).FullName, retPath);
107.                                 }
108.                                 Psd2UIFormSettings.Instance.UIFormOutputDir = retPath;
109.                                 Psd2UIFormSettings.Save();
110.                             }
111.                             GUIUtility.ExitGUI();
112.                         }
113.                         EditorGUI.EndDisabledGroup();
114.                     }
115.                     EditorGUILayout.EndHorizontal();
116.                 }
117.                 //EditorGUILayout.BeginHorizontal();
118.                 //{
119.                 //    Psd2UIFormSettings.Instance.AutoCreateUIFormScript = EditorGUILayout.ToggleLeft("生成UIForm代码:", Psd2UIFormSettings.Instance.AutoCreateUIFormScript, GUILayout.Width(150));
120.                 //    EditorGUI.BeginDisabledGroup(!Psd2UIFormSettings.Instance.AutoCreateUIFormScript);
121.                 //    {
122.                 //        Psd2UIFormSettings.Instance.UIFormScriptOutputDir = EditorGUILayout.TextField(Psd2UIFormSettings.Instance.UIFormScriptOutputDir);
123.                 //        if (GUILayout.Button("选择路径", GUILayout.Width(80)))
124.                 //        {
125.                 //            var retPath = EditorUtility.OpenFolderPanel("选择导出路径", Psd2UIFormSettings.Instance.UIFormScriptOutputDir, null);
126.                 //            if (!string.IsNullOrWhiteSpace(retPath))
127.                 //            {
128.                 //                if (!retPath.StartsWith("Assets/"))
129.                 //                {
130.                 //                    retPath = Path.GetRelativePath(Directory.GetParent(Application.dataPath).FullName, retPath);
131.                 //                }
132.                 //                Psd2UIFormSettings.Instance.UIFormScriptOutputDir = retPath;
133.                 //                Psd2UIFormSettings.Save();
134.                 //            }
135.                 //            GUIUtility.ExitGUI();
136.                 //        }
137.                 //        EditorGUI.EndDisabledGroup();
138.                 //    }
139.                 //    EditorGUILayout.EndHorizontal();
140.                 //}
141.                 EditorGUILayout.EndVertical();
142.             }
145.             EditorGUILayout.BeginHorizontal();
146.             {
147.                 if (GUILayout.Button(parsePsd2NodesBt, btHeight))
148.                 {
149.                     Psd2UIFormConverter.ParsePsd2LayerPrefab(targetLogic.PsdAssetName, targetLogic);
150.                 }
151.                 if (GUILayout.Button(exportUISpritesBt, btHeight))
152.                 {
153.                     targetLogic.ExportSprites();
154.                 }
155.                 EditorGUILayout.EndHorizontal();
156.             }
157.             if (GUILayout.Button(generateUIFormBt, btHeight))
158.             {
159.                 targetLogic.GenerateUIForm();
160.             }
161.             base.OnInspectorGUI();
162.         }
163.         public override bool HasPreviewGUI()
164.         {
165.             return targetLogic.BindPsdAsset != null;
166.         }
167.         public override void OnPreviewGUI(Rect r, GUIStyle background)
168.         {
169.             GUI.DrawTexture(r, targetLogic.BindPsdAsset.texture, ScaleMode.ScaleToFit);
170.             //base.OnPreviewGUI(r, background);
171.         }
172.     }
173.     /// <summary>
174.     /// Psd文件转成UIForm prefab
175.     /// </summary>
176.     [ExecuteInEditMode]
177.     [RequireComponent(typeof(SpriteRenderer))]
178.     public class Psd2UIFormConverter : MonoBehaviour
179.     {
180.         const string RecordLayerOperation = "Change Export Image";
181.         public static Psd2UIFormConverter Instance { get; private set; }
182.         [ReadOnlyField][SerializeField] public string psdAssetChangeTime;//文件修改时间标识
183.         [Tooltip("UIForm名字")][SerializeField] private string uiFormName;
184.         [Tooltip("关联的psd文件")][SerializeField] private UnityEngine.Sprite psdAsset;
185.         [Header("Debug:")][SerializeField] bool drawLayerRectGizmos = true;
186.         [SerializeField] UnityEngine.Color drawLayerRectGizmosColor = UnityEngine.Color.green;
188.         private PsdImage psdInstance;//psd文件解析实例
189.         private GUIStyle uiTypeLabelStyle;
190.         public string PsdAssetName => psdAsset != null ? AssetDatabase.GetAssetPath(psdAsset) : null;
191.         public UnityEngine.Sprite BindPsdAsset => psdAsset;
192.         public Vector2Int UIFormCanvasSize { get; private set; } = new Vector2Int(750, 1334);
193.         private void OnEnable()
194.         {
195.             Instance = this;
196.             uiTypeLabelStyle = new GUIStyle();
197.             uiTypeLabelStyle.fontSize = 13;
198.             uiTypeLabelStyle.fontStyle = UnityEngine.FontStyle.BoldAndItalic;
199.             UnityEngine.ColorUtility.TryParseHtmlString("#7ED994", out var color);
200.             uiTypeLabelStyle.normal.textColor = color;
202.             EditorApplication.hierarchyWindowItemOnGUI += OnHierarchyGUI;
204.             if (psdInstance == null && !string.IsNullOrWhiteSpace(PsdAssetName))
205.             {
206.                 RefreshNodesBindLayer();
207.             }
208.         }
210.         private void Start()
211.         {
212.             if (this.CheckPsdAssetHasChanged())
213.             {
214.                 if (EditorUtility.DisplayDialog("PSD -> UIForm", $"{gameObject.name}关联的psd文件[{this.PsdAssetName}]已改变,是否重新解析节点树?", "是", "否"))
215.                 {
216.                     if (Psd2UIFormConverter.ParsePsd2LayerPrefab(this.PsdAssetName, this))
217.                     {
218.                         RefreshNodesBindLayer();
219.                     }
221.                 }
222.             }
223.             else
224.             {
225.                 RefreshNodesBindLayer();
226.             }
227.         }
229.         private void OnDrawGizmos()
230.         {
231.             if (drawLayerRectGizmos)
232.             {
233.                 var nodes = this.GetComponentsInChildren<PsdLayerNode>();
234.                 Gizmos.color = drawLayerRectGizmosColor;
235.                 foreach (var item in nodes)
236.                 {
237.                     if (item.NeedExportImage())
238.                     {
239.                         Gizmos.DrawWireCube(item.LayerRect.position * 0.01f, item.LayerRect.size * 0.01f);
240.                     }
242.                 }
243.             }
244.         }
246.         private void OnHierarchyGUI(int instanceID, Rect selectionRect)
247.         {
248.             if (Event.current == null) return;
249.             var node = EditorUtility.InstanceIDToObject(instanceID) as GameObject;
250.             if (node == null || node == this.gameObject) return;
251.             if (!node.TryGetComponent<PsdLayerNode>(out var layer)) return;
253.             Rect tmpRect = selectionRect;
254.             tmpRect.x = 35;
255.             tmpRect.width = 10;
256.             Undo.RecordObject(layer, RecordLayerOperation);
257.             EditorGUI.BeginChangeCheck();
258.             {
259.                 layer.markToExport = EditorGUI.Toggle(tmpRect, layer.markToExport);
260.                 if (EditorGUI.EndChangeCheck())
261.                 {
262.                     if (Selection.gameObjects.Length > 1) SetExportImageTg(Selection.gameObjects, layer.markToExport);
263.                     EditorUtility.SetDirty(layer);
264.                 }
265.             }
266.             tmpRect.width = Mathf.Clamp(selectionRect.xMax * 0.2f, 100, 200);
267.             tmpRect.x = selectionRect.xMax - tmpRect.width;
269.             //EditorGUI.LabelField(tmpRect, layer.UIType.ToString(), uiTypeLabelStyle);
270.             if (EditorGUI.DropdownButton(tmpRect, new GUIContent(layer.UIType.ToString()), FocusType.Passive))
271.             {
272.                 var dropdownMenu = PopEnumMenu<GUIType>(layer.UIType, selectUIType =>
273.                 {
274.                     layer.SetUIType(selectUIType);
275.                     EditorUtility.SetDirty(layer);
276.                 });
278.                 dropdownMenu.ShowAsContext();
279.             }
280.         }
281.         private GenericMenu PopEnumMenu<T>(T currentValue, Action<T> onSelectEnum) where T : Enum
282.         {
283.             var names = Enum.GetValues(typeof(T));
284.             var dropdownMenu = new GenericMenu();
285.             foreach (T item in names)
286.             {
287.                 dropdownMenu.AddItem(new GUIContent(item.ToString()), item.Equals(currentValue), () => { onSelectEnum(item); });
288.             }
289.             return dropdownMenu;
290.         }
291.         /// <summary>
292.         /// 批量勾选导出图片
293.         /// </summary>
294.         /// <param name="selects"></param>
295.         /// <param name="exportImg"></param>
296.         private void SetExportImageTg(GameObject[] selects, bool exportImg)
297.         {
298.             var selectLayerNodes = selects.Where(item => item?.GetComponent<PsdLayerNode>() != null).ToArray();
299.             foreach (var layer in selectLayerNodes)
300.             {
301.                 layer.GetComponent<PsdLayerNode>().markToExport = exportImg;
302.             }
303.         }
304.         private void OnDestroy()
305.         {
306.             EditorApplication.hierarchyWindowItemOnGUI -= OnHierarchyGUI;
307.             if (this.psdInstance != null && !psdInstance.Disposed)
308.             {
309.                 psdInstance.Dispose();
310.             }
311.         }
313.         private void RefreshNodesBindLayer()
314.         {
315.             if (psdInstance == null || psdInstance.Disposed)
316.             {
317.                 if (!File.Exists(PsdAssetName))
318.                 {
319.                     Debug.LogError($"刷新节点绑定图层失败! psd文件不存在");
320.                     return;
321.                 }
322.                 var psdOpts = new PsdLoadOptions()
323.                 {
324.                     LoadEffectsResource = true,
325.                     ReadOnlyMode = false,
326.                 };
327.                 psdInstance = Aspose.PSD.Image.Load(PsdAssetName, psdOpts) as PsdImage;
328.                 UIFormCanvasSize.Set(psdInstance.Size.Width, psdInstance.Size.Height);
329.             }
330.             var layers = GetComponentsInChildren<PsdLayerNode>(true);
331.             foreach (var layer in layers)
332.             {
333.                 layer.InitPsdLayers(psdInstance);
334.             }
336.             var spRender = gameObject.GetOrAddComponent<SpriteRenderer>();
337.             spRender.sprite = this.psdAsset;
338.         }
339.         #region
340.         
341.         const string AsposeLicenseKey = "此处为Aspose.PSD证书";
342.         static bool licenseInitiated = false;
345.         [InitializeOnLoadMethod]
346.         static void InitAsposeLicense()
347.         {
348.             if (licenseInitiated) return;
349.             var harmonyHook = new Harmony("Crack.Aspose");
350.             harmonyHook.PatchAll();
352.             new Aspose.PSD.License().SetLicense(new MemoryStream(Convert.FromBase64String(AsposeLicenseKey)));
353.             licenseInitiated = true;
354.             harmonyHook.UnpatchAll();
356.             //GetAllLayerType();
357.         }
358.         static void GetAllLayerType()
359.         {
360.             var psdLib = Utility.Assembly.GetAssemblies().FirstOrDefault(item => item.GetName().Name == "Aspose.PSD");
361.             var layers = psdLib.GetTypes().Where(tp => tp.IsSubclassOf(typeof(Layer)) && !tp.IsAbstract);
362.             string layerEnumNames = "";
363.             foreach (var item in layers)
364.             {
365.                 layerEnumNames += $"{item.Name},\n";
366.             }
367.             Debug.Log(layerEnumNames);
368.         }
369.         #endregion Aspose License
370.         [MenuItem("Assets/GF Editor Tool/Psd2UIForm Editor", priority = 0)]
371.         static void Psd2UIFormPrefabMenu()
372.         {
373.             if (Selection.activeObject == null) return;
374.             var assetPath = AssetDatabase.GetAssetPath(Selection.activeObject);
375.             if (Path.GetExtension(assetPath).ToLower().CompareTo(".psd") != 0)
376.             {
377.                 Debug.LogWarning($"选择的文件({assetPath})不是psd格式, 工具只支持psd转换为UIForm");
378.                 return;
379.             }
380.             string psdLayerPrefab = GetPsdLayerPrefabPath(assetPath);
381.             if (!File.Exists(psdLayerPrefab))
382.             {
383.                 if (ParsePsd2LayerPrefab(assetPath))
384.                 {
385.                     OpenPsdLayerEditor(psdLayerPrefab);
386.                 }
387.             }
388.             else
389.             {
390.                 OpenPsdLayerEditor(psdLayerPrefab);
391.             }
392.         }
394.         public bool CheckPsdAssetHasChanged()
395.         {
396.             if (psdAsset == null) return false;
397.             var fileTag = GetAssetChangeTag(PsdAssetName);
398.             return psdAssetChangeTime.CompareTo(fileTag) != 0;
399.         }
400.         public static string GetAssetChangeTag(string fileName)
401.         {
402.             return new FileInfo(fileName).LastWriteTime.ToString("yyyyMMddHHmmss");
403.         }
404.         /// <summary>
405.         /// 打开psd图层信息prefab
406.         /// </summary>
407.         /// <param name="psdLayerPrefab"></param>
408.         public static void OpenPsdLayerEditor(string psdLayerPrefab)
409.         {
410.             PrefabStageUtility.OpenPrefab(psdLayerPrefab);
411.         }
412.         /// <summary>
413.         /// 把Psd图层解析成节点prefab
414.         /// </summary>
415.         /// <param name="psdPath"></param>
416.         /// <returns></returns>
417.         public static bool ParsePsd2LayerPrefab(string psdFile, Psd2UIFormConverter instanceRoot = null)
418.         {
419.             if (!File.Exists(psdFile))
420.             {
421.                 Debug.LogError($"Error: Psd文件不存在:{psdFile}");
422.                 return false;
423.             }
424.             var texImporter = AssetImporter.GetAtPath(psdFile) as TextureImporter;
425.             if (texImporter.textureType != TextureImporterType.Sprite)
426.             {
427.                 texImporter.textureType = TextureImporterType.Sprite;
428.                 texImporter.mipmapEnabled = false;
429.                 texImporter.alphaIsTransparency = true;
430.                 texImporter.SaveAndReimport();
431.             }
433.             var prefabFile = GetPsdLayerPrefabPath(psdFile);
434.             var rootName = Path.GetFileNameWithoutExtension(prefabFile);
436.             bool needDestroyInstance = instanceRoot == null;
437.             if (instanceRoot != null)
438.             {
439.                 ParsePsdLayer2Root(psdFile, instanceRoot);
440.                 instanceRoot.RefreshNodesBindLayer();
441.                 return true;
442.             }
443.             else
444.             {
445.                 Psd2UIFormConverter rootLayer = CreatePsdLayerRoot(rootName);
446.                 rootLayer.SetPsdAsset(psdFile);
447.                 ParsePsdLayer2Root(psdFile, rootLayer);
449.                 PrefabUtility.SaveAsPrefabAsset(rootLayer.gameObject, prefabFile, out bool savePrefabSuccess);
450.                 if (needDestroyInstance) GameObject.DestroyImmediate(rootLayer.gameObject);
451.                 AssetDatabase.Refresh();
452.                 if (savePrefabSuccess && AssetDatabase.GUIDFromAssetPath(StageUtility.GetCurrentStage().assetPath) != AssetDatabase.GUIDFromAssetPath(prefabFile))
453.                 {
454.                     PrefabStageUtility.OpenPrefab(prefabFile);
455.                 }
457.                 return savePrefabSuccess;
458.             }
459.         }
460.         private static void ParsePsdLayer2Root(string psdFile, Psd2UIFormConverter converter)
461.         {
462.             //清空已有节点重新解析
463.             for (int i = converter.transform.childCount - 1; i >= 0; i--)
464.             {
465.                 GameObject.DestroyImmediate(converter.transform.GetChild(i).gameObject);
466.             }
468.             var psdOpts = new PsdLoadOptions()
469.             {
470.                 LoadEffectsResource = true,
471.                 ReadOnlyMode = false
472.             };
473.             using (var psd = Aspose.PSD.Image.Load(psdFile, psdOpts) as PsdImage)
474.             {
475.                 List<GameObject> layerNodes = new List<GameObject> { converter.gameObject };
477.                 for (int i = 0; i < psd.Layers.Length; i++)
478.                 {
479.                     var layer = psd.Layers[i];
480.                     var curLayerType = layer.GetLayerType();
482.                     if (curLayerType == PsdLayerType.SectionDividerLayer)
483.                     {
484.                         var layerGroup = (layer as SectionDividerLayer).GetRelatedLayerGroup();
485.                         var layerGroupIdx = ArrayUtility.IndexOf(psd.Layers, layerGroup);
486.                         var layerGropNode = CreatePsdLayerNode(layerGroup, layerGroupIdx);
487.                         layerNodes.Add(layerGropNode.gameObject);
488.                     }
489.                     else if (curLayerType == PsdLayerType.LayerGroup)
490.                     {
491.                         var lastLayerNode = layerNodes.Last();
492.                         layerNodes.Remove(lastLayerNode);
494.                         if (layerNodes.Count > 0)
495.                         {
496.                             var parentLayerNode = layerNodes.Last();
497.                             lastLayerNode.transform.SetParent(parentLayerNode.transform);
498.                         }
499.                     }
500.                     else
501.                     {
502.                         var newLayerNode = CreatePsdLayerNode(layer, i);
503.                         newLayerNode.transform.SetParent(layerNodes.Last().transform);
504.                         newLayerNode.transform.localPosition = Vector3.zero;
505.                     }
506.                 }
507.             }
508.             converter.psdAssetChangeTime = GetAssetChangeTag(psdFile);
509.             var childrenNodes = converter.GetComponentsInChildren<PsdLayerNode>(true);
510.             foreach (var item in childrenNodes)
511.             {
512.                 item.RefreshUIHelper(false);
513.             }
514.             EditorUtility.SetDirty(converter.gameObject);
515.         }
516.         private void SetPsdAsset(string psdFile)
517.         {
518.             this.psdAsset = AssetDatabase.LoadAssetAtPath<UnityEngine.Sprite>(psdFile);
519.             if (string.IsNullOrWhiteSpace(Psd2UIFormSettings.Instance.UIImagesOutputDir))
520.             {
521.                 Psd2UIFormSettings.Instance.UIImagesOutputDir = Path.GetDirectoryName(psdFile);
522.             }
523.             if (string.IsNullOrWhiteSpace(this.uiFormName))
524.             {
525.                 this.uiFormName = this.psdAsset.name;
526.             }
527.         }
529.         /// <summary>
530.         /// 获取解析好的psd layers文件
531.         /// </summary>
532.         /// <param name="psd"></param>
533.         /// <returns></returns>
534.         public static string GetPsdLayerPrefabPath(string psd)
535.         {
536.             return UtilityBuiltin.ResPath.GetCombinePath(Path.GetDirectoryName(psd), Path.GetFileNameWithoutExtension(psd) + "_psd_layers_parsed.prefab");
537.         }
538.         private static Psd2UIFormConverter CreatePsdLayerRoot(string rootName)
539.         {
540.             var node = new GameObject(rootName);
541.             node.gameObject.tag = "EditorOnly";
542.             var layerRoot = node.AddComponent<Psd2UIFormConverter>();
543.             return layerRoot;
544.         }
545.         private static PsdLayerNode CreatePsdLayerNode(Layer layer, int bindLayerIdx)
546.         {
547.             string nodeName = layer.Name;
548.             if (string.IsNullOrWhiteSpace(nodeName))
549.             {
550.                 nodeName = $"PsdLayer-{bindLayerIdx}";
551.             }
552.             else
553.             {
554.                 if (Path.HasExtension(layer.Name))
555.                 {
556.                     nodeName = Path.GetFileNameWithoutExtension(layer.Name);
557.                 }
558.             }
559.             var node = new GameObject(nodeName);
560.             node.gameObject.tag = "EditorOnly";
561.             var layerNode = node.AddComponent<PsdLayerNode>();
562.             layerNode.BindPsdLayerIndex = bindLayerIdx;
563.             InitLayerNodeData(layerNode, layer);
564.             return layerNode;
565.         }
566.         /// <summary>
567.         /// 根据psd图层信息解析并初始化图层UI类型、是否导出等信息
568.         /// </summary>
569.         /// <param name="layerNode"></param>
570.         /// <param name="layer"></param>
571.         private static void InitLayerNodeData(PsdLayerNode layerNode, Layer layer)
572.         {
573.             if (layer == null || layer.Disposed) return;
574.             var layerTp = layer.GetLayerType();
575.             layerNode.BindPsdLayer = layer;
576.             if (UGUIParser.Instance.TryParse(layerNode, out var initRule))
577.             {
578.                 layerNode.SetUIType(initRule.UIType, false);
579.             }
580.             layerNode.markToExport = layerTp != PsdLayerType.LayerGroup && !(layerTp == PsdLayerType.TextLayer && layerNode.UIType.ToString().EndsWith("Text") && layerNode.UIType != GUIType.FillColor);
581.             layerNode.gameObject.SetActive(layer.IsVisible);
582.         }
584.         /// <summary>
585.         /// 导出psd图层为Sprites碎图
586.         /// </summary>
587.         /// <param name="psdAssetName"></param>
588.         internal void ExportSprites()
589.         {
590.             //var pngOpts = new PngOptions()
591.             //{
592.             //    ColorType = Aspose.PSD.FileFormats.Png.PngColorType.Truecolor
593.             //};
594.             //this.psdInstance.Save("Assets/AAAGame/Sprites/UI/Preview.png", pngOpts);
596.             //return;
597.             var exportLayers = this.GetComponentsInChildren<PsdLayerNode>().Where(node => node.NeedExportImage());
598.             var exportDir = GetUIFormImagesOutputDir();
599.             if (!Directory.Exists(exportDir))
600.             {
601.                 Directory.CreateDirectory(exportDir);
602.             }
603.             int exportIdx = 0;
604.             int totalCount = exportLayers.Count();
605.             foreach (var layer in exportLayers)
606.             {
607.                 var assetName = layer.ExportImageAsset();
608.                 if (assetName == null)
609.                 {
610.                     Debug.LogWarning($"导出图层[name:{layer.name}, layerIdx:{layer.BindPsdLayerIndex}]图片失败!");
611.                 }
612.                 ++exportIdx;
613.                 EditorUtility.DisplayProgressBar($"导出进度({exportIdx}/{totalCount})", $"导出UI图片:{assetName}", exportIdx / (float)totalCount);
614.             }
615.             EditorUtility.ClearProgressBar();
616.             AssetDatabase.Refresh();
617.         }
618.         /// <summary>
619.         /// 根据解析后的节点树生成UIForm Prefab
620.         /// </summary>
621.         internal void GenerateUIForm()
622.         {
623.             if (Psd2UIFormSettings.Instance.UseUIFormOutputDir && string.IsNullOrWhiteSpace(Psd2UIFormSettings.Instance.UIFormOutputDir))
624.             {
625.                 Debug.LogError($"生成UIForm失败! UIForm导出路径为空:{Psd2UIFormSettings.Instance.UIFormOutputDir}");
626.                 return;
627.             }
628.             if (Psd2UIFormSettings.Instance.UseUIFormOutputDir)
629.             {
630.                 ExportUIPrefab(Psd2UIFormSettings.Instance.UIFormOutputDir);
631.             }
632.             else
633.             {
634.                 string lastSaveDir = string.IsNullOrWhiteSpace(Psd2UIFormSettings.Instance.LastUIFormOutputDir) ? "Assets" : Psd2UIFormSettings.Instance.LastUIFormOutputDir;
635.                 string selectDir = EditorUtility.SaveFolderPanel("保存目录", lastSaveDir, null);
636.                 if (!string.IsNullOrWhiteSpace(selectDir))
637.                 {
638.                     if (!selectDir.StartsWith("Assets/"))
639.                         selectDir = Path.GetRelativePath(Directory.GetParent(Application.dataPath).FullName, selectDir);
640.                     Psd2UIFormSettings.Instance.LastUIFormOutputDir = selectDir;
641.                     ExportUIPrefab(selectDir);
642.                 }
643.             }
644.         }
645.         private bool ExportUIPrefab(string outputDir)
646.         {
647.             if (!string.IsNullOrWhiteSpace(outputDir))
648.             {
649.                 if (!Directory.Exists(outputDir))
650.                 {
651.                     try
652.                     {
653.                         Directory.CreateDirectory(outputDir);
654.                         AssetDatabase.Refresh();
655.                     }
656.                     catch (Exception err)
657.                     {
658.                         Debug.LogError($"导出UI prefab失败:{err.Message}");
659.                         return false;
660.                     }
661.                 }
662.             }
663.             if (string.IsNullOrWhiteSpace(uiFormName))
664.             {
665.                 Debug.LogError("导出UI Prefab失败: UI Form Name为空, 请填写UI Form Name.");
666.                 return false;
667.             }
668.             var prefabName = UtilityBuiltin.ResPath.GetCombinePath(outputDir, $"{uiFormName}.prefab");
669.             if (File.Exists(prefabName))
670.             {
671.                 if (!EditorUtility.DisplayDialog("警告", $"prefab文件已存在, 是否覆盖:{prefabName}", "覆盖生成", "取消生成"))
672.                 {
673.                     return false;
674.                 }
675.             }
676.             var uiHelpers = GetAvailableUIHelpers();
677.             if (uiHelpers == null || uiHelpers.Length < 1)
678.             {
679.                 return false;
680.             }
681.             var uiFormRoot = GameObject.Instantiate(UGUIParser.Instance.UIFormTemplate, Vector3.zero, Quaternion.identity);
682.             uiFormRoot.name = uiFormName;
684.             int curIdx = 0;
685.             int totalCount = uiHelpers.Length;
686.             foreach (var uiHelper in uiHelpers)
687.             {
688.                 EditorUtility.DisplayProgressBar($"生成UIFrom:({curIdx++}/{totalCount})", $"正在生成UI元素:{uiHelper.name}", curIdx /
689.                 (float)totalCount);
690.                 var uiElement = uiHelper.CreateUI();
691.                 if (uiElement == null) continue;
693.                 var goPath = GetGameObjectInstanceIdPath(uiHelper.gameObject, out var goNames);
694.                 var parentNode = GetOrCreateNodeByInstanceIdPath(uiFormRoot, goPath, goNames);
695.                 uiElement.transform.SetParent(parentNode.transform, true);
697.                 uiElement.transform.position += new Vector3(this.UIFormCanvasSize.x * 0.5f, this.UIFormCanvasSize.y * 0.5f, 0);
698.             }
699.             var uiStrKeys = uiFormRoot.GetComponentsInChildren<UIStringKey>(true);
700.             for (int i = uiStrKeys.Length - 1; i >= 0; i--)
701.             {
702.                 DestroyImmediate(uiStrKeys[i]);
703.             }
704.             
705.             var uiPrefab = PrefabUtility.SaveAsPrefabAsset(uiFormRoot, prefabName, out bool saveSuccess);
706.             if (saveSuccess)
707.             {
708.                 DestroyImmediate(uiFormRoot);
709.                 Selection.activeGameObject = uiPrefab;
710.             }
711.             EditorUtility.ClearProgressBar();
712.             return true;
713.         }
715.         private GameObject GetOrCreateNodeByInstanceIdPath(GameObject uiFormRoot, string[] goPath, string[] goNames)
716.         {
717.             GameObject result = uiFormRoot;
718.             if (goPath != null && goNames != null)
719.             {
720.                 for (int i = 0; i < goPath.Length; i++)
721.                 {
722.                     var nodeId = goPath[i];
723.                     var nodeName = goNames[i];
724.                     GameObject targetNode = null;
725.                     foreach (Transform child in result.transform)
726.                     {
727.                         if (child.gameObject == result) continue;
729.                         var idKey = child.GetComponent<UIStringKey>();
730.                         if (idKey != null && nodeId == idKey.Key)
731.                         {
732.                             targetNode = child.gameObject;
733.                             break;
734.                         }
735.                     }
736.                     if (targetNode == null)
737.                     {
738.                         targetNode = new GameObject(nodeName);
739.                         targetNode.transform.SetParent(result.transform, false);
740.                         targetNode.transform.SetLocalPositionAndRotation(Vector3.zero, Quaternion.identity);
741.                         var targetNodeKey = targetNode.GetOrAddComponent<UIStringKey>();
742.                         targetNodeKey.Key = nodeId;
743.                     }
744.                     result = targetNode;
745.                 }
746.             }
747.             return result;
748.         }
750.         private string[] GetGameObjectInstanceIdPath(GameObject go, out string[] names)
751.         {
752.             names = null;
753.             if (go == null || go.transform.parent == null || go.transform.parent == this.transform) return null;
755.             var parentGo = go.transform.parent;
756.             string[] result = new string[1] { parentGo.gameObject.GetInstanceID().ToString() };
757.             names = new string[1] { parentGo.gameObject.name };
758.             while (parentGo.parent != null && parentGo.parent != this.transform)
759.             {
760.                 ArrayUtility.Insert(ref result, 0, parentGo.parent.gameObject.GetInstanceID().ToString());
761.                 ArrayUtility.Insert(ref names, 0, parentGo.parent.gameObject.name);
762.                 parentGo = parentGo.parent;
763.             }
764.             return result;
765.         }
766.         private UIHelperBase[] GetAvailableUIHelpers()
767.         {
768.             var uiHelpers = this.GetComponentsInChildren<UIHelperBase>();
769.             uiHelpers = uiHelpers.Where(ui => ui.LayerNode.IsMainUIType).ToArray();
771.             List<int> dependInstIds = new List<int>();
772.             foreach (var item in uiHelpers)
773.             {
774.                 foreach (var depend in item.GetDependencies())
775.                 {
776.                     int dependId = depend.gameObject.GetInstanceID();
777.                     if (!dependInstIds.Contains(dependId))
778.                     {
779.                         dependInstIds.Add(dependId);
780.                     }
781.                 }
782.             }
783.             for (int i = uiHelpers.Length - 1; i >= 0; i--)
784.             {
785.                 var uiHelper = uiHelpers[i];
786.                 if (dependInstIds.Contains(uiHelper.gameObject.GetInstanceID()))
787.                 {
788.                     ArrayUtility.RemoveAt(ref uiHelpers, i);
789.                 }
790.             }
791.             return uiHelpers;
792.         }
793.         /// <summary>
794.         /// 把图片设置为为Sprite或Texture类型
795.         /// </summary>
796.         /// <param name="dir"></param>
797.         public static void ConvertTexturesType(string[] texAssets, bool isImage = true)
798.         {
799.             foreach (var item in texAssets)
800.             {
801.                 var texImporter = AssetImporter.GetAtPath(item) as TextureImporter;
802.                 if (texImporter == null)
803.                 {
804.                     Debug.LogError($"TextureImporter为空:{item}");
805.                     continue;
806.                 }
807.                 if (isImage)
808.                 {
809.                     texImporter.textureType = TextureImporterType.Sprite;
810.                     texImporter.spriteImportMode = SpriteImportMode.Single;
811.                     texImporter.alphaSource = TextureImporterAlphaSource.FromInput;
812.                     texImporter.alphaIsTransparency = true;
813.                     texImporter.mipmapEnabled = false;
814.                 }
815.                 else
816.                 {
817.                     texImporter.textureType = TextureImporterType.Default;
818.                     texImporter.textureShape = TextureImporterShape.Texture2D;
819.                     texImporter.alphaSource = TextureImporterAlphaSource.FromInput;
820.                     texImporter.alphaIsTransparency = true;
821.                     texImporter.mipmapEnabled = false;
822.                 }
824.                 texImporter.SaveAndReimport();
825.             }
826.         }
828.         /// <summary>
829.         /// 压缩图片文件
830.         /// </summary>
831.         /// <param name="asset">文件名(相对路径Assets)</param>
832.         /// <returns></returns>
833.         public static bool CompressImageFile(string asset)
834.         {
835.             var assetPath = asset.StartsWith("Assets/") ? Path.GetFullPath(asset, Directory.GetParent(Application.dataPath).FullName) : asset;
836.             var compressTool = Utility.Assembly.GetType("UGF.EditorTools.CompressTool");
837.             if (compressTool == null) return false;
839.             var compressMethod = compressTool.GetMethod("CompressImageOffline", new Type[] { typeof(string), typeof(string) });
840.             if (compressMethod == null) return false;
842.             return (bool)compressMethod.Invoke(null, new object[] { assetPath, assetPath });
843.         }
844.         /// <summary>
845.         /// 获取UIForm对应的图片导出目录
846.         /// </summary>
847.         /// <returns></returns>
848.         public string GetUIFormImagesOutputDir()
849.         {
850.             return UtilityBuiltin.ResPath.GetCombinePath(Psd2UIFormSettings.Instance.UIImagesOutputDir, uiFormName);
851.         }
853.         public SmartObjectLayer ConvertToSmartObjectLayer(Layer layer)
854.         {
855.             var smartObj = psdInstance.SmartObjectProvider.ConvertToSmartObject(new Layer[] { layer });
856.             return smartObj;
857.         }
858.     }
859. }
860. #endif

复制代码

7. 图层节点编辑器扩展，提供导出图片按钮以便单独导出选择图层，UI范例切换时自动添加对应的Helper剖析器并自动绑定子UI

1. #if UNITY_EDITOR
2. using UnityEngine;
3. using Aspose.PSD.FileFormats.Psd.Layers;
4. using Aspose.PSD.ImageOptions;
5. using UnityEditor;
6. using System.IO;
7. using System.Linq;
8. using Aspose.PSD.FileFormats.Psd;
9. using Aspose.PSD.FileFormats.Psd.Layers.SmartObjects;
10. using GameFramework;
12. namespace UGF.EditorTools.Psd2UGUI
13. {
14.     [CanEditMultipleObjects]
15.     [CustomEditor(typeof(PsdLayerNode))]
16.     public class PsdLayerNodeInspector : Editor
17.     {
18.         PsdLayerNode targetLogic;
19.         private void OnEnable()
20.         {
21.             targetLogic = target as PsdLayerNode;
22.             targetLogic.RefreshLayerTexture();
23.         }
25.         public override void OnInspectorGUI()
26.         {
27.             serializedObject.Update();
28.             base.OnInspectorGUI();
29.             EditorGUI.BeginChangeCheck();
30.             {
31.                 targetLogic.UIType = (GUIType)EditorGUILayout.EnumPopup("UI Type", targetLogic.UIType);
32.                 if (EditorGUI.EndChangeCheck())
33.                 {
34.                     targetLogic.SetUIType(targetLogic.UIType);
35.                 }
36.             }
37.             EditorGUILayout.BeginHorizontal();
38.             {
39.                 if (GUILayout.Button("导出图片"))
40.                 {
41.                     foreach (var item in targets)
42.                     {
43.                         if (item == null) continue;
45.                         (item as PsdLayerNode)?.ExportImageAsset();
46.                     }
47.                 }
48.                 EditorGUILayout.EndHorizontal();
49.             }
50.             serializedObject.ApplyModifiedProperties();
51.         }
53.         public override bool HasPreviewGUI()
54.         {
55.             var layerNode = (target as PsdLayerNode);
56.             return layerNode != null && layerNode.PreviewTexture != null;
57.         }
59.         public override void OnPreviewGUI(Rect r, GUIStyle background)
60.         {
61.             var layerNode = (target as PsdLayerNode);
62.             GUI.DrawTexture(r, layerNode.PreviewTexture, ScaleMode.ScaleToFit);
63.             //base.OnPreviewGUI(r, background);
64.         }
65.         public override string GetInfoString()
66.         {
67.             var layerNode = (target as PsdLayerNode);
68.             return layerNode.LayerInfo;
69.         }
70.     }
71.     [ExecuteInEditMode]
72.     [DisallowMultipleComponent]
73.     public class PsdLayerNode : MonoBehaviour
74.     {
75.         [ReadOnlyField] public int BindPsdLayerIndex = -1;
76.         [ReadOnlyField][SerializeField] PsdLayerType mLayerType = PsdLayerType.Unknown;
77.         [SerializeField] public bool markToExport;
78.         [HideInInspector] public GUIType UIType;
79.         public Texture2D PreviewTexture { get; private set; }
80.         public string LayerInfo { get; private set; }
81.         public Rect LayerRect { get; private set; }
82.         public PsdLayerType LayerType { get => mLayerType; }
83.         public bool IsMainUIType => UGUIParser.IsMainUIType(UIType);
84.         /// <summary>
85.         /// 绑定的psd图层
86.         /// </summary>
87.         private Layer mBindPsdLayer;
89.         public Layer BindPsdLayer
90.         {
91.             get => mBindPsdLayer;
92.             set
93.             {
94.                 mBindPsdLayer = value;
95.                 mLayerType = mBindPsdLayer.GetLayerType();
96.                 //if (IsTextLayer(out var txtLayer) && !txtLayer.TextBoundBox.IsEmpty)
97.                 //{
98.                 //    LayerRect = AsposePsdExtension.PsdRect2UnityRect(txtLayer.TextBoundBox, Psd2UIFormConverter.Instance.UIFormCanvasSize);
99.                 //}
100.                 //else
101.                 {
102.                     LayerRect = mBindPsdLayer.GetLayerRect();
103.                 }
104.                 LayerInfo = $"{LayerRect}";
105.             }
106.         }
107.         private void OnDestroy()
108.         {
109.             if (PreviewTexture != null)
110.             {
111.                 DestroyImmediate(PreviewTexture);
112.             }
113.         }
114.         public void SetUIType(GUIType uiType, bool triggerParseFunc = true)
115.         {
116.             this.UIType = uiType;
117.             RemoveUIHelper();
119.             if (triggerParseFunc)
120.             {
121.                 RefreshUIHelper(true);
122.             }
123.         }
124.         public void RefreshUIHelper(bool refreshParent = false)
125.         {
126.             if (UIType == GUIType.Null) return;
128.             var uiHelperTp = UGUIParser.Instance.GetHelperType(UIType);
129.             if (uiHelperTp != null)
130.             {
131.                 var helper = gameObject.GetOrAddComponent(uiHelperTp) as UIHelperBase;
132.                 helper.ParseAndAttachUIElements();
133.             }
134.             if (refreshParent)
135.             {
136.                 var parentHelper = transform.parent?.GetComponent<UIHelperBase>();
137.                 parentHelper?.ParseAndAttachUIElements();
138.             }
139.             EditorUtility.SetDirty(this);
140.         }
141.         private void RemoveUIHelper()
142.         {
143.             var uiHelpers = this.GetComponents<UIHelperBase>();
144.             if (uiHelpers != null)
145.             {
146.                 foreach (var uiHelper in uiHelpers)
147.                 {
148.                     DestroyImmediate(uiHelper);
149.                 }
150.             }
151.             EditorUtility.SetDirty(this);
152.         }
153.         /// <summary>
154.         /// 是否需要导出此图层
155.         /// </summary>
156.         /// <returns></returns>
157.         public bool NeedExportImage()
158.         {
159.             return gameObject.activeSelf && markToExport;
160.         }
161.         /// <summary>
162.         /// 导出图片
163.         /// </summary>
164.         /// <param name="forceSpriteType">强制贴图类型为Sprite</param>
165.         /// <returns></returns>
166.         public string ExportImageAsset(bool forceSpriteType = false)
167.         {
168.             string assetName = null;
169.             if (this.RefreshLayerTexture())
170.             {
171.                 var bytes = PreviewTexture.EncodeToPNG();
172.                 var imgName = Utility.Text.Format("{0}_{1}", string.IsNullOrWhiteSpace(name) ? UIType : name, BindPsdLayerIndex);
173.                 var exportDir = Psd2UIFormConverter.Instance.GetUIFormImagesOutputDir();
174.                 if (!Directory.Exists(exportDir))
175.                 {
176.                     try
177.                     {
178.                         Directory.CreateDirectory(exportDir);
179.                         AssetDatabase.Refresh();
180.                     }
181.                     catch (System.Exception)
182.                     {
183.                         return null;
184.                     }
185.                 }
186.                 var imgFileName = UtilityBuiltin.ResPath.GetCombinePath(exportDir, imgName + ".png");
187.                 File.WriteAllBytes(imgFileName, bytes);
188.                 if (Psd2UIFormSettings.Instance.CompressImage)
189.                 {
190.                     bool compressResult = Psd2UIFormConverter.CompressImageFile(imgFileName);
191.                     if (compressResult)
192.                     {
193.                         Debug.Log($"成功压缩图片:{imgFileName}");
194.                     }
195.                     else
196.                     {
197.                         Debug.LogWarning($"压缩图片失败:{imgFileName}");
198.                     }
199.                 }
200.                 assetName = imgFileName;
201.                 bool isImage = !(this.UIType == GUIType.FillColor || this.UIType == GUIType.RawImage);
202.                 AssetDatabase.Refresh();
203.                 Psd2UIFormConverter.ConvertTexturesType(new string[] { imgFileName }, isImage || forceSpriteType);
204.             }
206.             return assetName;
207.         }
208.         public bool RefreshLayerTexture(bool forceRefresh = false)
209.         {
210.             if (!forceRefresh && PreviewTexture != null)
211.             {
212.                 return true;
213.             }
215.             if (BindPsdLayer == null || BindPsdLayer.Disposed) return false;
217.             var pngOpt = new PngOptions
218.             {
219.                 ColorType = Aspose.PSD.FileFormats.Png.PngColorType.TruecolorWithAlpha
220.             };
221.             if (BindPsdLayer.CanSave(pngOpt))
222.             {
223.                 if (PreviewTexture != null)
224.                 {
225.                     DestroyImmediate(PreviewTexture);
226.                 }
227.                 PreviewTexture = this.ConvertPsdLayer2Texture2D();
228.             }
229.             return PreviewTexture != null;
230.         }
232.         /// <summary>
233.         /// 把psd图层转成Texture2D
234.         /// </summary>
235.         /// <param name="psdLayer"></param>
236.         /// <returns>Texture2D</returns>
237.         public Texture2D ConvertPsdLayer2Texture2D()
238.         {
239.             if (BindPsdLayer == null || BindPsdLayer.Disposed) return null;
241.             MemoryStream ms = new MemoryStream();
242.             var pngOpt = new Aspose.PSD.ImageOptions.PngOptions()
243.             {
244.                 ColorType = Aspose.PSD.FileFormats.Png.PngColorType.TruecolorWithAlpha,
245.                 FullFrame = true
246.             };
247.             if (BindPsdLayer.Opacity >= 255 || LayerType == PsdLayerType.LayerGroup)
248.             {
249.                 BindPsdLayer.Save(ms, pngOpt);
250.             }
251.             else
252.             {
253.                 var smartLayer = Psd2UIFormConverter.Instance.ConvertToSmartObjectLayer(BindPsdLayer);
254.                 smartLayer.Save(ms, pngOpt);
255.             }
257.             //var bitmap = BindPsdLayer.ToBitmap();
258.             //bitmap.Save(ms, System.Drawing.Imaging.ImageFormat.Png);
260.             var buffer = new byte[ms.Length];
261.             ms.Position = 0;
262.             ms.Read(buffer, 0, buffer.Length);
264.             Texture2D texture = new Texture2D(BindPsdLayer.Width, BindPsdLayer.Height);
265.             texture.alphaIsTransparency = true;
266.             texture.LoadImage(buffer);
267.             texture.Apply();
268.             ms.Dispose();
269.             return texture;
270.         }
272.         /// <summary>
273.         /// 从第一层子节点按类型查找LayerNode
274.         /// </summary>
275.         /// <param name="uiTp"></param>
276.         /// <returns></returns>
277.         public PsdLayerNode FindSubLayerNode(GUIType uiTp)
278.         {
279.             for (int i = 0; i < transform.childCount; i++)
280.             {
281.                 var child = transform.GetChild(i)?.GetComponent<PsdLayerNode>();
283.                 if (child != null && child.UIType == uiTp) return child;
284.             }
285.             return null;
286.         }
287.         /// <summary>
288.         /// 依次查找给定多个类型,返回最先找到的类型
289.         /// </summary>
290.         /// <param name="uiTps"></param>
291.         /// <returns></returns>
292.         public PsdLayerNode FindSubLayerNode(params GUIType[] uiTps)
293.         {
294.             foreach (var tp in uiTps)
295.             {
296.                 var result = FindSubLayerNode(tp);
297.                 if (result != null) return result;
298.             }
299.             return null;
300.         }
301.         public PsdLayerNode FindLayerNodeInChildren(GUIType uiTp)
302.         {
303.             var layers = GetComponentsInChildren<PsdLayerNode>(true);
304.             if (layers != null && layers.Length > 0)
305.             {
306.                 return layers.FirstOrDefault(layer => layer.UIType == uiTp);
307.             }
308.             return null;
309.         }
311.         /// <summary>
312.         /// 判断该图层是否为文本图层
313.         /// </summary>
314.         /// <param name="layer"></param>
315.         /// <returns></returns>
316.         public bool IsTextLayer(out TextLayer layer)
317.         {
318.             layer = null;
319.             if (BindPsdLayer == null) return false;
321.             if (BindPsdLayer is SmartObjectLayer smartLayer)
322.             {
323.                 layer = smartLayer.GetSmartObjectInnerTextLayer() as TextLayer;
324.                 return layer != null;
325.             }
326.             else if (BindPsdLayer is TextLayer txtLayer)
327.             {
328.                 layer = txtLayer;
329.                 return layer != null;
330.             }
331.             return false;
332.         }
333.         internal void InitPsdLayers(PsdImage psdInstance)
334.         {
335.             BindPsdLayer = psdInstance.Layers[BindPsdLayerIndex];
336.         }
337.         internal bool ParseTextLayerInfo(out string text, out int fontSize, out float characterSpace, out float lineSpace, out Color fontColor, out UnityEngine.FontStyle fontStyle, out TMPro.FontStyles tmpFontStyle, out string fontName)
338.         {
339.             text = null; fontSize = 0; characterSpace = 0f; lineSpace = 0f; fontColor = Color.white; fontStyle = FontStyle.Normal; tmpFontStyle = TMPro.FontStyles.Normal; fontName = null;
340.             if (IsTextLayer(out var txtLayer))
341.             {
342.                 text = txtLayer.Text;
343.                 fontSize = (int)txtLayer.Font.Size;
344.                 fontColor = new Color(txtLayer.TextColor.R, txtLayer.TextColor.G, txtLayer.TextColor.B, txtLayer.Opacity) / (float)255;
345.                 if (txtLayer.Font.Style.HasFlag(Aspose.PSD.FontStyle.Bold) && txtLayer.Font.Style.HasFlag(Aspose.PSD.FontStyle.Italic))
346.                 {
347.                     fontStyle = UnityEngine.FontStyle.BoldAndItalic;
348.                 }
349.                 else if (txtLayer.Font.Style.HasFlag(Aspose.PSD.FontStyle.Bold))
350.                 {
351.                     fontStyle = UnityEngine.FontStyle.Bold;
353.                 }
354.                 else if (txtLayer.Font.Style.HasFlag(Aspose.PSD.FontStyle.Italic))
355.                 {
356.                     fontStyle = UnityEngine.FontStyle.Italic;
357.                 }
358.                 else
359.                 {
360.                     fontStyle = UnityEngine.FontStyle.Normal;
361.                 }
363.                 if (txtLayer.Font.Style.HasFlag(Aspose.PSD.FontStyle.Italic))
364.                 {
365.                     tmpFontStyle |= TMPro.FontStyles.Italic;
366.                 }
367.                 if (txtLayer.Font.Style.HasFlag(Aspose.PSD.FontStyle.Bold))
368.                 {
369.                     tmpFontStyle |= TMPro.FontStyles.Bold;
370.                 }
371.                 if (txtLayer.Font.Style.HasFlag(Aspose.PSD.FontStyle.Underline))
372.                 {
373.                     tmpFontStyle |= TMPro.FontStyles.Underline;
374.                 }
375.                 if (txtLayer.Font.Style.HasFlag(Aspose.PSD.FontStyle.Strikeout))
376.                 {
377.                     tmpFontStyle |= TMPro.FontStyles.Strikethrough;
378.                 }
379.                 fontName = txtLayer.Font.Name;
380.                 if (txtLayer.TextData.Items.Length > 0)
381.                 {
382.                     var txtData = txtLayer.TextData.Items[0];
383.                     characterSpace = txtData.Style.Tracking * 0.1f;
384.                     lineSpace = (float)txtData.Style.Leading * 0.1f;
385.                 }
386.                 return true;
387.             }
388.             return false;
389.         }
390.     }
391. }
393. #endif

复制代码

五、UI元素剖析/天生器Helper

界说HelperBase剖析器基类，差别的UI范例重写UI初始化方法，如需支持新的UI范例可以很方便进行扩展支持：

1. #if UNITY_EDITOR
2. using System.Collections.Generic;
3. using UnityEditor;
4. using UnityEngine;
5. using UnityGameFramework.Runtime;
7. namespace UGF.EditorTools.Psd2UGUI
8. {
9.     public abstract class UIHelperBase : MonoBehaviour
10.     {
11.         public PsdLayerNode LayerNode => this.GetComponent<PsdLayerNode>();
12.         private void OnEnable()
13.         {
14.             ParseAndAttachUIElements();
15.         }
16.         /// <summary>
17.         /// 解析并关联UI元素,并且返回已经关联过的图层(已关联图层不再处理)
18.         /// </summary>
19.         /// <param name="layerNode"></param>
20.         /// <returns></returns>
21.         public abstract void ParseAndAttachUIElements();
23.         /// <summary>
24.         /// 获取UI依赖的LayerNodes
25.         /// </summary>
26.         /// <returns></returns>
27.         public abstract PsdLayerNode[] GetDependencies();
28.         /// <summary>
29.         /// 把UI实例进行UI元素初始化
30.         /// </summary>
31.         /// <param name="uiRoot"></param>
32.         protected abstract void InitUIElements(GameObject uiRoot);
33.         /// <summary>
34.         /// 筛选出UI依赖的非空LayerNode
35.         /// </summary>
36.         /// <param name="nodes"></param>
37.         /// <returns></returns>
38.         protected PsdLayerNode[] CalculateDependencies(params PsdLayerNode[] nodes)
39.         {
40.             if (nodes == null || nodes.Length == 0) return null;
42.             for (int i = nodes.Length - 1; i >= 0; i--)
43.             {
44.                 var node = nodes[i];
45.                 if (node == null || node == LayerNode) ArrayUtility.RemoveAt(ref nodes, i);
46.             }
47.             return nodes;
48.         }
49.         internal GameObject CreateUI(GameObject uiInstance = null)
50.         {
51.             if ((int)this.LayerNode.UIType > UGUIParser.UITYPE_MAX || LayerNode.UIType == GUIType.Null) return null;
53.             if (uiInstance == null)
54.             {
55.                 var rule = UGUIParser.Instance.GetRule(this.LayerNode.UIType);
56.                 if (rule == null || rule.UIPrefab == null)
57.                 {
58.                     Debug.LogWarning($"创建UI类型{LayerNode.UIType}失败:Rule配置项不存在或UIPrefab为空");
59.                     return null;
60.                 }
61.                 uiInstance = GameObject.Instantiate(rule.UIPrefab, Vector3.zero, Quaternion.identity);
62.                 if (LayerNode.IsMainUIType)
63.                 {
64.                     uiInstance.name = this.name;
65.                     var key = uiInstance.GetOrAddComponent<UIStringKey>();
66.                     key.Key = this.gameObject.GetInstanceID().ToString();
67.                 }
68.             }
69.             
70.             InitUIElements(uiInstance);
71.             return uiInstance;
72.         }
74.     }
75. }
76. #endif

复制代码

1. Text剖析器：

1. #if UNITY_EDITOR
2. using UnityEngine;
4. namespace UGF.EditorTools.Psd2UGUI
5. {
6.     [DisallowMultipleComponent]
7.     public class TextHelper : UIHelperBase
8.     {
9.         [SerializeField] PsdLayerNode text;
11.         public override PsdLayerNode[] GetDependencies()
12.         {
13.             return CalculateDependencies(text);
14.         }
16.         public override void ParseAndAttachUIElements()
17.         {
18.             if (LayerNode.IsTextLayer(out var _))
19.             {
20.                 text = LayerNode;
21.             }
22.             else
23.             {
24.                 LayerNode.SetUIType(UGUIParser.Instance.DefaultImage);
25.             }
26.         }
28.         protected override void InitUIElements(GameObject uiRoot)
29.         {
30.             var textCom = uiRoot.GetComponentInChildren<UnityEngine.UI.Text>();
31.             UGUIParser.SetTextStyle(text, textCom);
33.             UGUIParser.SetRectTransform(text, textCom);
34.         }
35.     }
36. }
37. #endif

复制代码

从ps文本图层获取文本字体、字号、颜色、字间距等信息，然后从Unity工程中查找对应的字体文件并赋值给Text组件:

1. internal bool ParseTextLayerInfo(out string text, out int fontSize, out float characterSpace, out float lineSpace, out Color fontColor, out UnityEngine.FontStyle fontStyle, out TMPro.FontStyles tmpFontStyle, out string fontName)
2.         {
3.             text = null; fontSize = 0; characterSpace = 0f; lineSpace = 0f; fontColor = Color.white; fontStyle = FontStyle.Normal; tmpFontStyle = TMPro.FontStyles.Normal; fontName = null;
4.             if (IsTextLayer(out var txtLayer))
5.             {
6.                 text = txtLayer.Text;
7.                 fontSize = (int)txtLayer.Font.Size;
8.                 fontColor = new Color(txtLayer.TextColor.R, txtLayer.TextColor.G, txtLayer.TextColor.B, txtLayer.Opacity) / (float)255;
9.                 if (txtLayer.Font.Style.HasFlag(Aspose.PSD.FontStyle.Bold) && txtLayer.Font.Style.HasFlag(Aspose.PSD.FontStyle.Italic))
10.                 {
11.                     fontStyle = UnityEngine.FontStyle.BoldAndItalic;
12.                 }
13.                 else if (txtLayer.Font.Style.HasFlag(Aspose.PSD.FontStyle.Bold))
14.                 {
15.                     fontStyle = UnityEngine.FontStyle.Bold;
17.                 }
18.                 else if (txtLayer.Font.Style.HasFlag(Aspose.PSD.FontStyle.Italic))
19.                 {
20.                     fontStyle = UnityEngine.FontStyle.Italic;
21.                 }
22.                 else
23.                 {
24.                     fontStyle = UnityEngine.FontStyle.Normal;
25.                 }
27.                 if (txtLayer.Font.Style.HasFlag(Aspose.PSD.FontStyle.Italic))
28.                 {
29.                     tmpFontStyle |= TMPro.FontStyles.Italic;
30.                 }
31.                 if (txtLayer.Font.Style.HasFlag(Aspose.PSD.FontStyle.Bold))
32.                 {
33.                     tmpFontStyle |= TMPro.FontStyles.Bold;
34.                 }
35.                 if (txtLayer.Font.Style.HasFlag(Aspose.PSD.FontStyle.Underline))
36.                 {
37.                     tmpFontStyle |= TMPro.FontStyles.Underline;
38.                 }
39.                 if (txtLayer.Font.Style.HasFlag(Aspose.PSD.FontStyle.Strikeout))
40.                 {
41.                     tmpFontStyle |= TMPro.FontStyles.Strikethrough;
42.                 }
43.                 fontName = txtLayer.Font.Name;
44.                 if (txtLayer.TextData.Items.Length > 0)
45.                 {
46.                     var txtData = txtLayer.TextData.Items[0];
47.                     characterSpace = txtData.Style.Tracking * 0.1f;
48.                     lineSpace = (float)txtData.Style.Leading * 0.1f;
49.                 }
50.                 return true;
51.             }
52.             return false;
53.         }

复制代码

根据字体内部名查找ttf字体和TextMeshPro字体资源：

1. /// <summary>
2.         /// 根据字体名查找TMP_FontAsset
3.         /// </summary>
4.         /// <param name="fontName"></param>
5.         /// <returns></returns>
6.         public static TMP_FontAsset FindTMPFontAsset(string fontName)
7.         {
8.             var fontGuids = AssetDatabase.FindAssets("t:TMP_FontAsset");
9.             foreach (var guid in fontGuids)
10.             {
11.                 var fontPath = AssetDatabase.GUIDToAssetPath(guid);
12.                 var font = AssetDatabase.LoadAssetAtPath<TMP_FontAsset>(fontPath);
13.                 if (font != null && font.faceInfo.familyName == fontName)
14.                 {
15.                     return font;
16.                 }
17.             }
18.             return null;
19.         }
20.         /// <summary>
21.         /// 根据字体名查找Font Asset
22.         /// </summary>
23.         /// <param name="fontName"></param>
24.         /// <returns></returns>
25.         public static UnityEngine.Font FindFontAsset(string fontName)
26.         {
27.             var fontGuids = AssetDatabase.FindAssets("t:font");
28.             foreach (var guid in fontGuids)
29.             {
30.                 var fontPath = AssetDatabase.GUIDToAssetPath(guid);
31.                 var font = AssetImporter.GetAtPath(fontPath) as TrueTypeFontImporter;
32.                 if (font != null && font.fontTTFName == fontName)
33.                 {
34.                     return AssetDatabase.LoadAssetAtPath<UnityEngine.Font>(fontPath);
35.                 }
36.             }
37.             return null;
38.         }

复制代码

2. Image剖析器：

1. #if UNITY_EDITOR
2. using UnityEngine;
4. namespace UGF.EditorTools.Psd2UGUI
5. {
6.     [DisallowMultipleComponent]
7.     public class ImageHelper : UIHelperBase
8.     {
9.         [SerializeField] PsdLayerNode image;
11.         public override PsdLayerNode[] GetDependencies()
12.         {
13.             return CalculateDependencies(image);
14.         }
16.         public override void ParseAndAttachUIElements()
17.         {
18.             image = LayerNode;
19.         }
21.         protected override void InitUIElements(GameObject uiRoot)
22.         {
23.             var imgCom = uiRoot.GetComponentInChildren<UnityEngine.UI.Image>();
24.             UGUIParser.SetRectTransform(image,imgCom);
25.             imgCom.sprite = UGUIParser.LayerNode2Sprite(image, imgCom.type == UnityEngine.UI.Image.Type.Sliced);
26.         }
27.     }
28. }
29. #endif

复制代码

自动把ps图层导出为Sprite资源，若Image为Sliced模式则自动盘算并设置Sprite 9宫边界：

1. /// <summary>
2.         /// 把LayerNode图片保存到本地并返回
3.         /// </summary>
4.         /// <param name="layerNode"></param>
5.         /// <param name="auto9Slice">若没有设置Sprite的九宫,是否自动计算并设置九宫</param>
6.         /// <returns></returns>
7.         public static Sprite LayerNode2Sprite(PsdLayerNode layerNode, bool auto9Slice = false)
8.         {
9.             if (layerNode != null)
10.             {
11.                 var spAssetName = layerNode.ExportImageAsset(true);
12.                 var sprite = AssetDatabase.LoadAssetAtPath<Sprite>(spAssetName);
13.                 if (sprite != null)
14.                 {
15.                     if (auto9Slice)
16.                     {
17.                         var spImpt = AssetImporter.GetAtPath(spAssetName) as TextureImporter;
18.                         var rawReadable = spImpt.isReadable;
19.                         if (!rawReadable)
20.                         {
21.                             spImpt.isReadable = true;
22.                             spImpt.SaveAndReimport();
23.                         }
24.                         if (spImpt.spriteBorder == Vector4.zero)
25.                         {
26.                             spImpt.spriteBorder = CalculateTexture9SliceBorder(sprite.texture, layerNode.BindPsdLayer.Opacity);
27.                             spImpt.isReadable = rawReadable;
28.                             spImpt.SaveAndReimport();
29.                         }
30.                     }
31.                     return sprite;
32.                 }
33.             }
34.             return null;
35.         }

复制代码

根据图片的Alpha通道盘算出9宫边界，通常设置9宫边界还会思量图片纹理因素，但程序难以智能辨认，这里自动9宫只是实用于普通环境，还需要根据实际效果进行手动调解：

1. /// <summary>
2.         /// 自动计算贴图的 9宫 Border
3.         /// </summary>
4.         /// <param name="texture"></param>
5.         /// <param name="alphaThreshold">0-255</param>
6.         /// <returns></returns>
7.         public static Vector4 CalculateTexture9SliceBorder(Texture2D texture, byte alphaThreshold = 3)
8.         {
9.             int width = texture.width;
10.             int height = texture.height;
12.             Color32[] pixels = texture.GetPixels32();
13.             int minX = width;
14.             int minY = height;
15.             int maxX = 0;
16.             int maxY = 0;
18.             // 寻找不透明像素的最小和最大边界
19.             for (int y = 0; y < height; y++)
20.             {
21.                 for (int x = 0; x < width; x++)
22.                 {
23.                     int pixelIndex = y * width + x;
24.                     Color32 pixel = pixels[pixelIndex];
26.                     if (pixel.a >= alphaThreshold)
27.                     {
28.                         minX = Mathf.Min(minX, x);
29.                         minY = Mathf.Min(minY, y);
30.                         maxX = Mathf.Max(maxX, x);
31.                         maxY = Mathf.Max(maxY, y);
32.                     }
33.                 }
34.             }
36.             // 计算最优的borderSize
37.             int borderSizeX = (maxX - minX) / 3;
38.             int borderSizeY = (maxY - minY) / 3;
39.             int borderSize = Mathf.Min(borderSizeX, borderSizeY);
41.             // 根据边界和Border Size计算Nine Slice Border
42.             int left = minX + borderSize;
43.             int right = maxX - borderSize;
44.             int top = minY + borderSize;
45.             int bottom = maxY - borderSize;
47.             // 确保边界在纹理范围内
48.             left = Mathf.Clamp(left, 0, width - 1);
49.             right = Mathf.Clamp(right, 0, width - 1);
50.             top = Mathf.Clamp(top, 0, height - 1);
51.             bottom = Mathf.Clamp(bottom, 0, height - 1);
53.             return new Vector4(left, top, width - right, height - bottom);
54.         }

复制代码

3. Dropdown剖析器，对于多种元素构成的复合型、嵌套型UI，可以很好的支持，而且可以任意嵌套组合，没有限定和束缚。比方Dropdown内包含了一个ScrollView和一个Toggle范例的Item，就可以直接用ScrollView Helper和Toggle Helper分别对其剖析：

1. #if UNITY_EDITOR
2. using UnityEngine;
3. using UnityEngine.UI;
5. namespace UGF.EditorTools.Psd2UGUI
6. {
7.     [DisallowMultipleComponent]
8.     public class DropdownHelper : UIHelperBase
9.     {
10.         [SerializeField] PsdLayerNode background;
11.         [SerializeField] PsdLayerNode label;
12.         [SerializeField] PsdLayerNode arrow;
13.         [SerializeField] PsdLayerNode scrollView;
14.         [SerializeField] PsdLayerNode toggleItem;
15.         public override PsdLayerNode[] GetDependencies()
16.         {
17.             return CalculateDependencies(background, label, arrow, scrollView, toggleItem);
18.         }
20.         public override void ParseAndAttachUIElements()
21.         {
22.             background = LayerNode.FindSubLayerNode(GUIType.Background, GUIType.Image, GUIType.RawImage);
23.             label = LayerNode.FindSubLayerNode(GUIType.Dropdown_Label, GUIType.Text, GUIType.TMPText);
24.             arrow = LayerNode.FindSubLayerNode(GUIType.Dropdown_Arrow);
25.             scrollView = LayerNode.FindSubLayerNode(GUIType.ScrollView);
26.             toggleItem = LayerNode.FindSubLayerNode(GUIType.Toggle);
27.         }
29.         protected override void InitUIElements(GameObject uiRoot)
30.         {
31.             var dpd = uiRoot.GetComponent<Dropdown>();
32.             UGUIParser.SetRectTransform(background, dpd);
33.             var bgImg = dpd.targetGraphic as Image;
34.             bgImg.sprite = UGUIParser.LayerNode2Sprite(background, bgImg.type == Image.Type.Sliced) ?? bgImg.sprite;
36.             UGUIParser.SetTextStyle(label, dpd.captionText);
37.             UGUIParser.SetRectTransform(label, dpd.captionText);
38.             var arrowImg = dpd.transform.Find("Arrow")?.GetComponent<Image>();
39.             if (arrowImg != null)
40.             {
41.                 UGUIParser.SetRectTransform(arrow, arrowImg);
42.                 arrowImg.sprite = UGUIParser.LayerNode2Sprite(arrow, arrowImg.type == Image.Type.Sliced);
43.             }
44.             if (scrollView != null)
45.             {
46.                 var svTmp = uiRoot.GetComponentInChildren<ScrollRect>(true).GetComponent<RectTransform>();
47.                 if (svTmp != null)
48.                 {
49.                     var sViewGo = scrollView.GetComponent<ScrollViewHelper>()?.CreateUI(svTmp.gameObject);
50.                     if (sViewGo != null)
51.                     {
52.                         var sViewRect = sViewGo.GetComponent<RectTransform>();
53.                         UGUIParser.SetRectTransform(scrollView, sViewRect);
54.                         sViewRect.anchorMin = Vector2.zero;
55.                         sViewRect.anchorMax = new Vector2(1, 0);
56.                         sViewRect.anchoredPosition = new Vector2(0, -2);
57.                     }
58.                     if (toggleItem != null)
59.                     {
60.                         var itemTmp = dpd.itemText != null ? dpd.itemText.transform.parent : null;
61.                         if (itemTmp != null)
62.                         {
63.                             toggleItem.GetComponent<ToggleHelper>()?.CreateUI(itemTmp.gameObject);
64.                         }
65.                     }
66.                 }
67.             }
68.         }
69.     }
70. }
71. #endif

复制代码

实现了每种底子UI元素的剖析后就可以任意进行UI元素组合，比方Slider中包含Slider配景和填充条，在Slider中添加一个文本图层，剖析出来后就是一个内在Text文本的Slider进度条，剖析前后的节点层级始终保持同一：

由于篇幅缘故原由别的UI范例的剖析代码就不贴了，UGUI和TextMeshProGUI共16种UI范例全部完美支持。
末了，附上psd源文件效果图和一键天生的UGUI预制体效果对比图，运行时效果(左)，psd原图(右)：

 工具开源地点：https://github.com/sunsvip/PSD2UGUI_X


来源：https://blog.csdn.net/final5788/article/details/131406527
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！