devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

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

作者：知新_RL | 2024-04-30 19:53:52

赞

踩

unity psd

解放UI程序/美术? psd文件一键转ui prefab 支持所有ui类型 支持textmeshpro

psd一键转ugui prefab工具 设计原理和详细使用方法

工具效果：

第一步，把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;
  10.  
  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,
  32.  
  33.         //UI的子类型, 以101开始。 0-100预留给UI类型, 新类型从尾部追加
  34.         Background = 101, //通用背景
  35.  
  36.         //Button的子类型
  37.         Button_Highlight,
  38.         Button_Press,
  39.         Button_Select,
  40.         Button_Disable,
  41.         Button_Text,
  42.  
  43.         //Dropdown/TMPDropdown的子类型
  44.         Dropdown_Label,
  45.         Dropdown_Arrow,
  46.  
  47.         //InputField/TMPInputField的子类型
  48.         InputField_Placeholder,
  49.         InputField_Text,
  50.  
  51.         //Toggle的子类型
  52.         Toggle_Checkmark,
  53.         Toggle_Label,
  54.  
  55.         //Slider的子类型
  56.         Slider_Fill,
  57.         Slider_Handle,
  58.  
  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;
  79.  
  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 = "使用说明";
  106.  
  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;
  132.  
  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.             }
  168.  
  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.         }
  183.  
  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.         }
  204.  
  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;
  265.  
  266.             Color32[] pixels = texture.GetPixels32();
  267.             int minX = width;
  268.             int minY = height;
  269.             int maxX = 0;
  270.             int maxY = 0;
  271.  
  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];
  279.  
  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.             }
  289.  
  290.             // 计算最优的borderSize
  291.             int borderSizeX = (maxX - minX) / 3;
  292.             int borderSizeY = (maxY - minY) / 3;
  293.             int borderSize = Mathf.Min(borderSizeX, borderSizeY);
  294.  
  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;
  300.  
  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);
  306.  
  307.             return new Vector4(left, top, width - right, height - bottom);
  308.         }
  309.  
  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.         }
  387.  
  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.             }
  408.  
  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类型标识列表:");
  416.  
  417.             foreach (var rule in rules)
  418.             {
  419.                 if (rule.UIType == GUIType.Null) continue;
  420.  
  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.             }
  430.  
  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.             }
  440.  
  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. }
  19.  
  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;
  54.  
  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;
  17.  
  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;
  41.  
  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.                 }
  92.  
  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.             }
  143.  
  144.  
  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;
  187.  
  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;
  201.  
  202.             EditorApplication.hierarchyWindowItemOnGUI += OnHierarchyGUI;
  203.  
  204.             if (psdInstance == null && !string.IsNullOrWhiteSpace(PsdAssetName))
  205.             {
  206.                 RefreshNodesBindLayer();
  207.             }
  208.         }
  209.  
  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.                     }
  220.  
  221.                 }
  222.             }
  223.             else
  224.             {
  225.                 RefreshNodesBindLayer();
  226.             }
  227.         }
  228.  
  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.                     }
  241.  
  242.                 }
  243.             }
  244.         }
  245.  
  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;
  252.  
  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;
  268.  
  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.                 });
  277.  
  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.         }
  312.  
  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.             }
  335.  
  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;
  343.  
  344.  
  345.         [InitializeOnLoadMethod]
  346.         static void InitAsposeLicense()
  347.         {
  348.             if (licenseInitiated) return;
  349.             var harmonyHook = new Harmony("Crack.Aspose");
  350.             harmonyHook.PatchAll();
  351.  
  352.             new Aspose.PSD.License().SetLicense(new MemoryStream(Convert.FromBase64String(AsposeLicenseKey)));
  353.             licenseInitiated = true;
  354.             harmonyHook.UnpatchAll();
  355.  
  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.         }
  393.  
  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.             }
  432.  
  433.             var prefabFile = GetPsdLayerPrefabPath(psdFile);
  434.             var rootName = Path.GetFileNameWithoutExtension(prefabFile);
  435.  
  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);
  448.  
  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.                 }
  456.  
  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.             }
  467.  
  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 };
  476.  
  477.                 for (int i = 0; i < psd.Layers.Length; i++)
  478.                 {
  479.                     var layer = psd.Layers[i];
  480.                     var curLayerType = layer.GetLayerType();
  481.  
  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);
  493.  
  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.         }
  528.  
  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.         }
  583.  
  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);
  595.  
  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;
  683.  
  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;
  692.  
  693.                 var goPath = GetGameObjectInstanceIdPath(uiHelper.gameObject, out var goNames);
  694.                 var parentNode = GetOrCreateNodeByInstanceIdPath(uiFormRoot, goPath, goNames);
  695.                 uiElement.transform.SetParent(parentNode.transform, true);
  696.  
  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.         }
  714.  
  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;
  728.  
  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.         }
  749.  
  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;
  754.  
  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();
  770.  
  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.                 }
  823.  
  824.                 texImporter.SaveAndReimport();
  825.             }
  826.         }
  827.  
  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;
  838.  
  839.             var compressMethod = compressTool.GetMethod("CompressImageOffline", new Type[] { typeof(string), typeof(string) });
  840.             if (compressMethod == null) return false;
  841.  
  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.         }
  852.  
  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;
  11.  
  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.         }
  24.  
  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;
  44.  
  45.                         (item as PsdLayerNode)?.ExportImageAsset();
  46.                     }
  47.                 }
  48.                 EditorGUILayout.EndHorizontal();
  49.             }
  50.             serializedObject.ApplyModifiedProperties();
  51.         }
  52.  
  53.         public override bool HasPreviewGUI()
  54.         {
  55.             var layerNode = (target as PsdLayerNode);
  56.             return layerNode != null && layerNode.PreviewTexture != null;
  57.         }
  58.  
  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;
  88.  
  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();
  118.  
  119.             if (triggerParseFunc)
  120.             {
  121.                 RefreshUIHelper(true);
  122.             }
  123.         }
  124.         public void RefreshUIHelper(bool refreshParent = false)
  125.         {
  126.             if (UIType == GUIType.Null) return;
  127.  
  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.             }
  205.  
  206.             return assetName;
  207.         }
  208.         public bool RefreshLayerTexture(bool forceRefresh = false)
  209.         {
  210.             if (!forceRefresh && PreviewTexture != null)
  211.             {
  212.                 return true;
  213.             }
  214.  
  215.             if (BindPsdLayer == null || BindPsdLayer.Disposed) return false;
  216.  
  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.         }
  231.  
  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;
  240.  
  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.             }
  256.  
  257.             //var bitmap = BindPsdLayer.ToBitmap();
  258.             //bitmap.Save(ms, System.Drawing.Imaging.ImageFormat.Png);
  259.  
  260.             var buffer = new byte[ms.Length];
  261.             ms.Position = 0;
  262.             ms.Read(buffer, 0, buffer.Length);
  263.  
  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.         }
  271.  
  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>();
  282.  
  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.         }
  310.  
  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;
  320.  
  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;
  352.  
  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.                 }
  362.  
  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. }
  392.  
  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;
  6.  
  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();
  22.  
  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;
  41.  
  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;
  52.  
  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.         }
  73.  
  74.     }
  75. }
  76. #endif

