Unityでアニメーション表現を行うにあたってエディタ拡張した話


#経緯
　先日まで『カラクリショウジョの涙と終』というゲームを制作していました。
　このゲームはアニメーションRPGというジャンルをとっており、全てのグラフィックを手書きアニメーションの要領で構成していています。
![30.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/147986/2e92fd91-9137-36f3-7f4e-dc4a98919e5b.png)
　制作の過程で、いくつかの作業をエディタ拡張によって効率化したため、そちらについてまとめました。
　(アニメーション表現自体は[こちら](https://qiita.com/haruyan/items/60b05832aab4cd0e4491)でまとめております。興味がございましたら。)
　使用したUnityのバージョンは2019.4.4f1です。
#発光処理の工程削減
　今回のグラフィックは『発光』を強調する方向性で効果を加えているのですが、絵における発光部位の指定には白黒のマップ画像を用いています。
<img src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/147986/9b29fdd9-0635-d8d1-bacd-082d8ad7eea9.png"width=500><img src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/147986/8774562f-1878-dc65-63b9-747dc0c1f9fb.jpeg"width=500>

　マップ画像作成の工程は<b>『発光させたいを白に、それ以外の色は黒に塗りつぶす』</b>と非常に単純です。
　またアニメーションの絵は、制作の都合上色の境目がくっきりとしておりアンチエイリアスもかかっていません。（ジャギーが発生している状態です）
![BattleStart_01のコピー.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/147986/44502107-a11c-6ae6-dd05-5d4289fa161d.png)

　そのため特定色の抽出を非常に容易かつ機械的に行うことができます。この性質を活かして自動生成処理をエディタ拡張で実装し作業コストの軽減を図りました。

#マップ生成
　まず発光部分の色を指定する処理からです。同じキャラクターの絵を扱う際には指定する色も同じになるため、色の情報はSciptableObject化し再利用可能にしています。

```c#:MappingTargetColorData.cs
using UnityEngine;

[CreateAssetMenu(fileName = "MappingTargetColorData",menuName ="EmissionMapGenerate/MappingTargetColorData",order =0)]
public class MappingTargetColorData :ScriptableObject
{

    [SerializeField] Color[] targetColors;
    public Color[] TargetColors { get { return targetColors; } }

}

```

(目のハイライトと白目の部分は同じ白に見えますが、RGBの値を調整しハイライトのみ指定するよう工夫しています)

---

マップ生成処理自体は以下のようになっています。

```c#
   private void DrawMap(Texture2D origin) {

        //同じサイズの空のテクスチャを生成
        Texture2D generatedMap = new Texture2D(origin.width, origin.height, TextureFormat.RGB565, false);

        //元の絵のピクセルを一つずつ確認し、発光させたい色だったら白、そうでなれば黒を塗る。
        for (int y = 0; y < generatedMap.height; y++) {

            for (int x = 0; x < generatedMap.width; x++) {

                if (mappingTargetColorData.TargetColors.Contains(origin.GetPixel(x, y))) {

                    generatedMap.SetPixel(x, y, Color.white);

                }
                else {

                    generatedMap.SetPixel(x, y, Color.black);

                }

            }

        }

        //画像の変更を保存
        generatedMap.Apply();

        //画像形式にして書き込み。
        string mapPath = /* パスを入れてください。".jpeg" など拡張子を忘れずに。　*/;

        var bytes = generatedMap.EncodeToJPG();
        File.WriteAllBytes(mapPath, bytes);

        EditorUtility.SetDirty(generatedMap);


    }
```

　この処理を扱うウィンドウを```EditorWindow```で合わせて実装しました。
　コードは以下の通りです。

```c#:EmissionMapGenerator.cs
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using System.IO;
using System.Linq;
using UniRx;


public class EmissionMapGenerator : EditorWindow {

    List<Texture2D> originTextures = new List<Texture2D>();

    string saveDirectoryPath;

    [SerializeField] MappingTargetColorData mappingTargetColorData;

    [MenuItem("Window/EmissionMapGenerator")]
    static void Init() {
        var window = (EmissionMapGenerator)GetWindow(typeof(EmissionMapGenerator));
        window.Show();
    }

    private const string emissionHeader = "Emission_";

    private const string AssetPathHeader = "Assets/";
    private string SaveDirectoryPathResult { get { return AssetPathHeader + saveDirectoryPath; } }


    public void OnGUI() {

        var own = new SerializedObject(this);

        own.Update();

        using (new GUILayout.HorizontalScope()) {
            saveDirectoryPath = EditorGUILayout.TextField("Save Directory Path", saveDirectoryPath);
        }

        using (new GUILayout.HorizontalScope()) {
            EditorGUILayout.PropertyField(own.FindProperty("mappingTargetColorData"), false);
        }

        own.ApplyModifiedProperties();

        using (new GUILayout.HorizontalScope()) {
            if (saveDirectoryPath == "" || saveDirectoryPath == null) {
                EditorGUILayout.HelpBox("保存先パスが未入力です。", MessageType.Warning);
            }

        }

        using (new GUILayout.HorizontalScope()) {
            if (mappingTargetColorData == null) {
                EditorGUILayout.HelpBox("カラーデータが選択されていません。", MessageType.Error);
            }
        }

        if (GUILayout.Button("Genarate")) {

            if (mappingTargetColorData == null) return;

            originTextures.Clear();

            List<string> originTexturePaths = Directory.GetFiles("Assets/MapGenerateTarget")//Assets直下に専用のファイルを作成し、その中の画像からマップを生成します。
                .Where((path) => IsTexturePath(path))
                .Select((path) => {
                    ChangeTextureToDrawableMap(path);//元の画像から情報を取得できるようにしています。
                    return path;
                })
                .ToList();

            originTextures = originTexturePaths
                .Select((path) => AssetDatabase.LoadAssetAtPath<Texture2D>(path))
                .ToList();

            GenerateMaps();

            for (int i = 0; i < originTexturePaths.Count; i++) {
                string path = originTexturePaths[i];
                ChangeTextureNotToReadable(path);

                //元の画像とマップ画像を同じファイルにまとめています。
                AssetDatabase.MoveAsset(path, SaveDirectoryPathResult + "/" + originTextures[i].name + Path.GetExtension(path));

            }

            AssetDatabase.SaveAssets();
            AssetDatabase.Refresh();

        }

    }


    private bool IsTexturePath(string path) {

        if (path.Contains(".meta")) return false;
        if (path.Contains(".DS_Store")) return false;
        return true;

    }


    private void ChangeTextureToDrawableMap(string path) {

        var textureImporter = AssetImporter.GetAtPath(path) as TextureImporter;
        textureImporter.isReadable = true;
        textureImporter.SaveAndReimport();

    }


    private void ChangeTextureNotToReadable(string path) {

        var textureImporter = AssetImporter.GetAtPath(path) as TextureImporter;
        textureImporter.isReadable = false;
        textureImporter.SaveAndReimport();

    }


    private void GenerateMaps() {

        Directory.CreateDirectory(SaveDirectoryPathResult);

        foreach (var origin in originTextures) {
            DrawMap(origin);
        }

        AssetDatabase.SaveAssets();
        AssetDatabase.Refresh();

    }


    private void DrawMap(Texture2D origin) {

        //同じサイズの空のテクスチャを生成
        Texture2D generatedMap = new Texture2D(origin.width, origin.height, TextureFormat.RGB565, false);

        //元の絵のピクセルを一つずつ確認し、発光させたい色だったら白、そうでなれば黒を塗る。
        for (int y = 0; y < generatedMap.height; y++) {

            for (int x = 0; x < generatedMap.width; x++) {

                if (mappingTargetColorData.TargetColors.Contains(origin.GetPixel(x, y))) {

                    generatedMap.SetPixel(x, y, Color.white);

                }
                else {

                    generatedMap.SetPixel(x, y, Color.black);

                }

            }

        }

        //画像の変更を保存
        generatedMap.Apply();

        string mapPath = SaveDirectoryPathResult + "/" + emissionHeader + origin.name + ".jpeg";


        //画像形式にして書き込み。
        var bytes = generatedMap.EncodeToJPG();
        File.WriteAllBytes(mapPath, bytes);

        EditorUtility.SetDirty(generatedMap);

    }


}
```
![スクリーンショット 2020-12-16 10.28.31.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/147986/4aac05a8-7090-0093-071d-c319e83294e4.png)
※ウィンドウ名が異なっていますがプログラムの方を参考にしていただければ大丈夫です。

#アニメーションさせるにあたって
　今回のアニメーションはパラパラ漫画のように画像を切り替えるだけですので、Unity標準のキーフレーム処理のみで構成されておりシンプルです。ですが元のアニメーションに合わせてマップ画像も変更する必要があるため、同じタイミングに二つもキーフレームを打たなければなりませんでした。
　この二度手間をなくすために、マップ切り替えのキーフレームをエディタ拡張で自動入力するようにしています。
　また今回はAnimationClipだけでなく、Timelineから直で入力したキーフレームにも対応させています。

#PlayableAssetの取り扱い
　Timelineで直に入力したアニメーションは、情報を保持するPlayableAssetの下に子オブジェクトのように存在します。
![スクリーンショット 2020-12-16 13.59.44.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/147986/bdb8d540-159f-67db-8a8e-ec4d09900f84.png)
　このようなアセットは『SubAsset』という方法で管理されており、アクセスするには```LoadAllAssetsAtPath()```を使います。
　取得したAsset郡には親にあたるPlayableAssetの情報も含まれているため、AnimationClipのみ抜き出したい場合は注意が必要です。
（SubAssetについては[こちら](https://light11.hatenadiary.com/entry/2018/12/30/230123)を参考にしました。）

#マップ画像の抽出
　次に元の絵に対応したマップ画像をAssetの中から検索する必要があります。
　前述した通り今回はマップ画像を自動生成していたため、命名にも規則ができていました。（元画像名の冒頭に"Emission_"が加わるだけ）
　そのため今回はその規則に基づき、名前からマップ画像を検索、抽出しています。

#キーフレーム入力
　続いて実装内容についてです。
　まず元のアニメーションの情報を取得する必要があります。

```c#
        EditorCurveBinding[] curveBindings = AnimationUtility.GetObjectReferenceCurveBindings(clip);

        //対応するEditorCurveBindingが無い=>絵の切り替えを取り扱っていないAnimationClipのためreturn
        if (!curveBindings.Any(binding => binding.propertyName == "元の絵を扱う変数名")) return;

        //絵の切り替えを行なっているEditorCurveBindingを取得
        var targetCurveBinding = curveBindings.First(binding => binding.propertyName == "元の絵を扱う変数名");
```

　情報は```EditorCurveBinding```というクラスで管理されており、このクラスはアニメーションで扱う値ごとにAnimationClip内に存在します。
　その情報を```AnimationUtility.GetObjectReferenceCurveBindings()```でまとめて取得し、そこから絵の切り替えを取り扱っているものを抽出します。
　判定には```EditorCurveBinding```に用意されている```propertyName```(アニメーションさせている変数名)を利用しました。

---

　次に元のアニメーション情報を利用して新たにキーフレームを定義します。

```c#
        var keyframes = new List<ObjectReferenceKeyframe>();

        foreach (var reference in AnimationUtility.GetObjectReferenceCurve(clip, targetCurveBinding)) {

            //マップ画像の名前
            string emissionMapName = "Emission_" + reference.value.name;

            //マップ画像のパスを取得
            var targetMapPath = texturePaths.FirstOrDefault(target => target.Contains(emissionMapName));

            //パスからマップ画像を取得
            var emissionMap = AssetDatabase.LoadAssetAtPath<Texture2D>(targetMapPath);

            //時間に対応させてキーフレームを定義
            keyframes.Add(new ObjectReferenceKeyframe {
                time = reference.time, //時間
                value = emissionMap //入力内容
            });

        }
```

　キーフレームの情報は```ObjectReferenceKeyframe```クラスで扱われており、```AnimationUtility.GetObjectReferenceCurve()```でAnimationClipから配列で取得できます。
　そして取得したキーフレームそれぞれの時間を参照し、同じタイミングでマップ画像を切り替えるようキーフレームを定義する、といった流れです。
　```ObjectReferenceKeyframe```に関しては[こちら](https://qiita.com/RyotaMurohoshi/items/5cb865c23a50055cf92f)を参考にしました。

---

　最後に、新たな```EditorCurveBinding```を生成し、```AnimationUtility.SetObjectReferenceCurve()```でAnimationClipに適用します

```c#
        EditorCurveBinding emissionMapCurve = new EditorCurveBinding() {
            path = string.Empty,
            type = typeof(/*マップ画像の変更を取り扱うクラス*/),
            propertyName = /*マップ画像を扱う変数名*/
        };

        //適用
        AnimationUtility.SetObjectReferenceCurve(clip, emissionMapCurve, keyframes.ToArray());
```

#コード全文
　以上の処理を利用するにあたって、前述したマップ画像生成と同じく```EditorWindow```を用いています。

```c#:EmissionKeyFrameSetter.cs
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using UnityEngine.Playables;
using System.IO;
using System.Linq;

public class EmissionKeyFrameSetter : EditorWindow {

    [MenuItem("Window/EmissionKeyFrameSetter")]
    static void Init() {
        var window = (EmissionKeyFrameSetter)GetWindow(typeof(EmissionKeyFrameSetter));
        window.Show();
    }

    string saveDirectoryPath;
    private const string AssetPathHeader = "Assets/";

    string[] texturePaths;

    public void OnGUI() {

        using (new GUILayout.HorizontalScope()) {
            saveDirectoryPath = EditorGUILayout.TextField("Save Directory Path", saveDirectoryPath);
        }

        using (new GUILayout.HorizontalScope()) {

            if (IsDirectoryEmpty) {
                EditorGUILayout.HelpBox("保存先パスが入力されていません", MessageType.Warning);
            }

        }

        if (GUILayout.Button("Set")) {

            string saveDirectoryPathResult = AssetPathHeader + saveDirectoryPath;

            if (!Directory.Exists(saveDirectoryPathResult)) {
                Directory.CreateDirectory(saveDirectoryPathResult);
                AssetDatabase.SaveAssets();
                AssetDatabase.Refresh();
            }
           
            //専用のファイルをAsset直下に作り、そこにあるAnimationClipやPlayableAssetに対して処理する
            var clipPaths = Directory.GetFiles("Assets/EmissionSetter").Where(path => !path.Contains("meta"));

            //SubAsset取得
            var subClips = new List<AnimationClip>();

            foreach (string path in clipPaths.Where(path => path.Contains("playable"))) {

                subClips.AddRange(AssetDatabase.LoadAllAssetsAtPath(path)
                    .Where(asset => IsRecordedAnimAsset(asset))
                   .Select(asset => (AnimationClip)asset)
                   .ToList());

                //PlayableAssetを保存先に移動
                string newPath = saveDirectoryPathResult + "/" + Path.GetFileName(path);
                AssetDatabase.MoveAsset(path, newPath);
                EditorUtility.SetDirty(AssetDatabase.LoadAssetAtPath<PlayableAsset>(newPath));
            }
            
            //全テクスチャ情報を取得
            texturePaths = Directory.GetFiles("Assets/Textures", "*", SearchOption.AllDirectories)
                .Where(texturePath => !texturePath.Contains("meta"))
                .ToArray();

            //AnimationClipに対して処理
            foreach (var path in clipPathes) {

                var clip = AssetDatabase.LoadAssetAtPath<AnimationClip>(path);

                if (clip == null) break;

                SetCurve(clip);

                AssetDatabase.MoveAsset(path, saveDirectoryPathResult + "/" + Path.GetFileName(path));
                EditorUtility.SetDirty(clip);
            }

            //SubAssetに対して処理
            foreach (var subClip in subClips) {
                if (subClip == null) break;
                SetCurve(subClip);
            }

            AssetDatabase.SaveAssets();
            AssetDatabase.Refresh();

        }

    }


    private bool IsDirectoryEmpty {

        get {
            if (saveDirectoryPath == null) return true;
            if (saveDirectoryPath == "") return true;
            return false;
        }

    }


    private bool IsRecordedAnimAsset(Object asset) {
        if (!asset.name.Contains("Recorded")) return false;
        if (asset.GetType() != typeof(AnimationClip)) return false;
        return true;
    }


    void SetCurve(AnimationClip clip) {

        EditorCurveBinding[] curveBindings = AnimationUtility.GetObjectReferenceCurveBindings(clip);

        //対応するEditorCurveBindingが無い=>絵の切り替えを取り扱っていないAnimationClipのためreturn
        if (!curveBindings.Any(binding => binding.propertyName == "元の絵を扱う変数名")) return;

        //絵の切り替えを行なっているEditorCurveBindingを取得
        var targetCurveBinding = curveBindings.First(binding => binding.propertyName == "元の絵を扱う変数名");

        var keyframes = new List<ObjectReferenceKeyframe>();

        foreach (var reference in AnimationUtility.GetObjectReferenceCurve(clip, targetCurveBinding)) {

            //マップ画像の名前
            string emissionMapName = "Emission_" + reference.value.name;

            //マップ画像のパスを取得
            var targetMapPath = texturePaths.FirstOrDefault(target => target.Contains(emissionMapName));

            //パスからマップ画像を取得
            var emissionMap = AssetDatabase.LoadAssetAtPath<Texture2D>(targetMapPath);

            //時間に対応させてキーフレームを定義
            keyframes.Add(new ObjectReferenceKeyframe {
                time = reference.time, //時間
                value = emissionMap //入力内容
            });

        }

        EditorCurveBinding emissionMapCurve = new EditorCurveBinding() {
            path = string.Empty,
            type = typeof(/*マップ画像の変更を取り扱うクラス*/),
            propertyName = /*マップ画像を扱う変数名*/
        };

        //適用
        AnimationUtility.SetObjectReferenceCurve(clip, emissionMapCurve, keyframes.ToArray());

    }


}
```
![スクリーンショット 2020-12-16 17.43.08.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/147986/8f280b3e-3527-f007-749e-ca0c45f940b5.png)

#まとめ
　以上のような自動化により単純な作業を減らすことで、作業効率は大きく改善されました。
　ここまで深くエディタ拡張に触れたのは初めてでしたが、どなたかの参考になりましたら幸いです。
#参考にさせていただいた記事
- [【Unity】【エディタ拡張】SubAssetの取り扱いまとめ](https://light11.hatenadiary.com/entry/2018/12/30/230123)
- [複数枚のSpriteからAnimationClipを生成するEditor拡張コード](https://qiita.com/RyotaMurohoshi/items/5cb865c23a50055cf92f)