【Unity】Timeline × Excelでスライドショーを効率よく制作する

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class SlideData : ScriptableObject
{	
	public List<Sheet> sheets = new List<Sheet> ();

	[System.SerializableAttribute]
	public class Sheet
	{
		public string name = string.Empty;
		public List<Param> list = new List<Param>();
	}

	[System.SerializableAttribute]
	public class Param
	{
		
		public double Frame;
		public string TexturePath;
		public string Message;
		public double PositionX;
		public double PositionY;
		public double MoveSpeedX;
		public double MoveSpeedY;
		public double Scale;
		public double ShowDuration;
		public double FadeInDuration;
		public double FadeOutDuration;
	}
}

using DG.Tweening;
using UnityEngine;
using UnityEngine.UI;

namespace MovieMaker.Slide.UI
{
    /// <summary>
    /// スライド画像UI
    /// </summary>
    public class SlideImage : MonoBehaviour
    {
        /// <summary>
        /// スライドImageUI
        /// </summary>
        [SerializeField] private Image _slideImage;

        /// <summary>
        /// スライドRectTransform
        /// </summary>
        [SerializeField] private RectTransform _slideRectTransform;

        /// <summary>
        /// 表示中か？
        /// </summary>
        private bool _isShowing = false;
        public bool IsShowing => _isShowing;

        private void Start()
        {
            // 最初は非表示
            Hide();
        }

        /// <summary>
        /// スライドデータの設定
        /// </summary>
        /// <param name="slideData">画像データ</param>
        public void SetData(SlideData.Param slideData)
        {
            ClearData();

            // 名前からテクスチャを取得
            var newTexture = Resources.Load<Texture2D>(slideData.TexturePath);
            if (newTexture == null)
            {
                Debug.LogError($"not found texture => {slideData.TexturePath}");
                return;
            }

            // スプライトの設定
            var newSprite = Sprite.Create(
                newTexture,
                new Rect(0, 0, newTexture.width, newTexture.height),
                new Vector2(0.5f, 0.5f));
            _slideImage.sprite = newSprite;
            _slideRectTransform.localPosition = new Vector3(
                (float) slideData.PositionX * (Screen.width / 2.0f),
                (float) slideData.PositionY * (Screen.height / 2.0f),
                0.0f);
            _slideRectTransform.sizeDelta = new Vector2(
                (float) slideData.Scale * newTexture.width,
                (float) slideData.Scale * newTexture.height);
        }

        /// <summary>
        /// 画像データのクリア
        /// </summary>
        public void ClearData()
        {
            _slideImage.sprite = null;
            _slideRectTransform.localPosition = Vector3.zero;
            _slideRectTransform.sizeDelta = Vector2.one;
        }

        /// <summary>
        /// 表示処理
        /// </summary>
        /// <param name="slideData">画像データ</param>
        public void Show(SlideData.Param slideData)
        {
            _isShowing = true;

            // 画像データ設定
            SetData(slideData);

            // アニメーション開始
            var sequence = DOTween.Sequence();

            // 移動処理
            var moveSpeedX = (float) slideData.MoveSpeedX;
            var moveSpeedY = (float) slideData.MoveSpeedY;
            var movePosition = new Vector3(moveSpeedX, moveSpeedY, 0f) * (float) slideData.ShowDuration;
            if (movePosition.sqrMagnitude > Mathf.Epsilon)
            {
                transform.DOMove(movePosition, (float)slideData.ShowDuration)
                    .SetRelative()
                    .SetEase(Ease.Linear);
            }

            // フェードイン
            var tmpColor = _slideImage.color;
            tmpColor.a = 0.0f;
            _slideImage.color = tmpColor;
            sequence.Append(DOTween.ToAlpha(
                () => _slideImage.color,
                color => _slideImage.color = color,
                1.0f,
                (float) slideData.FadeInDuration
                ));

            // 表示待機時間
            var showDuration = slideData.ShowDuration - slideData.FadeInDuration - slideData.FadeOutDuration;
            sequence.AppendInterval((float) showDuration);

            // フェードアウト
            sequence.Append(DOTween.ToAlpha(
                () => _slideImage.color,
                color => _slideImage.color = color,
                0.0f,
                (float) slideData.FadeOutDuration
            ));

            // 表示フラグをオフにする
            sequence.AppendCallback(() =>
            {
                _isShowing = false;
            });
        }

