TrackAsset AllocateTrack(TrackAsset trackAssetParent, string trackName, Type trackType)
{
if (trackAssetParent != null && trackAssetParent.timelineAsset != this)
{
throw new InvalidOperationException("Addtrack cannot parent to a track not in the Timeline");
}
if (!typeof(TrackAsset).IsAssignableFrom(trackType))
{
throw new InvalidOperationException("Supplied type must be a track asset");
}
var asset = (TrackAsset)CreateInstance(trackType);
asset.name = trackName;
const string createTrackUndoName = "Create Track";
PlayableAsset parent = trackAssetParent != null ? trackAssetParent as PlayableAsset : this;
TimelineCreateUtilities.SaveAssetIntoObject(asset, parent);
TimelineUndo.RegisterCreatedObjectUndo(asset, createTrackUndoName);
TimelineUndo.PushUndo(parent, createTrackUndoName);
if (trackAssetParent != null)
{
trackAssetParent.AddChild(asset);
}
else //TimelineAsset is the parent
{
AddTrackInternal(asset);
}
return(asset);
}
private void StartDirector(PlayableAsset asset)
{
Director.Stop();
Director.time = 0;
Director.playableAsset = asset;
Play();
}
internal Playable CompileTrackPlayable(PlayableGraph graph, TrackAsset track, GameObject go, IntervalTree <RuntimeElement> tree)
{
AnimationMixerPlayable animationMixerPlayable = AnimationMixerPlayable.Create(graph, track.clips.Length, false);
for (int i = 0; i < track.clips.Length; i++)
{
TimelineClip timelineClip = track.clips[i];
PlayableAsset playableAsset = timelineClip.asset as PlayableAsset;
if (!(playableAsset == null))
{
if (timelineClip.recordable)
{
AnimationPlayableAsset animationPlayableAsset = playableAsset as AnimationPlayableAsset;
if (animationPlayableAsset != null)
{
animationPlayableAsset.removeStartOffset = !timelineClip.recordable;
}
}
Playable playable = playableAsset.CreatePlayable(graph, go);
if (playable.IsValid <Playable>())
{
RuntimeClip item = new RuntimeClip(timelineClip, playable, animationMixerPlayable);
tree.Add(item);
graph.Connect <Playable, AnimationMixerPlayable>(playable, 0, animationMixerPlayable, i);
animationMixerPlayable.SetInputWeight(i, 0f);
}
}
}
return(this.ApplyTrackOffset(graph, animationMixerPlayable));
}
/// <summary>
/// 查找指定PlayableAsset的TimelineClip
/// </summary>
/// <param name="_trackAsset">TrackAsset</param>
/// <param name="_playableAsset">PlayableAsset</param>
/// <returns></returns>
public static TimelineClip FindTimelineClip(this TrackAsset _trackAsset, PlayableAsset _playableAsset)
{
TimelineClip mTimelineClip = null;
if (_playableAsset != null)
{
IEnumerator outClips = _trackAsset.GetClips().GetEnumerator();
while (outClips.MoveNext())
{
TimelineClip clip = (TimelineClip)outClips.Current;
if (clip.asset.Equals(_playableAsset))
{
mTimelineClip = clip;
break;
}
}
}
#if UNITY_EDITOR
if (mTimelineClip == null)
{
Debug.LogErrorFormat("Can't find TimelineClip by【{0}】in the【{1}]】.", _trackAsset, _playableAsset);
}
#endif
return(mTimelineClip);
}
private void PlaySecondCutscene(PlayableAsset cutscene)
{
float duration = (float)cutscene.duration;
objSys.playableDirector.playableAsset = cutscene;
objSys.playableDirector.Play();
}
public static PlayableDirector[] GetDirectorsInSceneUsingAsset(PlayableAsset asset)
{
const HideFlags hideFlags =
HideFlags.HideInHierarchy | HideFlags.HideInInspector |
HideFlags.DontSaveInEditor | HideFlags.NotEditable;
var prefabMode = PrefabStageUtility.GetCurrentPrefabStage();
var inScene = new List<PlayableDirector>();
var allDirectors = Resources.FindObjectsOfTypeAll(typeof(PlayableDirector)) as PlayableDirector[];
foreach (var director in allDirectors)
{
if ((director.hideFlags & hideFlags) != 0)
continue;
string assetPath = AssetDatabase.GetAssetPath(director.transform.root.gameObject);
if (!String.IsNullOrEmpty(assetPath))
continue;
if (prefabMode != null && !prefabMode.IsPartOfPrefabContents(director.gameObject))
continue;
if (asset == null || (asset != null && director.playableAsset == asset))
{
inScene.Add(director);
}
}
return inScene.ToArray();
}
/// <summary>
/// Add new slide Timeline
/// </summary>
/// <param name="slideTimeLine"></param>
public void AddNewSlideTimeLine(PlayableAsset slideTimeLine)
{
if (!presentaionSlidesTimeline.Contains(slideTimeLine))
{
presentaionSlidesTimeline.Add(slideTimeLine);
}
}
private static IEnumerable <PlayableBinding> FindAllPlayableBinding(this PlayableAsset playableAsset, Func <string, PlayableAsset, bool> conditionForPlayableAsset = null)
{
return(playableAsset
.outputs
.Where(x => x.sourceObject is PlayableAsset)
.Where(x => conditionForPlayableAsset == default(Func <string, PlayableAsset, bool>) || conditionForPlayableAsset(x.streamName, x.sourceObject as PlayableAsset)));
}
private void UpdatePlayableBindingsIfRequired(PlayableAsset playableAsset, PlayableDirector director)
{
m_SynchedPlayableBindings = new PlayableBinding[0];
if (playableAsset != null)
{
var bindings = playableAsset.outputs;
m_SynchedPlayableBindings = bindings.ToArray();
}
foreach (var binding in m_SynchedPlayableBindings)
{
// don't add bindings without a specific target type, clear previously bound objects
// This can happen with timeline tracks that do not have a specific binding.
if (binding.outputTargetType == null)
{
director.ClearGenericBinding(binding.sourceObject);
}
else if (!director.HasGenericBinding(binding.sourceObject))
{
director.SetGenericBinding(binding.sourceObject, null);
}
}
serializedObject.Update();
}
private static void Draw(PlayableDirector director, GizmoType gizmoType)
{
PlayableAsset asset = director.playableAsset;
IEnumerable <PlayableBinding> bindings = asset.outputs;
foreach (var item in bindings)
{
SkillTrack skillTrack = item.sourceObject as SkillTrack;
if (skillTrack != null)
{
foreach (var item2 in skillTrack.GetClips())
{
//Debug.LogError($"{playable.time} >= {item2.start}");
if (director.time >= item2.start && director.time <= item2.end)
{
var skillShot = item2.asset as SkillShot;
SkillShotPlayable shotPlayable = skillShot.template;
Vector3 position = (Vector3)shotPlayable.Path?.Position;
Vector3 direction = (Vector3)shotPlayable.Path?.Direction;
shotPlayable.Shape?.DrawGizmos(position, direction);
}
}
}
}
}
public void Init(string db_path, GameObject model, string timeLine_path)
{
QualitySettings.blendWeights = BlendWeights.FourBones;
GO = model;
this.timelinePath = timeLine_path;
AssetBundle ab = AssetBundle.LoadFromFile(timeLine_path);
PlayableAsset wallPrefab = ab.LoadAsset <PlayableAsset>(Vesal_DirFiles.get_file_name_from_full_path(timelinePath).Split('_')[0]);
PlayableDirector pad = model.GetComponent <PlayableDirector>();
pad.playableAsset = wallPrefab;
var timeline = pad.playableAsset as TimelineAsset;
foreach (var track in timeline.GetOutputTracks())
{
Debug.Log(track.name);
}
pad.SetGenericBinding(timeline.GetOutputTrack(0), GO);
this.db_path = db_path;
timelineControll.timeLine = pad;
showMode.model = model;
// showMode.Init();
ab.Unload(false);
loaddb();
}
public override Playable CreatePlayable(PlayableGraph graph, GameObject go)
{
List <Playable> list = new List <Playable>();
GameObject gameObject = this.sourceGameObject.Resolve(graph.GetResolver());
if (this.prefabGameObject != null)
{
Transform parentTransform = (!(gameObject != null)) ? null : gameObject.transform;
ScriptPlayable <PrefabControlPlayable> playable = PrefabControlPlayable.Create(graph, this.prefabGameObject, parentTransform);
gameObject = playable.GetBehaviour().prefabInstance;
list.Add(playable);
}
this.m_Duration = PlayableBinding.DefaultDuration;
this.m_SupportLoop = false;
Playable result;
if (gameObject == null)
{
result = Playable.Create(graph, 0);
}
else
{
IList <PlayableDirector> component = this.GetComponent <PlayableDirector>(gameObject);
IList <ParticleSystem> component2 = this.GetComponent <ParticleSystem>(gameObject);
this.UpdateDurationAndLoopFlag(component, component2);
PlayableDirector component3 = go.GetComponent <PlayableDirector>();
if (component3 != null)
{
this.m_ControlDirectorAsset = component3.playableAsset;
}
if (go == gameObject && this.prefabGameObject == null)
{
Debug.LogWarning("Control Playable (" + base.name + ") is referencing the same PlayableDirector component than the one in which it is playing.");
this.active = false;
if (!this.searchHierarchy)
{
this.updateDirector = false;
}
}
if (this.active)
{
this.CreateActivationPlayable(gameObject, graph, list);
}
if (this.updateDirector)
{
this.SearchHierarchyAndConnectDirector(component, graph, list);
}
if (this.updateParticle)
{
this.SearchHiearchyAndConnectParticleSystem(component2, graph, list);
}
if (this.updateITimeControl)
{
ControlPlayableAsset.SearchHierarchyAndConnectControlableScripts(ControlPlayableAsset.GetControlableScripts(gameObject), graph, list);
}
Playable playable2 = ControlPlayableAsset.ConnectPlayablesToMixer(graph, list);
result = playable2;
}
return(result);
}
internal override Playable OnCreatePlayableGraph(PlayableGraph graph, GameObject go, IntervalTree <RuntimeElement> tree)
{
AudioMixerPlayable audioMixerPlayable = AudioMixerPlayable.Create(graph, base.clips.Length, false);
for (int i = 0; i < base.clips.Length; i++)
{
TimelineClip timelineClip = base.clips[i];
PlayableAsset playableAsset = timelineClip.asset as PlayableAsset;
if (!(playableAsset == null))
{
float num = 0.1f;
AudioPlayableAsset audioPlayableAsset = timelineClip.asset as AudioPlayableAsset;
if (audioPlayableAsset != null)
{
num = audioPlayableAsset.bufferingTime;
}
Playable playable = playableAsset.CreatePlayable(graph, go);
if (playable.IsValid <Playable>())
{
tree.Add(new ScheduleRuntimeClip(timelineClip, playable, audioMixerPlayable, (double)num, 0.1));
graph.Connect <Playable, AudioMixerPlayable>(playable, 0, audioMixerPlayable, i);
playable.SetSpeed(timelineClip.timeScale);
playable.SetDuration(timelineClip.extrapolatedDuration);
audioMixerPlayable.SetInputWeight(playable, 1f);
}
}
}
return(audioMixerPlayable);
}
/// <summary>[Animancer Extension]
/// Calls <see cref="Gather(ICollection{AnimationClip}, AnimationClip)"/> for each clip in the `asset`.
/// </summary>
public static void GatherFromAsset(this ICollection <AnimationClip> clips, PlayableAsset asset)
{
if (asset == null)
{
return;
}
// We want to get the tracks out of a TimelineAsset without actually referencing that class directly
// because it comes from an optional package and Animancer does not need to depend on that package.
if (_TypeToGetRootTracks == null)
{
_TypeToGetRootTracks = new Editor.ConversionCache <Type, MethodInfo>((type) =>
{
var method = type.GetMethod("GetRootTracks");
if (method != null &&
typeof(IEnumerable).IsAssignableFrom(method.ReturnType) &&
method.GetParameters().Length == 0)
{
return(method);
}
else
{
return(null);
}
});
}
var getRootTracks = _TypeToGetRootTracks.Convert(asset.GetType());
if (getRootTracks != null)
{
var rootTracks = getRootTracks.Invoke(asset, null);
GatherAnimationClips(rootTracks as IEnumerable, clips);
}
}
public void SampleSceneValidityPass()
{
string sampleScenePath = "Assets/Scenes/defaultSample.unity";
Assert.IsTrue(File.Exists(sampleScenePath));
EditorSceneManager.OpenScene(sampleScenePath);
PlayableDirector[] pds = Object.FindObjectsOfType <PlayableDirector>();
foreach (PlayableDirector pd in pds)
{
PlayableAsset playableAsset = pd.playableAsset;
if (!(playableAsset is TimelineAsset))
{
continue;
}
TimelineAsset timelineAsset = playableAsset as TimelineAsset;
foreach (TrackAsset trackAsset in timelineAsset.GetOutputTracks())
{
//Make sure the Image is bound to the trackAsset
Assert.IsNotNull(pd.GetGenericBinding(trackAsset));
}
}
}
public void InitAni(PlayableAsset aniAsset)
{
mPlayableAsset = aniAsset;
mPlayableDirector.playableAsset = mPlayableAsset;
foreach (var item in mPlayableAsset.outputs)
{
var trackName = item.streamName;
mBindings.Add(trackName, item);
var track = item.sourceObject as TrackAsset;
if (track != null)
{
var cliplist = track.GetClips();
foreach (var clip in cliplist)
{
if (!mClips.ContainsKey(trackName))
{
mClips.Add(trackName, new Dictionary <string, PlayableAsset>());
}
var name2Clips = mClips[trackName];
if (!name2Clips.ContainsKey(clip.displayName))
{
name2Clips.Add(clip.displayName, clip.asset as PlayableAsset);
}
}
}
}
mPlayableDirector.stopped += E_OnStop;
}
public static void SetTrackParent(TrackAsset track, PlayableAsset parent)
{
SerializedObject trackSO = new SerializedObject(track);
SerializedProperty parentProp = trackSO.FindProperty("m_Parent");
parentProp.objectReferenceValue = parent;
trackSO.ApplyModifiedPropertiesWithoutUndo();
}
internal static void DestroyAssets(PlayableAsset playableAsset) {
string assetPath = AssetDatabase.GetAssetPath(playableAsset);
Assert.IsFalse(string.IsNullOrEmpty(assetPath));
Object.DestroyImmediate(playableAsset, true);
AssetDatabase.DeleteAsset(assetPath);
}
public void Awake()
{
playableDirector = GetComponent <PlayableDirector>();
PlayableAsset p = playableDirector.playableAsset;
SetParametersTwo();
Debug.Log("This function ran on edit mode!");
}
//트랙을 추가할 수 있는지 검사 (Static)
public static bool CheckTrackValidation(
#if UNITY_2017_1_OR_NEWER
PlayableDirector playableDirector, PlayableAsset playableAsset,
#endif
string trackName
)
{
#if UNITY_2017_1_OR_NEWER
if (playableDirector == null)
{
return(false);
}
if (playableAsset == null)
{
return(false);
}
if (playableDirector.playableAsset != playableAsset)
{
return(false);
}
foreach (PlayableBinding playableBinding in playableAsset.outputs)
{
#endif
#if UNITY_2018_1_OR_NEWER
bool isAnimTrack = playableBinding.sourceObject != null && playableBinding.sourceObject is AnimationTrack;
#elif UNITY_2017_1_OR_NEWER
bool isAnimTrack = playableBinding.streamType == DataStreamType.Animation;
#endif
//if (playableBinding.streamType != DataStreamType.Animation)
#if UNITY_2017_1_OR_NEWER
if (!isAnimTrack)
{
//애니메이션 타입이 아니라면 패스
continue;
}
AnimationTrack animTrack = playableBinding.sourceObject as AnimationTrack;
if (animTrack == null)
{
continue;
}
if (!animTrack.name.Equals(trackName))
{
//이름이 다르다.
continue;
}
//찾았당
return(true);
}
#endif
//못찾음
return(false);
}
PlayableBinding FindBinding(PlayableAsset source, UnityEngine.Object key)
{
if (source == null || key == null)
{
return(default(PlayableBinding));
}
return(source.outputs.FirstOrDefault(a => a.sourceObject == key));
}
public void Play(PlayableAsset playable)
{
m_playable = playable;
m_director.playableAsset = playable;
m_director.enabled = false;
m_director.enabled = true;
}
protected virtual void Awake()
{
director = GetComponent <PlayableDirector>();
director.extrapolationMode = DirectorWrapMode.None;
PlayableAsset playableAsset = director.playableAsset;
director.timeUpdateMode = DirectorUpdateMode.GameTime;
}
/************************************************************************************************************************/
#endregion
/************************************************************************************************************************/
#region Methods
/************************************************************************************************************************/
/// <summary>Constructs a new <see cref="PlayableAssetState"/> to play the `asset`.</summary>
public PlayableAssetState(PlayableAsset asset)
{
if (asset == null)
{
throw new ArgumentNullException("asset");
}
_Asset = asset;
}
/************************************************************************************************************************/
private void CreatePlayable(PlayableAsset asset)
{
if (asset == null)
{
throw new ArgumentNullException("asset");
}
_Asset = asset;
_Playable = asset.CreatePlayable(Root._Graph, Root.Component.gameObject);
}
private IEnumerator PlayCutscene(PlayableAsset cutscene)
{
float duration = (float)cutscene.duration;
objSys.playableDirector.playableAsset = cutscene;
objSys.playableDirector.Play();
yield return(new WaitForSeconds(duration));
objSys.playableDirector.Stop();
}
internal void Prepare(PlayableAsset animation)
{
m_Playable = GetComponent <PlayableDirector>();
if (m_Playable == null)
{
m_Playable = gameObject.AddComponent <PlayableDirector>();
}
m_Playable.playOnAwake = false;
m_Playable.playableAsset = animation;
}
public bool Remove(ScriptableObject item, TimelineAsset timelineAsset, PlayableAsset thingToDirty)
{
if (!m_Objects.Contains(item)) return false;
TimelineUndo.PushUndo(thingToDirty, "Delete Marker");
m_Objects.Remove(item);
m_CacheDirty = true;
TimelineUndo.PushDestroyUndo(timelineAsset, thingToDirty, item, "Delete Marker");
return true;
}
public override Playable CreatePlayable(PlayableGraph graph, GameObject go)
{
List <Playable> playableList = new List <Playable>();
GameObject gameObject = GetGameObjectBinding(go.GetComponent <PlayableDirector>());
if (this.prefabGameObject != null)
{
Transform parentTransform = !(gameObject != null) ? (Transform)null : gameObject.transform;
ScriptPlayable <PrefabControlPlayable> scriptPlayable = PrefabControlPlayable.Create(graph, this.prefabGameObject, parentTransform);
gameObject = scriptPlayable.GetBehaviour().prefabInstance;
playableList.Add((Playable)scriptPlayable);
}
this.UpdateDurationAndLoopFlag(gameObject);
if (gameObject == null)
{
return(Playable.Create(graph, 0));
}
PlayableDirector component = go.GetComponent <PlayableDirector>();
if (component != null)
{
this.m_ControlDirectorAsset = component.playableAsset;
}
if (go == gameObject && this.prefabGameObject == null)
{
UnityEngine.Debug.LogWarning((object)("Control Playable (" + this.name + ") is referencing the same PlayableDirector component than the one in which it is playing."));
this.active = false;
if (!this.searchHierarchy)
{
this.updateDirector = false;
}
}
if (this.active)
{
this.CreateActivationPlayable(gameObject, graph, playableList);
}
if (this.updateDirector)
{
this.SearchHierarchyAndConnectDirector(gameObject, graph, playableList);
}
if (this.updateParticle)
{
this.SearchHiearchyAndConnectParticleSystem(gameObject, graph, playableList);
}
if (this.updateITimeControl)
{
this.SearchHierarchyAndConnectControlableScripts(gameObject, graph, playableList);
}
return(this.ConnectPlayablesToMixer(graph, playableList));
}
public DragAndDropVisualMode HandleTrackDrop(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, TreeViewDragging.DropPosition dropPos)
{
((TimelineTreeView)this.m_Window.treeView.gui).showInsertionMarker = false;
TimelineDragging.TimelineDragData timelineDragData = (TimelineDragging.TimelineDragData)DragAndDrop.GetGenericData("TimelineDragging");
DragAndDropVisualMode result;
if (!TimelineDragging.ValidDrag(targetItem, timelineDragData.draggedItems))
{
result = 0;
}
else
{
TimelineGroupGUI timelineGroupGUI = targetItem as TimelineGroupGUI;
if (timelineGroupGUI != null && timelineGroupGUI.track != null)
{
((TimelineTreeView)this.m_Window.treeView.gui).showInsertionMarker = true;
}
if (dropPos == null)
{
TimelineGroupGUI timelineGroupGUI2 = targetItem as TimelineGroupGUI;
if (timelineGroupGUI2 != null)
{
timelineGroupGUI2.isDropTarget = true;
}
}
if (perform)
{
List <TrackAsset> draggedActors = (from x in timelineDragData.draggedItems.OfType <TimelineGroupGUI>()
select x.track).ToList <TrackAsset>();
if (draggedActors.Count == 0)
{
result = 0;
return(result);
}
PlayableAsset playableAsset = this.m_Timeline;
TimelineGroupGUI timelineGroupGUI3 = parentItem as TimelineGroupGUI;
if (timelineGroupGUI3 != null && timelineGroupGUI3.track != null)
{
playableAsset = timelineGroupGUI3.track;
}
TrackAsset trackAsset = (timelineGroupGUI == null) ? null : timelineGroupGUI.track;
if (playableAsset == this.m_Timeline && dropPos == 1 && trackAsset == null)
{
trackAsset = this.m_Timeline.tracks.LastOrDefault((TrackAsset x) => !draggedActors.Contains(x));
}
if (TrackExtensions.ReparentTracks(draggedActors, playableAsset, trackAsset, dropPos == 2))
{
this.m_Window.state.Refresh(true);
}
}
result = 16;
}
return(result);
}
