private void OnGUI()
{
GUILayout.BeginHorizontal();
GUILayout.Label("舞蹈名称");
m_name = GUILayout.TextField(m_name);
GUILayout.EndHorizontal();
m_targetDancer = (GameObject)EditorGUILayout.ObjectField("舞者模型", m_targetDancer, typeof(GameObject), false);
m_animationClip = (AnimationClip)EditorGUILayout.ObjectField("舞蹈动画", m_animationClip, typeof(AnimationClip), false);
m_audioClip = (AudioClip)EditorGUILayout.ObjectField("舞蹈音乐", m_audioClip, typeof(AudioClip), false);
if (GUILayout.Button("生成"))
{
AssetDatabase.CreateFolder(Path.Combine("Assets", "Builds"), m_name);
AssetDatabase.CreateFolder(Path.Combine("Assets", "Builds", m_name), "Animations");
AssetDatabase.CreateFolder(Path.Combine("Assets", "Builds", m_name), "Audios");
AssetDatabase.CreateFolder(Path.Combine("Assets", "Builds", m_name), "Prefabs");
var p1 = Copy(m_animationClip, "Animations");
var p2 = Copy(m_audioClip, "Audios");
TimelineAsset timeline = new TimelineAsset();
var animTrack = timeline.CreateTrack <AnimationTrack>();
var audioTrack = timeline.CreateTrack <AudioTrack>();
var danceTrack = timeline.CreateTrack <DanceTrack>();
var animClip = timeline.GetRootTrack(0).CreateClip <AnimationPlayableAsset>();
var anim = AssetDatabase.LoadAssetAtPath <AnimationClip>(p1);
(animClip.asset as AnimationPlayableAsset).clip = anim;
animClip.start = 0;
animClip.duration = anim.length;
var audioClip = timeline.GetRootTrack(1).CreateClip <AudioPlayableAsset>();
var audio = AssetDatabase.LoadAssetAtPath <AudioClip>(p2);
(audioClip.asset as AudioPlayableAsset).clip = audio;
audioClip.start = 0;
audioClip.duration = audio.length;
GameObject root = new GameObject(m_name);
root.transform.position = Vector3.zero;
root.AddComponent <DanceGameDisk>();
GameObject reference = GameObject.Instantiate <GameObject>(m_targetDancer);
reference.name = "Reference";
reference.transform.SetParent(root.transform);
reference.transform.localPosition = Vector3.zero;
reference.transform.localRotation = Quaternion.identity;
reference.transform.localScale = Vector3.one;
GameObject masks = new GameObject("MaskRoot");
masks.transform.SetParent(root.transform);
masks.transform.localPosition = Vector3.zero;
masks.transform.localRotation = Quaternion.identity;
masks.transform.localScale = Vector3.one;
AssetDatabase.CreateAsset(timeline, Path.Combine("Assets", "Builds", m_name, "Animations", m_name) + ".playable");
var dir = root.AddComponent <PlayableDirector>();
dir.playableAsset = timeline;
dir.SetGenericBinding(animTrack, reference);
}
}
public static TrackAsset CreateTrack(TimelineAsset timelineAsset, TRACK_TYPE type, string name, TrackAsset parent)
{
switch (type)
{
case TRACK_TYPE.TRACK_GROUP:
{
return(timelineAsset.CreateTrack <GroupTrack>(parent, name));
}
case TRACK_TYPE.TRACK_ANIMATION:
{
return(timelineAsset.CreateTrack <AnimationTrack>(parent, name));
}
case TRACK_TYPE.TRACK_CONTROL:
{
return(timelineAsset.CreateTrack <ControlTrack>(parent, name));
}
case TRACK_TYPE.TRACK_CINEMACHINE:
{
#if USING_CINEMACHINE
return(timelineAsset.CreateTrack <Cinemachine.Timeline.CinemachineTrack>(parent, name));
#else
break;
#endif
}
case TRACK_TYPE.TRACK_ACTIVATION:
{
return(timelineAsset.CreateTrack <ActivationTrack>(parent, name));
}
}
return(null);
}
// Use this for initialization
void Awake()
{
fc = FabulaContainer.Load(Path.Combine(Application.dataPath, "Scripts//CinemachineTimelineCode//FileIO_xml//fabula.xml"));
timeline = (TimelineAsset)ScriptableObject.CreateInstance("TimelineAsset");
director = GetComponent <PlayableDirector>();
ctrack = timeline.CreateTrack <ControlTrack>(null, "control_track");
ntrack = timeline.CreateTrack <PlayableTrack>(null, "nav_track");
foreach (FabulaClip clip in fc.Clips)
{
if (clip.Type.Equals("animate"))
{
populateAnimation(clip);
}
else if (clip.Type.Equals("navigate"))
{
populateNavigation(clip);
}
else
{
Debug.Log("What TYPE of clip is this?");
}
}
director.Play(timeline);
}
void SetTrackClip()
{
AudioSource.clip = Track.Clip;
AudioTrack track = TimelineAsset.CreateTrack <AudioTrack>(null, "TrackAudio");
track.CreateClip(AudioSource.clip);
}
// Use this for initialization
void Awake()
{
List <List <string> > clipList = readDiscourse();
foreach (List <string> clipItem in clipList)
{
Debug.Log("Clip:");
foreach (string item in clipItem)
{
Debug.Log(item);
}
}
main_camera_object = GameObject.Find("Main Camera");
timeline = (TimelineAsset)ScriptableObject.CreateInstance("TimelineAsset");
PlayableDirector director = GetComponent <PlayableDirector>();
TrackAsset track = timeline.CreateTrack <CinemachineTrack>(null, "trackname");
TrackAsset ctrack = timeline.CreateTrack <ControlTrack>(null, "control_track");
foreach (List <string> clipitem_list in clipList)
{
string name = clipitem_list[0];
string type = clipitem_list[1];
float start = float.Parse(clipitem_list[2]);
float dur = float.Parse(clipitem_list[3]);
string gameobj_name = clipitem_list[4];
if (type.Equals("cam"))
{
var clip = track.CreateDefaultClip();
clip.start = start;
clip.duration = dur;
clip.displayName = name;
CinemachineVirtualCamera new_cam = GameObject.Find(gameobj_name).GetComponent <CinemachineVirtualCamera>();
var cinemachineShot = clip.asset as CinemachineShot;
cinemachineShot.VirtualCamera.exposedName = UnityEditor.GUID.Generate().ToString();
director.SetReferenceValue(cinemachineShot.VirtualCamera.exposedName, new_cam);
}
else // assume control track
{
var clip = ctrack.CreateDefaultClip();
clip.start = start;
clip.duration = dur;
clip.displayName = name;
GameObject new_cam = GameObject.Find(gameobj_name);
var controlshot = clip.asset as ControlPlayableAsset;
controlshot.sourceGameObject.exposedName = UnityEditor.GUID.Generate().ToString();
director.SetReferenceValue(controlshot.sourceGameObject.exposedName, new_cam);
}
}
// Set cinemachine brain as track's game object
director.SetGenericBinding(track, main_camera_object);
// Set it to play when ready.
director.Play(timeline);
}
public void LoadBarrageLauncherData()
{
//获取timeline
TimelineAsset timelineAsset = playableDirector.playableAsset as TimelineAsset;
//创建父轨道进行分组
GroupTrack groupTrack = null;
groupTrack = timelineAsset.CreateTrack <GroupTrack>(null, "ShootGroup");
//创建轨道
List <DanmuTrack> danmuTracks = new List <DanmuTrack>();
for (int i = 0; i < barrageLauncher.danmus.Count; i++)
{
danmuTracks.Add(timelineAsset.CreateTrack <DanmuTrack>(groupTrack, "Shoot"));
}
//遍历所有弹幕轨道进行分组
for (int i = 0; i < danmuTracks.Count; i++)
{
var danmuTrack = danmuTracks[i];
var data = barrageLauncher.danmus[i];
playableDirector.SetGenericBinding(danmuTrack, barrageLauncher);
//分组
GroupTrack itemGroupTrack = timelineAsset.CreateTrack <GroupTrack>(groupTrack as TrackAsset, "DanmuShoot");
danmuTrack.SetGroup(itemGroupTrack);
danmuTrack.SetData(data, itemGroupTrack);
}
}
public static bool ImportText(string path, TextImportOptions opt, TimelineAsset timeline, PlayableDirector director)
{
if (timeline == null || director == null)
{
return(false);
}
var talks = RemoteTalkScript.TextFileToTalks(path);
if (talks == null)
{
return(false);
}
double time = opt.startTime;
var oldArrange = arrangeClips;
arrangeClips = ArrangeScope.CurrentTrack;
if (opt.parCastTrack)
{
var tracks = new Dictionary <string, RemoteTalkTrack>();
foreach (var talk in talks)
{
RemoteTalkTrack track = null;
if (!tracks.TryGetValue(talk.castName, out track))
{
track = timeline.CreateTrack <RemoteTalkTrack>(null, "RemoteTalk");
track.director = director;
track.name = talk.castName;
tracks[talk.castName] = track;
var audio = Misc.FindOrCreateGameObject(talk.castName + "_AudioSource");
track.audioSource = Misc.GetOrAddComponent <AudioSource>(audio);
}
var clip = track.AddClip(talk);
clip.start = time;
time += clip.duration + talk.wait + opt.interval;
}
}
else
{
var track = timeline.CreateTrack <RemoteTalkTrack>(null, "RemoteTalk");
track.director = director;
track.name = "RemoteTalkTrack";
var audio = Misc.FindOrCreateGameObject("RemoteTalkAudioSource");
track.audioSource = Misc.GetOrAddComponent <AudioSource>(audio);
foreach (var talk in talks)
{
var clip = track.AddClip(talk);
clip.start = time;
time += clip.duration + talk.wait + opt.interval;
}
}
arrangeClips = oldArrange;
Misc.RefreshTimelineWindow();
return(false);
}
static void CreateDanceDisk()
{
TimelineAsset timeline = new TimelineAsset();
timeline.CreateTrack <AnimationTrack>();
timeline.CreateTrack <DanceTrack>();
timeline.CreateTrack <AudioTrack>();
AssetDatabase.CreateAsset(timeline, "Assets/Temp.playable");
}
public void InstantiateExternally()
{
Debug.Log("Running in Edit Mode");
executeTimeline = (TimelineAsset)ScriptableObject.CreateInstance("TimelineAsset");
steerTrack = executeTimeline.CreateTrack <PlayableTrack>(null, "steerTrack");
lerpTrack = executeTimeline.CreateTrack <PlayableTrack>(null, "lerpTrack");
attachTrack = executeTimeline.CreateTrack <PlayableTrack>(null, "attachTrack");
ctrack = executeTimeline.CreateTrack <ControlTrack>(null, "control_track");
}
void Start()
{
fdirector = fabulaTimeline.GetComponent <PlayableDirector>();
fdirector.initialTime = 0f;
dc = DiscourseContainer.Load(Path.Combine(Application.dataPath, "Scripts//CinemachineTimelineCode//FileIO_xml//discourse.xml"));
timeline = (TimelineAsset)ScriptableObject.CreateInstance("TimelineAsset");
director = GetComponent <PlayableDirector>();
main_camera_object = GameObject.Find("Main Camera");
ftrack = timeline.CreateTrack <CinemachineTrack>(null, "film_track");
ctrack = timeline.CreateTrack <ControlTrack>(null, "control_track");
ntrack = timeline.CreateTrack <PlayableTrack>(null, "nav_track");
ptrack = timeline.CreateTrack <PlayableTrack>(null, "timetravel_track");
pos_track = timeline.CreateTrack <ControlTrack>(null, "pos_track");
foreach (DiscourseClip clip in dc.Clips)
{
if (clip.Type.Equals("cam_custom"))
{
populateCustom(clip);
}
else if (clip.Type.Equals("nav_cam"))
{
populateNavCam(clip);
}
else if (clip.Type.Equals("nav_virtual"))
{
populateNavVirtual(clip);
}
// cam_timeline cannot time travel
else if (clip.Type.Equals("cam_timeline"))
{
populateCamObject(clip);
}
else if (clip.Type.Equals("cntrl_timeline"))
{
populateCtrlObject(clip);
if (clip.fabulaStart >= 0f)
{
addTimeTravel(clip);
}
}
else
{
Debug.Log("What TYPE of discourse clip is this?");
}
}
director.SetGenericBinding(ftrack, main_camera_object);
director.Play(timeline);
}
public void InitiateExternally()
{
playableDirector = GetComponent <PlayableDirector>();
executeTimeline = (TimelineAsset)ScriptableObject.CreateInstance("TimelineAsset");
lerpTrack = executeTimeline.CreateTrack <PlayableTrack>(null, "lerpTrack");
attachTrack = executeTimeline.CreateTrack <PlayableTrack>(null, "attachTrack");
ctrack = executeTimeline.CreateTrack <ControlTrack>(null, "control_track");
ttTrack = executeTimeline.CreateTrack <PlayableTrack>(null, "timeTravelTrack");
filmTrack = executeTimeline.CreateTrack <CinemachineTrack>(null, "film_track");
var main_camera_object = GameObject.FindGameObjectWithTag("MainCamera");
playableDirector.SetGenericBinding(filmTrack, main_camera_object);
}
/// Handles drag and drop of a mono script.
public static DragAndDropVisualMode HandleClipPaneMonoScriptDragAndDrop(IEnumerable <MonoScript> scriptsBeingDropped, TrackAsset targetTrack, bool perform, TimelineAsset timeline, TrackAsset parent, PlayableDirector director, double candidateTime)
{
var playableAssetTypes = scriptsBeingDropped.Select(s => s.GetClass()).Where(TypeUtility.IsConcretePlayableAsset).Distinct();
if (!playableAssetTypes.Any())
{
return(DragAndDropVisualMode.Rejected);
}
var targetTrackType = typeof(PlayableTrack);
if (targetTrack != null)
{
targetTrackType = targetTrack.GetType();
}
var trackAssetsTypes = TypeUtility.GetPlayableAssetsHandledByTrack(targetTrackType);
var supportedTypes = trackAssetsTypes.Intersect(playableAssetTypes);
if (!supportedTypes.Any())
{
return(DragAndDropVisualMode.Rejected);
}
if (perform)
{
if (targetTrack == null)
{
targetTrack = timeline.CreateTrack(targetTrackType, parent, string.Empty);
}
TimelineHelpers.CreateClipsFromTypes(supportedTypes, targetTrack, candidateTime);
}
return(DragAndDropVisualMode.Copy);
}
private void buildAudioTracks(ProgressBar progress, PlayableDirector director, TimelineAsset timeline)
{
var audioData = GetComponentsInChildren <RecordedAudio>(includeInactive: true);
var sourceToData = audioData.Query().ToDictionary(a => a.target, a => a);
progress.Begin(sourceToData.Count, "", "Building Audio Track: ", () => {
foreach (var pair in sourceToData)
{
var track = timeline.CreateTrack <AudioTrack>(null, pair.Value.name);
director.SetGenericBinding(track.outputs.Query().First().sourceObject, pair.Key);
progress.Begin(pair.Value.data.Count, "", "", () => {
foreach (var clipData in pair.Value.data)
{
progress.Step(clipData.clip.name);
var clip = track.CreateClip(clipData.clip);
clip.start = clipData.startTime;
clip.timeScale = clipData.pitch;
clip.duration = clipData.clip.length;
}
});
}
});
}
public static TrackAsset CreateTrack(TimelineAsset asset, Type type, TrackAsset parent = null, string name = null)
{
if (asset == null)
{
return(null);
}
var track = asset.CreateTrack(type, parent, name);
if (track != null)
{
if (parent != null)
{
parent.SetCollapsed(false);
}
var editor = CustomTimelineEditorCache.GetTrackEditor(track);
try
{
editor.OnCreate(track, null);
}
catch (Exception e)
{
Debug.LogException(e);
}
TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved);
}
return(track);
}
/// <summary>
/// Create a Track and TimelineClip in a TimelineAsset.
/// </summary>
/// <param name="timelineAsset">The TimelineAsset in which the track and clip will be created</param>
/// <param name="trackName">The track Name</param>
/// <param name="trackType">The type of the Track</param>
/// <param name="clipAssetType">The type of the TimelineClip's asset</param>
/// <returns>The newly created TimelineClip</returns>
internal static TimelineClip CreateTrackAndClip(TimelineAsset timelineAsset, string trackName,
Type trackType, Type clipAssetType)
{
TrackAsset track = timelineAsset.CreateTrack(trackType, null, trackName);
TimelineClip clip = TimelineEditorReflection.CreateClipOnTrack(clipAssetType, track, 0);
return clip;
}
public static TimelineClip CreateAnimClipInTrack(string trackName, TimelineAsset timeline)
{
var track = timeline.CreateTrack <AnimationTrack>(null, trackName);
var clip = track.CreateDefaultClip();
return(clip);
}
void OnGUI()
{
source = EditorGUILayout.ObjectField(source, typeof(TextAsset), true);
if (GUILayout.Button("Add to scene"))
{
//find director
timeline = GameObject.Find("TIMELINE");
PlayableDirector director = timeline.GetComponent <PlayableDirector>();
TimelineAsset timelineAsset = (TimelineAsset)director.playableAsset;
//load json into class
string jsonText = File.ReadAllText(Application.dataPath + "/Resources/json/" + source.name + ".json");
PlayerStatsList myPlayerStatsList = new PlayerStatsList();
JsonUtility.FromJsonOverwrite(jsonText, myPlayerStatsList);
//loop through objects in class
foreach (PlayerStats p in myPlayerStatsList.characters)
{
//place asset in scene
MyClass myObject = new MyClass();
myObject.characterPath = p.model;
tempobj = (GameObject)Instantiate(Resources.Load(myObject.characterPath), new Vector3(0, 0, 0), Quaternion.identity);
tempobj.name = p.name;
//create animation track on TIMELINE
AnimationTrack newTrack = timelineAsset.CreateTrack <AnimationTrack>(null, "Animation Track " + tempobj.name);
director.SetGenericBinding(newTrack, tempobj);
myObject.animPath = p.anim;
animObject = Resources.Load("AnimTest/" + myObject.animPath);
AnimationClip animClip;
animClip = Resources.Load <AnimationClip>("AnimTest/" + myObject.animPath);
newTrack.CreateClip(animClip);
}
}
}
//----------------------------------------------------------------------------------------------------------------------
internal static TimelineClip CreateTestSISTimelineClip(PlayableDirector director)
{
string tempTimelineAssetPath = AssetDatabase.GenerateUniqueAssetPath("Assets/TempSISTimelineForTestRunner.playable");
//Create timeline asset
TimelineAsset timelineAsset = ScriptableObject.CreateInstance <TimelineAsset>();
director.playableAsset = timelineAsset;
AssetDatabase.CreateAsset(timelineAsset, tempTimelineAssetPath);
//Create empty asset
StreamingImageSequenceTrack sisTrack = timelineAsset.CreateTrack <StreamingImageSequenceTrack>(null, "SIS Track");
TimelineClip clip = sisTrack.CreateDefaultClip();
StreamingImageSequencePlayableAsset sisAsset = clip.asset as StreamingImageSequencePlayableAsset;
Assert.IsNotNull(sisAsset);
//Select gameObject and open Timeline Window. This will trigger the TimelineWindow's update etc.
EditorApplication.ExecuteMenuItem("Window/Sequencing/Timeline");
// Selection.activeTransform = director.gameObject.transform;
// TimelineEditor.selectedClip = sisAsset.GetBoundTimelineClip();
Selection.activeObject = director;
string fullPath = Path.GetFullPath(SRC_IMAGE_PATH);
ImageSequenceImporter.ImportImages(fullPath, sisAsset, false);
return(clip);
}
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;
}
}
}
private void buildMethodRecordingTracks(ProgressBar progress, PlayableDirector director, TimelineAsset timeline)
{
var recordings = GetComponentsInChildren <MethodRecording>();
if (recordings.Length > 0)
{
progress.Begin(recordings.Length, "", "Building Method Tracks: ", () => {
foreach (var recording in recordings)
{
progress.Step(recording.gameObject.name);
try {
var track = timeline.CreateTrack <MethodRecordingTrack>(null, recording.gameObject.name);
director.SetGenericBinding(track.outputs.Query().First().sourceObject, recording);
var clip = track.CreateClip <MethodRecordingClip>();
clip.duration = recording.GetDuration();
} catch (Exception e) {
Debug.LogException(e);
}
}
});
}
}
static bool HandleTrackAndItemCreation(IEnumerable <UnityEngine.Object> objectsBeingDropped, double candidateTime, TypeResolver typeResolver, TimelineAsset timeline, TrackAsset parent, IEnumerable <Type> validTrackTypes, TrackAsset insertBefore = null)
{
Action <Type> onResolved = t =>
{
var newTrack = timeline.CreateTrack(t, parent, string.Empty);
if (insertBefore != null)
{
if (parent != null)
{
parent.MoveLastTrackBefore(insertBefore);
}
else
{
timeline.MoveLastTrackBefore(insertBefore);
}
}
HandleItemCreation(objectsBeingDropped, newTrack, candidateTime, typeResolver, validTrackTypes.Count() == 1); // menu is popped if ambiguous clip choice and unambiguous track choice
if (parent != null)
{
parent.SetCollapsed(false);
}
TimelineEditor.Refresh(RefreshReason.ContentsAddedOrRemoved);
};
return(typeResolver(validTrackTypes, t => onResolved(t), k_SelectTrackWithClip)); // Did it create a track
}
public AudioTrack GenAudioTrack(TimelineAsset dstTimeline)
{
if (dstTimeline == null)
{
return(null);
}
var audioTrack = dstTimeline.CreateTrack <AudioTrack>(
parent != null ? parent as TrackAsset : null,
name);
var output = audioSource;
if (output != null)
{
director.SetGenericBinding(audioTrack, output);
}
foreach (var srcClip in GetClips())
{
var srcAsset = (RemoteTalkClip)srcClip.asset;
var ac = srcAsset.audioClip.defaultValue;
if (ac == null)
{
continue;
}
var dstClip = audioTrack.CreateClip((AudioClip)ac);
dstClip.displayName = srcClip.displayName;
dstClip.start = srcClip.start;
dstClip.duration = srcClip.duration;
}
return(audioTrack);
}
public IEnumerator CreatePlayableAsset()
{
EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects);
//Add director
GameObject directorGo = new GameObject("Director");
PlayableDirector director = directorGo.AddComponent <PlayableDirector>();
//Setup scene cache
GameObject sceneCacheGo = new GameObject();
SceneCachePlayer sceneCachePlayer = sceneCacheGo.AddComponent <SceneCachePlayer>();
Assert.IsFalse(sceneCachePlayer.IsSceneCacheOpened());
SceneCachePlayerEditorUtility.ChangeSceneCacheFile(sceneCachePlayer, Path.GetFullPath(MeshSyncTestEditorConstants.CUBE_TEST_DATA_PATH));
//Create timeline asset
TimelineAsset asset = ScriptableObject.CreateInstance <TimelineAsset>();
director.playableAsset = asset;
//Create PlayableAsset/Track/ etc
SceneCachePlayableAsset playableAsset = ScriptableObject.CreateInstance <SceneCachePlayableAsset>();
SceneCacheTrack sceneCacheTrack = asset.CreateTrack <SceneCacheTrack>(null, "TestSceneCacheTrack");
TimelineClip clip = sceneCacheTrack.CreateDefaultClip();
clip.asset = playableAsset;
director.SetReferenceValue(playableAsset.GetSceneCachePlayerRef().exposedName, sceneCachePlayer);
//Select gameObject and open Timeline Window. This will trigger the TimelineWindow's update etc.
EditorApplication.ExecuteMenuItem("Window/Sequencing/Timeline");
Selection.activeTransform = directorGo.transform;
yield return(null);
director.time = 0;
yield return(null);
Assert.AreEqual(0, sceneCachePlayer.GetRequestedNormalizedTime());
double timePerFrame = 1.0f / sceneCacheTrack.timelineAsset.editorSettings.fps;
double directorTime = clip.start + clip.duration - timePerFrame;
SetDirectorTime(director, directorTime);
yield return(null);
//Check clipData and curve
SceneCacheClipData clipData = playableAsset.GetBoundClipData();
Assert.IsNotNull(clipData);
AnimationCurve curve = clipData.GetAnimationCurve();
Assert.IsNotNull(curve);
float normalizedTime = curve.Evaluate((float)directorTime);
Assert.AreEqual(normalizedTime, sceneCachePlayer.GetRequestedNormalizedTime());
}
public GameObject GenerateUnityObject(CameraData playable, int frameOffset, AssetImportContext ctx, TimelineAsset parentTimeline, TrackAsset parentTrack, Transform parent)
{
var playableObj = MakePlayableBaseObject(playable, parent);
var transformAnchor = new GameObject("TransformAnchor");
playable.CurrentShotOffset.ApplyTo(transformAnchor.transform);
transformAnchor.transform.SetParent(playableObj.transform, false);
var cam = transformAnchor.AddComponent <Camera>();
cam.backgroundColor = stage.backgroundColor;
cam.clearFlags = CameraClearFlags.SolidColor;
// TODO: Field of view
cam.stereoTargetEye = StereoTargetEyeMask.None;
var pathForName = AnimationUtility.CalculateTransformPath(transformAnchor.transform, stageTransform);
var groupTrack = parentTimeline.CreateTrack <GroupTrack>(parentTrack, playable.displayName);
ctx.AddSubAsset(pathForName + "_GroupTrack", groupTrack);
if (playable.Timeline.Frames.Count > 0)
{
var animTrack = parentTimeline.CreateTrack <AnimationTrack>(groupTrack, pathForName + "_TransformTrack");
director.SetGenericBinding(animTrack, animator);
ctx.AddSubAsset(pathForName + "_TransformTrack", animTrack);
var animationClip = MakeAnimationClip(playable.Timeline, AnimationUtility.CalculateTransformPath(transformAnchor.transform, rootTransform));
ctx.AddSubAsset(pathForName + "_animation", animationClip);
var timelineClip = animTrack.CreateClip(animationClip);
timelineClip.start = (playable.AbsoluteTimeOffset + frameOffset) / stage.fps;
timelineClip.displayName = playable.displayName;
ctx.AddSubAsset(pathForName + "_asset", timelineClip.asset);
}
return(playableObj);
}
public IEnumerator CreatePlayableAsset()
{
EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects);
Color col = Color.green;
GameObject directorGo = new GameObject("Director");
PlayableDirector director = directorGo.AddComponent <PlayableDirector>();
//Create timeline asset
TimelineAsset asset = ScriptableObject.CreateInstance <TimelineAsset>();
director.playableAsset = asset;
//Create empty asset
FaderPlayableAsset faderAsset = ScriptableObject.CreateInstance <FaderPlayableAsset>();
FaderTrack faderTrack = asset.CreateTrack <FaderTrack>(null, "Footage");
TimelineClip clip = faderTrack.CreateDefaultClip();
clip.asset = faderAsset;
faderAsset.SetFadeType(FadeType.FADE_IN);
faderAsset.SetColor(col);
//Create new Image
Transform canvasT = UIUtility.CreateCanvas();
GameObject imageObj = new GameObject("Image");
imageObj.transform.SetParent(canvasT);
Image image = imageObj.AddComponent <Image>();
director.SetGenericBinding(faderTrack, image);
//Select gameObject and open Timeline Window. This will trigger the TimelineWindow's update etc.
EditorApplication.ExecuteMenuItem("Window/Sequencing/Timeline");
Selection.activeTransform = directorGo.transform;
yield return(null);
TimelineEditor.selectedClip = clip;
yield return(null);
//FadeIn
Color zeroAlphaCol = col;
zeroAlphaCol.a = 0;
Assert.AreEqual(zeroAlphaCol, image.color);
//FadeOut
faderAsset.SetFadeType(FadeType.FADE_OUT);
TimelineEditor.Refresh(RefreshReason.ContentsModified);
yield return(null); //Give time for the Timeline Window to update.
Assert.AreEqual(col, image.color);
}
private void CreateAudio()
{
TimelineAsset timelineAsset = (TimelineAsset)_timeline.playableAsset;
AudioTrack audioTrack = timelineAsset.CreateTrack <AudioTrack>(null, "Audio Track");
_timeline.SetGenericBinding(audioTrack, _audioSource);
TimelineClip clip = audioTrack.CreateClip <AudioPlayableAsset>();
AudioPlayableAsset asset = (AudioPlayableAsset)clip.asset;
asset.clip = _audioClip;
clip.duration = _audioClip.length;
}
static void CreateTimelineAndSignalTrack()
{
m_timelineAsset = ScriptableObject.CreateInstance <TimelineAsset>();
string path = EditorUtils.DisplayFolderPanel();
if (path == "")
{
return;
}
AssetDatabase.CreateAsset(m_timelineAsset, path + "/" + m_playableFileName);
m_trackAsset = m_timelineAsset.CreateTrack <SignalTrack>(null, "Signal Track");
}
private void Create()
{
//---タイムラインアセット作成---
TimelineAsset timelineAsset = ScriptableObject.CreateInstance <TimelineAsset>();
string savePath = exportPath + "/" + timelineAssetName + ".playable";
// ↓C:\xxx\xxxの部分を消す処理
AssetDatabase.CreateAsset(timelineAsset, savePath.Replace(Application.dataPath, "Assets"));
//---RecorderTrackをまとめるグループを作成---
GroupTrack groupTrack = timelineAsset.CreateTrack <GroupTrack>(null, "RecorderGroup");
foreach (ClipInfo clipInfo in clipInfos)
{
//---RecorderClip専用のトラックを作成---
RecorderTrack recorderTrack = timelineAsset.CreateTrack <RecorderTrack>(groupTrack, clipInfo.name + "_track");
//---RecorderClipの作成---
TimelineClip timelineClip = recorderTrack.CreateClip <RecorderClip>();
timelineClip.displayName = clipInfo.name + "_clip";
//---RecorderSetting---
RecorderClip recorderClip = timelineClip.asset as RecorderClip;
SetRecorderSettings(clipInfo.type, ref recorderClip.settings);
recorderClip.settings.name = clipInfo.name + "_asset";
//---Presetを使用---
if (clipInfo.isUsePreset)
{
presets[(int)clipInfo.type].ApplyTo(recorderClip.settings);
}
//---TimelineAssetにsettings(ScriptableObject)を追加---
// 追加しないと保持されない！
AssetDatabase.AddObjectToAsset(recorderClip.settings, timelineAsset);
}
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
//----------------------------------------------------------------------------------------------------------------------
internal static TimelineClip AddSceneCacheTrackAndClip(PlayableDirector director, string trackName,
SceneCachePlayer sceneCachePlayer)
{
TimelineAsset timelineAsset = director.playableAsset as TimelineAsset;
Assert.IsNotNull(timelineAsset);
SceneCacheTrack sceneCacheTrack = timelineAsset.CreateTrack<SceneCacheTrack>(null, trackName);
TimelineClip clip = sceneCacheTrack.CreateDefaultClip();
SceneCachePlayableAsset playableAsset = clip.asset as SceneCachePlayableAsset;
Assert.IsNotNull(playableAsset);
director.SetReferenceValue(playableAsset.GetSceneCachePlayerRef().exposedName, sceneCachePlayer );
return clip;
}
static T GetOrCreateTrack <T>(TimelineAsset tl, string name) where T : TrackAsset
{
foreach (var t in tl.GetOutputTracks())
{
if (t.name == name)
{
return(t as T);
}
}
Debug.LogFormat("CreateTrack: {0}", name);
return(tl.CreateTrack(typeof(T), null, name) as T);
}
