private TimelineClip CreateAndAddNewClipOfType(Type requestedType) { ScriptableObject scriptableObject = ScriptableObject.CreateInstance(requestedType); if (scriptableObject == null) { throw new InvalidOperationException("Could not create an instance of the ScriptableObject type " + requestedType.Name); } scriptableObject.name = requestedType.Name; TimelineCreateUtilities.SaveAssetIntoObject(scriptableObject, this); TimelineClip timelineClip = this.CreateNewClipContainerInternal(); timelineClip.displayName = scriptableObject.name; timelineClip.asset = scriptableObject; try { this.OnCreateClipFromAsset(scriptableObject, timelineClip); } catch (Exception ex) { Debug.LogError(ex.Message, scriptableObject); return(null); } this.AddClip(timelineClip); return(timelineClip); }
public IMarker CreateMarker(Type type, double time, TrackAsset owner) { if (!typeof(ScriptableObject).IsAssignableFrom(type) || !typeof(IMarker).IsAssignableFrom(type)) { throw new InvalidOperationException( "The requested type needs to inherit from ScriptableObject and implement IMarker"); } if (!owner.supportsNotifications && typeof(INotification).IsAssignableFrom(type)) { throw new InvalidOperationException( "Markers implementing the INotification interface cannot be added on tracks that do not support notifications"); } var markerSO = ScriptableObject.CreateInstance(type); var marker = (IMarker)markerSO; marker.time = time; TimelineCreateUtilities.SaveAssetIntoObject(markerSO, owner); TimelineUndo.RegisterCreatedObjectUndo(markerSO, "Create " + type.Name); TimelineUndo.PushUndo(owner, "Create " + type.Name); Add(markerSO); marker.Initialize(owner); return marker; }
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); }
/// <summary> /// Creates a marker track for the TimelineAsset. /// </summary> /// In the editor, the marker track appears under the Timeline ruler. /// <remarks> /// This track is always bound to the GameObject that contains the PlayableDirector component for the current timeline. /// The marker track is created the first time this method is called. If the marker track is already created, this method does nothing. /// </remarks> public void CreateMarkerTrack() { if (m_MarkerTrack == null) { m_MarkerTrack = CreateInstance <MarkerTrack>(); TimelineCreateUtilities.SaveAssetIntoObject(m_MarkerTrack, this); m_MarkerTrack.parent = this; m_MarkerTrack.name = "Markers"; // This name will show up in the bindings list if it contains signals Invalidate(); } }
/// <summary> /// Allows you to create a track and add it to the Timeline. /// </summary> /// <param name="type">The type of track to create. Must derive from TrackAsset.</param> /// <param name="parent">Track to parent to. This can be null.</param> /// <param name="name">Name to give the track.</param> /// <returns>The created track.</returns> /// <remarks> /// This method will throw an InvalidOperationException if the parent is not valid. The parent can be any GroupTrack, or a supported parent type of track. For example, this can be used to create override tracks in AnimationTracks. /// </remarks> public TrackAsset CreateTrack(Type type, TrackAsset parent, string name) { if (parent != null && parent.timelineAsset != this) { throw new InvalidOperationException("Addtrack cannot parent to a track not in the Timeline"); } if (!typeof(TrackAsset).IsAssignableFrom(type)) { throw new InvalidOperationException("Supplied type must be a track asset"); } if (parent != null) { if (!TimelineCreateUtilities.ValidateParentTrack(parent, type)) { throw new InvalidOperationException("Cannot assign a child of type " + type.Name + " to a parent of type " + parent.GetType().Name); } } var actualParent = parent != null ? parent as PlayableAsset : this; TimelineUndo.PushUndo(actualParent, "Create Track"); var baseName = name; if (string.IsNullOrEmpty(baseName)) { baseName = type.Name; #if UNITY_EDITOR baseName = UnityEditor.ObjectNames.NicifyVariableName(baseName); #endif } var trackName = baseName; if (parent != null) { trackName = TimelineCreateUtilities.GenerateUniqueActorName(parent.subTracksObjects, baseName); } else { trackName = TimelineCreateUtilities.GenerateUniqueActorName(trackObjects, baseName); } TrackAsset newTrack = AllocateTrack(parent, trackName, type); if (newTrack != null) { newTrack.name = trackName; TimelineCreateUtilities.SaveAssetIntoObject(newTrack, actualParent); } return(newTrack); }
internal TimelineClip CreateClipOfType(Type requestedType) { if (!ValidateClipType(requestedType)) throw new System.InvalidOperationException("Clips of type " + requestedType + " are not permitted on tracks of type " + GetType()); var playableAsset = CreateInstance(requestedType); if (playableAsset == null) { throw new System.InvalidOperationException("Could not create an instance of the ScriptableObject type " + requestedType.Name); } playableAsset.name = requestedType.Name; TimelineCreateUtilities.SaveAssetIntoObject(playableAsset, this); TimelineUndo.RegisterCreatedObjectUndo(playableAsset, "Create Clip"); return CreateClipFromAsset(playableAsset); }
internal override void OnCreateClipFromAsset(Object asset, TimelineClip clip) { AnimationClip animationClip = asset as AnimationClip; if (animationClip != null) { if (animationClip.legacy) { throw new InvalidOperationException("Legacy Animation Clips are not supported"); } AnimationPlayableAsset animationPlayableAsset = ScriptableObject.CreateInstance <AnimationPlayableAsset>(); TimelineCreateUtilities.SaveAssetIntoObject(animationPlayableAsset, this); animationPlayableAsset.clip = animationClip; clip.asset = animationPlayableAsset; this.AssignAnimationClip(clip, animationClip); } }
public TrackAsset CreateTrack(Type type, TrackAsset parent, string name) { if (parent != null && parent.timelineAsset != this) { throw new InvalidOperationException("Addtrack cannot parent to a track not in the Timeline"); } if (!typeof(TrackAsset).IsAssignableFrom(type)) { throw new InvalidOperationException("Supplied type must be a track asset"); } if (parent != null) { if (!TimelineCreateUtilities.ValidateParentTrack(parent, type)) { throw new InvalidOperationException("Cannot assign a child of type " + type.Name + "to a parent of type " + parent.GetType().Name); } } PlayableAsset masterAsset = (!(parent != null)) ? this : parent; string text = name; if (string.IsNullOrEmpty(text)) { text = type.Name; } string text2; if (parent != null) { text2 = TimelineCreateUtilities.GenerateUniqueActorName(parent.subTracksObjects, text); } else { text2 = TimelineCreateUtilities.GenerateUniqueActorName(this.trackObjects, text); } TrackAsset trackAsset = this.AllocateTrack(parent, text2, type); if (trackAsset != null) { trackAsset.name = text2; TimelineCreateUtilities.SaveAssetIntoObject(trackAsset, masterAsset); } return(trackAsset); }
static void MoveToTrack_Impl(TimelineClip clip, TrackAsset destinationTrack, Object asset, TrackAsset parentTrack) { TimelineUndo.PushUndo(asset, k_UndoSetParentTrackText); if (parentTrack != null) { TimelineUndo.PushUndo(parentTrack, k_UndoSetParentTrackText); } TimelineUndo.PushUndo(destinationTrack, k_UndoSetParentTrackText); clip.SetParentTrack_Internal(destinationTrack); if (parentTrack == null) { TimelineCreateUtilities.SaveAssetIntoObject(asset, destinationTrack); } else if (parentTrack.timelineAsset != destinationTrack.timelineAsset) { TimelineCreateUtilities.RemoveAssetFromObject(asset, parentTrack); TimelineCreateUtilities.SaveAssetIntoObject(asset, destinationTrack); } }
public IMarker CreateMarker(Type type, double time, TrackAsset owner) { if (!typeof(ScriptableObject).IsAssignableFrom(type) || !typeof(IMarker).IsAssignableFrom(type)) { throw new InvalidOperationException( "The requested type needs to inherit from ScriptableObject and implement IMarker"); } var markerSO = ScriptableObject.CreateInstance(type); var marker = (IMarker)markerSO; marker.time = time; TimelineCreateUtilities.SaveAssetIntoObject(markerSO, owner); TimelineUndo.RegisterCreatedObjectUndo(markerSO, "Create " + type.Name); TimelineUndo.PushUndo(owner, "Create " + type.Name); Add(markerSO); marker.Initialize(owner); return(marker); }