void OnApplicationQuit()
{
List <TrackAsset> tracks = TimelineAsset.GetOutputTracks().ToList();
for (int i = tracks.Count - 1; i >= 0; i--)
{
TimelineAsset.DeleteTrack(tracks[i]);
}
}
public static void Create(BGMList.Param param)
{
//TimelineAssetの生成
TimelineAsset timeline = Initialize <TimelineAsset>(param.dictKey);
AudioTrack[] audioTracks = timeline.GetRootTracks() as AudioTrack[];
List <AudioClip> audioClips = AssetLoader.LoadAll <AudioClip>("BGM/" + param.dictKey); //ここでファイル名でソートさせる必要がありそう
foreach (AudioTrack audioTrack in audioTracks)
{
timeline.DeleteTrack(audioTrack);
}
//AudioTrackの作成
for (int i = 0; i <= param.subTrackTimeMarkers.Count; i++)
{
timeline.CreateTrack <AudioTrack>();
}
audioTracks = timeline.GetRootTracks() as AudioTrack[];
//AudioClipの割り当て
//メイントラック
audioTracks[0].CreateClip(audioClips[0]);
IEnumerable <TimelineClip> timelineClips = audioTracks[0].GetClips();
foreach (TimelineClip clip in timelineClips)
{
clip.clipIn = 0;
clip.duration = audioClips[1].length;
clip.start = 0;
}
timeline.CreateMarkerTrack();
//ループマーカーの追加
timeline.markerTrack.CreateMarker(typeof(LoopStartMarker), param.loopTimeMarkers.loopStartTime);
timeline.markerTrack.CreateMarker(typeof(LoopEndMarker), param.loopTimeMarkers.loopEndTime);
//セクションマーカーの追加
if (param.sectionMarkers.Count > 0)
{
foreach (double sectionmarker in param.sectionMarkers)
{
timeline.markerTrack.CreateMarker(typeof(SectionMarker), sectionmarker);
}
}
if (param.subTrackTimeMarkers.Count <= 0)
{
return;
}
//サブトラックの割り当て
for (int i = 1; i <= param.subTrackTimeMarkers.Count; i++)
{
audioTracks[i].CreateClip(audioClips[i]);
timelineClips = audioTracks[i].GetClips();
foreach (TimelineClip clip in timelineClips)
{
clip.clipIn = 0;
clip.duration = param.subTrackTimeMarkers[i - 1].endTime - param.subTrackTimeMarkers[i - 1].startTime;
clip.start = param.subTrackTimeMarkers[i - 1].startTime;
}
}
}
public static bool DeleteTrack(TimelineAsset timeline, TrackAsset track)
{
if (TimelineEditor.inspectedDirector != null)
{
TimelineUndo.PushUndo(TimelineEditor.inspectedDirector, "Delete Track");
TimelineEditor.inspectedDirector.ClearGenericBinding(track);
}
return(timeline.DeleteTrack(track));
}
public static void DeleteAllTracks(this TimelineAsset timeline)
{
var tracks = timeline.GetOutputTracks();
foreach (var t in tracks)
{
timeline.DeleteTrack(t);
}
EditorUtility.SetDirty(timeline);
}
public static void DeleteTracksOfType <T>(this TimelineAsset timeline)
{
var tracks = timeline.GetOutputTracks();
var routeTracks = tracks.Where(t => t is T);
foreach (var t in routeTracks)
{
timeline.DeleteTrack(t);
}
EditorUtility.SetDirty(timeline);
}
//----------------------------------------------------------------------------------------------------------------------
internal static void DestroyTestTimelineAssets(TimelineClip clip)
{
TrackAsset movieTrack = clip.parentTrack;
TimelineAsset timelineAsset = movieTrack.timelineAsset;
string tempTimelineAssetPath = AssetDatabase.GetAssetPath(timelineAsset);
Assert.False(string.IsNullOrEmpty(tempTimelineAssetPath));
timelineAsset.DeleteTrack(movieTrack);
ObjectUtility.Destroy(timelineAsset);
AssetDatabase.DeleteAsset(tempTimelineAssetPath);
}
public void ResetExternally()
{
var tracksToDelete = executeTimeline.GetRootTracks();
foreach (var track in tracksToDelete)
{
executeTimeline.DeleteTrack(track);
}
executeTimeline = null;
steerTrack = null;
lerpTrack = null;
attachTrack = null;
ctrack = null;
}
static private void ProcessTracks(TrackAsset parentTrack, List <TrackAsset> tracks, List <Object> goList, int currentIndex)
{
List <TrackAsset> newList = new List <TrackAsset>();
foreach (var track in tracks)
{
var trackType = track.GetType();
if (trackType == typeof(GroupTrack))
{
var childTracks = UpdateManager.GetTrackList(track as GroupTrack);
ProcessTracks(track, childTracks, goList, currentIndex);
}
else if (trackType == typeof(MovieProxyTrack))
{
newList.Add(track);
}
}
List <TrackAsset> toBeDelated = new List <TrackAsset>();
foreach (var track in newList)
{
var tmp = newPlayableDirector.GetGenericBinding(track) as MovieProxyNativeRenderer;
GameObject go = null;
if (tmp != null)
{
go = tmp.gameObject;
}
if (go == null)
{
continue;
}
toBeDelated.Add(track);
var srcClips = track.GetClips();
int counter = 0;
foreach (var srcClip in srcClips)
{
var activationTrack = newAsset.CreateTrack <ActivationTrack>(parentTrack, track.name);
if (counter == 0)
{
newPlayableDirector.SetGenericBinding(activationTrack, go);
}
else
{
GameObject goDup = DuplicateGameObject(go);
newPlayableDirector.SetGenericBinding(activationTrack, goDup);
go = goDup;
}
var dstClip = activationTrack.CreateDefaultClip();
dstClip.start = srcClip.start;
dstClip.duration = srcClip.duration;
var animator = go.GetComponent <Animator>();
if (animator == null)
{
animator = go.AddComponent <Animator>();
}
var movieProxyAsset = srcClip.asset as MovieProxyPlayableAsset;
Sprite[] sprites = new Sprite[movieProxyAsset.Pictures.Length];
string strSrcFolder = Path.Combine(UpdateManager.GetProjectFolder(), movieProxyAsset.Folder).Replace("\\", "/");
string strDistFolder = GetDistinationFolder(movieProxyAsset.Pictures[0]);
for (int ii = 0; ii < movieProxyAsset.Pictures.Length; ii++)
{
string strAssetPath = Path.Combine(strDistFolder, movieProxyAsset.Pictures[ii]).Replace("\\", "/");
string strSrcPath = Path.Combine(strSrcFolder, movieProxyAsset.Pictures[ii]).Replace("\\", "/");
if (!File.Exists(strAssetPath))
{
FileUtil.CopyFileOrDirectory(strSrcPath, strAssetPath);
}
}
for (int ii = 0; ii < movieProxyAsset.Pictures.Length; ii++)
{
string strAssetPath = Path.Combine(strDistFolder, movieProxyAsset.Pictures[ii]).Replace("\\", "/");
strAssetPath = UpdateManager.ToRelativePath(strAssetPath);
AssetDatabase.ImportAsset(strAssetPath);
AssetImporter tmpImporter = AssetImporter.GetAtPath(strAssetPath);
TextureImporter importer = tmpImporter as TextureImporter;
importer.textureType = TextureImporterType.Sprite;
importer.spriteImportMode = SpriteImportMode.Single;
importer.anisoLevel = 16;
AssetDatabase.WriteImportSettingsIfDirty(strAssetPath);
}
for (int ii = 0; ii < movieProxyAsset.Pictures.Length; ii++)
{
string strAssetPath = Path.Combine(strDistFolder, movieProxyAsset.Pictures[ii]).Replace("\\", "/");
strAssetPath = UpdateManager.ToRelativePath(strAssetPath);
AssetDatabase.ImportAsset(strAssetPath);
Sprite sp = (Sprite)AssetDatabase.LoadAssetAtPath(strAssetPath, typeof(Sprite));
sprites[ii] = sp;
}
AnimationClip newClip = new AnimationClip();
newClip.wrapMode = WrapMode.Once;
SerializedObject serializedClip = new SerializedObject(newClip);
SerializedProperty settings = serializedClip.FindProperty("m_AnimationClipSettings");
while (settings.Next(true))
{
if (settings.name == "m_LoopTime")
{
break;
}
}
settings.boolValue = true;
serializedClip.ApplyModifiedProperties();
ObjectReferenceKeyframe[] Keyframes = new ObjectReferenceKeyframe[movieProxyAsset.Pictures.Length];
EditorCurveBinding curveBinding = new EditorCurveBinding();
if (go.GetComponent <Image>() != null)
{
curveBinding.type = typeof(Image);
curveBinding.path = string.Empty;
curveBinding.propertyName = "m_Sprite";
}
else if (go.GetComponent <SpriteRenderer>() != null)
{
curveBinding.type = typeof(SpriteRenderer);
curveBinding.path = string.Empty;
curveBinding.propertyName = "m_Sprite";
}
float delta = (float)srcClip.duration / (float)(movieProxyAsset.Pictures.Length - 1);
for (int ii = 0; ii < movieProxyAsset.Pictures.Length; ii++)
{
Keyframes[ii] = new ObjectReferenceKeyframe();
Keyframes[ii].time = delta * ii;
Keyframes[ii].value = sprites[ii];
}
counter++;
AnimationUtility.SetObjectReferenceCurve(newClip, curveBinding, Keyframes);
strDistFolder = UpdateManager.ToRelativePath(strDistFolder);
var uniquePath = AssetDatabase.GenerateUniqueAssetPath(Path.Combine(strDistFolder, "Animation.anim").Replace("\\", "/"));
AssetDatabase.CreateAsset(newClip, uniquePath);
uniquePath = AssetDatabase.GenerateUniqueAssetPath(Path.Combine(strDistFolder, "Animator.controller").Replace("\\", "/"));
var controller = AnimatorController.CreateAnimatorControllerAtPath(uniquePath);
controller.AddParameter("Start", AnimatorControllerParameterType.Trigger);
var rootStateMachine = controller.layers[0].stateMachine;
var stateA1 = rootStateMachine.AddState("stateA1");
//var resetTransition = rootStateMachine.AddAnyStateTransition(stateA1);
controller.SetStateEffectiveMotion(stateA1, newClip);
animator.runtimeAnimatorController = controller;
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
} // foreach.
foreach (var track in toBeDelated)
{
newAsset.DeleteTrack(track);
}
AssetDatabase.Refresh();
}
private void OnGUI()
{
GUILayout.BeginVertical();
//
GUILayout.BeginHorizontal();
//区域B 展示区域
int x = 0;
int y = 0;
int size = 60;
int padding = 10;
int maxCount = 600 / (size + padding);
int count = 0;
Rect rect = Rect.zero;
Rect labelRect = Rect.zero;
GUILayout.BeginArea(new Rect(padding, padding, 600, 600));
GUILayout.BeginScrollView(new Vector2(300, 0),
GUILayout.Width(600), GUILayout.ExpandHeight(true));
var nodeInfos = BGMSwitchHelper.config.topics;
if (nodeInfos != null)
{
foreach (var nodeInfo in nodeInfos)
{
if (nodeInfo == null)
{
return;
}
rect = new Rect(x, y, size, size);
string topicname = nodeInfo.topicname;
if (GUI.Button(rect, topicname))
{
System.Random random = new System.Random();
int rat = random.Next(nodeInfo.items.Count);
Debug.Log("rat: " + rat);
string id = nodeInfo.items[rat].id;
AudioClip audioclip = Resources.Load <AudioClip>(id);
if (audioclip == null)
{
Debug.LogError("audioclip is null. path: " + id);
}
else
{
TimelineAsset timelineAsset = BGMSwitchHelper.bgmPlayableDirector.playableAsset as TimelineAsset;
List <TrackAsset> lstTrackAsset = timelineAsset.GetRootTracks().ToList <TrackAsset>();
for (int i = 0; i < lstTrackAsset.Count; i++)
{
TrackAsset trackAsset = timelineAsset.GetRootTrack(i);
timelineAsset.DeleteTrack(trackAsset);
}
var track = timelineAsset.CreateTrack <AudioTrack>(null, "bgmTrack");
BGMSwitchHelper.bgmPlayableDirector.SetGenericBinding(track, BGMSwitchHelper.BMGMgrGo);
var clip = track.CreateClip(audioclip);
clip.displayName = audioclip.name;
AudioPlayableAsset clipasset = clip.asset as AudioPlayableAsset;
clipasset.loop = true;
AssetDatabase.SaveAssets();
}
Close();
}
x += size + padding;
count++;
if ((count + 1) % maxCount == 0)
{
x = 0;
y += size + padding;
}
}
}
GUILayout.EndScrollView();
GUILayout.EndArea();
GUILayout.EndHorizontal();
// if (GUILayout.Button("Generate"))
// {
//
// }
GUILayout.EndVertical();
}
public void BuildTimeline()
{
Debug.Log("Buidilng Timeline");
TimelineAsset timelineAsset = (TimelineAsset)timeline.playableAsset;
//TODO: make it so that it deletes all tracks and rebuilds them every each time
for (int i = 0; i < timelineAsset.rootTrackCount; i++)
{
timelineAsset.DeleteTrack(timelineAsset.GetRootTrack(0));
}
for (int i = 0; i < timelineAsset.outputTrackCount; i++)
{
timelineAsset.DeleteTrack(timelineAsset.GetOutputTrack(0));
}
ControlTrack controlTrack = (ControlTrack)timelineAsset.CreateTrack(typeof(ControlTrack), null, "Control Track");
clipToTime = new Dictionary <ClipSettings, double>();
// map all timeline clips first
for (int i = 0; i < timelineClips.Count; i++)
{
TimelineClip tc = controlTrack.CreateDefaultClip();
ControlPlayableAsset cpa = tc.asset as ControlPlayableAsset;
cpa.sourceGameObject.exposedName = UnityEditor.GUID.Generate().ToString();
timeline.SetReferenceValue(cpa.sourceGameObject.exposedName, timelineClips[i].timelineTrack.gameObject);
if (i != 0)
{
tc.start = tc.start + 1;
}
clipToTime.Add(timelineClips[i], tc.start);
tc.duration = timelineClips[i].timelineTrack.duration;
}
//map remix clips
int j = 0;
foreach (TimelineClip tc in controlTrack.GetClips())
{
foreach (TriggerMapping triggerMapping in timelineClips[j].triggers)
{
TimeMachineTrack timeMachineTrack = (TimeMachineTrack)timelineAsset.CreateTrack(typeof(TimeMachineTrack), null, "Trigger Track");
if (triggerMapping.type == TriggerType.CONTINUOUS)
{
TimelineClip triggerCip = timeMachineTrack.CreateDefaultClip();
TimeMachineAsset tma = triggerCip.asset as TimeMachineAsset;
tma.action = TimeMachineBehavior.TimeMachineAction.JumpToTime;
tma.condition = TimeMachineBehavior.Condition.TriggerOff;
tma.timeToJumpTo = (float)clipToTime[triggerMapping.targetTrack];
triggerCip.start = tc.start;
triggerCip.duration = tc.duration;
tma.trigger.exposedName = UnityEditor.GUID.Generate().ToString();
// tma.timeToJumpTo = triggerMapping.timeToJumpTo;
timeline.SetReferenceValue(tma.trigger.exposedName, triggerMapping.trigger);
}
else
{
TimelineClip triggerCip = timeMachineTrack.CreateDefaultClip();
TimeMachineAsset tma = triggerCip.asset as TimeMachineAsset;
tma.action = TimeMachineBehavior.TimeMachineAction.JumpToTime;
tma.condition = TimeMachineBehavior.Condition.TriggerOff;
tma.timeToJumpTo = (float)clipToTime[triggerMapping.targetTrack];
triggerCip.start = tc.end;
triggerCip.duration = 1;
tma.trigger.exposedName = UnityEditor.GUID.Generate().ToString();
timeline.SetReferenceValue(tma.trigger.exposedName, triggerMapping.trigger);
}
}
j++;
}
Debug.Log("Finished");
}
//----------------------------------------------------------------------------------------------------------------------
/// <summary>
/// Destroy Timeline assets related to the passed TimelineClip
/// </summary>
/// <param name="clip">The clip which assets will be destroyed</param>
internal static void DestroyAssets(TimelineClip clip) {
TrackAsset movieTrack = clip.GetParentTrack();
TimelineAsset timelineAsset = movieTrack.timelineAsset;
timelineAsset.DeleteTrack(movieTrack);
DestroyAssets(timelineAsset);
}
public static bool DeleteTrack(TimelineAsset timeline, TrackAsset track)
{
return(timeline.DeleteTrack(track));
}
