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
        private static void HandleGroupObject(PSDLayerGroupInfo groupInfo,
                                              Dictionary <PSDLayerGroupInfo, GameObject> groupHeaders,
                                              bool startGroup, IPsdConstructor constructor,
                                              ref GameObject lastParent)
        {
            if (startGroup)
            {
                string     groupName = Utility.PinYinHelper.Convert(groupInfo.name);
                GameObject groupRoot = constructor.CreateGameObject(groupName, lastParent);

                constructor.HandleGroupOpen(groupRoot);

                lastParent = groupRoot;
                groupHeaders.Add(groupInfo, groupRoot);
                return;
            }

            // If not startGroup, closing group
            var header = groupHeaders[groupInfo].transform;

            if (header.parent != null)
            {
                constructor.HandleGroupClose(lastParent);

                lastParent = groupHeaders[groupInfo].transform.parent.gameObject;
            }
            else
            {
                lastParent = null;
            }
        }
Exemple #3
0
        private Rect DrawLayerGroupStart(PSDLayerGroupInfo groupInfo,
                                         int layerIndex, int indentLevel)
        {
            GUIStyle style = styleLayerNormal;

            if (selectedGroup != null && selectedGroup.ContainsLayer(layerIndex))
            {
                style = styleLayerSelected;
            }

            EditorGUILayout.BeginHorizontal(style);

            // Draw group visibility toggle
            bool visToggle = EditorGUILayout.Toggle(groupInfo.visible, GUILayout.Width(colVisible));

            float indentAmount = indentLevel * indentSize;

            GUILayout.Space(indentAmount);

            // Draw the layer group name
            GUIContent groupDisplay = new GUIContent()
            {
                image = icnFolder,
                text  = groupInfo.name
            };

            groupInfo.opened = EditorGUILayout.Foldout(groupInfo.opened, GUIContent.none);

            var foldoutRect = GUILayoutUtility.GetLastRect();

            foldoutRect.xMin += 13f;
            foldoutRect.width = 250f;
            EditorGUI.LabelField(foldoutRect, groupDisplay);

            GUILayout.FlexibleSpace();

            // Save the data into group info and file info
            groupInfo.visible = visToggle;
            fileInfo.LayerVisibility[layerIndex] = visToggle;

            EditorGUILayout.EndHorizontal();
            Rect groupRect = GUILayoutUtility.GetLastRect();

            return(groupRect);
        }
Exemple #4
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 #5
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()