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 void CleanupTimelineAsset(TimelineAsset tA)
{
Object[] assets = AssetDatabase.LoadAllAssetsAtPath(AssetDatabase.GetAssetPath(tA));
bool needsSave = false;
List <AnimationClip> allAnimationClips = new List <AnimationClip> ();
GetAllAnimationClipsRecursive(tA.GetRootTracks(), allAnimationClips);
foreach (Object asset in assets)
{
AnimationClip animClip = asset as AnimationClip;
if (animClip == null || AssetDatabase.IsMainAsset(asset))
{
continue;
}
if (allAnimationClips.Contains(animClip))
{
continue;
}
Object.DestroyImmediate(asset, true);
needsSave = true;
}
if (needsSave)
{
AssetDatabase.SaveAssets();
}
}
private static void SetExpandedStates(TimelineAsset asset, HashSet <TrackAsset> expanded)
{
foreach (TrackAsset track in asset.GetRootTracks())
{
SetExpandedStates(track, expanded);
}
}
public static void EnumerateTracks(TimelineAsset timeline, Action <TrackAsset> act)
{
foreach (var track in timeline.GetRootTracks())
{
EnumerateTracks(track, act);
}
}
public static void RunOnRootTracks(TimelineAsset timelineAsset, Action <TrackAsset> @Action)
{
IEnumerable <TrackAsset> tracks = timelineAsset.GetRootTracks();
foreach (TrackAsset track in tracks)
{
@Action.Invoke(track);
}
}
// 导出rootTrack
private void ExportRootTrack(JSONObject rootTrackIndexArr, JSONObject trackListArr, JSONObject clipListArr)
{
IEnumerable <TrackAsset> trackAssetList = timelineAsset.GetRootTracks();
List <int> indexList = ExportTrackList(trackAssetList, trackListArr, clipListArr);
foreach (int index in indexList)
{
rootTrackIndexArr.Add(index);
}
}
/// <summary>
/// From a given timeline asset, see if we can find a track with the matching name
/// </summary>
public static TrackAsset FindTrackByName(TimelineAsset timelineAsset, string name)
{
var trackList = timelineAsset.GetRootTracks();
var thisTrack = FindTrackByNameInternal(trackList, name);
if (thisTrack == null)
{
UnityEngine.Debug.Log("Could not find track in Timeline with name: " + name);
}
return(thisTrack);
}
internal static int CalcAnimClipHash(TimelineAsset asset)
{
int hash = 0;
foreach (var t in asset.GetRootTracks())
{
if (t != null)
{
hash ^= CalcAnimClipHash(t);
}
}
return(hash);
}
public static void SetAllClipDurations(this TimelineAsset timeline, double duration)
{
foreach (var track in timeline.GetRootTracks())
{
foreach (var clip in track.GetClips())
{
if (clip.asset is IExpandableClip playable && playable.inheritDuration)
{
clip.timeScale = 1;
clip.start = 0;
clip.duration = duration;
}
}
}
}
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;
}
public static bool TryGetClip <T>(this TimelineAsset timeline, out T clipAsset)
where T : UnityEngine.Object
{
foreach (var track in timeline.GetRootTracks())
{
foreach (var clip in track.GetClips())
{
clipAsset = clip.asset as T;
if (clipAsset != default)
{
return(true);
}
}
}
clipAsset = default;
return(false);
}
//Finds the TimelineClip corresponding to a playable asset in a timeline
public static TimelineClip GetClip(TimelineAsset timeline, IPlayableAsset Clip)
{
if (timeline != null)
{
foreach (TrackAsset track in timeline.GetRootTracks())
{
TimelineClip clip = GetClipInAllTracks(track, Clip);
if (clip != null)
{
return(clip);
}
}
}
return(null);
}
AnimationTrack GetOrCreateAnimationTrack(string name, TimelineAsset timeline, Action <AnimationTrack> prepareFunc = null)
{
var track = timeline.GetRootTracks().OfType <AnimationTrack>()
.FirstOrDefault(t => t != null && t.name == name);
if (track != null)
{
if (prepareFunc != null)
{
prepareFunc(track);
}
}
else
{
track = timeline.CreateTrack <AnimationTrack>(null, name);
}
return(track);
}
/**************
* UTA Getters *
**************/
private List <TimelineAsset> GetAllUTATimelines()
{
List <TimelineAsset> res = new List <TimelineAsset>();
string[] guids = AssetDatabase.FindAssets("t:timelineasset", new string[] { "Assets" });
foreach (string guid in guids)
{
TimelineAsset a = AssetDatabase.LoadAssetAtPath <TimelineAsset>(AssetDatabase.GUIDToAssetPath(guid));
foreach (TrackAsset track in a.GetRootTracks())
{
if (track.GetType().IsAssignableFrom(typeof(UTAPlayableTrack)))
{
res.Add(a);
break;
}
}
}
return(res);
}
static void ParseScreenplay()
{
Clear();
// load file
var selectedFilepath = EditorUtility.OpenFilePanel("Select Screenplay", "", "txt");
FileInfo fileInfo = new FileInfo(selectedFilepath);
string timeText = System.DateTime.Now.ToString("hh.mm.ss"); // get time so we can mark where these changes were made
// create playabledirector in scene
currentPlayableGameObject = new GameObject();
currentPlayableGameObject.name = fileInfo.Name.Replace(".txt", string.Empty) + " " + timeText + " Timeline";
currentDataSlate = currentPlayableGameObject.AddComponent <screenwriterDataSlate> ();
currentPlayable = currentPlayableGameObject.AddComponent <PlayableDirector> ();
// create timeline asset
TimelineAsset currentTimeline = ScriptableObject.CreateInstance("TimelineAsset") as TimelineAsset;
AssetDatabase.CreateAsset(currentTimeline, "Assets/Timelines/" + fileInfo.Name.Replace(".txt", string.Empty) + " " + timeText + ".playable");
currentTimeline = (TimelineAsset)AssetDatabase.LoadAssetAtPath("Assets/Timelines/" + fileInfo.Name.Replace(".txt", string.Empty) + " " + timeText + ".playable", typeof(TimelineAsset));
currentPlayable.playableAsset = currentTimeline;
masterTrack = currentTimeline.CreateTrack <GroupTrack> (null, "Master Group");
currentTimeline.CreateTrack <ControlTrack> (masterTrack, "Shots");
currentTimeline.CreateTrack <ControlTrack> (masterTrack, "Lighting");
// currentTimeline.CreateTrack<SignalTrack> (null, "Track");
// currentTimeline.CreateTrack<AnimationTrack> (null, "Track");
string filePath = fileInfo.FullName;
line = null;
StreamReader reader = new StreamReader(filePath);
using (reader) {
do
{
thirdLastLine = lastLine;
lastLine = line;
line = reader.ReadLine();
if (System.String.IsNullOrEmpty(line) == false)
{
// this is where we actually parse the screenplay
lineCount++;
// print ("Parsing line #" + lineCount);
// capital letters checker
char[] possibleCharacter = line.ToCharArray();
int capitalization = 0;
for (int i = 0; i < possibleCharacter.Length; i++)
{
if (System.Char.IsUpper(possibleCharacter[i]))
{
capitalization++;
}
}
// location, time of day
if (line.Contains("EXT") || line.Contains("INT"))
{
char splitChar = '-';
string[] splitString = line.Split(splitChar);
currentDataSlate.TryAddLocation(splitString[0]);
currentLocation = splitString[0];
currentDataSlate.TryAddLightingScenario(splitString[1]);
currentLightingScenario = splitString[1];
continue;
}
// character check - all capitals and no :
if (capitalization > possibleCharacter.Length * 0.8f && line.Contains(":") == false)
{
currentDataSlate.TryAddCharacter(line);
currentCharacter = line;
continue;
}
// extra actor instructions check - has ()
if (line.Contains("("))
{
currentMood = line;
continue;
}
// transition data - contains : and is caps
if (line.Contains(":") && capitalization > possibleCharacter.Length * 0.5f)
{
continue;
}
// at this point there arent many edge cases left - check if we have a actor guidelines or an actor name above us to see if this is dialogue
if (lastLine != null)
{
if (lastLine.Contains("(") || currentDataSlate.characters.Contains(lastLine))
{
//dialogue callback
// check if we already have a character group
bool alreadyCreatedCharacter = false;
IEnumerable <TrackAsset> duplicateCharacterCheck = currentTimeline.GetRootTracks();
foreach (TrackAsset track in duplicateCharacterCheck)
{
print(track.name);
if (track.name == currentCharacter)
{
alreadyCreatedCharacter = true;
}
}
if (alreadyCreatedCharacter == false)
{
TrackAsset characterTrack = currentTimeline.CreateTrack <GroupTrack> (null, currentCharacter);
TrackAsset possibleSignalTrack = currentTimeline.CreateTrack <SignalTrack> (characterTrack, currentCharacter + " Signals");
TrackAsset animationTrack = currentTimeline.CreateTrack <AnimationTrack> (characterTrack, currentCharacter + " Animation Overrides");
}
IEnumerable <TrackAsset> allTracksForActors = currentTimeline.GetOutputTracks();
foreach (TrackAsset track in allTracksForActors)
{
if (track.name == currentCharacter + " Signals")
{
IMarker newMarker = track.CreateMarker <SignalEmitter> (currentTimelineScrub);
}
if (track.name == currentCharacter + " Animation Overrides")
{
TimelineClip newClip = track.CreateDefaultClip();
newClip.start = currentTimelineScrub;
newClip.duration = Convert.ToDouble(line.Length) / 12.0;
newClip.displayName = "Dialogue Animation";
}
}
}
}
// shot callback
IEnumerable <TrackAsset> allTracksForActions = currentTimeline.GetOutputTracks();
foreach (TrackAsset track in allTracksForActions)
{
if (track.name == "Shots")
{
GameObject cameraInstance = PrefabUtility.InstantiatePrefab(currentDataSlate.cameraPrefab) as GameObject;
cameraInstance.name = "Shot Camera";
cameraInstance.transform.parent = currentPlayableGameObject.transform;
// TimelineClip newClip = track.CreateDefaultClip ();
//
TimelineClip tlClip = track.CreateClip <ControlPlayableAsset> ();
ControlPlayableAsset clip = tlClip.asset as ControlPlayableAsset;
clip.sourceGameObject.exposedName = UnityEditor.GUID.Generate().ToString();
currentPlayable.SetReferenceValue(clip.sourceGameObject.exposedName, cameraInstance);
tlClip.clipIn = currentTimelineScrub;
tlClip.duration = Convert.ToDouble(line.Length) / 12.0;
tlClip.displayName = line;
}
if (track.name == "Lighting")
{
TimelineClip newClip = track.CreateDefaultClip();
newClip.displayName = currentLightingScenario;
newClip.clipIn = currentTimelineScrub;
newClip.duration = Convert.ToDouble(line.Length) / 12.0;
}
}
currentTimelineScrub = currentTimeline.duration;
}
}while (line != null);
reader.Close();
}
}
public DragAndDropVisualMode HandleTrackDrop(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, DropPosition dropPos)
{
((TimelineTreeView)m_Window.treeView.gui).showInsertionMarker = false;
var trackDragData = (TimelineDragData)DragAndDrop.GetGenericData(k_GenericDragId);
bool validDrag = ValidDrag(targetItem, trackDragData.draggedItems);
if (!validDrag)
return DragAndDropVisualMode.None;
var draggedTracks = trackDragData.draggedItems.OfType<TimelineGroupGUI>().Select(x => x.track).ToList();
if (draggedTracks.Count == 0)
return DragAndDropVisualMode.None;
if (parentItem != null)
{
var parentActor = parentItem as TimelineGroupGUI;
if (parentActor != null && parentActor.track != null)
{
if (parentActor.track.lockedInHierarchy)
return DragAndDropVisualMode.Rejected;
if (draggedTracks.Any(x => !TimelineCreateUtilities.ValidateParentTrack(parentActor.track, x.GetType())))
return DragAndDropVisualMode.Rejected;
}
}
var insertAfterItem = targetItem as TimelineGroupGUI;
if (insertAfterItem != null && insertAfterItem.track != null)
{
((TimelineTreeView)m_Window.treeView.gui).showInsertionMarker = true;
}
if (dropPos == DropPosition.Upon)
{
var groupGUI = targetItem as TimelineGroupGUI;
if (groupGUI != null)
groupGUI.isDropTarget = true;
}
if (perform)
{
PlayableAsset targetParent = m_Timeline;
var parentActor = parentItem as TimelineGroupGUI;
if (parentActor != null && parentActor.track != null)
targetParent = parentActor.track;
TrackAsset siblingTrack = insertAfterItem != null ? insertAfterItem.track : null;
// where the user drops after the last track, make sure to place it after all the tracks
if (targetParent == m_Timeline && dropPos == DropPosition.Below && siblingTrack == null)
{
siblingTrack = m_Timeline.GetRootTracks().LastOrDefault(x => !draggedTracks.Contains(x));
}
if (TrackExtensions.ReparentTracks(TrackExtensions.FilterTracks(draggedTracks).ToList(), targetParent, siblingTrack, dropPos == DropPosition.Above))
{
m_Window.state.Refresh();
}
}
return DragAndDropVisualMode.Move;
}
public static void DupTimeline()
{
// Fetch playable director, fetch timeline
GameObject playableDirectorObj = UnityEditor.Selection.activeObject as GameObject;
PlayableDirector playableDirector = playableDirectorObj.GetComponent <PlayableDirector>();
TimelineAsset timelineAsset = playableDirector.playableAsset as TimelineAsset;
// Duplicate
string path = AssetDatabase.GetAssetPath(timelineAsset);
string newPath = path.Replace(".", "(Clone).");
if (!AssetDatabase.CopyAsset(path, newPath))
{
if (showLogs)
{
Debug.LogError("Couldn't Clone Asset");
}
return;
}
// Copy Bindings
TimelineAsset newTimelineAsset = AssetDatabase.LoadMainAssetAtPath(newPath) as TimelineAsset;
PlayableBinding[] oldBindings = timelineAsset.outputs.ToArray();
PlayableBinding[] newBindings = newTimelineAsset.outputs.ToArray();
for (int i = 0; i < oldBindings.Length; i++)
{
playableDirector.playableAsset = timelineAsset;
Object boundTo = playableDirector.GetGenericBinding(oldBindings[i].sourceObject);
playableDirector.playableAsset = newTimelineAsset;
playableDirector.SetGenericBinding(newBindings[i].sourceObject, boundTo);
}
// Copy Exposed References
playableDirector.playableAsset = newTimelineAsset;
foreach (TrackAsset newTrackAsset in newTimelineAsset.GetRootTracks())
{
foreach (TimelineClip newClip in newTrackAsset.GetClips())
{
foreach (FieldInfo fieldInfo in newClip.asset.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
{
if (fieldInfo.FieldType.IsGenericType && fieldInfo.FieldType.GetGenericTypeDefinition() == typeof(ExposedReference <>))
{
// Fetch Old Exposed Name
object exposedReference = fieldInfo.GetValue(newClip.asset);
PropertyName oldExposedName = (PropertyName)fieldInfo.FieldType
.GetField("exposedName")
.GetValue(exposedReference);
bool isValid;
// Fetch Old Exposed Value
Object oldExposedValue = playableDirector.GetReferenceValue(oldExposedName, out isValid);
if (!isValid)
{
if (showLogs)
{
Debug.LogError("Failed to copy exposed references to duplicate timeline. Could not find: " + oldExposedName);
}
return;
}
// Replace exposedName on struct
PropertyName newExposedName = new PropertyName(UnityEditor.GUID.Generate().ToString());
fieldInfo.FieldType
.GetField("exposedName")
.SetValue(exposedReference, newExposedName);
// Set ExposedReference
fieldInfo.SetValue(newClip.asset, exposedReference);
// Set Reference on Playable Director
playableDirector.SetReferenceValue(newExposedName, oldExposedValue);
}
}
}
}
}
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 static TimelineClip GetClipForAsset(TimelineAsset timelineAsset, UnityEngine.Object playableAsset)
{
return(timelineAsset.GetRootTracks()
.SelectMany(track => GetClipsInTrack(track, clip => clip.asset == playableAsset))
.FirstOrDefault());
}
public static GroupTrack GetGroupTrackWithName(TimelineAsset timeline, string name)
{
IEnumerable <TrackAsset> tracks = timeline.GetRootTracks();
return(tracks.OfType <GroupTrack>().FirstOrDefault(groupTrack => groupTrack.name.Equals(name)));
}
public static void RunOnAllTracks(TimelineAsset timelineAsset, Action <TrackAsset> Action, bool runOnGroupTracks)
{
RunOnTrackIEnumerable(timelineAsset.GetRootTracks(), Action, runOnGroupTracks);
}
public static T RunOnAllTracksReturn <T> (TimelineAsset timelineAsset, Func <TrackAsset, object> @Func, bool runOnGroupTracks)
{
return((T)RunOnTrackIEnumerableReturn(timelineAsset.GetRootTracks(), @Func, runOnGroupTracks));
}