Exemple #1
0
 public static void BuildSprites(GameObject root, PSDLayerGroupInfo group,
                                 PsdExportSettings settings, PsdFileInfo fileInfo,
                                 SpriteAlignment createAlign)
 {
     BuildPsd(root, group, settings, fileInfo,
              createAlign, new SpriteConstructor());
 }
Exemple #2
0
        public static void Export(PsdExportSettings settings, PsdFileInfo fileInfo, bool exportExisting = true)
        {
            List <int> layerIndices = GetExportLayers(settings, fileInfo);

            // If not going to export existing, filter out layers with existing files
            if (exportExisting == false)
            {
                layerIndices = layerIndices.Where(delegate(int layerIndex)
                {
                    string filePath = GetLayerFilename(settings, layerIndex);
                    // If file exists, don't export
                    return(!File.Exists(filePath));
                }).ToList();
            }

            int exportCount = 0;

            foreach (int layerIndex in  layerIndices)
            {
                string infoString = string.Format("Importing {0} / {1} Layers", exportCount, layerIndices.Count);
                string fileString = string.Format("Importing PSD Layers: {0}", settings.Filename);

                float progress = exportCount / (float)layerIndices.Count;

                EditorUtility.DisplayProgressBar(fileString, infoString, progress);

                CreateSprite(settings, layerIndex);
                exportCount++;
            }

            EditorUtility.ClearProgressBar();
            settings.SaveMetaData();
            settings.SaveLayerMetaData();
        }
 /// <summary>
 /// Setup the layer settings using a PsdFileInfo,
 /// tries to read settings from file labels if available
 /// </summary>
 /// <param name="fileInfo"></param>
 public void LoadLayers(PsdFileInfo fileInfo)
 {
     layerSettings = new Dictionary <int, LayerSetting>();
     foreach (var layerIndex in fileInfo.LayerIndices)
     {
         string layerName = Psd.Layers[layerIndex].Name;
         bool   visible   = fileInfo.LayerVisibility[layerIndex];
         LoadLayerSetting(layerName, layerIndex, visible);
     }
 }
Exemple #4
0
        private bool LoadImage()
        {
            settings           = new PsdExportSettings(image);
            showImportSettings = !settings.HasMetaData;

            bool valid = (settings.Psd != null);

            if (valid)
            {
                // Parse the layer info
                fileInfo = new PsdFileInfo(settings.Psd);
                settings.LoadLayers(fileInfo);
            }
            return(valid);
        }
Exemple #5
0
        private static void ExecuteAutoImport()
        {
            // This function only fires once, unhook from update function immediately
            EditorApplication.update -= ExecuteAutoImport;

            for (int i = 0; i < reimports.Count; i++)
            {
                var target         = reimports[i];
                var exportSettings = new PsdExportSettings(target);
                if (exportSettings.AutoReImport)
                {
                    PsdFileInfo psdInfo = new PsdFileInfo(exportSettings.Psd);
                    exportSettings.LoadLayers(psdInfo);
                    PSDExporter.Export(exportSettings, psdInfo);
                }
            }

            reimports.Clear();
        }
Exemple #6
0
        public static List <int> GetExportLayers(PsdExportSettings settings, PsdFileInfo fileInfo)
        {
            List <int> exportLayers = new List <int>();

            foreach (var keypair in settings.layerSettings)
            {
                PsdExportSettings.LayerSetting layerSetting = keypair.Value;
                // Don't export if not set to export
                if (!layerSetting.doExport)
                {
                    continue;
                }

                // Don't export if group is off
                var groupInfo = fileInfo.GetGroupByLayerIndex(layerSetting.layerIndex);
                if (groupInfo != null && !groupInfo.visible)
                {
                    continue;
                }

                exportLayers.Add(layerSetting.layerIndex);
            }
            return(exportLayers);
        }
