Beispiel #1
0
        public static string[] Export(AtlasRaw atlas, SpriteRaw[] sprites, string folder)
        {
            var exportSprites = new string[sprites.Length];
            var atlasSprites  = sprites.Select(i => PackAtlasSprite.ParseSprite(atlas.bins[i.bin], i)).ToArray();

            PackUtil.LoadAtlasTextures(atlasSprites);
            for (int i = 0; i < atlasSprites.Length; i++)
            {
                var sprite  = atlasSprites[i];
                var rect    = sprite.rect;
                var texture = PackUtil.CreateBlankTexture((int)rect.width, (int)rect.height, sprite.transparency ? TextureFormat.RGBA32 : TextureFormat.RGB24);
                texture.SetPixels(sprite.Read());
                var bytes = sprite.transparency ? texture.EncodeToPNG() : texture.EncodeToJPG();
                var path  = Path.Combine(folder, sprite.name) + (sprite.transparency ? ".png" : ".jpg");
                var dir   = Path.GetDirectoryName(path);
                if (!Directory.Exists(dir))
                {
                    Directory.CreateDirectory(dir);
                }
                File.WriteAllBytes(path, bytes);
                exportSprites[i] = path;
                if (EditorUtility.DisplayCancelableProgressBar("", "export: " + sprite.name, (float)i / sprites.Length))
                {
                    break;
                }
            }
            EditorUtility.ClearProgressBar();
            AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
            return(exportSprites);
        }
Beispiel #2
0
        public AtlasRaw GenerateAtlas()
        {
            if (sprites.Length > PackConst.MaxNumberOfSpriteInAtlas)
            {
                Debug.LogError(string.Format("Sprites in excess of {0}.", PackConst.MaxNumberOfSpriteInAtlas));
                return(null);
            }
            for (int i = 0; i < sprites.Length; i++)
            {
                var texName = sprites[i].name;
                var texRect = sprites[i].rect;
                if (texRect.width > setting.maxAtlasSize ||
                    texRect.height > setting.maxAtlasSize)
                {
                    Debug.LogError(string.Format("Texture size should be lower than {0}: {1}.", setting.maxAtlasSize, texName));
                    return(null);
                }
            }

            var atlasSprites = sprites.Where(i => i is PackAtlasSprite).Select(i => i as PackAtlasSprite).ToArray();

            PackUtil.LoadAtlasTextures(atlasSprites);

            var groups = sprites.GroupBy(texture => new { texture.quality, texture.transparency })
                         .OrderBy(group => group.Key.quality)
                         .ThenBy(group => group.Key.transparency);
            var bins = groups.Select(group =>
            {
                var groupQuality      = group.Key.quality;
                var groupTransparency = group.Key.transparency;
                var groupSprites      = group.ToArray();
                var groupProcessor    = PackProcessor.Fetch(groupQuality);
                groupProcessor.Setup(setting, groupSprites, groupTransparency);
                var groupBins = groupProcessor.Execute();
                foreach (var groupBin in groupBins)
                {
                    groupBin.quality = (int)groupQuality;
                }
                return(groupBins);
            }).SelectMany(i => i).ToArray();

            for (int i = 0; i < bins.Length; i++)
            {
                foreach (var sprite in bins[i].sprites)
                {
                    sprite.bin = i;
                }
            }

            var atlasRaw   = AssetDatabase.LoadAssetAtPath <AtlasRaw>(atlasPath);
            var atlasExist = atlasRaw != null;

            if (atlasExist)
            {
                RemoveAtlasTextures(atlasRaw);
            }
            else
            {
                atlasRaw = ScriptableObject.CreateInstance <AtlasRaw>();
            }
            atlasRaw.hideFlags   = HideFlags.DontUnloadUnusedAsset;
            atlasRaw.bins        = bins;
            atlasRaw.maxSize     = setting.maxAtlasSize;
            atlasRaw.padding     = setting.padding;
            atlasRaw.isPOT       = setting.isPOT;
            atlasRaw.forceSquare = setting.forceSquare;
            if (atlasRaw.id == 0)
            {
                atlasRaw.id = PackUtil.GenerateAtlasId();
            }
            CreateAtlasTextures(atlasRaw);
            if (atlasExist)
            {
                EditorUtility.SetDirty(atlasRaw);
                AssetDatabase.SaveAssets();
            }
            else
            {
                AssetDatabase.CreateAsset(atlasRaw, atlasPath);
            }

            return(atlasRaw);
        }