增加PSD2UGUI

Unity/Assets/PSD2UGUI.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: fbd4b8f46ec2cb94bad5f0bc1fc1ec7f
+folderAsset: yes
+timeCreated: 1498468878
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Doc.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: ff197d3006a211540b474e7c5b219f65
+folderAsset: yes
+timeCreated: 1484192848
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Doc/unity读取XML数据生成预设规则.doc.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4596d1816e9fa3e4ab7203eb5d39af0d
+timeCreated: 1484638882
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Doc/version.txt

@@ -0,0 +1,23 @@
+测试所用版本，unity 版本：5.3.3f1，ps版本：cs6 64位
+
+v1.0.2
+2017.02.06
+1.增加网格布局(GridLayoutGroup)组件的导出和生成
+2.增加滑动条(Slider)组件的导出和生成
+
+v1.0.1
+2017.01.22
+1.修改导出psd时的xml配置结构，改images层级为layer，ugui生成代码对应修改
+2.增加九宫格的导出，根据命名时的border值自动切九宫格图
+3.滑动列表（ScrollRect）的导出和生成，可动态布局滑动项,支持单行和单列，暂不支持grid
+
+v1.0.0
+2017.01.12
+1.正常文本的导出和生成
+2.静态文本和图片文本的导出和生成
+3.正常图片的导出和生成
+4.九宫格的生成，暂时无法从ps导出，还需手动切图
+5.RawImage的导出和生成
+6.对称图片切半的导出和生成
+7.公用图片的导出和生成
+8.按钮控件的导出和生成

Unity/Assets/PSD2UGUI/Doc/version.txt.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 44b8e0c4494fd1e47a4cbb503392f080
+timeCreated: 1484275479
+licenseType: Pro
+TextScriptImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Doc/使用说明及UI命名规则.docx.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 0de6096a71760b04fb2b2996752357f6
+timeCreated: 1484192848
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: d133ed2f8da01544faaa533b074a6ce0
+folderAsset: yes
+timeCreated: 1478827254
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/Const.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: a7ad3a9b419ab954f9a71b6523eff979
+folderAsset: yes
+timeCreated: 1478826124
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/Const/PSDImporterConst.cs

@@ -0,0 +1,43 @@
+using UnityEngine;
+using System.Collections;
+namespace PSDUIImporter
+{
+    public class PSDImporterConst
+    {
+        public const string BASE_FOLDER = "UI/";
+        public const string PNG_SUFFIX = ".png";
+        public const string Globle_BASE_FOLDER = "Assets/Textures/HomeCommon/";        //公用ui路径，按需修改
+        public const string Globle_FOLDER_NAME = "HomeCommon";
+
+        public const string RENDER = "Render";
+        public const string NINE_SLICE = "9Slice";
+        public const string IMAGE = "Image";
+
+        //字体路径，按需修改
+        public const string FONT_FOLDER = "Assets/PSD2UGUI/Font/";
+        public const string FONT_STATIC_FOLDER = "Assets/PSD2UGUI/Font/StaticFont/";
+        public const string FONT_SUFIX = ".ttf";
+
+        //修改资源模板加载路径，不能放在resources目录
+        public const string PSDUI_PATH = "Assets/PSD2UGUI/Template/UI/";
+        public const string PSDUI_SUFFIX = ".prefab";
+
+        public static string ASSET_PATH_EMPTY = PSDUI_PATH + "Empty" + PSDUI_SUFFIX;
+        public static string ASSET_PATH_BUTTON = PSDUI_PATH + "Button" + PSDUI_SUFFIX;
+        public static string ASSET_PATH_TOGGLE = PSDUI_PATH + "Toggle" + PSDUI_SUFFIX;
+        public static string ASSET_PATH_CANVAS = PSDUI_PATH + "Canvas" + PSDUI_SUFFIX;
+        public static string ASSET_PATH_EVENTSYSTEM = PSDUI_PATH + "EventSystem" + PSDUI_SUFFIX;
+        public static string ASSET_PATH_GRID = PSDUI_PATH + "Grid" + PSDUI_SUFFIX;
+        public static string ASSET_PATH_IMAGE = PSDUI_PATH + "Image" + PSDUI_SUFFIX;
+        public static string ASSET_PATH_RAWIMAGE = PSDUI_PATH + "RawImage" + PSDUI_SUFFIX;
+        public static string ASSET_PATH_HALFIMAGE = PSDUI_PATH + "HalfImage" + PSDUI_SUFFIX;
+        public static string ASSET_PATH_SCROLLVIEW = PSDUI_PATH + "ScrollView" + PSDUI_SUFFIX;
+        public static string ASSET_PATH_SLIDER = PSDUI_PATH + "Slider" + PSDUI_SUFFIX;
+        public static string ASSET_PATH_TEXT = PSDUI_PATH + "Text" + PSDUI_SUFFIX;
+        public static string ASSET_PATH_SCROLLBAR = PSDUI_PATH + "Scrollbar" + PSDUI_SUFFIX;
+        public static string ASSET_PATH_GROUP_V = PSDUI_PATH + "VerticalGroup" + PSDUI_SUFFIX;
+        public static string ASSET_PATH_GROUP_H = PSDUI_PATH + "HorizontalGroup" + PSDUI_SUFFIX;
+        public static string ASSET_PATH_INPUTFIELD = PSDUI_PATH + "InputField" + PSDUI_SUFFIX;
+        public static string ASSET_PATH_LAYOUTELEMENT = PSDUI_PATH + "LayoutElement" + PSDUI_SUFFIX;
+    }
+}

Unity/Assets/PSD2UGUI/Editor/Const/PSDImporterConst.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 2361049c1c17f46e0ae4fd7fac51b6a8
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Unity/Assets/PSD2UGUI/Editor/Core.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 7be1f86b28835d04aaab142bc3a0a610
+folderAsset: yes
+timeCreated: 1479091812
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/Core/PSDImportCtrl.cs

