public static string GetTrackMenuName(System.Type trackType) { return(L10n.Tr(TypeUtility.GetDisplayName(trackType))); }
public void SaveCurve(AnimationWindowCurve curve) { Undo.RegisterCompleteObjectUndo(activeAnimationClip, L10n.Tr("Edit Curve")); AnimationWindowUtility.SaveCurve(activeAnimationClip, curve); }
public override void OnInspectorGUI() { if (target == null) { return; } serializedObject.Update(); m_SourceObjectLabel.text = m_SourceObject.displayName; if (m_PrefabObject.objectReferenceValue != null) { m_SourceObjectLabel.text = L10n.Tr("Parent Object"); } bool selfControlled = false; EditorGUI.BeginChangeCheck(); using (new GUIMixedValueScope(m_SourceObject.hasMultipleDifferentValues)) EditorGUILayout.PropertyField(m_SourceObject, m_SourceObjectLabel); var sourceGameObject = m_SourceObject.exposedReferenceValue as GameObject; selfControlled = m_PrefabObject.objectReferenceValue == null && TimelineWindow.instance != null && TimelineWindow.instance.state != null && contextDirector != null && sourceGameObject == contextDirector.gameObject; if (EditorGUI.EndChangeCheck()) { CheckForCyclicReference(); if (!selfControlled) { DisablePlayOnAwake(sourceGameObject); } } if (selfControlled) { EditorGUILayout.HelpBox(L10n.Tr("The assigned GameObject references the same PlayableDirector component being controlled."), MessageType.Warning); } else if (m_CycleReference) { EditorGUILayout.HelpBox(L10n.Tr("The assigned GameObject contains a PlayableDirector component that results in a circular reference."), MessageType.Warning); } EditorGUI.indentLevel++; EditorGUILayout.PropertyField(m_PrefabObject, Styles.prefabContent); EditorGUI.indentLevel--; using (new EditorGUI.DisabledScope(selfControlled)) { EditorGUILayout.PropertyField(m_UseActivation, selfControlled ? Styles.activationDisabledContent : Styles.activationContent); if (m_UseActivation.boolValue) { EditorGUI.indentLevel++; EditorGUILayout.PropertyField(m_PostPlayback, Styles.postPlayableContent); EditorGUI.indentLevel--; } } m_SourceObject.isExpanded = EditorGUILayout.Foldout(m_SourceObject.isExpanded, Styles.advancedContent, true); if (m_SourceObject.isExpanded) { EditorGUI.indentLevel++; using (new EditorGUI.DisabledScope(selfControlled && !m_SearchHierarchy.boolValue)) { EditorGUI.BeginChangeCheck(); EditorGUILayout.PropertyField(m_UpdateDirector, selfControlled ? Styles.updatePlayableDirectorDisabledContent : Styles.updatePlayableDirectorContent); if (EditorGUI.EndChangeCheck()) { CheckForCyclicReference(); } } EditorGUILayout.PropertyField(m_UpdateParticle, Styles.updateParticleSystemsContent); if (m_UpdateParticle.boolValue) { EditorGUI.indentLevel++; EditorGUILayout.PropertyField(m_RandomSeed, Styles.randomSeedContent); EditorGUI.indentLevel--; } EditorGUILayout.PropertyField(m_UpdateITimeControl, Styles.updateITimeControlContent); EditorGUILayout.PropertyField(m_SearchHierarchy, Styles.updateHierarchy); EditorGUI.indentLevel--; } serializedObject.ApplyModifiedProperties(); }
internal static void AddTimeAreaMenuItems(GenericMenu menu, WindowState state) { foreach (var value in Enum.GetValues(typeof(TimelineAsset.DurationMode))) { var mode = (TimelineAsset.DurationMode)value; var item = EditorGUIUtility.TextContent(string.Format(TimelineWindow.Styles.DurationModeText, L10n.Tr(ObjectNames.NicifyVariableName(mode.ToString())))); if (state.recording || state.IsEditingASubTimeline() || state.editSequence.asset == null || state.editSequence.isReadOnly) { menu.AddDisabledItem(item); } else { menu.AddItem(item, state.editSequence.asset.durationMode == mode, () => SelectDurationCallback(state, mode)); } menu.AddItem(DirectorStyles.showMarkersOnTimeline, state.showMarkerHeader, () => new ToggleShowMarkersOnTimeline().Execute(state)); } }
public static GUIContent TrTextContentWithIcon(string text, string tooltip, string iconName) { return(L10n.TextContentWithIcon(text, tooltip, iconName == null ? null : ResolveIcon(iconName))); }
public static GUIContent TrTextContent(string text, string tooltip = null) { return(L10n.TextContent(text, tooltip)); }
public static GUIContent TrIconContent(string iconName, string tooltip = null) { return(L10n.IconContent(iconName == null ? null : ResolveIcon(iconName), tooltip)); }
void DrawOptions() { if (currentMode.headerState.options == TimelineModeGUIState.Hidden || state.editSequence.asset == null) { return; } using (new EditorGUI.DisabledScope(currentMode.headerState.options == TimelineModeGUIState.Disabled)) { var rect = new Rect(position.width - WindowConstants.cogButtonWidth, 0, WindowConstants.cogButtonWidth, WindowConstants.timeAreaYPosition); if (EditorGUI.DropdownButton(rect, DirectorStyles.optionsCogIcon, FocusType.Keyboard, EditorStyles.toolbarButton)) { GenericMenu menu = new GenericMenu(); menu.AddItem(L10n.TextContent("Preferences Page..."), false, () => SettingsWindow.Show(SettingsScope.User, "Preferences/Timeline")); menu.AddSeparator(""); menu.AddItem(MenuItemFrames, state.timeFormat == TimeFormat.Frames, () => state.timeFormat = TimeFormat.Frames); menu.AddItem(MenuItemTimecode, state.timeFormat == TimeFormat.Timecode, () => state.timeFormat = TimeFormat.Timecode); menu.AddItem(MenuItemSeconds, state.timeFormat == TimeFormat.Seconds, () => state.timeFormat = TimeFormat.Seconds); menu.AddSeparator(""); TimeAreaContextMenu.AddTimeAreaMenuItems(menu, state); menu.AddSeparator(""); bool standardFrameRate = false; for (int i = 0; i < TimelineProjectSettings.framerateValues.Length; i++) { standardFrameRate |= AddStandardFrameRateMenu(menu, "Frame Rate/" + TimelineProjectSettings.framerateLabels[i], TimelineProjectSettings.framerateValues[i]); } if (standardFrameRate) { menu.AddDisabledItem(L10n.TextContent("Frame Rate/Custom")); } else { menu.AddItem(L10n.TextContent("Frame Rate/Custom (" + state.editSequence.frameRate + ")"), true, () => {}); } menu.AddSeparator(""); if (state.playRangeEnabled) { menu.AddItem(L10n.TextContent("Play Range Mode/Loop"), state.playRangeLoopMode, () => state.playRangeLoopMode = true); menu.AddItem(L10n.TextContent("Play Range Mode/Once"), !state.playRangeLoopMode, () => state.playRangeLoopMode = false); } else { menu.AddDisabledItem(L10n.TextContent("Play Range Mode")); } if (Unsupported.IsDeveloperMode()) { menu.AddSeparator(""); menu.AddItem(L10n.TextContent("Show Snapping Debug"), SnapEngine.displayDebugLayout, () => SnapEngine.displayDebugLayout = !SnapEngine.displayDebugLayout); menu.AddItem(L10n.TextContent("Debug TimeArea"), false, () => Debug.LogFormat("translation: {0} scale: {1} rect: {2} shownRange: {3}", m_TimeArea.translation, m_TimeArea.scale, m_TimeArea.rect, m_TimeArea.shownArea)); menu.AddItem(L10n.TextContent("Edit Skin"), false, () => Selection.activeObject = DirectorStyles.Instance.customSkin); menu.AddItem(L10n.TextContent("Show QuadTree Debugger"), state.showQuadTree, () => state.showQuadTree = !state.showQuadTree); } menu.DropDown(rect); } } }
void DrawNoSequenceGUI(WindowState windowState) { bool showCreateButton = false; var currentlySelectedGo = UnityEditor.Selection.activeObject != null ? UnityEditor.Selection.activeObject as GameObject : null; var textContent = DirectorStyles.noTimelineAssetSelected; var existingDirector = currentlySelectedGo != null?currentlySelectedGo.GetComponent <PlayableDirector>() : null; var existingAsset = existingDirector != null ? existingDirector.playableAsset : null; if (currentlySelectedGo != null && !TimelineUtility.IsPrefabOrAsset(currentlySelectedGo) && existingAsset == null) { showCreateButton = true; textContent = new GUIContent(String.Format(DirectorStyles.createTimelineOnSelection.text, currentlySelectedGo.name, L10n.Tr("a Director component and a Timeline asset"))); } GUILayout.FlexibleSpace(); GUILayout.BeginVertical(); GUILayout.FlexibleSpace(); GUILayout.Label(textContent); if (showCreateButton) { GUILayout.BeginHorizontal(); var textSize = GUI.skin.label.CalcSize(textContent); GUILayout.Space((textSize.x / 2.0f) - (WindowConstants.createButtonWidth / 2.0f)); if (GUILayout.Button(L10n.Tr("Create"), GUILayout.Width(WindowConstants.createButtonWidth))) { var message = DirectorStyles.createNewTimelineText.text + " '" + currentlySelectedGo.name + "'"; var defaultName = currentlySelectedGo.name.EndsWith(DirectorStyles.newTimelineDefaultNameSuffix, StringComparison.OrdinalIgnoreCase) ? currentlySelectedGo.name : currentlySelectedGo.name + DirectorStyles.newTimelineDefaultNameSuffix; // Use the project window path by default only if it's under the asset folder. // Otherwise the saveFilePanel will reject the save (case 1289923) var defaultPath = ProjectWindowUtil.GetActiveFolderPath(); if (!defaultPath.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase)) { defaultPath = "Assets"; } string newSequencePath = EditorUtility.SaveFilePanelInProject(DirectorStyles.createNewTimelineText.text, defaultName, "playable", message, defaultPath); if (!string.IsNullOrEmpty(newSequencePath)) { var newAsset = TimelineUtility.CreateAndSaveTimelineAsset(newSequencePath); Undo.IncrementCurrentGroup(); if (existingDirector == null) { existingDirector = Undo.AddComponent <PlayableDirector>(currentlySelectedGo); } existingDirector.playableAsset = newAsset; SetTimeline(existingDirector); windowState.previewMode = false; } // If we reach this point, the state of the panel has changed; skip the rest of this GUI phase // Fixes: case 955831 - [OSX] NullReferenceException when creating a timeline on a selected object GUIUtility.ExitGUI(); } GUILayout.EndHorizontal(); } GUILayout.FlexibleSpace(); GUILayout.EndVertical(); GUILayout.FlexibleSpace(); }
public void Grab(IEnumerable <ITimelineItem> items, TrackAsset referenceTrack, Vector2 mousePosition) { if (items == null) { return; } items = items.ToArray(); // Cache enumeration result if (!items.Any()) { return; } m_GrabbedModalUndoGroup = Undo.GetCurrentGroup(); var trackItems = items.GroupBy(c => c.parentTrack).ToArray(); var trackItemsCount = trackItems.Length; var tracks = items.Select(c => c.parentTrack).Where(x => x != null).Distinct(); movingItems = new MovingItems[trackItemsCount]; allowTrackSwitch = trackItemsCount == 1 && !trackItems.SelectMany(x => x).Any(x => x is MarkerItem); // For now, track switch is only supported when all items are on the same track and there are no items // one push per track handles all the clips on the track UndoExtensions.RegisterTracks(tracks, L10n.Tr("Move Items")); foreach (var sourceTrack in tracks) { // push all markers on the track because of ripple UndoExtensions.RegisterMarkers(sourceTrack.GetMarkers(), L10n.Tr("Move Items")); } for (var i = 0; i < trackItemsCount; ++i) { var track = trackItems[i].Key; var grabbedItems = new MovingItems(m_State, track, trackItems[i].ToArray(), referenceTrack, mousePosition, allowTrackSwitch); movingItems[i] = grabbedItems; } m_LeftMostMovingItems = null; m_RightMostMovingItems = null; foreach (var grabbedTrackItems in movingItems) { if (m_LeftMostMovingItems == null || m_LeftMostMovingItems.start > grabbedTrackItems.start) { m_LeftMostMovingItems = grabbedTrackItems; } if (m_RightMostMovingItems == null || m_RightMostMovingItems.end < grabbedTrackItems.end) { m_RightMostMovingItems = grabbedTrackItems; } } m_ItemGUIs = new HashSet <TimelineItemGUI>(); m_ItemsGroup = new ItemsGroup(items); foreach (var item in items) { m_ItemGUIs.Add(item.gui); } targetTrack = referenceTrack; EditMode.BeginMove(this); m_Grabbing = true; }
public AnimationClip PrepareTrack(TrackAsset track, WindowState state, GameObject gameObject, out double startTime) { AnimationClip animationClip = null; // if we are not in clip mode, we simply use the track clip var animationTrack = (AnimationTrack)track; // ignore recording if we are in Legacy auto mode startTime = -1; var parentTrack = TimelineUtility.GetSceneReferenceTrack(track) as AnimationTrack; if (parentTrack != null && parentTrack.trackOffset == TrackOffset.Auto) { return(null); } if (!animationTrack.inClipMode) { var trackClip = animationTrack.GetOrCreateClip(); startTime = trackClip.frameRate * state.editSequence.time; // Make the first key be at time 0 of the clip if (trackClip.empty) { animationTrack.infiniteClipTimeOffset = 0; // state.time; animationTrack.infiniteClipPreExtrapolation = TimelineClip.ClipExtrapolation.Hold; animationTrack.infiniteClipPostExtrapolation = TimelineClip.ClipExtrapolation.Hold; } animationClip = trackClip; } else { TimelineClip activeClip = null; // if it fails, but returns no clip, we can add one. if (!track.FindRecordingClipAtTime(state.editSequence.time, out activeClip) && activeClip != null) { return(null); } if (activeClip == null) { activeClip = AddRecordableClip(track, state, state.editSequence.time); } var clip = activeClip.animationClip; // flags this as the clip being recorded for the track var clipTime = state.editSequence.time - activeClip.start; // if we are in the past if (clipTime < 0) { Undo.RegisterCompleteObjectUndo(clip, L10n.Tr("Record Key")); UndoExtensions.RegisterTrack(track, L10n.Tr("Prepend Key")); ShiftAnimationClip(clip, (float)-clipTime); activeClip.start = state.editSequence.time; activeClip.duration += -clipTime; clipTime = 0; } m_ClipTime = clipTime; recordClip = activeClip; startTime = recordClip.ToLocalTimeUnbound(state.editSequence.time) * clip.frameRate; m_needRebuildRects = clip.empty; animationClip = clip; } m_TargetClip = animationClip; m_CurveCount = GetCurveCount(animationClip); m_TrackHasPreviewComponents = animationTrack.hasPreviewComponents; return(animationClip); }