        /// <summary>
        /// 非表示処理
        /// </summary>
        public void Hide()
        {
            ClearData();

            // 画像非表示
            var tmpColor = _slideImage.color;
            tmpColor.a = 0.0f;
            _slideImage.color = tmpColor;
        }
    }
}

using System.Linq;
using MovieMaker.Slide.UI;
using UnityEngine;
using UnityEngine.Playables;

namespace MovieMaker.Slide
{
    /// <summary>
    /// スライドデータPlayableBehavior
    /// </summary>
    public class SlidePlayableBehaviour : PlayableBehaviour
    {
        /// <summary>
        /// スライドデータ
        /// </summary>
        public SlideData.Param SlideData { set; private get; }

        /// <summary>
        /// 文字列未設定時の値
        /// </summary>
        private const string StringNoneValue = "-";

        /// <summary>
        /// PlayableAsset再生時処理
        /// </summary>
        /// <param name="playable"></param>
        /// <param name="info"></param>
        public override void OnBehaviourPlay(Playable playable, FrameData info)
        {
            base.OnBehaviourPlay(playable, info);

            if (SlideData == null)
            {
                Debug.LogError($"not set image data => {info.frameId}");
                return;
            }

            if (SlideData.TexturePath != StringNoneValue)
            {
                // ========== 画像の場合 ==========
                // Scene上からSlideImageオブジェクトを取得
                var slideImageArray = GameObject.FindObjectsByType<SlideImage>(FindObjectsSortMode.None);

                // 表示中でないオブジェクトに対してデータを設定して表示する
                var slideImage = slideImageArray.FirstOrDefault(s => !s.IsShowing);
                if (slideImage == null)
                {
                    Debug.LogError($"all image showing => {info.frameId}");
                    return;
                }
                slideImage.Show(SlideData);
            }
            else if (SlideData.Message != StringNoneValue)
            {
                // ========== テキストの場合 ==========
                // Scene上からSlideImageオブジェクトを取得
                var slideTextArray = GameObject.FindObjectsByType<SlideText>(FindObjectsSortMode.None);

                // 表示中でないオブジェクトに対してデータを設定して表示する
                var slideText = slideTextArray.FirstOrDefault(s => !s.IsShowing);
                if (slideText == null)
                {
                    Debug.LogError($"all text showing => {info.frameId}");
                    return;
                }
                slideText.Show(SlideData);
            }
        }
    }
}

using UnityEngine;
using UnityEngine.Playables;

namespace MovieMaker.Slide
{
    /// <summary>
    /// スライドデータPlayableAsset
    /// </summary>
    public class SlidePlayableAsset : PlayableAsset
    {
        /// <summary>
        /// スライド情報(初期設定用)
        /// </summary>
        [SerializeField] private SlideData.Param _slideData;

        /// <summary>
        /// スライド情報の設定
        /// </summary>
        /// <param name="slideData"></param>
        public void SetSlideData(SlideData.Param slideData)
        {
            _slideData = slideData;
        }

        public override Playable CreatePlayable(PlayableGraph graph, GameObject owner)
        {
            // playableのBehaviourにデータを設定して返却
            var playable = ScriptPlayable<SlidePlayableBehaviour>.Create(graph);
            var playableBehaviour = playable.GetBehaviour();
            playableBehaviour.SlideData = _slideData;
            return playable;
        }
    }
}

using System.Collections.Generic;
using System.IO;
using MovieMaker.Slide;
using UnityEditor;
using UnityEngine;
using UnityEngine.Timeline;

namespace MovieMaker.Editor
{
    /// <summary>
    /// スライドTimelineエディタ拡張
    /// ScriptableObjectデータからKeyframe用のGUIを表示する
    /// </summary>
    [CustomEditor(typeof(TimelineAsset))]
    public class SlideTimelineEditor : UnityEditor.Editor
    {
        /// <summary>
        /// スライド情報（内部保持用）
        /// </summary>
        private SlideData _slideData;

        /// <summary>
        /// Timeline格納パス
        /// </summary>
        private static readonly string TimelineDirPath = "Assets/MovieMaker/Timeline";

        /// <summary>
        /// Slideトラック格納パス
        /// ※トラック生成時に保存される
        /// </summary>
        private static readonly string SlideTracksDirPath = $"{TimelineDirPath}/SlideTracks";

        /// <summary>
        /// DummyTimelineアセットパス
        /// ※更新後のタイムライン表示を切り替えるために一時的に切り替える
        /// </summary>
        private static readonly string DummyTimelineAssetPath = $"{TimelineDirPath}/Dummy/DummyTimeline.playable";

