void DrawSaveSettingSelect()
 {
     string[] savedSetNames = new string[config.SettingsSets.Count];
     int[] savedSetIndeces = new int[savedSetNames.Length];
     for (int i = 0; i < savedSetNames.Length; i++) {
         savedSetNames[i] = config.SettingsSets[i].Name;
         savedSetIndeces[i] = i;
     }
     // Make sure a previously selected index still exists
     if (selectedSettingIndex >= savedSetNames.Length) {
         selectedSettingIndex = savedSetNames.Length -1;
     }
     EditorGUILayout.BeginHorizontal ();
     selectedSettingIndex = EditorGUILayout.IntPopup ("Setting to Apply", selectedSettingIndex,
                                                 savedSetNames, savedSetIndeces);
     currentSelectedSettings = config.SettingsSets [selectedSettingIndex];
     if (GUILayout.Button ("Edit", GUILayout.MaxWidth(80.0f))) {
         ShowConfigWindow (selectedSettingIndex);
     }
     EditorGUILayout.EndHorizontal ();
 }
        public static void ApplySpriteSettings(Texture2D texture,
            SpriteSettings prefs, SpriteFileSettings fileSettings)
        {
            if (prefs == null) return;

            string path = AssetDatabase.GetAssetPath (texture);
            var importer = AssetImporter.GetAtPath(path) as TextureImporter;

            // When we have text file data
            SpriteSlicingOptions slicingOptions = fileSettings.SlicingOptions;
            if (slicingOptions.ImportMode == SpriteImportMode.Multiple)
            {
                // Clamp cellSize to texture width and height
                slicingOptions.CellSize.x = Mathf.Min (texture.width, slicingOptions.CellSize.x);
                slicingOptions.CellSize.y = Mathf.Min (texture.height, slicingOptions.CellSize.y);

                SpriteMetaData[] spriteSheet;
                spriteSheet = SpriteSlicer.CreateSpriteSheetForTexture (AssetDatabase.LoadAssetAtPath(path,
                    typeof(Texture2D)) as Texture2D, slicingOptions);

                // If we don't do this it won't update the new sprite meta data
                importer.spriteImportMode = SpriteImportMode.Single;
                importer.spriteImportMode = SpriteImportMode.Multiple;

                importer.spritesheet = spriteSheet;
            }
            else if (slicingOptions.ImportMode == SpriteImportMode.Single)
            {
                importer.spriteImportMode = SpriteImportMode.Single;
            } else if (slicingOptions.ImportMode == SpriteImportMode.None)
            {
                // Do nothing for None mode for now.
            } else
            {
                throw new System.NotSupportedException ("Encountered unsupported SpriteImportMode:"
                    + slicingOptions.ImportMode);
            }

            TextureImporterSettings settings = new TextureImporterSettings();
            importer.ReadTextureSettings(settings);
            importer.textureType = TextureImporterType.Advanced;

            settings.filterMode = prefs.FilterMode;
            settings.wrapMode = prefs.WrapMode;
            settings.mipmapEnabled = prefs.GenerateMipMaps;
            settings.textureFormat = prefs.TextureFormat;
            settings.maxTextureSize = prefs.MaxSize;

            settings.spritePixelsPerUnit = prefs.PixelsPerUnit;

            settings.spriteExtrude = (uint)Mathf.Clamp(prefs.ExtrudeEdges, 0, 32);
            settings.spriteMeshType = prefs.SpriteMeshType;

            // Settings also store Sprite Alignment for Single spritemode
            settings.spriteAlignment = (int)slicingOptions.Pivot;
            if (slicingOptions.Pivot == SpriteAlignment.Custom)
            {
                settings.spritePivot = slicingOptions.CustomPivot;
            }

            importer.spritePackingTag = fileSettings.PackingTag;

            importer.SetTextureSettings(settings);
            #if UNITY_5_0
            importer.SaveAndReimport();
            #else
            AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate);
            #endif
            EditorUtility.SetDirty(texture);
            WriteSpriteFileSettings (path, prefs.SpritesheetDataFile, texture.name + ".png", fileSettings);
        }