Exemple #7
0
        public static void BuildPsd(GameObject root, PSDLayerGroupInfo group,
                                    PsdExportSettings settings, PsdFileInfo fileInfo,
                                    SpriteAlignment align, IPsdConstructor initConstructor)
        {
            // Run the export on non exported layers
//			PSDExporter.Export(settings, fileInfo, false);

            // Find all the layers being exported
            var exportLayers = PSDExporter.GetExportLayers(settings, fileInfo);

            // Stores the root object for each encountered group
            Dictionary <PSDLayerGroupInfo, GameObject> groupHeaders = new Dictionary <PSDLayerGroupInfo, GameObject>();

            // Store the last parent, for traversal
            GameObject lastParent = root;
            GameObject rootBase   = root;

            int groupVisibleMask = 1;
            int groupDepth       = 0;

            // Loop through all the layers of the PSD file
            // backwards so they appear in the expected order
            // Going through all the layers, and not just the exported layers
            // so that the groups can be setup
            for (int i = group.end; i >= group.start; i--)
            {
                IPsdConstructor constructor = initConstructor;

                // Skip if layer is hidden
                if (fileInfo.LayerVisibility[i] == false)
                {
                    continue;
                }

                var  groupInfo = fileInfo.GetGroupByLayerIndex(i);
                bool inGroup   = groupInfo != null;

                // Skip if layer belongs to a hidden group
                if (inGroup && groupInfo.visible == false)
                {
                    continue;
                }


                // When inside a group...
                if (inGroup)
                {
                    // Inverted because starting backwards
                    bool startGroup = groupInfo.end == i;
                    bool closeGroup = groupInfo.start == i;

                    // Go up or down group depths
                    if (startGroup)
                    {
                        groupDepth++;
                        groupVisibleMask |= ((groupInfo.visible ? 1 : 0) << groupDepth);
                    }
                    if (closeGroup)
                    {
                        // Reset group visible flag when closing group
                        groupVisibleMask &= ~(1 << groupDepth);
                        groupDepth--;
                    }

                    // First, check if parents of this group is visible in the first place
                    bool parentVisible = true;
                    for (int parentMask = groupDepth - 1; parentMask > 0; parentMask--)
                    {
                        bool isVisible = (groupVisibleMask & (1 << parentMask)) > 0;
                        parentVisible &= isVisible;
                    }
                    // Parents not visible, continue to next layer
                    if (!parentVisible)
                    {
                        continue;
                    }

                    // Finally, check if layer being processed is start/end of group
                    if (startGroup || closeGroup)
                    {
                        // If start or end of the group, call HandleGroupObject
                        // which creates the group layer object and assignment of lastParent
                        HandleGroupObject(groupInfo, groupHeaders,
                                          startGroup, constructor, ref lastParent);

                        // A bunch of book keeping needs to be done at the start of a group
                        if (startGroup)
                        {
                            // If this is the start of the group being constructed
                            // store as the rootBase
                            if (i == group.end)
                            {
                                rootBase = lastParent;
                            }
                        }

                        // Start or end group doesn't have visible sprite object, skip to next layer
                        continue;
                    }
                }                 // End processing of group start/end

                // If got to here, processing a visual layer

                // Skip if the export layers list doesn't contain this index
                if (exportLayers.Contains(i) == false)
                {
                    continue;
                }

                // If got here and root base hasn't been set, that's a problem
                if (rootBase == null)
                {
                    throw new Exception("Trying to create image layer before root base has been set");
                }

                // Get layer info
                Layer layer = settings.Psd.Layers[i];
                if (layer.IsText)
                {
                    constructor = new TextConstructor();
                }
                constructor.layer = layer;

                // Create the game object for the sprite
                string     layerName    = Utility.PinYinHelper.Convert(layer.Name);
                GameObject spriteObject = constructor.CreateGameObject(layerName, lastParent);
                // Reparent created object to last parent
                if (lastParent != null)
                {
                    spriteObject.transform.SetParent(lastParent.transform, false);
                }

                Vector2 spritePivot = GetPivot(SpriteAlignment.Center);
                if (layer.IsText)
                {
                    constructor.AddComponents(i, spriteObject, null, null);
                }
                else
                {
#if NGUI
                    // Add components to the sprite object for the visuals
                    constructor.AddComponents(i, spriteObject, null, null);
#else
                    // Retrieve sprite from asset database
                    string sprPath = PSDExporter.GetLayerFilename(settings, i);

                    Sprite sprite = AssetDatabase.LoadAssetAtPath <Sprite>(sprPath);

                    // Get the pivot settings for the sprite
                    TextureImporter         sprImporter = (TextureImporter)AssetImporter.GetAtPath(sprPath);
                    TextureImporterSettings sprSettings = new TextureImporterSettings();
                    sprImporter.ReadTextureSettings(sprSettings);
                    sprImporter = null;

                    // Add components to the sprite object for the visuals
                    constructor.AddComponents(i, spriteObject, sprite, sprSettings);

                    // Reposition the sprite object according to PSD position
                    spritePivot = GetPivot(sprSettings);
#endif
                }

                Vector3 layerPos = constructor.GetLayerPosition(layer.Rect, spritePivot, settings.PixelsToUnitSize);
                // reverse y axis
                layerPos.y = fileInfo.height - layerPos.y;
                layerPos  -= new Vector3(fileInfo.width, fileInfo.height) * 0.5f;

                // Scaling factor, if sprites were scaled down
                float posScale = 1f;
                switch (settings.ScaleBy)
                {
                case 1:
                    posScale = 0.5f;
                    break;

                case 2:
                    posScale = 0.25f;
                    break;
                }
                layerPos *= posScale;

                // Sprite position is based on root object position initially
                Transform spriteT = spriteObject.transform;
#if NGUI
                spriteT.localPosition = layerPos;
#else
                RectTransform rectTrans = spriteObject.GetComponent <RectTransform>();
                rectTrans.anchoredPosition3D = layerPos;
#endif
            }             // End layer loop

            parseComponent(root);
        }         // End BuildPsd()
Exemple #8
0
        public static GameObject BuildPsdRoot(GameObject root, PsdExportSettings settings, PsdFileInfo fileInfo,
                                              SpriteAlignment align, IPsdConstructor constructor)
        {
            GameObject spriteObject = constructor.CreateGameObject(settings.Filename, root);

            spriteObject.name += "[name:_root_]";
            LayerWordBinder.registWord();

            PSDLayerGroupInfo rootGroup = new PSDLayerGroupInfo(settings.Filename, settings.Psd.Layers.Count - 1, true, true);

            rootGroup.start = 0;

            BuildPsd(spriteObject, rootGroup, settings, fileInfo, align, constructor);

            //bind gen flag
            bindGenFlags(spriteObject);

            return(spriteObject);
        }
Exemple #9
0
        public static int GetExportCount(PsdExportSettings settings, PsdFileInfo fileInfo)
        {
            var exportLayers = GetExportLayers(settings, fileInfo);

            return(exportLayers.Count);
        }