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); }