スプライトパッカー

スプライトによるグラフィックスをデザインする場合、スプライトキャラクター毎にテクスチャファイルを分けた方が作業はしやすくなります。しかし、スプライトテクスチャは空白部分が広いことも多く、そのまま並べると無駄なビデオメモリを消費する結果になります。パフォーマンスを最適化するためには、いくつかのスプライトテクスチャ画像を一緒にまとめて、アトラスとして知られている単一のテクスチャにパックするのが最善です。 Unity は、個々のスプライトテクスチャからアトラスを自動的に生成するユーティリティ、 Sprite Packer を提供しています。

Unity がスプライトアトラステクスチャの生成と処理を行い、ユーザーは手動で割り当てを行う必要はありません。アトラスは必要に応じて再生モードへの移行やビルド時にパックすることができ、スプライトオブジェクトの画像がアトラスから生成されて取得できます。

ユーザーはそのテクスチャのスプライトのパッキングを有効にするテクスチャインポーターでパッキングタグを指定する必要があります。

スプライトパッカーの使い方

スプライトパッカーは、デフォルトでは無効になっていますが、エディターの設定から変更することができます(メニューの Edit -> Project Settings -> Editor)。スプライトパッキングモードは Disabled から Enabled for Builds （パッキングはビルドで有効、プレイモードでは無効）、または Always Enabled (パッキングはプレイモードとビルドの両方で有効）に変更できます。

Sprite Packer window を開いたら(menu: Window -> Sprite Packer)、左上の隅にある Pack ボタンをクリックすると、テクスチャが配置されたアトラスを確認することができます。

プロジェクトパネルでスプライトを選択した場合は、アトラスでの位置を示すために強調表示されます。輪郭は実際のメッシュの輪郭を描画し、それはまた、結合したパッキングの領域を定義する。

スプライトパッカーウィンドウ上部にあるツールバーには、パッキングとビューイングのためのコントロールがいくつか有ります。 Pack ボタンを押すとパッキング処理を開始しますが、アトラスが最後にパッキングされてから変更が無ければ、何も更新されません（下記の Customizing the Sprite Packer で説明していますが、カスタムパッキングポリシーを実装している場合は Repack ボタンが表示されます）。メニューの View Atlas と Page # では、どのアトラスのどのページをウインドウに表示するか、選択することができます（テクスチャサイズが最大でも、すべてのスプライトを格納するのに十分なスペースがない場合は、一つのアトラスが複数の「ページ」に分割されます）。ページ番号の横にあるメニューで、アトラスの“パッキングポリシー” を選択できます（下記参照）。ツールバーの右にある 2 つのコントロールでは、ビューをズームしたり、表示するアトラスのカラーチャンネルを切り替えることができます。

Packing Policy

スプライトパッカーがアトラスにスプライトをどう割り当てるか決めるために、 パッキングポリシー を使用します。独自のパッキングポリシーを作成することも可能ですが（下記参照）、 Default Packer Policy と Tight Packer Policy 、それに Tight Rotate Enabled Sprite Packer Policy オプションがすでに用意されているので、いつでも使う事ができます。これらのポリシーでは Texture Importerの Packing Tag プロパティーからアトラスの名前を直接選択して、スプライトをパックします。したがって、同じパッキングタグを持つスプライトは全て、同じアトラスにパックされます。その後、アトラスはソーステクスチャの設定と一致するように、テクスチャのインポート設定によりソートされます。テクスチャ圧縮設定が同じスプライトは、可能であれば、同じアトラスにまとめられます。

• Packing Tag で “[TIGHT]” が指定されていなければ、 DefaultPackerPolicy は、デフォルトで長方形のパッキングを使用します（つまり、” [TIGHT]Character"とパッキングタグを設定すれば、詰めてパッキングします）。
• TightPackerPolicy は、スプライトがタイトメッシュを持っている場合、デフォルトではタイトパッキングを使用します。 Packing Tag で “[RECT] ” が指定されている場合は、長方形パッキングが行われます（つまり、パッキングタグを “[RECT]UI_Elements” に設定すると、強制的に長方形パッキングになります）。
• TightRotateEnabledSpritePackerPolicy は、スプライトがタイトメッシュを持っていて、スプライトの回転が有効な場合、デフォルトではタイトパッキングを使用します。 Packing Tag で “[RECT]” が指定されている場合は、長方形パッキングが行われます（つまり、パッキングタグを “[RECT]UI_Elements” に設定すると、強制的に長方形パッキングになります）。

スプライトパッカーのカスタマイズ

ほとんどの場合、 DefaultPackerPolicy オプションで十分ですが、必要ならば、独自のカスタム·パッキングポリシーを実装することができます。そのためには、エディター·スクリプトのクラスに UnityEditor.Sprites.IPackerPolicy インターフェースを実装する必要があります。このインターフェースには次のメソッドが必要です:

• GetVersion - パッキングポリシーのバージョン値を返します。ポリシースクリプトに変更がある場合にバージョンが一つあがり、バージョン管理にこのポリシーが保存されます。
• OnGroupAtlases - ここにパッキングロジックを実装します。PackerJob のアトラスを定義し、与えられた TextureImporters からスプライトを割り当てます。

DefaultPackerPolicy はデフォルトではタイトなパッキング（ SpritePackingMode を参照）を使用しています。カスタムポリシーは、これを上書きし、代わりに矩形パッキングを使用することができます。texture-space エフェクトの使用やスプライトをレンダリングするための別のメッシュを使用したい場合に便利です。

• Repack ボタンはカスタムポリシーが選択された場合のみ有効になります。
  • OnGroupAtlases は TextureImporter のメタデータや選択している PackerPolicy のバージョンが変更されないかぎり呼び出されません。
  • カスタムポリシーで作業する際は Repack ボタンを使用してください。
• スプライトは自動的に TightRotateEnabledSpritePackerPolicy により回転を有効にしてパックすることができます。
  • SpritePackingRotation 型は将来の Unity バージョンのために予約されています。

その他

• アトラスは Project\Library\AtlasCache にキャッシュされてます。
  • このフォルダーを削除して Unity を起動すると、Unity はアトラスを強制的に再パックします。フォルダーの削除をする場合は必ず Unity を閉じてから行うようにしてください。
• アトラスキャッシュは起動時に読み込みません。
  • すべてのテクスチャは Unity が再起動した後、最初にパッキングする時にチェックされます。この処理はプロジェクト内のテクスチャの総数により時間がかかる場合があります。
  • 必要なアトラスだけが読み込まれます。
• デフォルトの最大アトラスサイズは 2048x2048 です。
• PackingTag が設定されている場合、テクスチャは圧縮されないため、SpritePacker は元のピクセル値を取得後、アトラスで圧縮を行います。

DefaultPackerPolicy

using System;
using System.Linq;
using UnityEngine;
using UnityEditor;
using System.Collections.Generic;


public class DefaultPackerPolicySample : UnityEditor.Sprites.IPackerPolicy
{
        protected class Entry
        {
            public Sprite            sprite;
        public UnityEditor.Sprites.AtlasSettings settings;
            public string            atlasName;
            public SpritePackingMode packingMode;
            public int               anisoLevel;
        }

        private const uint kDefaultPaddingPower = 3; // Good for base and two mip levels.

        public virtual int GetVersion() { return 1; }
        protected virtual string TagPrefix { get { return "[TIGHT]"; } }
        protected virtual bool AllowTightWhenTagged { get { return true; } }
        protected virtual bool AllowRotationFlipping { get { return false; } }

    public static bool IsCompressedFormat(TextureFormat fmt)
    {
        if (fmt >= TextureFormat.DXT1 && fmt <= TextureFormat.DXT5)
            return true;
        if (fmt >= TextureFormat.DXT1Crunched && fmt <= TextureFormat.DXT5Crunched)
            return true;
        if (fmt >= TextureFormat.PVRTC_RGB2 && fmt <= TextureFormat.PVRTC_RGBA4)
            return true;
        if (fmt == TextureFormat.ETC_RGB4)
            return true;
        if (fmt >= TextureFormat.ATC_RGB4 && fmt <= TextureFormat.ATC_RGBA8)
            return true;
        if (fmt >= TextureFormat.EAC_R && fmt <= TextureFormat.EAC_RG_SIGNED)
            return true;
        if (fmt >= TextureFormat.ETC2_RGB && fmt <= TextureFormat.ETC2_RGBA8)
            return true;
        if (fmt >= TextureFormat.ASTC_RGB_4x4 && fmt <= TextureFormat.ASTC_RGBA_12x12)
            return true;
        if (fmt >= TextureFormat.DXT1Crunched && fmt <= TextureFormat.DXT5Crunched)
            return true;
        return false;
    }

    public void OnGroupAtlases(BuildTarget target, UnityEditor.Sprites.PackerJob job, int[] textureImporterInstanceIDs)
        {
            List<Entry> entries = new List<Entry>();

            foreach (int instanceID in textureImporterInstanceIDs)
            {
                TextureImporter ti = EditorUtility.InstanceIDToObject(instanceID) as TextureImporter;

                TextureFormat desiredFormat;
                ColorSpace colorSpace;
                int compressionQuality;
                ti.ReadTextureImportInstructions(target, out desiredFormat, out colorSpace, out compressionQuality);

                TextureImporterSettings tis = new TextureImporterSettings();
                ti.ReadTextureSettings(tis);

            Sprite[] sprites =
                AssetDatabase.LoadAllAssetRepresentationsAtPath(ti.assetPath)
                    .Select(x => x as Sprite)
                    .Where(x => x != null)
                    .ToArray();
                foreach (Sprite sprite in sprites)
                {
                    Entry entry = new Entry();
                    entry.sprite = sprite;
                    entry.settings.format = desiredFormat;
                    entry.settings.colorSpace = colorSpace;
                    // Use Compression Quality for Grouping later only for Compressed Formats. Otherwise leave it Empty.
                entry.settings.compressionQuality = IsCompressedFormat(desiredFormat) ? compressionQuality : 0;
                entry.settings.filterMode = Enum.IsDefined(typeof(FilterMode), ti.filterMode)
                    ? ti.filterMode
                    : FilterMode.Bilinear;
                    entry.settings.maxWidth = 2048;
                    entry.settings.maxHeight = 2048;
                    entry.settings.generateMipMaps = ti.mipmapEnabled;
                    entry.settings.enableRotation = AllowRotationFlipping;
                    if (ti.mipmapEnabled)
                        entry.settings.paddingPower = kDefaultPaddingPower;
                    else
                        entry.settings.paddingPower = (uint)EditorSettings.spritePackerPaddingPower;
                    #if ENABLE_ANDROID_ATLAS_ETC1_COMPRESSION
                        entry.settings.allowsAlphaSplitting = ti.GetAllowsAlphaSplitting ();
                    #endif //ENABLE_ANDROID_ATLAS_ETC1_COMPRESSION

                    entry.atlasName = ParseAtlasName(ti.spritePackingTag);
                    entry.packingMode = GetPackingMode(ti.spritePackingTag, tis.spriteMeshType);
                    entry.anisoLevel = ti.anisoLevel;

                    entries.Add(entry);
                }

                Resources.UnloadAsset(ti);
            }

            // First split sprites into groups based on atlas name
            var atlasGroups =
                from e in entries
                group e by e.atlasName;
            foreach (var atlasGroup in atlasGroups)
            {
                int page = 0;
                // Then split those groups into smaller groups based on texture settings
                var settingsGroups =
                    from t in atlasGroup
                    group t by t.settings;
                foreach (var settingsGroup in settingsGroups)
                {
                    string atlasName = atlasGroup.Key;
                    if (settingsGroups.Count() > 1)
                        atlasName += string.Format(" (Group {0})", page);

                UnityEditor.Sprites.AtlasSettings settings = settingsGroup.Key;
                    settings.anisoLevel = 1;
                    // Use the highest aniso level from all entries in this atlas
                    if (settings.generateMipMaps)
                        foreach (Entry entry in settingsGroup)
                            if (entry.anisoLevel > settings.anisoLevel)
                                settings.anisoLevel = entry.anisoLevel;

                    job.AddAtlas(atlasName, settings);
                    foreach (Entry entry in settingsGroup)
                    {
                        job.AssignToAtlas(atlasName, entry.sprite, entry.packingMode, SpritePackingRotation.None);
                    }

                    ++page;
                }
            }
        }

        protected bool IsTagPrefixed(string packingTag)
        {
            packingTag = packingTag.Trim();
            if (packingTag.Length < TagPrefix.Length)
                return false;
            return (packingTag.Substring(0, TagPrefix.Length) == TagPrefix);
        }

        private string ParseAtlasName(string packingTag)
        {
            string name = packingTag.Trim();
            if (IsTagPrefixed(name))
                name = name.Substring(TagPrefix.Length).Trim();
            return (name.Length == 0) ? "(unnamed)" : name;
        }

        private SpritePackingMode GetPackingMode(string packingTag, SpriteMeshType meshType)
        {
            if (meshType == SpriteMeshType.Tight)
                if (IsTagPrefixed(packingTag) == AllowTightWhenTagged)
                    return SpritePackingMode.Tight;
            return SpritePackingMode.Rectangle;
        }
}

TightPackerPolicy

using System;
using System.Linq;
using UnityEngine;
using UnityEditor;
using UnityEditor.Sprites;
using System.Collections.Generic;

// TightPackerPolicy will tightly pack non-rectangle Sprites unless their packing tag contains "[RECT]".
class TightPackerPolicySample : DefaultPackerPolicySample
{
        protected override string TagPrefix { get { return "[RECT]"; } }
        protected override bool AllowTightWhenTagged { get { return false; } }
        protected override bool AllowRotationFlipping { get { return false; } }
}

TightRotateEnabledSpritePackerPolicy

using System;
using System.Linq;
using UnityEngine;
using UnityEditor;
using UnityEditor.Sprites;
using System.Collections.Generic;

// TightPackerPolicy will tightly pack non-rectangle Sprites unless their packing tag contains "[RECT]".
class TightRotateEnabledSpritePackerPolicySample : DefaultPackerPolicySample
{
        protected override string TagPrefix { get { return "[RECT]"; } }
        protected override bool AllowTightWhenTagged { get { return false; } }
        protected override bool AllowRotationFlipping { get { return true; } }
}