1. Text解析器：

  1. #if UNITY_EDITOR
  2. using UnityEngine;
  3.  
  4. namespace UGF.EditorTools.Psd2UGUI
  5. {
  6.     [DisallowMultipleComponent]
  7.     public class TextHelper : UIHelperBase
  8.     {
  9.         [SerializeField] PsdLayerNode text;
  10.  
  11.         public override PsdLayerNode[] GetDependencies()
  12.         {
  13.             return CalculateDependencies(text);
  14.         }
  15.  
  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.         }
  27.  
  28.         protected override void InitUIElements(GameObject uiRoot)
  29.         {
  30.             var textCom = uiRoot.GetComponentInChildren<UnityEngine.UI.Text>();
  31.             UGUIParser.SetTextStyle(text, textCom);
  32.  
  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;
  16.  
  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.                 }
  26.  
  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;
  3.  
  4. namespace UGF.EditorTools.Psd2UGUI
  5. {
  6.     [DisallowMultipleComponent]
  7.     public class ImageHelper : UIHelperBase
  8.     {
  9.         [SerializeField] PsdLayerNode image;
  10.  
  11.         public override PsdLayerNode[] GetDependencies()
  12.         {
  13.             return CalculateDependencies(image);
  14.         }
  15.  
  16.         public override void ParseAndAttachUIElements()
  17.         {
  18.             image = LayerNode;
  19.         }
  20.  
  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;
  11.  
  12.             Color32[] pixels = texture.GetPixels32();
  13.             int minX = width;
  14.             int minY = height;
  15.             int maxX = 0;
  16.             int maxY = 0;
  17.  
  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];
  25.  
  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.             }
  35.  
  36.             // 计算最优的borderSize
  37.             int borderSizeX = (maxX - minX) / 3;
  38.             int borderSizeY = (maxY - minY) / 3;
  39.             int borderSize = Mathf.Min(borderSizeX, borderSizeY);
  40.  
  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;
  46.  
  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);
  52.  
  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;
  4.  
  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.         }
  19.  
  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.         }
  28.  
  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;
  35.  
  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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/514936
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号