Esempio n. 3
0
        public static void ApplyDefaultTextureSettings(
            SpriteSettings prefs,
            bool changePivot,
            bool changePackingTag)
        {
            if (prefs == null)
            {
                return;
            }

            foreach (var obj in Selection.objects)
            {
                if (!AssetDatabase.Contains(obj))
                {
                    continue;
                }

                string path = AssetDatabase.GetAssetPath(obj);

                var importer = AssetImporter.GetAtPath(path) as TextureImporter;
                if (importer == null)
                {
                    continue;
                }

                // Try to slice it
                var             fileName        = Path.GetFileNameWithoutExtension(path);
                SpriteSheetData spriteSheetData = GetSpriteData(path, prefs.SpritesheetDataFile);

                // When we have text file data
                if (spriteSheetData != null)
                {
                    var gridRects = InternalSpriteUtility.GenerateGridSpriteRectangles(
                        AssetDatabase.LoadAssetAtPath(path, typeof(Texture2D)) as Texture2D,
                        Vector2.zero, spriteSheetData.Size, Vector2.zero);

                    var spriteSheet = importer.spritesheet ?? new SpriteMetaData[gridRects.Length];

                    if (importer.spritesheet != null)
                    {
                        spriteSheet = spriteSheet.Concat(new SpriteMetaData[Mathf.Max(0, gridRects.Length - importer.spritesheet.Length)]).ToArray();
                    }

                    for (var i = 0; i < spriteSheet.Length; i++)
                    {
                        bool sliceExists = importer.spritesheet != null && i < importer.spritesheet.Length;
                        bool changed     = changePivot || !(sliceExists);
                        spriteSheet[i] = new SpriteMetaData
                        {
                            alignment = changed ? (int)prefs.Pivot : spriteSheet[i].alignment,
                            pivot     = changed ? prefs.CustomPivot : spriteSheet[i].pivot,
                            name      = sliceExists ? spriteSheet[i].name : fileName + "_" + Array.IndexOf(gridRects, gridRects[i]),
                            rect      = gridRects[i]
                        };
                    }

                    // If we don't do this it won't update the new sprite meta data
                    importer.spriteImportMode = SpriteImportMode.Single;
                    importer.spriteImportMode = SpriteImportMode.Multiple;

                    if (spriteSheetData.Frames > 0)
                    {
                        importer.spritesheet = spriteSheet.Take((int)spriteSheetData.Frames).ToArray();
                    }
                    else
                    {
                        importer.spritesheet = spriteSheet;
                    }
                }
                else if (importer.spritesheet != null && changePivot) // for existing sliced sheets without data in the text file and wantint to change pivot
                {
                    var spriteSheet = new SpriteMetaData[importer.spritesheet.Length];

                    for (int i = 0; i < importer.spritesheet.Length; i++)
                    {
                        var spriteMetaData = importer.spritesheet[i];
                        spriteMetaData.alignment = (int)prefs.Pivot;
                        spriteMetaData.pivot     = prefs.CustomPivot;
                        spriteSheet[i]           = spriteMetaData;
                    }

                    importer.spritesheet = spriteSheet;
                }
                else
                {
                    importer.spriteImportMode = SpriteImportMode.Single;
                }

                TextureImporterSettings settings = new TextureImporterSettings();
                importer.ReadTextureSettings(settings);

                settings.filterMode     = prefs.FilterMode;
                settings.wrapMode       = prefs.WrapMode;
                settings.mipmapEnabled  = prefs.GenerateMipMaps;
                settings.textureFormat  = prefs.TextureFormat;
                settings.maxTextureSize = prefs.MaxSize;

                settings.spritePixelsPerUnit = prefs.PixelsPerUnit;

                settings.spriteExtrude  = (uint)Mathf.Clamp(prefs.ExtrudeEdges, 0, 32);
                settings.spriteMeshType = prefs.SpriteMeshType;

                if (changePivot)
                {
                    settings.spriteAlignment = (int)prefs.Pivot;
                    if (prefs.Pivot == SpriteAlignment.Custom)
                    {
                        settings.spritePivot = prefs.CustomPivot;
                    }
                }

                if (changePackingTag)
                {
                    importer.spritePackingTag = prefs.PackingTag;
                }

                importer.SetTextureSettings(settings);
#if UNITY_5_0
                importer.SaveAndReimport();
#else
                AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate);
#endif
                EditorUtility.SetDirty(obj);
            }
        }