        /// <summary>
        /// 生成対象のトラック名
        /// </summary>
        private const string SlideTrackName = "SlidePlayableTrack";

        public override void OnInspectorGUI()
        {
            base.OnInspectorGUI();

            // キーフレーム作成用のGUI表示
            EditorGUILayout.Separator();
            EditorGUILayout.LabelField("Slide Track Generate", EditorStyles.boldLabel);

            // TODO: ObjectFieldだと保存されないので、本当はSerializedFieldを使いたい.
            // TODO: しかしその場合にはCustomのTimelineAssetを作成する必要があり、Timelineアセットの生成など面倒なことになりそうなので保留.
            _slideData = (SlideData) EditorGUILayout.ObjectField("Slide Data", _slideData, typeof(SlideData), false);

            // Generateボタン
            if (GUILayout.Button("Generate"))
            {
                // Timelineの内容が動的に更新されないため、一時的に他のアセットを選択
                var dummy = AssetDatabase.LoadAssetAtPath<TimelineAsset>(DummyTimelineAssetPath);
                Selection.activeObject = dummy;

                // トラック生成
                var timelineAsset = (TimelineAsset) target;
                GenerateTracks(timelineAsset, _slideData);
                EditorUtility.SetDirty(timelineAsset);

                // 選択しなおすことでTimelineを強制再描画
                Selection.activeObject = timelineAsset;
            }
        }

        /// <summary>
        /// PlayableTrack生成
        /// 管理を簡潔にするために 1スライド/1トラック で生成する
        /// </summary>
        /// <param name="playableTrack">PlayableTrack</param>
        /// <param name="slideDaraParam">スライド情報データ</param>
        private static void GenerateTrack(PlayableTrack playableTrack, SlideData.Param slideDaraParam)
        {
            // SlidePlayableAssetの作成
            var slidePlayableAsset = ScriptableObject.CreateInstance<SlidePlayableAsset>();
            slidePlayableAsset.SetSlideData(slideDaraParam);
            var slidePlayableAssetPath = Path.Join(SlideTracksDirPath, $"{playableTrack.name}.asset");
            AssetDatabase.CreateAsset(slidePlayableAsset, slidePlayableAssetPath);

            // Clipに設定
            var clip = playableTrack.CreateClip<SlidePlayableAsset>();
            clip.asset = slidePlayableAsset;
            clip.start = slideDaraParam.Frame;
            clip.duration = slideDaraParam.ShowDuration;
        }

        /// <summary>
        /// 全てのPlayableTrack生成
        /// </summary>
        /// <param name="timelineAsset">Timelineアセット</param>
        /// <param name="slideData">スライド情報データ</param>
        private static void GenerateTracks(TimelineAsset timelineAsset, SlideData slideData)
        {
            if (slideData == null)
            {
                Debug.LogError("please set slide data.");
                return;
            }

            // 作成済のキーフレームを削除する
            var deleteTracks = new List<TrackAsset>();
            foreach (var outputTrack in timelineAsset.GetOutputTracks())
            {
                if (outputTrack.name.Contains(SlideTrackName))
                {
                    deleteTracks.Add(outputTrack);
                }
            }
            foreach (var deleteTrack in deleteTracks)
            {
                var deleteTrackName = deleteTrack.name;
                timelineAsset.DeleteTrack(deleteTrack);
                Debug.Log($"delete track => {deleteTrackName}");
            }

            // 作成済のスライド情報アセットを削除
            var slideDataAssetGuids = AssetDatabase.FindAssets("t:ScriptableObject", new[] { SlideTracksDirPath });
            foreach (var slideDataAssetGuid in slideDataAssetGuids)
            {
                var assetPath = AssetDatabase.GUIDToAssetPath(slideDataAssetGuid);
                AssetDatabase.DeleteAsset(assetPath);
                Debug.Log($"delete asset => {assetPath}");
            }

            // AssetDatabaseを更新
            AssetDatabase.Refresh();

            // パラメータごとにTrackを生成する
            var slideTrackIndex = 1;
            foreach (var sheet in slideData.sheets)
            {
                // パラメータからTrackを生成
                foreach (var param in sheet.list)
                {
                    var trackName = $"{SlideTrackName}_{slideTrackIndex}";
                    var track = timelineAsset.CreateTrack<PlayableTrack>(null, trackName);
                    GenerateTrack(track, param);
                    slideTrackIndex++;
                    Debug.Log($"create track => {trackName}");
                }
            }
        }
    }
}