@@ -0,0 +1,347 @@
+using UnityEditor;
+using UnityEngine;
+using System.IO;
+#if UNITY_5_3
+using UnityEditor.SceneManagement;
+#endif
+
+namespace PSDUIImporter
+{
+    public class PSDImportCtrl
+    {
+        private PSDUI psdUI;
+
+        private IImageImport spriteImport;
+        private IImageImport textImport;
+        private IImageImport textureImport;
+        private IImageImport slicedSpriteImport;
+        private IImageImport halfSpriteImport;
+
+        private ILayerImport buttonImport;
+        private ILayerImport toggleImport;
+        private ILayerImport panelImport;
+        private ILayerImport scrollViewImport;
+        private ILayerImport scrollBarImport;
+        private ILayerImport sliderImport;
+        private ILayerImport gridImport;
+        private ILayerImport emptyImport;
+        private ILayerImport groupImport;
+        private ILayerImport inputFiledImport;
+        private ILayerImport layoutElemLayerImport;
+
+        public PSDImportCtrl(string xmlFilePath)
+        {
+            InitDataAndPath(xmlFilePath);
+            InitCanvas();
+            LoadLayers();
+            MoveLayers();
+            InitDrawers();
+            PSDImportUtility.ParentDic.Clear();
+        }
+
+        public void DrawLayer(Layer layer, GameObject parent)
+        {
+            switch (layer.type)
+            {
+                case LayerType.Panel:
+                    panelImport.DrawLayer(layer, parent);
+                    break;
+                case LayerType.Normal:
+                    emptyImport.DrawLayer(layer, parent);
+                    break;
+                case LayerType.Button:
+                    buttonImport.DrawLayer(layer, parent);
+                    break;
+                case LayerType.Toggle:
+                    toggleImport.DrawLayer(layer, parent);
+                    break;
+                case LayerType.Grid:
+                    gridImport.DrawLayer(layer, parent);
+                    break;
+                case LayerType.ScrollView:
+                    scrollViewImport.DrawLayer(layer, parent);
+                    break;
+                case LayerType.Slider:
+                    sliderImport.DrawLayer(layer, parent);
+                    break;
+                case LayerType.Group:
+                    groupImport.DrawLayer(layer, parent);
+                    break;
+                case LayerType.InputField:
+                    inputFiledImport.DrawLayer(layer, parent);
+                    break;
+                case LayerType.ScrollBar:
+                    scrollBarImport.DrawLayer(layer, parent);
+                    break;
+                case LayerType.LayoutElement:
+                    layoutElemLayerImport.DrawLayer(layer, parent);
+                    break;
+                default:
+                    break;
+
+            }
+        }
+
+        public void DrawLayers(Layer[] layers, GameObject parent)
+        {
+            if (layers != null)
+            {
+                for (int layerIndex = 0; layerIndex < layers.Length; layerIndex++)
+                {
+                    DrawLayer(layers[layerIndex], parent);
+                }
+            }
+        }
+
+        public void DrawImage(PSImage image, GameObject parent, GameObject ownObj = null)
+        {
+            switch (image.imageType)
+            {
+                case ImageType.Image:
+                    spriteImport.DrawImage(image, parent, parent);
+                    break;
+                case ImageType.Texture:
+                    textureImport.DrawImage(image, parent, parent);
+                    break;
+                case ImageType.Label:
+                    textImport.DrawImage(image, parent, parent);
+                    break;
+                case ImageType.SliceImage:
+                    slicedSpriteImport.DrawImage(image, parent, parent);
+                    break;
+                case ImageType.LeftHalfImage:
+                    halfSpriteImport.DrawImage(image, parent);
+                    break;
+                case ImageType.BottomHalfImage:
+                    halfSpriteImport.DrawImage(image, parent);
+                    break;
+                case ImageType.QuarterImage:
+                    halfSpriteImport.DrawImage(image, parent);
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        private void InitDataAndPath(string xmlFilePath)
+        {
+            psdUI = (PSDUI)PSDImportUtility.DeserializeXml(xmlFilePath, typeof(PSDUI));
+            Debug.Log(psdUI.psdSize.width + "=====psdSize======" + psdUI.psdSize.height);
+            if (psdUI == null)
+            {
+                Debug.Log("The file " + xmlFilePath + " wasn't able to generate a PSDUI.");
+                return;
+            }
+#if UNITY_5_2
+            if (EditorApplication.SaveCurrentSceneIfUserWantsTo() == false) { return; }
+#elif UNITY_5_3
+            if (EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo() == false) { return; }
+#endif
+            PSDImportUtility.baseFilename = Path.GetFileNameWithoutExtension(xmlFilePath);
+            PSDImportUtility.baseDirectory = "Assets/" + Path.GetDirectoryName(xmlFilePath.Remove(0, Application.dataPath.Length + 1)) + "/";
+        }
+
+        private void InitCanvas()
+        {
+#if UNITY_5_2
+            EditorApplication.NewScene();
+#elif UNITY_5_3
+            EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects);
+#endif
+            Canvas temp = AssetDatabase.LoadAssetAtPath(PSDImporterConst.ASSET_PATH_CANVAS, typeof(Canvas)) as Canvas;
+            PSDImportUtility.canvas = GameObject.Instantiate(temp) as Canvas;
+            PSDImportUtility.canvas.renderMode = RenderMode.ScreenSpaceOverlay;
+
+            UnityEngine.UI.CanvasScaler scaler = PSDImportUtility.canvas.GetComponent<UnityEngine.UI.CanvasScaler>();
+            scaler.screenMatchMode = UnityEngine.UI.CanvasScaler.ScreenMatchMode.MatchWidthOrHeight;
+            scaler.matchWidthOrHeight = 1f;
+            scaler.referenceResolution = new Vector2(psdUI.psdSize.width, psdUI.psdSize.height);
+
+            GameObject go = AssetDatabase.LoadAssetAtPath(PSDImporterConst.ASSET_PATH_EVENTSYSTEM, typeof(GameObject)) as GameObject;
+            PSDImportUtility.eventSys = GameObject.Instantiate(go) as GameObject;
+        }
+
+        private void LoadLayers()
+        {
+            for (int layerIndex = 0; layerIndex < psdUI.layers.Length; layerIndex++)
+            {
+                ImportLayer(psdUI.layers[layerIndex], PSDImportUtility.baseDirectory);
+            }
+        }
+
+        private void InitDrawers()
+        {
+            spriteImport = new SpriteImport();
+            textImport = new TextImport();
+            textureImport = new TextureImport();
+            slicedSpriteImport = new SliceSpriteImport();
+            halfSpriteImport = new HalfSpriteImport();
+
+
+            buttonImport = new ButtonLayerImport(this);
+            toggleImport = new ToggleLayerImport(this);
+            panelImport = new PanelLayerImport(this);
+            scrollViewImport = new ScrollViewLayerImport(this);
+            scrollBarImport = new ScrollBarLayerImport(this);
+            sliderImport = new SliderLayerImport(this);
+            gridImport = new GridLayerImport(this);
+            emptyImport = new DefultLayerImport(this);
+            groupImport = new GroupLayerImport(this);
+            inputFiledImport = new InputFieldLayerImport(this);
+            layoutElemLayerImport = new LayoutElementLayerImport(this);
+        }
+
+        public void BeginDrawUILayers()
+        {
+            RectTransform obj = PSDImportUtility.LoadAndInstant<RectTransform>(PSDImporterConst.ASSET_PATH_EMPTY, PSDImportUtility.baseFilename, PSDImportUtility.canvas.gameObject);
+            obj.offsetMin = Vector2.zero;
+            obj.offsetMax = Vector2.zero;
+            obj.anchorMin = Vector2.zero;
+            obj.anchorMax = Vector2.one;
+
+            for (int layerIndex = 0; layerIndex < psdUI.layers.Length; layerIndex++)
+            {
+                DrawLayer(psdUI.layers[layerIndex], obj.gameObject);
+            }
+            AssetDatabase.Refresh();
+        }
+
+        public void BeginSetUIParents()
+        {
+            foreach (var item in PSDImportUtility.ParentDic)
+            {
+                item.Key.SetParent(item.Value);
+            }
+        }
+
+
+        private void MoveLayers()
+        {
+            for (int layerIndex = 0; layerIndex < psdUI.layers.Length; layerIndex++)
+            {
+                MoveAsset(psdUI.layers[layerIndex], PSDImportUtility.baseDirectory);
+            }
+
+            AssetDatabase.Refresh();
+        }
+
+        //--------------------------------------------------------------------------
+        // private methods,按texture或image的要求导入图片到unity可加载的状态
+        //-------------------------------------------------------------------------
+
+        private void ImportLayer(Layer layer, string baseDirectory)
+        {
+            if (layer.image != null)
+            {
+                //for (int imageIndex = 0; imageIndex < layer.images.Length; imageIndex++)
+                //{
+                    // we need to fixup all images that were exported from PS
+                    //PSImage image = layer.images[imageIndex];
+                    PSImage image = layer.image;
+
+                    if (image.imageType != ImageType.Label)
+                    {
+                        string texturePathName = PSDImportUtility.baseDirectory + image.name + PSDImporterConst.PNG_SUFFIX;
+
+                        Debug.Log(texturePathName);
+                        // modify the importer settings
+                        TextureImporter textureImporter = AssetImporter.GetAtPath(texturePathName) as TextureImporter;
+
+                        if (textureImporter != null && image.imageType != ImageType.Texture)           //Texture类型不设置属性
+                        {
+                            textureImporter.textureType = TextureImporterType.Sprite;
+                            textureImporter.spriteImportMode = SpriteImportMode.Single;
+                            textureImporter.mipmapEnabled = false;          //默认关闭mipmap
+                            if(image.imageSource == ImageSource.Global)
+                            {
+                                textureImporter.spritePackingTag = PSDImporterConst.Globle_FOLDER_NAME;
+                            }
+                            else
+                            {
+                                textureImporter.spritePackingTag = PSDImportUtility.baseFilename;
+                            }
+                            
+                            textureImporter.maxTextureSize = 2048;
+
+                            if (image.imageType == ImageType.SliceImage)  //slice才需要设置border,可能需要根据实际修改border值
+                            {
+                                setSpriteBorder(textureImporter, image.arguments);
+                                //textureImporter.spriteBorder = new Vector4(3, 3, 3, 3);   // Set Default Slice type  UnityEngine.UI.Image's border to Vector4 (3, 3, 3, 3)
+                            }
+
+                            AssetDatabase.WriteImportSettingsIfDirty(texturePathName);
+                            AssetDatabase.ImportAsset(texturePathName);
+                        }              
+                    }
+                //}
+            }
+
+            if (layer.layers != null)
+            {
+                //LoadLayers();
+                for (int layerIndex = 0; layerIndex < layer.layers.Length; layerIndex++)
+                {
+                    ImportLayer(layer.layers[layerIndex], PSDImportUtility.baseDirectory);
+                }
+            }
+        }
+        //设置九宫格
+        void setSpriteBorder(TextureImporter textureImporter,string[] args)
+        {
+            textureImporter.spriteBorder = new Vector4(float.Parse(args[0]), float.Parse(args[1]), float.Parse(args[2]), float.Parse(args[3]));
+        }
+
+        //------------------------------------------------------------------
+        //when it's a common psd, then move the asset to special folder
+        //------------------------------------------------------------------
+        private void MoveAsset(Layer layer, string baseDirectory)
+        {
+            if (layer.image != null)
+            {
+                string newPath = PSDImporterConst.Globle_BASE_FOLDER;
+                if (layer.name == PSDImporterConst.IMAGE)
+                {
+                    newPath += PSDImporterConst.IMAGE + "/";
+                }
+                else if (layer.name == PSDImporterConst.NINE_SLICE)
+                {
+                    newPath += PSDImporterConst.NINE_SLICE + "/";
+                }
+
+                if (!System.IO.Directory.Exists(newPath))
+                {
+                    System.IO.Directory.CreateDirectory(newPath);
+                    Debug.Log("creating new folder : " + newPath);
+                }
+                
+                AssetDatabase.Refresh();
+
+                //for (int imageIndex = 0; imageIndex < layer.images.Length; imageIndex++)
+                //{
+                    // we need to fixup all images that were exported from PS
+                    PSImage image = layer.image;
+                    if(image.imageSource == ImageSource.Global)
+                    {
+                        string texturePathName = PSDImportUtility.baseDirectory + image.name + PSDImporterConst.PNG_SUFFIX;
+                        string targetPathName = newPath + image.name + PSDImporterConst.PNG_SUFFIX;
+
+                        if (File.Exists(texturePathName))
+                        {
+                            AssetDatabase.MoveAsset(texturePathName, targetPathName);
+                            Debug.Log(texturePathName);
+                            Debug.Log(targetPathName);
+                        }                           
+                    }                 
+                //}
+            }
+
+            if (layer.layers != null)
+            {
+                for (int layerIndex = 0; layerIndex < layer.layers.Length; layerIndex++)
+                {
+                    MoveAsset(layer.layers[layerIndex], PSDImportUtility.baseDirectory);
+                }
+            }
+        }
+    }
+}

Unity/Assets/PSD2UGUI/Editor/Core/PSDImportCtrl.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 4ad95c2c509fc48459d0661d0fbf9336
+timeCreated: 1478845085
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/Core/PSDImportMenu.cs

@@ -0,0 +1,32 @@
+using UnityEditor;
+using UnityEngine;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Xml;
+using System.Xml.Serialization;
+
+namespace PSDUIImporter
+{
+    //------------------------------------------------------------------------------
+    // class definition
+    //------------------------------------------------------------------------------
+    public class PSDImportMenu : Editor
+    {
+
+        [MenuItem("PSD2UGUI/PSDImport ...")]
+        static public void ImportHogSceneMenuItem()
+        {
+            string inputFile = EditorUtility.OpenFilePanel("Choose PSDUI File to Import", Application.dataPath, "xml");
+            if ((inputFile != null) && (inputFile != "") && (inputFile.StartsWith(Application.dataPath)))
+            {
+                PSDImportCtrl import = new PSDUIImporter.PSDImportCtrl(inputFile);
+                import.BeginDrawUILayers();
+                import.BeginSetUIParents();
+            }
+            GC.Collect();
+        }
+    }
+}

Unity/Assets/PSD2UGUI/Editor/Core/PSDImportMenu.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: b2a2d9b181de45540b7542840a0ddf6e
+timeCreated: 1478843516
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/Core/PSDImportUtility.cs

@@ -0,0 +1,92 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Xml;
+using System.Xml.Serialization;
+using UnityEditor;
+using UnityEngine;
+
+namespace PSDUIImporter
+{
+    public static class PSDImportUtility
+    {
+        public static string baseFilename;
+        public static string baseDirectory;
+        public static Canvas canvas;
+        public static GameObject eventSys;
+        public static readonly Dictionary<Transform, Transform> ParentDic = new Dictionary<Transform, Transform>();
+
+        public static object DeserializeXml(string filePath, System.Type type)
+        {
+            object instance = null;
+            StreamReader xmlFile = File.OpenText(filePath);
+            if (xmlFile != null)
+            {
+                string xml = xmlFile.ReadToEnd();
+                if ((xml != null) && (xml.ToString() != ""))
+                {
+                    XmlSerializer xs = new XmlSerializer(type);
+                    System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding();
+                    byte[] byteArray = encoding.GetBytes(xml);
+                    MemoryStream memoryStream = new MemoryStream(byteArray);
+                    XmlTextWriter xmlTextWriter = new XmlTextWriter(memoryStream, System.Text.Encoding.UTF8);
+                    if (xmlTextWriter != null)
+                    {
+                        instance = xs.Deserialize(memoryStream);
+                    }
+                }
+            }
+            xmlFile.Close();
+            return instance;
+        }
+
+//         public static T InstantiateItem<T>(string resourcePatn, string name,GameObject parent) where T : UnityEngine.Object
+//         {
+//             GameObject temp = Resources.Load(resourcePatn, typeof(GameObject)) as GameObject;
+//             GameObject item = GameObject.Instantiate(temp) as GameObject;
+//             item.name = name;
+//             item.transform.SetParent(canvas.transform, false);
+//             ParentDic[item.transform] =  parent.transform;
+//             return item.GetComponent<T>();
+//         }
+
+        /// <summary>
+        /// 加载并实例化prefab，编辑器下不用Resources.Load，否则这些预设会打到安装包
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="assetPath">assets全路径，带后缀</param>
+        /// <param name="name"></param>
+        /// <param name="parent"></param>
+        /// <returns></returns>
+        public static T LoadAndInstant<T>(string assetPath, string name, GameObject parent) where T : UnityEngine.Object
+        {
+            GameObject temp = AssetDatabase.LoadAssetAtPath(assetPath, typeof(GameObject)) as GameObject;
+            GameObject item = GameObject.Instantiate(temp) as GameObject;
+            if(item == null)
+            {
+                Debug.LogError("LoadAndInstant asset failed : " + assetPath);
+                return null;
+            }
+            item.name = name;
+            //item.transform.SetParent(parent.transform);
+            item.transform.SetParent(canvas.transform, false);
+            ParentDic[item.transform] = parent.transform;
+            item.transform.localScale = Vector3.one;
+            return item.GetComponent<T>();
+        }
+
+        public static void SetAnchorMiddleCenter(RectTransform rectTransform)
+        {
+            if (rectTransform == null)
+            {
+                Debug.LogWarning("rectTransform is null...");
+                return;
+            }
+            rectTransform.offsetMin = new Vector2(0.5f, 0.5f);
+            rectTransform.offsetMax = new Vector2(0.5f, 0.5f);
+            rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
+            rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
+        }
+
+    }
+}

Unity/Assets/PSD2UGUI/Editor/Core/PSDImportUtility.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 2e7148f00bdc30f48a4437d9be51886d
+timeCreated: 1478843267
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/Data.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 1a15e9ab1a4d33c4ab71e5993c42e91c
+folderAsset: yes
+timeCreated: 1478825293
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/Data/Image.cs

@@ -0,0 +1,15 @@
+using System;
+using UnityEngine;
+namespace PSDUIImporter
+{
+    public class PSImage
+    {
+        public ImageType imageType;
+        public ImageSource imageSource;
+        public string name;
+        public Position position;
+        public Size size;
+
+        public string[] arguments;
+    }
+}

Unity/Assets/PSD2UGUI/Editor/Data/Image.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 14789b8ca1d156648bd9fe7517c31dc6
+timeCreated: 1478825616
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/Data/Layer.cs

@@ -0,0 +1,21 @@
+using System;
+using UnityEngine;
+using UnityEngine.Events;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace PSDUIImporter
+{
+    public class Layer
+    {
+        public string name;
+        public LayerType type;
+        public Layer[] layers;
+        public string[] arguments;
+        //public PSImage[] images;
+        public PSImage image;
+        public Size size;
+        public Position position;
+    }
+}
+

Unity/Assets/PSD2UGUI/Editor/Data/Layer.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 61b590b44beade947bb2e39fb663c3ff
+timeCreated: 1478825408
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/Data/PSDUI.cs

@@ -0,0 +1,15 @@
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.Events;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace PSDUIImporter
+{
+    public class PSDUI
+    {
+        public Size psdSize;
+        public Layer[] layers;
+    }
+}

Unity/Assets/PSD2UGUI/Editor/Data/PSDUI.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: a01e67100d0c1c149ace0b2f2d641874
+timeCreated: 1478825844
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/Data/Position.cs

@@ -0,0 +1,14 @@
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.Events;
+using System.Collections;
+using System.Collections.Generic;
+namespace PSDUIImporter
+{
+    public class Position
+    {
+        public float x;
+        public float y;
+    }
+}

Unity/Assets/PSD2UGUI/Editor/Data/Position.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 748459ad37bc6064cace0d208d7e6a14
+timeCreated: 1478825966
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/Data/Size.cs

@@ -0,0 +1,14 @@
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.Events;
+using System.Collections;
+using System.Collections.Generic;
+namespace PSDUIImporter
+{
+    public class Size
+    {
+        public float width;
+        public float height;
+    }
+}

Unity/Assets/PSD2UGUI/Editor/Data/Size.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 475e79c444641ce4c948570eccbb8a7e
+timeCreated: 1478825947
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/Effects.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: e18df75f59f8bd347992ad8b532ca0a8
+folderAsset: yes
+timeCreated: 1486174641
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/Effects/MirrorEditor.cs

@@ -0,0 +1,66 @@
+using System.Collections;
+using UnityEditor;
+using UnityEditor.AnimatedValues;
+using UnityEngine;
+using UnityEngine.UI;
+
+/// <summary>
+///
+/// name:MirrorEditor
+/// author:Administrator
+/// date:2017/2/4 10:18:04
+/// versions:
+/// introduce:
+/// note:
+/// 
+/// </summary>
+namespace UGUI.Effects
+{
+    [CustomEditor(typeof(Mirror), true)]
+    [CanEditMultipleObjects]
+    public class MirrorEditor : Editor
+    {
+        protected SerializedProperty m_MirrorType;
+
+        private GUIContent m_CorrectButtonContent;
+        private GUIContent m_MirrorTypeContent;
+
+        protected virtual void OnDisable()
+        {
+            
+        }
+
+        protected virtual void OnEnable()
+        {
+            m_CorrectButtonContent = new GUIContent("Set Native Size", "Sets the size to match the content.");
+
+            m_MirrorTypeContent = new GUIContent("Mirror Type");
+
+            m_MirrorType = serializedObject.FindProperty("m_MirrorType");
+        }
+
+        public override void OnInspectorGUI()
+        {
+            EditorGUILayout.PropertyField(m_MirrorType, m_MirrorTypeContent);
+
+            if (GUILayout.Button(m_CorrectButtonContent, EditorStyles.miniButton))
+            {
+                int len = targets.Length;
+
+                for (int i = 0; i < len; i++)
+                {
+                    if (targets[i] is Mirror)
+                    {
+                        Mirror mirror = targets[i] as Mirror;
+
+                        Undo.RecordObject(mirror.rectTransform, "Set Native Size");
+                        mirror.SetNativeSize();
+                        EditorUtility.SetDirty(mirror);
+                    }
+                }
+            }
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

Unity/Assets/PSD2UGUI/Editor/Effects/MirrorEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 7f38fce6b2a9a7a4cba217bee3a8ec37
+timeCreated: 1486174738
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/Enum.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 91a845b7f20e75142b973b2cab83e528
+folderAsset: yes
+timeCreated: 1478826118
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/Enum/ImageSource.cs

@@ -0,0 +1,15 @@
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.Events;
+using System.Collections;
+using System.Collections.Generic;
+namespace PSDUIImporter
+{
+    public enum ImageSource
+    {
+        Common,
+        Custom,
+        Global
+    }
+}

Unity/Assets/PSD2UGUI/Editor/Enum/ImageSource.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 09e892510b9e11c40b8796141336cf46
+timeCreated: 1478825711
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/Enum/ImageType.cs

@@ -0,0 +1,20 @@
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.Events;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace PSDUIImporter
+{
+    public enum ImageType
+    {
+        Image,
+        Texture,
+        Label,
+        SliceImage,
+        LeftHalfImage,
+        BottomHalfImage,
+        QuarterImage,
+    }
+}

Unity/Assets/PSD2UGUI/Editor/Enum/ImageType.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 8d9e50b5e575f3f4da7f4249426d3321
+timeCreated: 1478825763
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/Enum/LayerType.cs

@@ -0,0 +1,25 @@
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.Events;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace PSDUIImporter
+{
+    public enum LayerType
+    {
+        Panel,
+        Normal,
+        ScrollView,
+        Grid,
+        Button,
+        Lable,
+        Toggle,
+        Slider,
+        Group,
+        InputField,
+        ScrollBar,
+        LayoutElement,
+    }
+}

Unity/Assets/PSD2UGUI/Editor/Enum/LayerType.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 41142419e48957744bf4b44b9d1c06aa
+timeCreated: 1478825583
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/ImageImports.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 74380596d48513a488b90e8ddd8836f1
+folderAsset: yes
+timeCreated: 1478845021
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/ImageImports/HalfSpriteImport.cs

@@ -0,0 +1,65 @@
+using System;
+using UnityEngine;
+using UnityEditor;
+using UnityEngine.UI;
+using UnityEngine.Events;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace PSDUIImporter
+{
+    //只有一半的图片的生成类，需要组合拼接
+    public class HalfSpriteImport : IImageImport
+    {
+        public void DrawImage(PSImage image, GameObject parent, GameObject ownObj = null)
+        {
+            RectTransform halfRectTrans = parent.GetComponent<RectTransform>();
+
+            //2017.1.20注：因为已经修改为layer会创建gameobject，所以不再需要加载预设,直接在parent下组装即可
+            //创建一个节点存放两张半图  
+            //var halfRectTrans = PSDImportUtility.LoadAndInstant<RectTransform>(PSDImporterConst.ASSET_PATH_HALFIMAGE, image.name, parent);
+            PSDImportUtility.SetAnchorMiddleCenter(halfRectTrans);
+            halfRectTrans.sizeDelta = new Vector2(image.size.width, image.size.height);
+            halfRectTrans.anchoredPosition = new Vector2(image.position.x, image.position.y);
+
+            UnityEngine.UI.Image leftOrUpSprite = PSDImportUtility.LoadAndInstant<UnityEngine.UI.Image>(PSDImporterConst.ASSET_PATH_IMAGE, image.name, halfRectTrans.gameObject);
+
+            string assetPath = "";
+            if (image.imageSource == ImageSource.Common || image.imageSource == ImageSource.Custom)
+            {
+                assetPath = PSDImportUtility.baseDirectory + image.name + PSDImporterConst.PNG_SUFFIX;
+            }
+            else
+            {
+                assetPath = PSDImporterConst.Globle_BASE_FOLDER + image.name.Replace(".", "/") + PSDImporterConst.PNG_SUFFIX;
+            }
+
+            Sprite sprite = AssetDatabase.LoadAssetAtPath(assetPath, typeof(Sprite)) as Sprite;
+            if (sprite == null)
+            {
+                Debug.Log("loading asset at path: " + assetPath);
+            }
+
+            leftOrUpSprite.sprite = sprite;
+            RectTransform lOrURectTrans = leftOrUpSprite.GetComponent<RectTransform>();
+            lOrURectTrans.anchoredPosition = new Vector2(image.position.x, image.position.y);
+
+            //添加镜像组件
+            var mirror = lOrURectTrans.gameObject.AddComponent<UGUI.Effects.Mirror>();
+            if (image.imageType == ImageType.BottomHalfImage)
+            {
+                mirror.mirrorType = UGUI.Effects.Mirror.MirrorType.Vertical;
+            }
+            else if (image.imageType == ImageType.LeftHalfImage)
+            {
+                mirror.mirrorType = UGUI.Effects.Mirror.MirrorType.Horizontal;                
+            }
+            else if (image.imageType == ImageType.QuarterImage)
+            {
+                mirror.mirrorType = UGUI.Effects.Mirror.MirrorType.Quarter;
+            }
+            mirror.SetNativeSize();
+            
+        }
+    }
+}

Unity/Assets/PSD2UGUI/Editor/ImageImports/HalfSpriteImport.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 33f72c9ad0af98f489432a3b2edafa0b
+timeCreated: 1484103566
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/ImageImports/SliceSpriteImport.cs

@@ -0,0 +1,46 @@
+using System;
+using UnityEngine;
+using UnityEditor;
+using UnityEngine.Events;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace PSDUIImporter
+{
+    public class SliceSpriteImport : IImageImport
+    {
+        public void DrawImage(PSImage image, GameObject parent, GameObject ownObj)
+        {
+            //UnityEngine.UI.Image pic = AssetDatabase.LoadAssetAtPath(PSDImporterConst.PREFAB_PATH_IMAGE, typeof(UnityEngine.UI.Image)) as UnityEngine.UI.Image;
+            //string commonImagePath = PSDImporterConst.Globle_BASE_FOLDER + image.name.Replace(".", "/") + PSDImporterConst.PNG_SUFFIX;
+            //Debug.Log("==  CommonImagePath  ====" + commonImagePath);
+            //Sprite sprite = AssetDatabase.LoadAssetAtPath(commonImagePath, typeof(Sprite)) as Sprite;
+
+            UnityEngine.UI.Image pic;
+            if (ownObj != null)
+                pic = ownObj.AddComponent<UnityEngine.UI.Image>();
+            else
+                pic = PSDImportUtility.LoadAndInstant<UnityEngine.UI.Image>(PSDImporterConst.ASSET_PATH_IMAGE, image.name, parent);
+
+            RectTransform rectTransform = pic.GetComponent<RectTransform>();
+            PSDImportUtility.SetAnchorMiddleCenter(rectTransform);
+            string assetPath = PSDImportUtility.baseDirectory + image.name + PSDImporterConst.PNG_SUFFIX;
+            Sprite sprite = AssetDatabase.LoadAssetAtPath(assetPath, typeof(Sprite)) as Sprite;
+            if (sprite == null)
+            {
+                Debug.Log("loading asset at path: " + PSDImportUtility.baseDirectory + image.name);
+            }
+
+            //string assetPath = PSDImportUtility.baseDirectory + image.name + PSDImporterConst.PNG_SUFFIX;
+            //Sprite sprite = AssetDatabase.LoadAssetAtPath(assetPath, typeof(Sprite)) as Sprite;
+            //UnityEngine.UI.Image myImage = GameObject.Instantiate(pic) as UnityEngine.UI.Image;
+
+            pic.sprite = sprite;
+            pic.type = UnityEngine.UI.Image.Type.Sliced;
+
+            //RectTransform rectTransform = pic.GetComponent<RectTransform>();
+            rectTransform.sizeDelta = new Vector2(image.size.width, image.size.height);
+            rectTransform.anchoredPosition = new Vector2(image.position.x, image.position.y);
+        }
+    }
+}

Unity/Assets/PSD2UGUI/Editor/ImageImports/SliceSpriteImport.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: f7e7145c125548944bcb482a5f88eefc
+timeCreated: 1478847268
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/ImageImports/SpriteImport.cs

@@ -0,0 +1,76 @@
+using System;
+using UnityEngine;
+using UnityEditor;
+using UnityEngine.UI;
+using UnityEngine.Events;
+using System.Collections;
+using System.Collections.Generic;
+
+
+
+namespace PSDUIImporter
+{
+    public class SpriteImport : IImageImport
+    {
+        public void DrawImage(PSImage image, GameObject parent, GameObject ownObj = null)
+        {
+            if (image.imageSource == ImageSource.Common || image.imageSource == ImageSource.Custom)
+            {
+                UnityEngine.UI.Image pic;
+                if (ownObj != null)
+                    pic = ownObj.AddComponent<UnityEngine.UI.Image>();
+                else
+                    pic = PSDImportUtility.LoadAndInstant<UnityEngine.UI.Image>(PSDImporterConst.ASSET_PATH_IMAGE, image.name, parent);
+
+                RectTransform rectTransform = pic.GetComponent<RectTransform>();
+                rectTransform.offsetMin = new Vector2(0.5f, 0.5f);
+                rectTransform.offsetMax = new Vector2(0.5f, 0.5f);
+                rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
+                rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
+
+                string assetPath = PSDImportUtility.baseDirectory + image.name + PSDImporterConst.PNG_SUFFIX;
+                Sprite sprite = AssetDatabase.LoadAssetAtPath(assetPath, typeof(Sprite)) as Sprite;
+
+                if (sprite == null)
+                {
+                    Debug.Log("loading asset at path: " + PSDImportUtility.baseDirectory + image.name);
+                }
+
+                pic.sprite = sprite;
+
+                rectTransform.sizeDelta = new Vector2(image.size.width, image.size.height);
+                rectTransform.anchoredPosition = new Vector2(image.position.x, image.position.y);
+            }
+            else if (image.imageSource == ImageSource.Global)
+            {
+                UnityEngine.UI.Image pic;
+                if (ownObj != null)
+                    pic = ownObj.AddComponent<UnityEngine.UI.Image>();
+                else
+                    pic = PSDImportUtility.LoadAndInstant<UnityEngine.UI.Image>(PSDImporterConst.ASSET_PATH_IMAGE, image.name, parent); 
+
+                RectTransform rectTransform = pic.GetComponent<RectTransform>();
+                rectTransform.offsetMin = new Vector2(0.5f, 0.5f);
+                rectTransform.offsetMax = new Vector2(0.5f, 0.5f);
+                rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
+                rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
+
+                string commonImagePath = PSDImporterConst.Globle_BASE_FOLDER + image.name.Replace(".", "/") + PSDImporterConst.PNG_SUFFIX;
+                Debug.Log("==  CommonImagePath  ====" + commonImagePath);
+                Sprite sprite = AssetDatabase.LoadAssetAtPath(commonImagePath, typeof(Sprite)) as Sprite;
+                pic.sprite = sprite;
+
+                pic.name = image.name;
+
+                if (image.imageType == ImageType.SliceImage)
+                {
+                    pic.type = UnityEngine.UI.Image.Type.Sliced;
+                }
+
+                //RectTransform rectTransform = pic.GetComponent<RectTransform>();
+                rectTransform.sizeDelta = new Vector2(image.size.width, image.size.height);
+                rectTransform.anchoredPosition = new Vector2(image.position.x, image.position.y);
+            }
+        }
+    }
+}

Unity/Assets/PSD2UGUI/Editor/ImageImports/SpriteImport.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: c9df3e026e17e904e93a396386b100de
+timeCreated: 1478843833
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/ImageImports/TextImport.cs

@@ -0,0 +1,123 @@
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.Events;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace PSDUIImporter
+{
+    //arguments[]: color,font,fontSize,text,alignment
+    public class TextImport : IImageImport
+    {
+        public void DrawImage(PSImage image, GameObject parent, GameObject ownObj = null)
+        {
+            UnityEngine.UI.Text myText;
+            if (ownObj != null)
+                myText = ownObj.AddComponent<UnityEngine.UI.Text>();
+            else
+                myText = PSDImportUtility.LoadAndInstant<UnityEngine.UI.Text>(PSDImporterConst.ASSET_PATH_TEXT, image.name, parent);
+
+            RectTransform rectTransform = myText.GetComponent<RectTransform>();
+            rectTransform.offsetMin = new Vector2(0.5f, 0.5f);
+            rectTransform.offsetMax = new Vector2(0.5f, 0.5f);
+            rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
+            rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
+
+            //UnityEngine.UI.Text myText = PSDImportUtility.LoadAndInstant<Text>(PSDImporterConst.ASSET_PATH_TEXT, image.name, parent);
+            //                        myText.color = image.arguments[0];
+            //                        myText.font = image.arguments[1];
+            Debug.Log("Label Color : " + image.arguments[0]);
+            Debug.Log("fontSize : " + image.arguments[2]);
+
+            Color color;
+            if (UnityEngine.ColorUtility.TryParseHtmlString(("#" + image.arguments[0]), out color))
+            {
+                myText.color = color;
+            }
+            else
+            {
+                Debug.Log(image.arguments[0]);
+            }
+
+            float size;
+            if (float.TryParse(image.arguments[2], out size))
+            {
+                myText.fontSize = (int)size;
+            }
+
+            myText.text = image.arguments[3];
+
+            //设置字体,注意unity中的字体名需要和导出的xml中的一致
+            string fontFolder;
+            
+            if(image.arguments[1].ToLower().Contains("static"))
+            {
+                fontFolder = PSDImporterConst.FONT_STATIC_FOLDER;
+            }
+            else
+            {
+                fontFolder = fontFolder = PSDImporterConst.FONT_FOLDER; 
+            }
+            string fontFullName = fontFolder + image.arguments[1] + PSDImporterConst.FONT_SUFIX;
+            Debug.Log("font name ; " + fontFullName);
+            var font = AssetDatabase.LoadAssetAtPath(fontFullName, typeof(Font)) as Font;
+            if (font == null)
+            {
+                Debug.LogWarning("Load font failed : " + fontFullName);
+            }
+            else
+            {
+                myText.font = font;
+            }
+            //ps的size在unity里面太小，文本会显示不出来,暂时选择溢出
+            myText.verticalOverflow = VerticalWrapMode.Overflow;
+            myText.horizontalOverflow = HorizontalWrapMode.Overflow;
+            //设置对齐
+            if (image.arguments.Length >= 5)
+                myText.alignment = ParseAlignmentPS2UGUI(image.arguments[4]);
+
+            rectTransform.sizeDelta = new Vector2(image.size.width, image.size.height);
+            rectTransform.anchoredPosition = new Vector2(image.position.x, image.position.y);
+        }
+
+        /// <summary>
+        /// ps的对齐转换到ugui，暂时只做水平的对齐
+        /// </summary>
+        /// <param name="justification"></param>
+        /// <returns></returns>
+        public TextAnchor ParseAlignmentPS2UGUI(string justification)
+        {
+            var defaut = TextAnchor.MiddleCenter;
+            if (string.IsNullOrEmpty(justification))
+            {
+                return defaut;
+            }
+
+            string[] temp = justification.Split('.');
+            if (temp.Length != 2)
+            {
+                Debug.LogWarning("ps exported justification is error !");
+                return defaut;
+            }
+            Justification justi = (Justification)System.Enum.Parse(typeof(Justification), temp[1]);
+            int index = (int)justi;
+            defaut = (TextAnchor)System.Enum.ToObject(typeof(TextAnchor), index);;
+
+            return defaut;
+        }
+
+        //ps的对齐方式
+        public enum Justification
+        {       
+            CENTERJUSTIFIED = 0,
+            LEFTJUSTIFIED = 1,
+            RIGHTJUSTIFIED = 2,          
+            LEFT = 3,
+            CENTER = 4,
+            RIGHT = 5,
+            FULLYJUSTIFIED = 6,
+        }
+    }
+}

Unity/Assets/PSD2UGUI/Editor/ImageImports/TextImport.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 30956e66724a95f44a5254fc6e67685f
+timeCreated: 1478843796
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/ImageImports/TextureImport.cs

@@ -0,0 +1,35 @@
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.Events;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace PSDUIImporter
+{
+    public class TextureImport : IImageImport
+    {
+        public void DrawImage(PSImage image, GameObject parent, GameObject ownObj = null)
+        {
+            UnityEngine.UI.RawImage pic;
+            if (ownObj != null)
+                pic = ownObj.AddComponent<UnityEngine.UI.RawImage>();
+            else
+                pic = PSDImportUtility.LoadAndInstant<UnityEngine.UI.RawImage>(PSDImporterConst.ASSET_PATH_RAWIMAGE, image.name, parent);
+            
+            string assetPath = PSDImportUtility.baseDirectory + image.name + PSDImporterConst.PNG_SUFFIX;
+            Texture2D texture = AssetDatabase.LoadAssetAtPath(assetPath, typeof(Texture2D)) as Texture2D;
+            if (texture == null)
+            {
+                Debug.Log("loading asset at path: " + PSDImportUtility.baseDirectory + image.name);
+            }
+
+            pic.texture = texture as Texture;
+            RectTransform rectTransform = pic.GetComponent<RectTransform>();
+            PSDImportUtility.SetAnchorMiddleCenter(rectTransform);
+            rectTransform.sizeDelta = new Vector2(image.size.width, image.size.height);
+            rectTransform.anchoredPosition = new Vector2(image.position.x, image.position.y);
+        }
+    }
+}

Unity/Assets/PSD2UGUI/Editor/ImageImports/TextureImport.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 55243d337e5401d4a9ba6237dafc6ca2
+timeCreated: 1478843841
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/Interface.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 70a16ed2643234b468b677c4ff6e5c0c
+folderAsset: yes
+timeCreated: 1478843166
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/Interface/IImageImport.cs

@@ -0,0 +1,15 @@
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.Events;
+using System.Collections;
+using System.Collections.Generic;
+
+
+namespace PSDUIImporter
+{
+    public interface IImageImport
+    {
+        void DrawImage(PSImage image, GameObject parent, GameObject ownObj = null);
+    }
+}

Unity/Assets/PSD2UGUI/Editor/Interface/IImageImport.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 4f7cbd8a0291a0740aa4d2731c245e7b
+timeCreated: 1478843149
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/Interface/ILayerImport.cs

@@ -0,0 +1,15 @@
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.Events;
+using System.Collections;
+using System.Collections.Generic;
+
+
+namespace PSDUIImporter
+{
+    public interface ILayerImport
+    {
+        void DrawLayer(Layer layer, GameObject parent);
+    }
+}

Unity/Assets/PSD2UGUI/Editor/Interface/ILayerImport.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 3cccecbaec608ee4eb8402e243793bff
+timeCreated: 1478843159
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/LayerImport.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 2853b5233eee4e041a77980fbf545788
+folderAsset: yes
+timeCreated: 1478845046
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/LayerImport/ButtonLayerImport.cs

@@ -0,0 +1,117 @@
+using System;
+using UnityEngine;
+using UnityEditor;
+using UnityEngine.Events;
+using System.Collections;
+using System.Collections.Generic;
+
+
+namespace PSDUIImporter
+{
+    public class ButtonLayerImport : ILayerImport
+    {
+        PSDImportCtrl ctrl;
+        public ButtonLayerImport(PSDImportCtrl ctrl)
+        {
+            this.ctrl = ctrl;
+        }
+
+        public void DrawLayer(Layer layer, GameObject parent)
+        {
+            UnityEngine.UI.Button button = PSDImportUtility.LoadAndInstant<UnityEngine.UI.Button>(PSDImporterConst.ASSET_PATH_BUTTON, layer.name, parent);
+
+            if (layer.layers != null)
+            {
+                for (int imageIndex = 0; imageIndex < layer.layers.Length; imageIndex++)
+                {
+                    PSImage image = layer.layers[imageIndex].image;
+                    string lowerName = image.name.ToLower();
+                    if (image.imageType != ImageType.Label && image.imageType != ImageType.Texture)
+                    {
+                        if (image.imageSource == ImageSource.Custom || image.imageSource == ImageSource.Common)
+                        {
+                            string assetPath = PSDImportUtility.baseDirectory + image.name + PSDImporterConst.PNG_SUFFIX;
+                            Sprite sprite = AssetDatabase.LoadAssetAtPath(assetPath, typeof(Sprite)) as Sprite;
+
+                            if (image.name.ToLower().Contains("normal"))
+                            {
+                                button.image.sprite = sprite;                                
+                                RectTransform rectTransform = button.GetComponent<RectTransform>();
+                                rectTransform.sizeDelta = new Vector2(image.size.width, image.size.height);
+                                rectTransform.anchoredPosition = new Vector2(image.position.x, image.position.y);
+
+                                adjustButtonBG(image.imageType,button);
+                            }
+                            else if (image.name.ToLower().Contains("pressed"))
+                            {
+                                button.transition = UnityEngine.UI.Selectable.Transition.SpriteSwap;
+                                UnityEngine.UI.SpriteState state = button.spriteState;
+                                state.pressedSprite = sprite;
+                                button.spriteState = state;
+                            }
+                            else if (image.name.ToLower().Contains("disabled"))
+                            {
+                                button.transition = UnityEngine.UI.Selectable.Transition.SpriteSwap;
+                                UnityEngine.UI.SpriteState state = button.spriteState;
+                                state.disabledSprite = sprite;
+                                button.spriteState = state;
+                            }
+                            else if (image.name.ToLower().Contains("highlighted"))
+                            {
+                                button.transition = UnityEngine.UI.Selectable.Transition.SpriteSwap;
+                                UnityEngine.UI.SpriteState state = button.spriteState;
+                                state.highlightedSprite = sprite;
+                                button.spriteState = state;
+                            }
+                        }
+                    }
+                    else
+                    {
+                        //ctrl.DrawImage(image, button.gameObject);
+                        ctrl.DrawLayer(layer.layers[imageIndex], button.gameObject);
+                    }
+                }
+            }
+
+        }
+
+        //调整按钮背景
+        private void adjustButtonBG(ImageType imageType,UnityEngine.UI.Button button)
+        {
+            if (imageType == ImageType.SliceImage)
+            {
+                button.image.type = UnityEngine.UI.Image.Type.Sliced;
+            }
+            else if (imageType == ImageType.LeftHalfImage)
+            {
+                var mirror = button.gameObject.AddComponent<UGUI.Effects.Mirror>();
+                mirror.mirrorType = UGUI.Effects.Mirror.MirrorType.Horizontal;
+                mirror.SetNativeSize();
+            }
+            else if (imageType == ImageType.BottomHalfImage)
+            {
+                var mirror = button.gameObject.AddComponent<UGUI.Effects.Mirror>();
+                mirror.mirrorType = UGUI.Effects.Mirror.MirrorType.Vertical;
+                mirror.SetNativeSize();
+            }
+            else if (imageType == ImageType.QuarterImage)
+            {
+                var mirror = button.gameObject.AddComponent<UGUI.Effects.Mirror>();
+                mirror.mirrorType = UGUI.Effects.Mirror.MirrorType.Quarter;
+                mirror.SetNativeSize();
+            }
+        }
+    }
+
+
+    [ExecuteInEditMode]
+    public class PosLoader : MonoBehaviour
+    {
+        public Vector2 worldPos;
+        void Start()
+        {
+            transform.position = worldPos;
+            DestroyImmediate(this);
+        }
+    }
+}

Unity/Assets/PSD2UGUI/Editor/LayerImport/ButtonLayerImport.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: e93f1d08e65133148972f2a1860dfffd
+timeCreated: 1478843854
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/LayerImport/DefultLayerImport.cs

@@ -0,0 +1,42 @@
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.Events;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace PSDUIImporter
+{
+    public class DefultLayerImport : ILayerImport
+    {
+        PSDImportCtrl ctrl;
+        public DefultLayerImport(PSDImportCtrl ctrl)
+        {
+            this.ctrl = ctrl;
+        }
+        public void DrawLayer(Layer layer, GameObject parent)
+        {
+            RectTransform obj = PSDImportUtility.LoadAndInstant<RectTransform>(PSDImporterConst.ASSET_PATH_EMPTY, layer.name, parent);
+            obj.offsetMin = Vector2.zero;
+            obj.offsetMax = Vector2.zero;
+            obj.anchorMin = Vector2.zero;
+            obj.anchorMax = Vector2.one;
+
+            RectTransform rectTransform = parent.GetComponent<RectTransform>();
+            obj.sizeDelta = rectTransform.sizeDelta;
+            obj.anchoredPosition = rectTransform.anchoredPosition;
+
+            if (layer.image != null)
+            {
+                //for (int imageIndex = 0; imageIndex < layer.images.Length; imageIndex++)
+                //{
+                    PSImage image = layer.image;
+                    ctrl.DrawImage(image, obj.gameObject);
+                //}
+            }
+
+            ctrl.DrawLayers(layer.layers, obj.gameObject);
+            //obj.transform.SetParent(parent.transform, false); //parent.transform;
+        }
+    }
+}

Unity/Assets/PSD2UGUI/Editor/LayerImport/DefultLayerImport.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: bc3cbfefdd8d3d6449af4d4c4632745a
+timeCreated: 1478846666
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/LayerImport/DropDownLayerImport.cs

@@ -0,0 +1,22 @@
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.Events;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace PSDUIImporter
+{
+    public class DropDownLayerImport : ILayerImport
+    {
+        PSDImportCtrl ctrl;
+        public DropDownLayerImport(PSDImportCtrl ctrl)
+        {
+            this.ctrl = ctrl;
+        }
+        public void DrawLayer(Layer layer, GameObject parent)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

Unity/Assets/PSD2UGUI/Editor/LayerImport/DropDownLayerImport.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 301ba37bb5ea7a84f9b6991aa924c818
+timeCreated: 1478846440
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/LayerImport/GridLayerImport.cs

@@ -0,0 +1,39 @@
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.Events;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace PSDUIImporter
+{
+    //arguments:行数,列数,render width, render height,spacingx ,spacingy
+    public class GridLayerImport : ILayerImport
+    {
+        PSDImportCtrl ctrl;
+        public GridLayerImport(PSDImportCtrl ctrl)
+        {
+            this.ctrl = ctrl;
+        }
+        public void DrawLayer(Layer layer, GameObject parent)
+        {
+            UnityEngine.UI.GridLayoutGroup gridLayoutGroup = PSDImportUtility.LoadAndInstant<UnityEngine.UI.GridLayoutGroup>(PSDImporterConst.ASSET_PATH_GRID, layer.name, parent);            
+
+            RectTransform rectTransform = gridLayoutGroup.GetComponent<RectTransform>();
+            rectTransform.sizeDelta = new Vector2(layer.size.width, layer.size.height);
+            rectTransform.anchoredPosition = new Vector2(layer.position.x, layer.position.y);
+
+            gridLayoutGroup.padding = new RectOffset();
+
+            float width, height;
+            if (float.TryParse(layer.arguments[2], out width) && float.TryParse(layer.arguments[3], out height))
+            {
+                gridLayoutGroup.cellSize = new Vector2(width, height);
+            }         
+            gridLayoutGroup.spacing = new Vector2(System.Convert.ToInt32(layer.arguments[4]), System.Convert.ToInt32(layer.arguments[5]));
+
+            ctrl.DrawLayers(layer.layers, gridLayoutGroup.gameObject);
+        }
+    }
+}

Unity/Assets/PSD2UGUI/Editor/LayerImport/GridLayerImport.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 4ea435b6610587d46b46ead2ad1c2246
+timeCreated: 1478846629
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/LayerImport/GroupLayerImport.cs

@@ -0,0 +1,48 @@
+using System;
+using UnityEditor;
+using UnityEngine;
+
+namespace PSDUIImporter
+{
+    internal class GroupLayerImport : ILayerImport
+    {
+        private PSDImportCtrl pSDImportCtrl;
+
+        public GroupLayerImport(PSDImportCtrl pSDImportCtrl)
+        {
+            this.pSDImportCtrl = pSDImportCtrl;
+        }
+
+        public void DrawLayer(Layer layer, GameObject parent)
+        {
+            GameObject temp;
+            string type = layer.arguments[0].ToUpper();
+            switch (type.ToUpper())
+            {
+                case "V":
+                    temp = AssetDatabase.LoadAssetAtPath(PSDImporterConst.ASSET_PATH_GROUP_V, typeof(GameObject)) as GameObject;
+                    break;
+                case "H":
+                    temp = AssetDatabase.LoadAssetAtPath(PSDImporterConst.ASSET_PATH_GROUP_H, typeof(GameObject)) as GameObject;
+                    break;
+                default:
+                    return;
+            }
+
+            UnityEngine.UI.HorizontalOrVerticalLayoutGroup group = GameObject.Instantiate(temp).GetComponent<UnityEngine.UI.HorizontalOrVerticalLayoutGroup>();//as UnityEngine.UI.HorizontalOrVerticalLayoutGroup;
+            group.transform.SetParent(parent.transform, false); //parent = parent.transform;
+
+            RectTransform rectTransform = group.GetComponent<RectTransform>();
+            rectTransform.sizeDelta = new Vector2(layer.size.width, layer.size.height);
+            rectTransform.anchoredPosition = new Vector2(layer.position.x, layer.position.y);
+
+            float span;
+            if (float.TryParse(layer.arguments[1],out span))
+            {
+                group.spacing = span;
+            }
+
+            pSDImportCtrl.DrawLayers(layer.layers, group.gameObject);
+        }
+    }
+}

Unity/Assets/PSD2UGUI/Editor/LayerImport/GroupLayerImport.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 0a8f54787a6ee6743bd77844d5a7deef
+timeCreated: 1478852430
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/LayerImport/InputFieldLayerImport.cs

@@ -0,0 +1,82 @@
+using System;
+using UnityEngine;
+using UnityEditor;
+
+namespace PSDUIImporter
+{
+    internal class InputFieldLayerImport : ILayerImport
+    {
+        private PSDImportCtrl pSDImportCtrl;
+
+        public InputFieldLayerImport(PSDImportCtrl pSDImportCtrl)
+        {
+            this.pSDImportCtrl = pSDImportCtrl;
+        }
+
+        public void DrawLayer(Layer layer, GameObject parent)
+        {
+            UnityEngine.UI.InputField temp = AssetDatabase.LoadAssetAtPath(PSDImporterConst.ASSET_PATH_INPUTFIELD, typeof(UnityEngine.UI.InputField)) as UnityEngine.UI.InputField;
+            UnityEngine.UI.InputField inputfield = GameObject.Instantiate(temp) as UnityEngine.UI.InputField;
+            inputfield.transform.SetParent(parent.transform, false);//.parent = parent.transform;
+            inputfield.name = layer.name;
+
+            if (layer.image != null)
+            {
+                //for (int imageIndex = 0; imageIndex < layer.images.Length; imageIndex++)
+                //{
+                    PSImage image = layer.image;
+
+                    if (image.imageType == ImageType.Label)
+                    {
+                        if (image.name.ToLower().Contains("text"))
+                        {
+                            UnityEngine.UI.Text text = (UnityEngine.UI.Text)inputfield.textComponent;//inputfield.transform.Find("Text").GetComponent<UnityEngine.UI.Text>();
+                            Color color;
+                            if (UnityEngine.ColorUtility.TryParseHtmlString(("#" + image.arguments[0]), out color))
+                            {
+                                text.color = color;
+                            }
+
+                            int size;
+                            if (int.TryParse(image.arguments[2], out size))
+                            {
+                                text.fontSize = size;
+                            }
+                        }
+                        else if (image.name.ToLower().Contains("holder"))
+                        {
+                            UnityEngine.UI.Text text = (UnityEngine.UI.Text)inputfield.placeholder;//.transform.Find("Placeholder").GetComponent<UnityEngine.UI.Text>();
+                            Color color;
+                            if (UnityEngine.ColorUtility.TryParseHtmlString(("#" + image.arguments[0]), out color))
+                            {
+                                text.color = color;
+                            }
+
+                            int size;
+                            if (int.TryParse(image.arguments[2], out size))
+                            {
+                                text.fontSize = size;
+                            }
+                        }
+                    }
+                    else
+                    {
+                        if (image.name.ToLower().Contains("background"))
+                        {
+                            if (image.imageSource == ImageSource.Common || image.imageSource == ImageSource.Custom)
+                            {
+                                string assetPath = PSDImportUtility.baseDirectory + image.name + PSDImporterConst.PNG_SUFFIX;
+                                Sprite sprite = AssetDatabase.LoadAssetAtPath(assetPath, typeof(Sprite)) as Sprite;
+                                inputfield.image.sprite = sprite;
+
+                                RectTransform rectTransform = inputfield.GetComponent<RectTransform>();
+                                rectTransform.sizeDelta = new Vector2(image.size.width, image.size.height);
+                                rectTransform.anchoredPosition = new Vector2(image.position.x, image.position.y);
+                            }
+                        }
+                    }
+                //}
+            }
+        }
+    }
+}

Unity/Assets/PSD2UGUI/Editor/LayerImport/InputFieldLayerImport.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: ad317b052ccb81146a4b34688b6b1006
+timeCreated: 1478855612
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/LayerImport/LayoutElementLayerImport.cs

@@ -0,0 +1,42 @@
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.Events;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace PSDUIImporter
+{
+
+    public class LayoutElementLayerImport : ILayerImport
+    {
+        PSDImportCtrl ctrl;
+        public LayoutElementLayerImport(PSDImportCtrl ctrl)
+        {
+            this.ctrl = ctrl;
+        }
+        public void DrawLayer(Layer layer, GameObject parent)
+        {
+            RectTransform obj = PSDImportUtility.LoadAndInstant<RectTransform>(PSDImporterConst.ASSET_PATH_LAYOUTELEMENT, layer.name, parent);
+            RectTransform rectTransform = parent.GetComponent<RectTransform>();
+            obj.sizeDelta = new Vector2(layer.size.width, layer.size.height);
+            obj.anchoredPosition = new Vector2(layer.position.x, layer.position.y);
+
+            var le = obj.GetComponent<LayoutElement>();
+            le.preferredWidth = layer.size.width;
+            le.preferredHeight = layer.size.height;
+
+            if (layer.image != null)
+            {
+                //for (int imageIndex = 0; imageIndex < layer.layers.Length; imageIndex++)
+                //{
+                    PSImage image = layer.image;
+                    ctrl.DrawImage(image, obj.gameObject);
+                //}
+            }
+
+            ctrl.DrawLayers(layer.layers, obj.gameObject);
+            //obj.transform.SetParent(parent.transform, false); //parent.transform;
+        }
+    }
+}

Unity/Assets/PSD2UGUI/Editor/LayerImport/LayoutElementLayerImport.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 2d2536e1b49773c4aae68a01443fc97c
+timeCreated: 1484551655
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/LayerImport/PanelLayerImport.cs

@@ -0,0 +1,51 @@
+using System;
+using UnityEngine;
+using UnityEditor;
+using UnityEngine.UI;
+using UnityEngine.Events;
+using System.Collections;
+using System.Collections.Generic;
+namespace PSDUIImporter
+{
+    public class PanelLayerImport : ILayerImport
+    {
+        PSDImportCtrl ctrl;
+        public PanelLayerImport(PSDImportCtrl ctrl)
+        {
+            this.ctrl = ctrl;
+        }
+
+        public void DrawLayer(Layer layer, GameObject parent)
+        {
+            //UnityEngine.UI.Image temp = AssetDatabase.LoadAssetAtPath(PSDImporterConst.PREFAB_PATH_IMAGE, typeof(UnityEngine.UI.Image)) as UnityEngine.UI.Image;
+            UnityEngine.UI.Image panel = PSDImportUtility.LoadAndInstant<UnityEngine.UI.Image>(PSDImporterConst.ASSET_PATH_IMAGE, layer.name, parent);//GameObject.Instantiate(temp) as UnityEngine.UI.Image;
+
+            panel.name = layer.name;
+
+            ctrl.DrawLayers(layer.layers, panel.gameObject);//子节点
+
+            //for (int i = 0; i < layer.images.Length; i++)
+            //{
+                PSImage image = layer.image;
+
+                if (image.name.ToLower().Contains("background"))
+                {
+                    string assetPath = PSDImportUtility.baseDirectory + image.name + PSDImporterConst.PNG_SUFFIX;
+                    Sprite sprite = AssetDatabase.LoadAssetAtPath(assetPath, typeof(Sprite)) as Sprite;
+                    panel.sprite = sprite;
+
+                    RectTransform rectTransform = panel.GetComponent<RectTransform>();
+                    rectTransform.sizeDelta = new Vector2(image.size.width, image.size.height);
+                    rectTransform.anchoredPosition = new Vector2(image.position.x, image.position.y);
+
+                    //panel.transform.SetParent(parent.transform, false); //parent = parent.transform;
+                }
+                else
+                {
+                    ctrl.DrawImage(image, panel.gameObject);
+                }
+            //}
+
+        }
+    }
+}

Unity/Assets/PSD2UGUI/Editor/LayerImport/PanelLayerImport.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 3c17117d4c907f34c8fa8b1a5ca3beed
+timeCreated: 1478846287
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/LayerImport/ScrollBarLayerImport.cs

@@ -0,0 +1,71 @@
+using System;
+using UnityEngine;
+using UnityEditor;
+using UnityEngine.UI;
+using UnityEngine.Events;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace PSDUIImporter
+{
+    public class ScrollBarLayerImport : ILayerImport
+    {
+        PSDImportCtrl ctrl;
+        public ScrollBarLayerImport(PSDImportCtrl ctrl)
+        {
+            this.ctrl = ctrl;
+        }
+        public void DrawLayer(Layer layer, GameObject parent)
+        {
+            UnityEngine.UI.Scrollbar temp = AssetDatabase.LoadAssetAtPath(PSDImporterConst.ASSET_PATH_SCROLLBAR, typeof(UnityEngine.UI.Scrollbar)) as UnityEngine.UI.Scrollbar;
+            UnityEngine.UI.Scrollbar scrollBar = GameObject.Instantiate(temp) as UnityEngine.UI.Scrollbar;
+            scrollBar.transform.SetParent(parent.transform, false); //parent = parent.transform;
+
+            string type = layer.arguments[0].ToUpper();
+            switch (type)
+            {
+                case "R":
+                    scrollBar.direction = Scrollbar.Direction.RightToLeft;
+                    break;
+                case "L":
+                    scrollBar.direction = Scrollbar.Direction.LeftToRight;
+                    break;
+                case "T":
+                    scrollBar.direction = Scrollbar.Direction.TopToBottom;
+                    break;
+                case "B":
+                    scrollBar.direction = Scrollbar.Direction.BottomToTop;
+                    break;
+                default:
+                    break;
+            }
+
+            float pecent;
+            if (float.TryParse(layer.arguments[1], out pecent))
+            {
+                scrollBar.size = pecent;
+            }
+
+
+            //for (int i = 0; i < layer.images.Length; i++)
+            //{
+                PSImage image = layer.image;
+                string assetPath = PSDImportUtility.baseDirectory + image.name + PSDImporterConst.PNG_SUFFIX; Debug.Log("==  CommonImagePath  ====" + assetPath);
+                Sprite sprite = AssetDatabase.LoadAssetAtPath(assetPath, typeof(Sprite)) as Sprite;
+
+                if (image.name.ToLower().Contains("background"))
+                {
+                    scrollBar.GetComponent<UnityEngine.UI.Image>().sprite = sprite;
+                    RectTransform rectTransform = scrollBar.GetComponent<RectTransform>();
+
+                    rectTransform.sizeDelta = new Vector2(image.size.width, image.size.height);
+                    rectTransform.anchoredPosition = new Vector2(image.position.x, image.position.y);
+                }
+                else if (image.name.ToLower().Contains("handle"))
+                {
+                    scrollBar.handleRect.GetComponent<UnityEngine.UI.Image>().sprite = sprite;
+                }
+            //}
+        }
+    }
+}

Unity/Assets/PSD2UGUI/Editor/LayerImport/ScrollBarLayerImport.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: fe23793912ae8a84ea0410425001b185
+timeCreated: 1478846410
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/LayerImport/ScrollViewLayerImport.cs

@@ -0,0 +1,130 @@
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.Events;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace PSDUIImporter
+{
+    public class ScrollViewLayerImport : ILayerImport
+    {
+        PSDImportCtrl ctrl;
+        public ScrollViewLayerImport(PSDImportCtrl ctrl)
+        {
+            this.ctrl = ctrl;
+        }
+        public void DrawLayer(Layer layer, GameObject parent)
+        {
+            //UnityEngine.UI.ScrollRect temp = AssetDatabase.LoadAssetAtPath(PSDImporterConst.PREFAB_PATH_SCROLLVIEW, typeof(UnityEngine.UI.ScrollRect)) as UnityEngine.UI.ScrollRect;
+            UnityEngine.UI.ScrollRect scrollRect = PSDImportUtility.LoadAndInstant<UnityEngine.UI.ScrollRect>(PSDImporterConst.ASSET_PATH_SCROLLVIEW, layer.name, parent);
+            //scrollRect.transform.SetParent(parent.transform, false); //parent = parent.transform;
+
+
+            RectTransform rectTransform = scrollRect.GetComponent<RectTransform>();
+            rectTransform.sizeDelta = new Vector2(layer.size.width, layer.size.height);
+            rectTransform.anchoredPosition = new Vector2(layer.position.x, layer.position.y);
+
+            if (layer.layers != null)
+            {
+                string type = layer.arguments[0].ToUpper();
+                switch (type)
+                {
+                    case "V":
+                        //scrollRect.vertical = true;
+                        //scrollRect.horizontal = false;
+                        BuildVerticalScrollView(scrollRect, layer);
+                        break;
+                    case "H":
+                        //scrollRect.vertical = false;
+                        //scrollRect.horizontal = true;
+                        BuildHorizonScrollView(scrollRect, layer);
+                        break;
+                    default:
+                        break;
+                }
+
+                ctrl.DrawLayers(layer.layers, scrollRect.content.gameObject);
+            }
+        }
+
+        /// <summary>
+        /// 构建水平滑动，主要是添加自动布局
+        /// </summary>
+        /// <param name="scrollRect"></param>
+        /// <param name="layer"></param>
+        public void BuildHorizonScrollView(UnityEngine.UI.ScrollRect scrollRect,Layer layer)
+        {
+            scrollRect.vertical = false;
+            scrollRect.horizontal = true;
+
+            //水平默认从左向右滑动
+            scrollRect.content.anchorMin = Vector2.zero;
+            scrollRect.content.anchorMax = new Vector2(0,1);
+            scrollRect.content.pivot = new Vector2(0,0.5f);         //锚定左侧，否则动态增长时会从两边添加cell
+           
+            var contentSizeFilter = scrollRect.content.GetComponent<ContentSizeFitter>();
+            contentSizeFilter.horizontalFit = ContentSizeFitter.FitMode.PreferredSize;
+            contentSizeFilter.verticalFit = ContentSizeFitter.FitMode.PreferredSize;
+
+            var hLayout = scrollRect.content.gameObject.AddComponent<HorizontalLayoutGroup>();  //添加水平布局组件
+            if (layer.arguments.Length < 4)
+            {
+                Debug.LogWarning("ScrollView arguments error !");
+            }
+            else
+            {
+                float spacing;
+                if (float.TryParse(layer.arguments[1], out spacing))
+                {
+                    hLayout.spacing = spacing;
+                }
+                int left, top;
+                if (int.TryParse(layer.arguments[2], out left) && int.TryParse(layer.arguments[3], out top))
+                {
+                    hLayout.padding = new RectOffset(left, left, top, top);
+                }
+            }                      
+        }
+
+        /// <summary>
+        /// 构建垂直滑动
+        /// </summary>
+        /// <param name="scrollRect"></param>
+        /// <param name="layer"></param>
+        public void BuildVerticalScrollView(UnityEngine.UI.ScrollRect scrollRect, Layer layer)
+        {
+            scrollRect.vertical = true;
+            scrollRect.horizontal = false;
+
+            //垂直默认从上向下滑动
+            scrollRect.content.anchorMin = new Vector2(0,1);
+            scrollRect.content.anchorMax = Vector2.one;
+            scrollRect.content.pivot = new Vector2(0.5f, 1);         //锚定上侧，否则动态增长时会从两边添加cell
+
+            var contentSizeFilter = scrollRect.content.GetComponent<ContentSizeFitter>();
+            contentSizeFilter.horizontalFit = ContentSizeFitter.FitMode.PreferredSize;
+            contentSizeFilter.verticalFit = ContentSizeFitter.FitMode.PreferredSize;
+
+            var vLayout = scrollRect.content.gameObject.AddComponent<VerticalLayoutGroup>();  //添加水平布局组件
+            if (layer.arguments.Length < 4)
+            {
+                Debug.LogWarning("ScrollView arguments error !");
+            }
+            else
+            {
+                float spacing;
+                if (float.TryParse(layer.arguments[1], out spacing))
+                {
+                    vLayout.spacing = spacing;
+                }
+                int left, top;
+                if (int.TryParse(layer.arguments[2], out left) && int.TryParse(layer.arguments[3], out top))
+                {
+                    vLayout.padding = new RectOffset(left, left, top, top);
+                }
+            }
+        }
+
+    }
+}

Unity/Assets/PSD2UGUI/Editor/LayerImport/ScrollViewLayerImport.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: a09716bb0cfa1244fad68cad325cb686
+timeCreated: 1478846362
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/LayerImport/SliderLayerImport.cs

@@ -0,0 +1,91 @@
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.Events;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+namespace PSDUIImporter
+{
+    public class SliderLayerImport : ILayerImport
+    {
+        PSDImportCtrl ctrl;
+        public SliderLayerImport(PSDImportCtrl ctrl)
+        {
+            this.ctrl = ctrl;
+        }
+        public void DrawLayer(Layer layer, GameObject parent)
+        {
+            //UnityEngine.UI.Slider temp = AssetDatabase.LoadAssetAtPath(PSDImporterConst.PREFAB_PATH_SLIDER, typeof(UnityEngine.UI.Slider)) as UnityEngine.UI.Slider;
+            UnityEngine.UI.Slider slider = PSDImportUtility.LoadAndInstant<UnityEngine.UI.Slider>(PSDImporterConst.ASSET_PATH_SLIDER, layer.name, parent); //GameObject.Instantiate(temp) as UnityEngine.UI.Slider;
+
+            RectTransform rectTransform = slider.GetComponent<RectTransform>();
+            rectTransform.sizeDelta = new Vector2(layer.size.width, layer.size.height);
+            rectTransform.anchoredPosition = new Vector2(layer.position.x, layer.position.y);
+
+            //slider.transform.SetParent(parent.transform, true); //parent = parent.transform;
+
+            PosLoader posloader = slider.gameObject.AddComponent<PosLoader>();
+            posloader.worldPos = rectTransform.position;
+
+            string type = layer.arguments[0].ToUpper();
+            switch (type)
+            {
+                case "R":
+                    slider.direction = Slider.Direction.RightToLeft;
+                    break;
+                case "L":
+                    slider.direction = Slider.Direction.LeftToRight;
+                    break;
+                case "T":
+                    slider.direction = Slider.Direction.TopToBottom;
+                    break;
+                case "B":
+                    slider.direction = Slider.Direction.BottomToTop;
+                    break;
+                default:
+                    break;
+            }
+
+            for (int i = 0; i < layer.layers.Length; i++)
+            {
+                PSImage image = layer.layers[i].image;
+                string assetPath = PSDImportUtility.baseDirectory + image.name + PSDImporterConst.PNG_SUFFIX;
+                Sprite sprite = AssetDatabase.LoadAssetAtPath(assetPath, typeof(Sprite)) as Sprite;
+
+                if (image.name.ToLower().Contains("bg"))
+                {
+                    var bgRect = slider.transform.Find("Background").GetComponent<RectTransform>();
+                    var bgImage = bgRect.GetComponent<UnityEngine.UI.Image>();
+                    if (image.imageType != ImageType.SliceImage)
+                    {
+                        bgImage.type = Image.Type.Simple;
+                    }
+                    bgImage.sprite = sprite;
+                    bgRect.sizeDelta = new Vector2(image.size.width, image.size.height);
+                }
+                else if (image.name.ToLower().Contains("fill"))
+                {
+                    var fillImage = slider.fillRect.GetComponent<UnityEngine.UI.Image>();
+                    if (image.imageType != ImageType.SliceImage)
+                    {
+                        fillImage.type = Image.Type.Simple;
+                    }
+                    fillImage.sprite = sprite;
+
+                    var fillArea = slider.transform.Find("Fill Area").GetComponent<RectTransform>();
+                    fillArea.sizeDelta = new Vector2(image.size.width, image.size.height);
+                }
+                else if (image.name.ToLower().Contains("handle"))       //默认没有handle
+                {
+                    var handleRectTrans = slider.transform.Find("Handle Slide Area/Handle").GetComponent<RectTransform>();
+                    var handleSprite = handleRectTrans.GetComponent<UnityEngine.UI.Image>();
+                    slider.handleRect = handleRectTrans;
+                    handleSprite.sprite = sprite;
+
+                    handleRectTrans.gameObject.SetActive(true);
+                }
+            }
+        }
+    }
+}

Unity/Assets/PSD2UGUI/Editor/LayerImport/SliderLayerImport.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: da09ea19ec2225d4e9c196f80a460c63
+timeCreated: 1478846312
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Editor/LayerImport/ToggleLayerImport.cs

@@ -0,0 +1,63 @@
+using System;
+using UnityEngine;
+using UnityEditor;
+using UnityEngine.Events;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace PSDUIImporter
+{
+    public class ToggleLayerImport : ILayerImport
+    {
+        PSDImportCtrl ctrl;
+        public ToggleLayerImport(PSDImportCtrl ctrl)
+        {
+            this.ctrl = ctrl;
+        }
+        public void DrawLayer(Layer layer, GameObject parent)
+        {
+            //UnityEngine.UI.Toggle temp = AssetDatabase.LoadAssetAtPath(PSDImporterConst.PREFAB_PATH_TOGGLE, typeof(UnityEngine.UI.Toggle)) as UnityEngine.UI.Toggle;
+            UnityEngine.UI.Toggle toggle = PSDImportUtility.LoadAndInstant<UnityEngine.UI.Toggle>(PSDImporterConst.ASSET_PATH_TOGGLE, layer.name, parent);// GameObject.Instantiate(temp) as UnityEngine.UI.Toggle;
+
+            if (layer.image != null)
+            {
+                //for (int imageIndex = 0; imageIndex < layer.images.Length; imageIndex++)
+                //{
+                    PSImage image = layer.image;
+
+                    if (image.name.ToLower().Contains("background"))
+                    {
+                        if (image.imageSource == ImageSource.Common || image.imageSource == ImageSource.Custom)
+                        {
+                            string assetPath = PSDImportUtility.baseDirectory + image.name + PSDImporterConst.PNG_SUFFIX;
+                            Sprite sprite = AssetDatabase.LoadAssetAtPath(assetPath, typeof(Sprite)) as Sprite;
+                            toggle.image.sprite = sprite;
+
+                            RectTransform rectTransform = toggle.GetComponent<RectTransform>();
+                            rectTransform.sizeDelta = new Vector2(image.size.width, image.size.height);
+                            rectTransform.anchoredPosition = new Vector2(image.position.x, image.position.y);
+
+                            //rectTransform.SetParent(parent.transform, true);
+
+                            //PosLoader posloader = toggle.gameObject.AddComponent<PosLoader>();
+                            //posloader.worldPos = rectTransform.position;
+                        }
+                    }
+                    else if (image.name.ToLower().Contains("mask"))
+                    {
+                        if (image.imageSource == ImageSource.Common || image.imageSource == ImageSource.Custom)
+                        {
+                            string assetPath = PSDImportUtility.baseDirectory + image.name + PSDImporterConst.PNG_SUFFIX;
+                            Sprite sprite = AssetDatabase.LoadAssetAtPath(assetPath, typeof(Sprite)) as Sprite;
+                            toggle.graphic.GetComponent<UnityEngine.UI.Image>().sprite = sprite;
+                        }
+                    }
+                    else
+                    {
+                        ctrl.DrawImage(image, toggle.graphic.gameObject);
+                    }
+                //}
+            }
+        }
+    }
+}

Unity/Assets/PSD2UGUI/Editor/LayerImport/ToggleLayerImport.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 3bb33cb09345fea43b2fc6d175a88a4d
+timeCreated: 1478843864
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Effects.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: c94ee146760c26148966c68256cac8e0
+folderAsset: yes
+timeCreated: 1494918440
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Effects/Collections.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 277e80768a15caa46be2c67982a993aa
+folderAsset: yes
+timeCreated: 1494918526
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Effects/Collections/ListPool.cs

@@ -0,0 +1,20 @@
+using System.Collections;
+using System.Collections.Generic;
+
+namespace UGUI.Collections
+{
+    internal static class ListPool<T>
+    {
+        private static readonly Pool<List<T>> _listPool = new Pool<List<T>>(null, l => l.Clear());
+
+        public static List<T> Get()
+        {
+            return _listPool.Get();
+        }
+
+        public static void Recycle(List<T> element)
+        {
+            _listPool.Recycle(element);
+        }
+    }
+}

Unity/Assets/PSD2UGUI/Effects/Collections/ListPool.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: e45925eea4a843246be53091a0caaaea
+timeCreated: 1487670266
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Effects/Collections/Pool.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace UGUI.Collections
+{
+    internal class Pool<T> where T : new()
+    {
+        private readonly Stack<T> _stack = new Stack<T>();
+
+        private readonly Action<T> _actionOnGet;
+
+        private readonly Action<T> _actionOnRecycle;
+
+        public int count { get; private set; }
+        public int activeCount { get { return count - inactiveCount; } }
+        public int inactiveCount { get { return _stack.Count; } }
+
+        public Pool(Action<T> actionOnGet, Action<T> actionOnRecycle)
+        {
+            _actionOnGet = actionOnGet;
+            _actionOnRecycle = actionOnRecycle;
+        }
+
+        public T Get()
+        {
+            T element;
+            if (_stack.Count == 0)
+            {
+                element = new T();
+                count++;
+            }
+            else
+            {
+                element = _stack.Pop();
+            }
+            if (_actionOnGet != null)
+                _actionOnGet(element);
+            return element;
+        }
+
+        public void Recycle(T element)
+        {
+            if (_stack.Count > 0 && ReferenceEquals(_stack.Peek(), element))
+            {
+                throw new Exception("Internal error. Trying to destroy object that is already released to pool.");
+            }
+
+            if (_actionOnRecycle != null)
+            {
+                _actionOnRecycle(element);
+            }
+            _stack.Push(element);
+        }
+
+        public void Clear()
+        {
+            _stack.Clear();
+            count = 0;
+        }
+    }
+}

Unity/Assets/PSD2UGUI/Effects/Collections/Pool.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 7bf865b41b11e2146ae2b0bf6a0f8596
+timeCreated: 1487670263
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Effects/Mirror.cs

@@ -0,0 +1,392 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Sprites;
+using UnityEngine.UI;
+using UGUI.Collections;
+
+namespace UGUI.Effects
+{
+    [AddComponentMenu("UI/Effects/Mirror", 20)]
+    [RequireComponent(typeof(Graphic))]
+    public class Mirror : BaseMeshEffect
+    {
+        public enum MirrorType
+        {
+            /// <summary>
+            /// 水平
+            /// </summary>
+            Horizontal, 
+
+            /// <summary>
+            /// 垂直
+            /// </summary>
+            Vertical,
+
+            /// <summary>
+            /// 四分之一
+            /// 相当于水平，然后再垂直
+            /// </summary>
+            Quarter,
+        }
+
+        /// <summary>
+        /// 镜像类型
+        /// </summary>
+        [SerializeField]
+        private MirrorType m_MirrorType = MirrorType.Horizontal;
+
+        public MirrorType mirrorType
+        {
+            get { return m_MirrorType; }
+            set
+            {
+                if (m_MirrorType != value)
+                {
+                    m_MirrorType = value;
+                    if(graphic != null){
+                        graphic.SetVerticesDirty();
+                    }
+                }
+            }
+        }
+
+        [NonSerialized]
+        private RectTransform m_RectTransform;
+
+        public RectTransform rectTransform
+        {
+            get { return m_RectTransform ?? (m_RectTransform = GetComponent<RectTransform>()); }
+        }
+
+        /// <summary>
+        /// 设置原始尺寸
+        /// </summary>
+        public void SetNativeSize()
+        {
+            if (graphic != null && graphic is Image)
+            {
+                Sprite overrideSprite = (graphic as Image).overrideSprite;
+
+                if(overrideSprite != null){
+                    float w = overrideSprite.rect.width / (graphic as Image).pixelsPerUnit;
+                    float h = overrideSprite.rect.height / (graphic as Image).pixelsPerUnit;
+                    rectTransform.anchorMax = rectTransform.anchorMin;
+
+                    switch (m_MirrorType)
+                    {
+                        case MirrorType.Horizontal:
+                            rectTransform.sizeDelta = new Vector2(w * 2, h);
+                            break;
+                        case MirrorType.Vertical:
+                            rectTransform.sizeDelta = new Vector2(w, h * 2);
+                            break;
+                        case MirrorType.Quarter:
+                            rectTransform.sizeDelta = new Vector2(w * 2, h * 2);
+                            break;
+                    }
+
+                    graphic.SetVerticesDirty();
+                }
+            }
+        }
+
+        public override void ModifyMesh(VertexHelper vh)
+        {
+            if (!IsActive())
+            {
+                return;
+            }
+
+            var output = ListPool<UIVertex>.Get();
+            vh.GetUIVertexStream(output);
+
+            int count = output.Count;
+
+            if (graphic is Image)
+            {
+                Image.Type type = (graphic as Image).type;
+
+                switch (type)
+                {
+                    case Image.Type.Simple:
+                        DrawSimple(output, count);
+                        break;
+                    case Image.Type.Sliced:
+                        DrawSliced(output, count);
+                        break;
+                    case Image.Type.Tiled:
+                        
+                        break;
+                    case Image.Type.Filled:
+
+                        break;
+                }
+            }
+            else
+            {
+                DrawSimple(output, count);
+            }
+
+            vh.Clear();
+            vh.AddUIVertexTriangleStream(output);
+
+            ListPool<UIVertex>.Recycle(output);
+        }
+
+        /// <summary>
+        /// 绘制Simple版
+        /// </summary>
+        /// <param name="output"></param>
+        /// <param name="count"></param>
+        protected void DrawSimple(List<UIVertex> output, int count)
+        {
+            Rect rect = graphic.GetPixelAdjustedRect();
+
+            SimpleScale(rect, output, count);
+
+            switch (m_MirrorType)
+            {
+                case MirrorType.Horizontal:
+                    ExtendCapacity(output, count);
+                    MirrorVerts(rect, output, count, true);
+                    break;
+                case MirrorType.Vertical:
+                    ExtendCapacity(output, count);
+                    MirrorVerts(rect, output, count, false);
+                    break;
+                case MirrorType.Quarter:
+                    ExtendCapacity(output, count * 3);
+                    MirrorVerts(rect, output, count, true);
+                    MirrorVerts(rect, output, count * 2, false);
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// 绘制Sliced版
+        /// </summary>
+        /// <param name="output"></param>
+        /// <param name="count"></param>
+        protected void DrawSliced(List<UIVertex> output, int count)
+        {
+            if (!(graphic as Image).hasBorder)
+            {
+                DrawSimple(output, count);
+            }
+
+            Rect rect = graphic.GetPixelAdjustedRect();
+
+            SlicedScale(rect, output, count);
+
+            count = SliceExcludeVerts(output, count);
+
+            switch (m_MirrorType)
+            {
+                case MirrorType.Horizontal:
+                    ExtendCapacity(output, count);
+                    MirrorVerts(rect, output, count, true);
+                    break;
+                case MirrorType.Vertical:
+                    ExtendCapacity(output, count);
+                    MirrorVerts(rect, output, count, false);
+                    break;
+                case MirrorType.Quarter:
+                    ExtendCapacity(output, count * 3);
+                    MirrorVerts(rect, output, count, true);
+                    MirrorVerts(rect, output, count * 2, false);
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// 扩展容量
+        /// </summary>
+        /// <param name="verts"></param>
+        /// <param name="addCount"></param>
+        protected void ExtendCapacity(List<UIVertex> verts, int addCount)
+        {
+            var neededCapacity = verts.Count + addCount;
+            if (verts.Capacity < neededCapacity)
+            {
+                verts.Capacity = neededCapacity;
+            }
+        }
+
+        /// <summary>
+        /// Simple缩放位移顶点（减半）
+        /// </summary>
+        /// <param name="rect"></param>
+        /// <param name="verts"></param>
+        /// <param name="count"></param>
+        protected void SimpleScale(Rect rect, List<UIVertex> verts, int count)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                UIVertex vertex = verts[i];
+
+                Vector3 position = vertex.position;
+
+                if (m_MirrorType == MirrorType.Horizontal || m_MirrorType == MirrorType.Quarter)
+                {
+                    position.x = (position.x + rect.x) * 0.5f;
+                }
+
+                if (m_MirrorType == MirrorType.Vertical || m_MirrorType == MirrorType.Quarter)
+                {
+                    position.y = (position.y + rect.y) * 0.5f;
+                }
+
+                vertex.position = position;
+
+                verts[i] = vertex;
+            }
+        }
+
+        /// <summary>
+        /// Sliced缩放位移顶点（减半）
+        /// </summary>
+        /// <param name="rect"></param>
+        /// <param name="verts"></param>
+        /// <param name="count"></param>
+        protected void SlicedScale(Rect rect, List<UIVertex> verts, int count)
+        {
+            Vector4 border = GetAdjustedBorders(rect);
+
+            float halfWidth = rect.width * 0.5f;
+
+            float halfHeight = rect.height * 0.5f;
+
+            for (int i = 0; i < count; i++)
+            {
+                UIVertex vertex = verts[i];
+
+                Vector3 position = vertex.position;
+
+                if (m_MirrorType == MirrorType.Horizontal || m_MirrorType == MirrorType.Quarter)
+                {
+                    if (halfWidth < border.x && position.x >= rect.center.x)
+                    {
+                        position.x = rect.center.x;
+                    }
+                    else if (position.x >= border.x)
+                    {
+                        position.x = (position.x + rect.x) * 0.5f;
+                    }
+                }
+
+                if (m_MirrorType == MirrorType.Vertical || m_MirrorType == MirrorType.Quarter)
+                {
+                    if (halfHeight < border.y && position.y >= rect.center.y)
+                    {
+                        position.y = rect.center.y;
+                    }
+                    else if (position.y >= border.y)
+                    {
+                        position.y = (position.y + rect.y) * 0.5f;
+                    }
+                }
+
+                vertex.position = position;
+
+                verts[i] = vertex;
+            }
+        }
+
+        /// <summary>
+        /// 镜像顶点
+        /// </summary>
+        /// <param name="rect"></param>
+        /// <param name="verts"></param>
+        /// <param name="count"></param>
+        /// <param name="isHorizontal"></param>
+        protected void MirrorVerts(Rect rect, List<UIVertex> verts, int count, bool isHorizontal = true)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                UIVertex vertex = verts[i];
+
+                Vector3 position = vertex.position;
+
+                if (isHorizontal)
+                {
+                    position.x = rect.center.x * 2 - position.x;
+                }
+                else
+                {
+                    position.y = rect.center.y * 2 - position.y;
+                }
+
+                vertex.position = position;
+
+                verts.Add(vertex);
+            }
+        }
+
+        /// <summary>
+        /// 清理掉不能成三角面的顶点
+        /// </summary>
+        /// <param name="verts"></param>
+        /// <param name="count"></param>
+        /// <returns></returns>
+        protected int SliceExcludeVerts(List<UIVertex> verts, int count)
+        {
+            int realCount = count;
+
+            int i = 0;
+
+            while (i < realCount)
+            {
+                UIVertex v1 = verts[i];
+                UIVertex v2 = verts[i + 1];
+                UIVertex v3 = verts[i + 2];
+
+                if (v1.position == v2.position || v2.position == v3.position || v3.position == v1.position)
+                {
+                    verts[i] = verts[realCount - 3];
+                    verts[i + 1] = verts[realCount - 2];
+                    verts[i + 2] = verts[realCount - 1];
+
+                    realCount -= 3;
+                    continue;
+                }
+
+                i += 3;
+            }
+
+            if (realCount < count)
+            {
+                verts.RemoveRange(realCount, count - realCount);
+            }
+
+            return realCount;
+        }
+
+        /// <summary>
+        /// 返回矫正过的范围
+        /// </summary>
+        /// <param name="rect"></param>
+        /// <returns></returns>
+        protected Vector4 GetAdjustedBorders(Rect rect)
+        {
+            Sprite overrideSprite = (graphic as Image).overrideSprite;
+
+            Vector4 border = overrideSprite.border;
+
+            border = border / (graphic as Image).pixelsPerUnit;
+
+            for (int axis = 0; axis <= 1; axis++)
+            {
+                float combinedBorders = border[axis] + border[axis + 2];
+                if (rect.size[axis] < combinedBorders && combinedBorders != 0)
+                {
+                    float borderScaleRatio = rect.size[axis] / combinedBorders;
+                    border[axis] *= borderScaleRatio;
+                    border[axis + 2] *= borderScaleRatio;
+                }
+            }
+            return border;
+        }
+    }
+}

Unity/Assets/PSD2UGUI/Effects/Mirror.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 645d624fb0bb6a342ae3b4cbe052b595
+timeCreated: 1484798005
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Font.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: a90321bc43f033142836cca7e98d3e70
+folderAsset: yes
+timeCreated: 1486364804
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Font/MicrosoftYaHei-Bold.ttf.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: 3e385d59b2173604b8f35878f2698ac6
+timeCreated: 1486364843
+licenseType: Pro
+TrueTypeFontImporter:
+  serializedVersion: 2
+  fontSize: 16
+  forceTextureCase: -2
+  characterSpacing: 1
+  characterPadding: 0
+  includeFontData: 1
+  use2xBehaviour: 0
+  fontNames: []
+  fallbackFontReferences: []
+  customCharacters: 
+  fontRenderingMode: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Font/StaticFont.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: cafa7ea612dfbb34997eeaf7282ddc69
+folderAsset: yes
+timeCreated: 1486364852
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/Font/StaticFont/MicrosoftYaHei-Bold_Static.ttf.meta

@@ -0,0 +1,20 @@
+fileFormatVersion: 2
+guid: cee776ef102ed9349ac1de13337425d8
+timeCreated: 1482409454
+licenseType: Pro
+TrueTypeFontImporter:
+  serializedVersion: 2
+  fontSize: 32
+  forceTextureCase: 3
+  characterSpacing: 1
+  characterPadding: 0
+  includeFontData: 1
+  use2xBehaviour: 0
+  fontNames: []
+  fallbackFontReferences:
+  - {fileID: 12800000, guid: 3e385d59b2173604b8f35878f2698ac6, type: 3}
+  customCharacters: "0123456789zxcvbnm,./asdfghjkl;'\\qwertyuiopABCDEFGHIJKLMNOPQRSTUVWXYZ\u5546\u5E97[]?:\"|}{!@#$%^&*()-_=+\uFF0C\u3002\u3001\uFF1B\u2018\u3010\u3011\u89C2\u770B\u300A\u300B\uFF1F\u4E13\u5C5E\u5361\u724C\uFF1A\u201C\u2014\uFF01\uFFE5\u2026\uFF08\uFF09\u786E\u5B9A\u53D6\u6D88\u516C\u4F1A\u5BF9\u6218\u7ADE\u6280\u573A\u957F\u6B21\u8001\u90E8\u843D\u81EA\u7531\u4E4B\u6682\u65E0\u8BB0\u5F55\u672A\u53C2\u52A0\u6392\u4F4D\u8D5B\u73A9\u5BB6\u7B49\u7EA7\u51FA\u7EC4\u5E73\u5747\u82B1\u8D39\u5723\u6C34\u5347\u804C\u964D\u8E22\u79D2\u9884\u8BA1\u65F6\u95F4\u8054\u76DF\u5C0F\u5206\u524D\u641C\u7D22\u663E\u793A\u6D4F\u89C8\u521B\u5EFA\u590F\u5A03\u7A00\u6709\u5EA6\u7C7B\u578B\u666E\u901A\u961F\u804A\u5929"
+  fontRenderingMode: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/JSCode.meta

@@ -0,0 +1,5 @@
+fileFormatVersion: 2
+guid: f847f4378a01f455bb2b82dfa03f1d8c
+folderAsset: yes
+DefaultImporter:
+  userData: 

Unity/Assets/PSD2UGUI/JSCode/Export PSDUI.jsx

@@ -0,0 +1,1142 @@
+// **************************************************
+// This file created by Brett Bibby (c) 2010-2013
+// You may freely use and modify this file as you see fit
+// You may not sell it
+//**************************************************
+// hidden object game exporter
+//$.writeln("=== Starting Debugging Session ===");
+
+// enable double clicking from the Macintosh Finder or the Windows Explorer
+#target photoshop
+
+// debug level: 0-2 (0:disable, 1:break on error, 2:break at beginning)
+// $.level = 0;
+// debugger; // launch debugger on next line
+
+var sceneData;
+var sourcePsd;
+var duppedPsd;
+var destinationFolder;
+var uuid;
+var sourcePsdName;
+var slicePaddingArr = new Array(0,0,0,0)
+var sliceOriArr = new Array(0,0,0,0)
+
+main();
+
+function main(){
+    // got a valid document?
+    if (app.documents.length <= 0)
+    {
+        if (app.playbackDisplayDialogs != DialogModes.NO)
+        {
+            alert("You must have a document open to export!");
+        }
+        // quit, returning 'cancel' makes the actions palette not record our script
+        return 'cancel';
+    }
+
+    // ask for where the exported files should go
+    destinationFolder = Folder.selectDialog("Choose the destination for export.");
+    if (!destinationFolder)
+    {
+        return;
+    }
+
+    // cache useful variables
+    uuid = 1;
+    sourcePsdName = app.activeDocument.name;
+    var layerCount = app.documents[sourcePsdName].layers.length;
+    var layerSetsCount = app.documents[sourcePsdName].layerSets.length;
+
+    if ((layerCount <= 1) && (layerSetsCount <= 0))
+    {
+        if (app.playbackDisplayDialogs != DialogModes.NO)
+        {
+            alert("You need a document with multiple layers to export!");
+            // quit, returning 'cancel' makes the actions palette not record our script
+            return 'cancel';
+        }
+    }
+
+    // setup the units in case it isn't pixels
+    var savedRulerUnits = app.preferences.rulerUnits;
+    var savedTypeUnits = app.preferences.typeUnits;
+    app.preferences.rulerUnits = Units.PIXELS;
+    app.preferences.typeUnits = TypeUnits.PIXELS;
+
+    // duplicate document so we can extract everythng we need
+    duppedPsd = app.activeDocument.duplicate();
+    duppedPsd.activeLayer = duppedPsd.layers[duppedPsd.layers.length - 1];
+
+    hideAllLayers(duppedPsd);
+
+    // export layers
+    sceneData = "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
+    sceneData += "<PSDUI>";
+    
+    sceneData += "\n<psdSize>";
+    sceneData += "<width>" + duppedPsd.width.value + "</width>";
+    sceneData += "<height>" + duppedPsd.height.value+ "</height>";
+    sceneData += "</psdSize>";
+    
+    sceneData += "\n<layers>";
+    exportAllLayers(duppedPsd);
+    sceneData += "</layers>";
+
+    sceneData += "\n</PSDUI>";
+    $.writeln(sceneData);
+
+    duppedPsd.close(SaveOptions.DONOTSAVECHANGES);
+
+    // create export
+    var sceneFile = new File(destinationFolder + "/" + destinationFolder.name + ".xml");
+    sceneFile.encoding = "utf-8";   //写文件时指定编码，不然中文会出现乱码
+    sceneFile.open('w');
+    sceneFile.writeln(sceneData);
+    sceneFile.close();
+
+    app.preferences.rulerUnits = savedRulerUnits;
+    app.preferences.typeUnits = savedTypeUnits;
+}
+
+function exportAllLayers(obj)
+{
+    if  (typeof(obj) == "undefined"){
+        return;
+    }
+
+    if (typeof(obj.layers) != "undefined" && obj.layers.length>0) {
+
+        for (var i = obj.layers.length - 1; 0 <= i; i--)
+        {
+            exportLayer(obj.layers[i])
+        }
+        
+    }
+    else{
+        exportLayer(obj)
+    };
+}
+
+function exportLayer(obj)
+{
+    if  (typeof(obj) == "undefined"){
+        return;
+    }
+
+    if (obj.typename == "LayerSet") {
+            exportLayerSet(obj);
+    }
+    else if  (obj.typename = "ArtLayer"){
+        exportArtLayer(obj);
+    }
+}
+
+function exportLayerSet(_layer)
+{
+    if (typeof(_layer.layers) == "undefined" || _layer.layers.length<=0 ){
+        return
+    }
+    if (_layer.name.search("@ScrollView") >= 0)
+    {
+      exportScrollView(_layer);
+  }
+  else if (_layer.name.search("@Grid") >= 0)
+  {
+      exportGrid(_layer);
+  }
+  else if (_layer.name.search("@Button") >= 0)
+  {
+      exportButton(_layer);
+  }
+  else if (_layer.name.search("@Toggle") >= 0)
+  {
+      exportToggle(_layer);
+  }
+  else if (_layer.name.search("@Panel") >= 0)
+  {
+      exportPanel(_layer);
+  }
+  else if (_layer.name.search("@Slider")>=0) {
+      exportSlider(_layer);
+  }
+  else if (_layer.name.search("@Group")>=0) {
+      exportGroup(_layer);
+  }
+  else if (_layer.name.search("@InputField") >=0) {
+      exportInputField(_layer);
+  }
+  else if (_layer.name.search("@Scrollbar") >=0) {
+      exportScrollBar(_layer);
+  }else if (_layer.name.search("@LE") >=0) {//增加布局元素导出
+        exportLayoutElement(_layer);
+    }
+  else
+  {
+    sceneData += "<Layer>";
+    sceneData += "<type>Normal</type>";
+    sceneData += "<name>" + _layer.name + "</name>";    
+    sceneData += "<layers>";
+    exportAllLayers(_layer)
+    sceneData += "</layers>";
+    sceneData += "</Layer>";
+  }
+}
+
+function exportLayoutElement(obj)
+{
+    sceneData += "<Layer>";
+    sceneData += "<type>LayoutElement</type>";
+    var itemName = obj.name.substring(0, obj.name.search("@"));
+    sceneData += "<name>" + itemName + "</name>";
+
+    sceneData += "<layers>";
+    exportAllLayers(obj);
+
+    // sceneData += "<images>";
+    // for (var j = obj.artLayers.length - 1; 0 <= j; j--)
+    // {
+    //     exportArtLayer(obj.artLayers[j]);
+    // }
+    // sceneData += "</images>";
+    sceneData += "</layers>";
+    
+    obj.visible = true;
+    showAllLayers(obj); 
+    
+    var recSize = getLayerRec(duppedPsd.duplicate());
+
+    sceneData += "<position>";
+    sceneData += "<x>" + recSize.x + "</x>";
+    sceneData += "<y>" + recSize.y + "</y>";
+    sceneData += "</position>";
+
+    sceneData += "<size>";
+    sceneData += "<width>" + recSize.width + "</width>";
+    sceneData += "<height>" + recSize.height + "</height>";
+    sceneData += "</size>";
+
+    hideAllLayers(obj);
+    
+    sceneData += "</Layer>";
+}
+
+function exportScrollView(obj)
+{
+    var itemName = obj.name.substring(0, obj.name.search("@"));
+    sceneData += ("<Layer>\n<type>ScrollView</type>\n<name>" + itemName + "</name>\n");
+    sceneData += ("<layers>\n");
+    exportAllLayers(obj);
+    sceneData += ("</layers>");
+
+    var params = obj.name.split(":");
+
+    if (params.length > 2)
+    {
+        alert(obj.name + "-------Layer's name is illegal------------");
+    }
+
+    var recSize;
+    if (obj.layers[obj.layers.length - 1].name.search("@Size") < 0)
+    {
+        alert("Bottom layer's name doesn't contain '@Size'");
+    }
+    else
+    {
+        obj.layers[obj.layers.length - 1].visible = true;
+
+        recSize = getLayerRec(duppedPsd.duplicate());
+
+        sceneData += "<position>";
+        sceneData += "<x>" + recSize.x + "</x>";
+        sceneData += "<y>" + recSize.y + "</y>";
+        sceneData += "</position>";
+
+        sceneData += "<size>";
+        sceneData += "<width>" + recSize.width + "</width>";
+        sceneData += "<height>" + recSize.height + "</height>";
+        sceneData += "</size>";
+
+        obj.layers[obj.layers.length - 1].visible = false;
+    }
+    
+    //以下计算padding和spacing
+    obj.layers[0].visible = true;
+    showAllLayers(obj.layers[0]);                           //子图层组已经在上面导出过，要再次计算size需先将其显示
+    var rec0 = getLayerRec(duppedPsd.duplicate());
+    hideAllLayers(obj.layers[0]);
+    obj.layers[0].visible = false;
+    
+    obj.layers[1].visible = true;
+    showAllLayers(obj.layers[1]);
+    var rec1 = getLayerRec(duppedPsd.duplicate());
+    hideAllLayers(obj.layers[0]);
+    obj.layers[1].visible = false;
+    
+    var spacing;
+    var paddingx;
+    var paddingy;
+    if(params[1].search("H") >= 0)          //水平间距
+    {
+        spacing = rec1.x - rec0.x - rec0.width;
+        paddingx =  rec0.x - (recSize.x - recSize.width / 2) -  rec0.width / 2;                                      //x方向边距，默认左右相等
+        paddingy = (recSize.height - rec0.height) / 2 ;                                                          //暂时只考虑上下边距相等             
+        //paddingy = recSize.height / 2 - rec0.height / 2 - (rec0.y - recSize.y);                                                                   //上边距
+        //paddingy2 = recSize.height - rec0.height - paddingy;                      //下边距
+    }
+    else                                                //垂直间距
+    {
+        spacing = rec0.y - rec1.y - rec0.height;
+        paddingx =  (recSize.width - rec0.width) / 2 ; 
+        paddingy = (recSize.y + recSize.height / 2)  - rec0.y -  rec0.height / 2;     
+    }                                    
+
+    sceneData += "<arguments>";
+    sceneData += "<string>" + params[1] + "</string>";     //滑动方向
+    sceneData += "<string>" + spacing + "</string>";   
+    sceneData += "<string>" + Math.floor (paddingx) + "</string>";  
+    sceneData += "<string>" + Math.floor (paddingy) + "</string>";  
+    sceneData += "</arguments>";
+
+    sceneData += "</Layer>";
+}
+
+function setLayerSizeAndPos(layer)
+{
+    layer.visible = true;
+
+    var recSize = getLayerRec(duppedPsd.duplicate());
+
+    sceneData += "<position>";
+    sceneData += "<x>" + recSize.x + "</x>";
+    sceneData += "<y>" + recSize.y + "</y>";
+    sceneData += "</position>";
+
+    sceneData += "<size>";
+    sceneData += "<width>" + recSize.width + "</width>";
+    sceneData += "<height>" + recSize.height + "</height>";
+    sceneData += "</size>";
+
+    layer.visible = false;
+}
+
+function exportGrid(obj)
+{
+    var itemName = obj.name.substring(0, obj.name.search("@"));
+    sceneData += ("<Layer>\n<type>Grid</type>\n<name>" + itemName + "</name>\n");
+    sceneData += ("<layers>\n");
+    exportAllLayers(obj);
+    sceneData += ("</layers>");
+
+    var params = obj.name.split(":");
+
+    if (params.length != 3)
+    {
+        alert("Layer's name is illegal");
+    }
+
+    var recSize;
+    if (obj.layers[obj.layers.length - 1].name.search("@Size") < 0)
+    {
+        alert("Bottom layer's name doesn't contain '@Size'");
+    }
+    else
+    {  
+        setLayerSizeAndPos(obj.layers[obj.layers.length - 1]);
+    }
+
+    var totalContentCount = obj.layers.length - 1;  
+    
+    obj.layers[0].visible = true;
+    showAllLayers(obj.layers[0]);                           //子图层组已经在上面导出过，要再次计算size需先将其显示
+    var rec0 = getLayerRec(duppedPsd.duplicate());
+    hideAllLayers(obj.layers[0]);
+    obj.layers[0].visible = false;
+    
+    var renderHorizontalGap = params[2] > 1 ? (recSize.width - rec0.width * params[2])/(params[2] - 1) : 0;
+    var renderVerticalGap = params[1] > 1 ? (recSize.height - rec0.height * params[1])/(params[1] - 1) : 0;
+
+    sceneData += "<arguments>";
+    sceneData += "<string>" + params[1] + "</string>";   //行数
+    sceneData += "<string>" + params[2] + "</string>";   //列数
+    sceneData += "<string>" + rec0.width + "</string>";   //render width
+    sceneData += "<string>" + rec0.height + "</string>";   //render height
+    sceneData += "<string>" + Math.floor(renderHorizontalGap) + "</string>"; //水平间距
+    sceneData += "<string>" + Math.floor(renderVerticalGap) + "</string>"; //垂直间距
+    sceneData += "</arguments>";
+
+    sceneData += "</Layer>";
+}
+
+function exportGroup(obj)
+{
+    var itemName = obj.name.substring(0, obj.name.search("@"));
+    sceneData += ("<Layer>\n<type>Group</type>\n<name>" + itemName + "</name>\n");
+
+    exportAllLayers(obj);
+
+    var params = obj.name.split(":");
+
+    if (params.length != 3 )
+    {
+        alert(obj.name + "-------Layer's name not equals 2------------");
+    }
+
+    var recSize;
+    if (obj.layers[obj.layers.length - 1].name.search("@Size") < 0)
+    {
+        alert("Bottom layer's name doesn't contain '@Size'");
+    }
+    else
+    {
+        obj.layers[obj.layers.length - 1].visible = true;
+
+        recSize = getLayerRec(duppedPsd.duplicate());
+
+        sceneData += "<position>";
+        sceneData += "<x>" + recSize.x + "</x>";
+        sceneData += "<y>" + recSize.y + "</y>";
+        sceneData += "</position>";
+
+        sceneData += "<size>";
+        sceneData += "<width>" + recSize.width + "</width>";
+        sceneData += "<height>" + recSize.height + "</height>";
+        sceneData += "</size>";
+
+        obj.layers[obj.layers.length - 1].visible = false;
+    }
+
+    sceneData += "<arguments>";
+    sceneData += "<string>" + params[1] + "</string>";   //方向
+    sceneData += "<string>" + params[2] + "</string>";   //span
+    sceneData += "</arguments>";
+
+    sceneData += "</Layer>";
+}
+
+function exportInputField(obj)
+{
+    var itemName = obj.name.substring(0, obj.name.search("@"));
+    sceneData += ("<Layer>\n<type>InputField</type>\n<name>" + itemName + "</name>\n");
+    sceneData += "<layers>";
+
+    // sceneData += "<images>\n";
+
+    for (var i = obj.layers.length - 1; 0 <= i; i--)
+    {
+        exportArtLayer(obj.layers[i]);
+    }
+
+    sceneData += "</layers>";
+    // sceneData += "\n</images>\n</Layer>";
+    sceneData += "\n</Layer>";
+}
+
+function exportButton(obj)
+{
+    var itemName = obj.name.substring(0, obj.name.search("@"));
+    sceneData += ("<Layer>\n<type>Button</type>\n<name>" + itemName + "</name>\n");
+    sceneData += "<layers>";
+
+    // sceneData += "<images>\n";
+
+    for (var i = obj.layers.length - 1; 0 <= i; i--)
+    {
+        exportArtLayer(obj.layers[i]);
+    }
+    sceneData += "</layers>";
+    // sceneData += "\n</images>\n</Layer>";
+    sceneData += "\n</Layer>";
+}
+
+function exportToggle(obj)
+{
+    var itemName = obj.name.substring(0, obj.name.search("@"));
+    sceneData += ("<Layer>\n<type>Toggle</type>\n<name>" + itemName + "</name>\n");
+    sceneData += "<layers>";
+
+    // sceneData += "<images>\n";
+
+    for (var i = obj.layers.length - 1; 0 <= i; i--)
+    {
+        exportArtLayer(obj.layers[i]);
+    }
+
+    sceneData += "</layers>";
+    // sceneData += "\n</images>\n</Layer>";
+    sceneData += "\n</Layer>";
+}
+
+function exportSlider(obj)
+{
+    var itemName = obj.name.substring(0, obj.name.search("@"));
+    sceneData += ("<Layer>\n<type>Slider</type>\n<name>" + itemName + "</name>\n");
+
+    var params = obj.name.split(":");
+
+    if (params.length != 2)
+    {
+        alert(obj.name + "-------Layer's name is not 1 argument------------");
+    }
+    
+    var recSize;
+    if (obj.layers[obj.layers.length - 1].name.search("@Size") < 0)
+    {
+        alert("Bottom layer's name doesn't contain '@Size'");
+    }
+    else
+    {
+        setLayerSizeAndPos(obj.layers[obj.layers.length - 1]);
+    }
+
+    sceneData += "<arguments>";
+    sceneData += "<string>" + params[1] + "</string>"; //滑动方向
+    sceneData += "</arguments>";
+    
+    // sceneData += "<images>\n";
+    sceneData += "<layers>";
+
+    for (var i = obj.layers.length - 1; 0 <= i; i--)
+    {
+        exportArtLayer(obj.layers[i]);
+    }
+    sceneData += "</layers>";
+
+    // sceneData += "\n</images>\n</Layer>";
+    sceneData += "\n</Layer>";
+}
+
+function exportScrollBar(obj)
+{
+    var itemName = obj.name.substring(0, obj.name.search("@"));
+    sceneData += ("<Layer>\n<type>ScrollBar</type>\n<name>" + itemName + "</name>\n");
+
+    var params = obj.name.split(":");
+
+    if (params.length != 3)
+    {
+        alert(obj.name + "-------Layer's name is not 1 argument------------");
+    }
+    
+    sceneData += "<arguments>";
+    sceneData += "<string>" + params[1] + "</string>"; //滑动方向
+    sceneData += "<string>" + params[2] + "</string>"; //比例
+    sceneData += "</arguments>";
+
+    // sceneData += "<images>\n";
+    sceneData += "<layers>";
+
+    for (var i = obj.layers.length - 1; 0 <= i; i--)
+    {
+        exportArtLayer(obj.layers[i]);
+    }
+    sceneData += "</layers>";
+
+    // sceneData += "\n</images>\n</Layer>";
+    sceneData += "\n</Layer>";
+}
+
+function exportPanel(obj)
+{
+    var itemName = obj.name.substring(0, obj.name.search("@"));
+    sceneData += ("<Layer>\n<type>Panel</type>\n<name>" + itemName + "</name>\n");
+
+    exportAllLayers(obj);
+
+    // sceneData += "<images>\n";
+    sceneData += "<layers>";
+
+    for (var j = obj.artLayers.length - 1; 0 <= j; j--)
+    {
+        exportArtLayer(obj.artLayers[j]);
+    }
+    sceneData += "</layers>";
+
+    // sceneData += "\n</images>\n</Layer>";
+    sceneData += "\n</Layer>";
+}
+
+function exportArtLayer(obj)
+{
+    if (typeof(obj) == "undefined") {return};
+    if (obj.name.search("@Size") >= 0) {return};
+
+    sceneData += "\n<Layer>";
+    sceneData += "<type>Normal</type>";
+    //sceneData += "<name>" + makeValidFileName(obj.name) + "</name>";
+    var validFileName = makeValidFileName(obj.name);
+    sceneData += "<name>" + validFileName + "</name>";
+    sceneData += "<image>\n";
+    // sceneData += "<PSImage>\n";
+    if (LayerKind.TEXT == obj.kind)
+    {
+        exportLabel(obj,validFileName);
+    }
+    else if (obj.name.search("Texture") >= 0)
+    {
+        exportTexture(obj,validFileName);
+    }
+    else
+    {
+        exportImage(obj,validFileName);
+    }
+    sceneData += "</image>";
+    // sceneData += "</PSImage>";
+    sceneData += "\n</Layer>";
+}
+
+function exportLabel(obj,validFileName)
+{
+    //有些文本如标题，按钮，美术用的是其他字体，可能还加了各种样式，需要当做图片切出来使用
+    if(obj.name.search("_ArtStatic") >= 0)
+    {
+        exportImage(obj,validFileName);   
+        return;
+    }
+
+    //处理静态文本，会对应unity的静态字体
+    var StaticText = false;
+    if(obj.name.search("_Static") >= 0)
+    {
+        StaticText = true;
+    }
+
+    sceneData += "<imageType>" + "Label" + "</imageType>\n";
+    //var validFileName = makeValidFileName(obj.name);
+    sceneData += "<name>" + validFileName + "</name>\n";
+    obj.visible = true;
+    saveScenePng(duppedPsd.duplicate(), validFileName, false);
+    obj.visible = false;    
+    
+    sceneData += "<arguments>";
+    sceneData += "<string>" + obj.textItem.color.rgb.hexValue + "</string>";
+    
+    if(StaticText == true)
+    {
+        sceneData += "<string>" + obj.textItem.font + "_Static" + "</string>";
+    }
+    else
+    {
+        sceneData += "<string>" + obj.textItem.font + "</string>";
+    }
+    //sceneData += "<string>" + obj.textItem.font + "</string>";
+    sceneData += "<string>" + obj.textItem.size.value + "</string>";
+    sceneData += "<string>" + obj.textItem.contents + "</string>";
+    
+    //段落文本带文本框，可以取得对齐方式
+    if(obj.textItem.kind == TextType.PARAGRAPHTEXT)
+    {
+        sceneData += "<string>" + obj.textItem.justification + "</string>";     //加对齐方式
+    }
+    sceneData += "</arguments>";
+}
+
+function exportTexture(obj,validFileName)
+{
+    //var validFileName = makeValidFileName(obj.name);
+    sceneData += "<imageType>" + "Texture" + "</imageType>\n";
+    sceneData += "<name>" + validFileName + "</name>\n";
+    obj.visible = true;
+    saveScenePng(duppedPsd.duplicate(), validFileName, true);
+    obj.visible = false;
+}
+
+function exportImage(obj,validFileName)
+{
+    //var validFileName = makeValidFileName(obj.name);
+    var oriName = obj.name
+    sceneData += "<name>" + validFileName + "</name>\n";
+
+    if (obj.name.search("Common") >= 0)
+    {
+        sceneData += "<imageSource>" + "Common" + "</imageSource>\n";
+    }
+    else if(obj.name.search("Global") >= 0)
+    {
+        sceneData += "<imageSource>" + "Global" + "</imageSource>\n";
+    }
+    else
+    {
+        sceneData += "<imageSource>" + "Custom" + "</imageSource>\n";      
+    }
+
+  if (oriName.search("_9S") >= 0)
+  {
+      sceneData += "<imageType>" + "SliceImage" + "</imageType>\n";
+      obj.visible = true;
+      var _objName = obj.name
+      // var newDoc = app.documents.add(duppedPsd.width, duppedPsd.height,duppedPsd.resolution, _objName+"doc",NewDocumentMode.RGB,DocumentFill.TRANSPARENT)
+      // app.activeDocument = duppedPsd
+      // obj.copy()
+      // app.activeDocument = newDoc
+      // newDoc.paste()
+      //   newDoc.activeLayer.name = _objName
+      var recSize = getLayerRec(duppedPsd.duplicate(),true);
+        sceneData += "<position>";
+        sceneData += "<x>" + recSize.x + "</x>";
+        sceneData += "<y>" + recSize.y + "</y>";
+        sceneData += "</position>";
+
+        sceneData += "<size>";
+        sceneData += "<width>" + recSize.width + "</width>";
+        sceneData += "<height>" + recSize.height + "</height>";
+        sceneData += "</size>";
+
+      // _9sliceCutImg(newDoc,_objName,validFileName); 
+      _9sliceCutImg(duppedPsd.duplicate(),_objName,validFileName); 
+      obj.visible = false;
+      return;
+  }
+    else if(oriName.search("LeftHalf") > 0)       //左右对称的图片切左边一半
+    {
+        sceneData += "<imageType>" + "LeftHalfImage" + "</imageType>\n";
+        
+        obj.visible = true;
+        
+        var recSize = getLayerRec(duppedPsd.duplicate());
+        sceneData += "<position>";
+        sceneData += "<x>" + recSize.x + "</x>";
+        sceneData += "<y>" + recSize.y + "</y>";
+        sceneData += "</position>";
+
+        sceneData += "<size>";
+        sceneData += "<width>" + recSize.width + "</width>";
+        sceneData += "<height>" + recSize.height + "</height>";
+        sceneData += "</size>";
+        
+        cutLeftHalf(duppedPsd.duplicate(),validFileName); 
+        obj.visible = false;
+        return;
+    }
+    else if(obj.name.search("BottomHalf") > 0)     //上下对称的图片切底部一半
+    {
+        sceneData += "<imageType>" + "BottomHalfImage" + "</imageType>\n";
+        
+        obj.visible = true;
+        
+        //半图要先计算出大小和位置
+        var recSize = getLayerRec(duppedPsd.duplicate());
+        sceneData += "<position>";
+        sceneData += "<x>" + recSize.x + "</x>";
+        sceneData += "<y>" + recSize.y + "</y>";
+        sceneData += "</position>";
+
+        sceneData += "<size>";
+        sceneData += "<width>" + recSize.width + "</width>";
+        sceneData += "<height>" + recSize.height + "</height>";
+        sceneData += "</size>";
+        
+        cutBottomHalf(duppedPsd.duplicate(),validFileName); 
+        obj.visible = false;
+        return;
+    }
+    else if(obj.name.search("Quarter") > 0)     //上下左右均对称的图片切左下四分之一
+    {
+        sceneData += "<imageType>" + "QuarterImage" + "</imageType>\n";
+        
+        obj.visible = true;
+        
+        var recSize = getLayerRec(duppedPsd.duplicate());
+        sceneData += "<position>";
+        sceneData += "<x>" + recSize.x + "</x>";
+        sceneData += "<y>" + recSize.y + "</y>";
+        sceneData += "</position>";
+
+        sceneData += "<size>";
+        sceneData += "<width>" + recSize.width + "</width>";
+        sceneData += "<height>" + recSize.height + "</height>";
+        sceneData += "</size>";
+        
+        cutQuarter(duppedPsd.duplicate(),validFileName); 
+        obj.visible = false;
+        return;
+    }
+    else
+    {
+        sceneData += "<imageType>" + "Image" + "</imageType>\n";
+    }
+
+    obj.visible = true;
+    saveScenePng(duppedPsd.duplicate(), validFileName, true);
+    obj.visible = false;
+          
+}
+
+function hideAllLayers(obj)
+{
+    hideLayerSets(obj);
+}
+
+function hideLayerSets(obj)
+{
+    for (var i = obj.layers.length - 1; 0 <= i; i--)
+    {
+        if (obj.layers[i].typename == "LayerSet")
+        {
+            hideLayerSets(obj.layers[i]);
+        }
+        else
+        {
+            obj.layers[i].visible = false;
+        }
+    }
+}
+
+//显示图层组及组下所有图层
+function showAllLayers(obj)
+{
+    showLayerSets(obj);
+}
+
+function showLayerSets(obj)
+{
+    for (var i = obj.layers.length - 1; 0 <= i; i--)
+    {
+        if (obj.layers[i].typename == "LayerSet")
+        {
+            showLayerSets(obj.layers[i]);
+        }
+        else
+        {
+            obj.layers[i].visible = true;
+        }
+    }
+}
+
+
+function getLayerRec(psd,notMerge)
+{
+    // we should now have a single art layer if all went well
+    if  (!notMerge){
+          psd.mergeVisibleLayers();
+        }
+  
+    // figure out where the top-left corner is so it can be exported into the scene file for placement in game
+    // capture current size
+    var height = psd.height.value;
+    var width = psd.width.value;
+    var top = psd.height.value;
+    var left = psd.width.value;
+    // trim off the top and left
+    psd.trim(TrimType.TRANSPARENT, true, true, false, false);
+    // the difference between original and trimmed is the amount of offset
+    top -= psd.height.value;
+    left -= psd.width.value;
+    // trim the right and bottom
+    psd.trim(TrimType.TRANSPARENT);
+    // find center
+    top += (psd.height.value / 2)
+    left += (psd.width.value / 2)
+    // unity needs center of image, not top left
+    top = -(top - (height / 2));
+    left -= (width / 2);
+
+    height = psd.height.value;
+    width = psd.width.value;
+
+    psd.close(SaveOptions.DONOTSAVECHANGES);
+
+    return {
+        y: top,
+        x: left,
+        width: width,
+        height: height
+    };
+}
+
+function saveScenePng(psd, fileName, writeToDisk,notMerge)
+{
+    // we should now have a single art layer if all went well
+    if(!notMerge)
+    {
+        psd.mergeVisibleLayers();
+    }
+    
+    // figure out where the top-left corner is so it can be exported into the scene file for placement in game
+    // capture current size
+    var height = psd.height.value;
+    var width = psd.width.value;
+    var top = psd.height.value;
+    var left = psd.width.value;
+    // trim off the top and left
+    psd.trim(TrimType.TRANSPARENT, true, true, false, false);
+    // the difference between original and trimmed is the amount of offset
+    top -= psd.height.value;
+    left -= psd.width.value;
+    // trim the right and bottom
+    psd.trim(TrimType.TRANSPARENT);
+    // find center
+    top += (psd.height.value / 2)
+    left += (psd.width.value / 2)
+    // unity needs center of image, not top left
+    top = -(top - (height / 2));
+    left -= (width / 2);
+
+    height = psd.height.value;
+    width = psd.width.value;
+
+    var rec = {
+        y: top,
+        x: left,
+        width: width,
+        height: height
+    };
+
+    // save the scene data
+    if(!notMerge){
+        sceneData += "<position>";
+        sceneData += "<x>" + rec.x + "</x>";
+        sceneData += "<y>" + rec.y + "</y>";
+        sceneData += "</position>";
+
+        sceneData += "<size>";
+        sceneData += "<width>" + rec.width + "</width>";
+        sceneData += "<height>" + rec.height + "</height>";
+        sceneData += "</size>";
+    }
+    
+     if (writeToDisk)
+     {
+        // save the image
+        var pngFile = new File(destinationFolder + "/" + fileName + ".png");
+        var pngSaveOptions = new PNGSaveOptions();
+        psd.saveAs(pngFile, pngSaveOptions, true, Extension.LOWERCASE);
+    }
+    psd.close(SaveOptions.DONOTSAVECHANGES);
+
+}
+
+function makeValidFileName(fileName)
+{
+    var validName = fileName.replace(/^\s+|\s+$/gm, ''); // trim spaces
+    //删除九宫格关键字符
+    validName = validName.replace(/\s*_9S(\:\d+)+/g,"")
+    validName = validName.replace(/[\\\*\/\?:"\|<>]/g, ''); // remove characters not allowed in a file name
+    validName = validName.replace(/[ ]/g, '_'); // replace spaces with underscores, since some programs still may have troubles with them
+
+    if (validName.match("Common") || validName.match("Global"))
+    {
+        validName = validName.substring (0,validName.lastIndexOf ("@"));  //截取@之后的字符串作为图片的名称。
+    }
+    else if(!sourcePsdName.match("Common") || !sourcePsdName.match("Global"))    // 判断是否为公用的PSD素材文件，如果不是，则自动为图片增加后缀，防止重名。 公用psd文件的图片层不允许重名。
+    {
+        validName += "_" + uuid++;
+    }
+    
+     $.writeln(validName);
+    return validName;
+}
+
+/***************************************************************************************************************************************************************************************************************/
+//对称的图片处理，切一半
+//2017.01.10
+//by zs
+
+// 裁切 基于透明像素
+function trim(doc){
+    doc.trim(TrimType.TRANSPARENT,true,true,true,true);
+}
+
+// 裁剪左半部分
+function cutLeftHalf(doc,layerName){
+    doc.mergeVisibleLayers();
+    
+    trim(doc);
+    var _obj = doc.activeLayer
+
+    var width = doc.width;
+    var height = doc.height;
+    var side = width / 2;
+
+    var region = Array(Array(0,height),Array(0,0),Array(side,0),Array(side,height));
+        
+    var selectRect = doc.selection.select(region);
+    doc.selection.copy();
+    var newStem = doc.paste();
+    newStem.name = layerName;
+
+    var deltaX = 0;
+    var deltaY = 0;
+    if(region[0][0] != 0){
+        deltaX = -(width - side*2);
+    }
+    newStem.translate(deltaX,deltaY);
+
+    _obj.visible = false;
+    trim(doc);
+    saveScenePng(doc, layerName, true,true);
+    // exportHalfImage(doc,"LeftHalf");
+}
+
+// 裁剪下半部分
+function cutBottomHalf(doc,layerName){
+    doc.mergeVisibleLayers();
+    
+    trim(doc);
+    var _obj = doc.activeLayer
+    var width = doc.width;
+    var height = doc.height;
+    var side = height / 2;
+
+    //var region = Array(Array(0,side),Array(0,0),Array(width,0),Array(width,side));
+    var region = Array(Array(0,height),Array(0,side),Array(width,side),Array(width,height));
+        
+    var selectRect = doc.selection.select(region);
+    doc.selection.copy();
+    var newStem = doc.paste();
+    newStem.name = layerName;
+
+    var deltaX = 0;
+    var deltaY = 0;
+    if (region[0][1] != side){
+        deltaY = -(height - side*2);
+    }
+    newStem.translate(deltaX,deltaY);
+
+    _obj.visible = false;
+
+    trim(doc);
+    saveScenePng(doc, layerName, true,true);
+    //exportHalfImage(doc,"UpHalf");
+}
+
+// 裁剪左下四分之一
+function cutQuarter(doc,layerName){
+    doc.mergeVisibleLayers();
+    
+    trim(doc);
+    var _obj = doc.activeLayer
+    var width = doc.width;
+    var height = doc.height;
+    var side = height / 2;
+
+    var region = Array(Array(0,height),Array(0,height / 2),Array(width / 2,height / 2),Array(width / 2,height));
+        
+    var selectRect = doc.selection.select(region);
+    doc.selection.copy();
+    var newStem = doc.paste();
+    newStem.name = layerName;
+
+    var deltaX = 0;
+    var deltaY = 0;
+    if (region[0][1] != side){
+        deltaY = -(height - side*2);
+    }
+    newStem.translate(deltaX,deltaY);
+
+    _obj.visible = false;
+
+    trim(doc);
+    saveScenePng(doc, layerName, true,true);
+}
+
+function exportHalfImage(psd,halfType)
+{
+    hideAllLayers(psd);
+    
+    var layerName  = "";
+     for (var i = psd.layers.length - 1; 0 <= i; i--)
+     {
+         layerName = psd.layers[i].name;
+         if(layerName.match(halfType))
+         {
+             psd.layers[i].visible = true;
+             saveScenePng(psd, layerName, true,true);
+         }
+     }
+}
+
+
+/***************************************************************************************************************************************************************************************************************/
+//九宫格切图
+//2017.01.13
+//by HuangLang
+
+function _9sliceCutImg(doc,layerName,vaildName){
+    // 创建图层组
+    var _obj = doc.activeLayer
+    var stemGroup = doc.layerSets.add();
+    stemGroup.name = layerName
+    // _obj.move(stemGroup,ElementPlacement.PLACEATEND)
+    doc.mergeVisibleLayers();
+  trim(doc);
+   var width = doc.width;
+   var height = doc.height;
+    var re = /\s*_9S(\:\d+)+/g;
+    var getStr = ""
+    var result = layerName.match(re)
+    if (result) {
+        getStr = result[0]
+    }else{
+        alert("图层名为："+layerName+"的九宫格格式不对！应为_9S:XX或:XX:XX:XX:XX");
+        return;
+    }
+
+   var  nums = getStr.split(":")
+   if ( nums.length == 2) {
+      for(var j = 0;j<slicePaddingArr.length;j++)
+      {
+        sliceOriArr[j] = parseInt(nums[1])
+         slicePaddingArr[j] = parseInt(nums[1])
+         }
+     }
+     else if ( nums.length == 5) 
+     {
+      for(var j = 0;j<slicePaddingArr.length;j++)
+      {
+          var num = parseInt(nums[j+1])
+          sliceOriArr[j] = num
+          if  (num == 0 ){
+              if ((j+1) %2 == 0) {
+                num = parseInt(height/2)
+
+              }else{
+                
+                num = parseInt(width/2)
+              }
+          }
+         slicePaddingArr[j] = num
+     }
+    }else{
+      alert("图层名为："+layerName+"的九宫格格式不对！应为_9S:XX或:XX:XX:XX:XX");
+      return;
+    }
+    
+    var _obj = doc.activeLayer
+    //左下左上，右上右下
+    var selRegion = Array(
+        Array(Array(0,slicePaddingArr[1]),Array(0, 0),Array(slicePaddingArr[0] , 0),Array(slicePaddingArr[0], slicePaddingArr[1])),
+        Array(Array(width-slicePaddingArr[2],slicePaddingArr[1]),Array(width-slicePaddingArr[2], 0),Array(width , 0),Array(width, slicePaddingArr[1])),
+        Array(Array(0,height),Array(0, height-slicePaddingArr[3]),Array(slicePaddingArr[0] , height-slicePaddingArr[3]),Array(slicePaddingArr[0], height)),
+        Array(Array(width-slicePaddingArr[2],height),Array(width-slicePaddingArr[2], height-slicePaddingArr[3]),Array(width , height-slicePaddingArr[3]),Array(width, height)),
+        );
+    for (var i = 0;i<selRegion.length;i++)
+    {
+        doc.activeLayer = _obj;
+        doc.selection.select(selRegion[i]);
+        doc.selection.copy();
+        var newStem = doc.paste();
+        newStem.name = vaildName;
+        var deltaX = 0;
+        var deltaY = 0;
+        if(selRegion[i][0][0] != 0){
+            deltaX = - (width - slicePaddingArr[0]-slicePaddingArr[2]);
+        }
+        if(selRegion[i][1][1] != 0){
+            deltaY = - (height - slicePaddingArr[1]-slicePaddingArr[3]);
+        }
+        newStem.translate(deltaX,deltaY);
+    }
+    _obj.visible = false;
+    doc.mergeVisibleLayers();
+    sceneData += "<arguments>";
+    sceneData += "<string>" + sliceOriArr[0] + "</string>";
+    sceneData += "<string>" + sliceOriArr[1] + "</string>";
+    sceneData += "<string>" + sliceOriArr[2] + "</string>";
+    sceneData += "<string>" + sliceOriArr[3] + "</string>";
+    sceneData += "</arguments>";
+
+    trim(doc);
+    saveScenePng(doc, vaildName, true,true);
+}

Unity/Assets/PSD2UGUI/JSCode/Export PSDUI.jsx.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4d288650cafb9b248b1f9bd0854bad25
+timeCreated: 1484187089
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/Assets/PSD2UGUI/JSCode/ReadMe.txt

@@ -0,0 +1 @@
+Place "Export PSDUI.jsx" in the sub-directory Presets/Scripts inside the Photoshop application installation directory.

Unity/Assets/PSD2UGUI/JSCode/ReadMe.txt.meta

@@ -0,0 +1,4 @@
+fileFormatVersion: 2
+guid: 0ae7ab0db33a34c67827e81fbf3d95f4
+TextScriptImporter:
+  userData: