wehub-resource-sync
982 lines
40 KiB
C#
982 lines
40 KiB
C#
#nullable enable
|
|
|
|
using System.Diagnostics;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using ImGuiNET;
|
|
using T3.Core.Animation;
|
|
using T3.Core.DataTypes;
|
|
using T3.Core.Operator;
|
|
using T3.Core.Operator.Slots;
|
|
using T3.Core.Utils;
|
|
using T3.Editor.Gui.Interaction;
|
|
using T3.Editor.Gui.Interaction.Keyboard;
|
|
using T3.Editor.Gui.Interaction.Snapping;
|
|
using T3.Editor.Gui.Interaction.Timing;
|
|
using T3.Editor.Gui.Interaction.WithCurves;
|
|
using T3.Editor.Gui.Styling;
|
|
using T3.Editor.Gui.UiHelpers;
|
|
using T3.Editor.Gui.Windows.TimeLine.Raster;
|
|
using T3.Editor.Gui.Windows.TimeLine.TimeClips;
|
|
using T3.Editor.UiModel;
|
|
using T3.Editor.UiModel.ProjectHandling;
|
|
using T3.Editor.UiModel.Selection;
|
|
|
|
// ReSharper disable ForeachCanBePartlyConvertedToQueryUsingAnotherGetEnumerator
|
|
|
|
namespace T3.Editor.Gui.Windows.TimeLine;
|
|
|
|
/// <summary>
|
|
/// Combines multiple <see cref="ITimeObjectManipulation"/>s into a single consistent
|
|
/// timeline that allows dragging selected time elements of various types.
|
|
/// </summary>
|
|
[HelpUiID("Timeline")]
|
|
internal sealed class TimeLineCanvas : AnimationCanvas
|
|
{
|
|
public TimeLineCanvas(NodeSelection nodeSelection, Func<Instance> getCompositionOp, Func<Guid, bool> requestChildCompositionFunc)
|
|
{
|
|
_nodeSelection = nodeSelection;
|
|
|
|
DopeSheetArea = new DopeSheetArea(SnapHandlerForU, this);
|
|
_timelineCurveEditArea = new TimelineCurveEditor(this, SnapHandlerForU, SnapHandlerForV);
|
|
_timeSelectionRange = new TimeSelectionRange(this, SnapHandlerForU);
|
|
_selectionRangeIndicator = new SelectionRangeIndicator(this, SnapHandlerForU);
|
|
_timeSelectionArea = new TimeSelectionArea(this);
|
|
ClipArea = new ClipArea(this, getCompositionOp, requestChildCompositionFunc, SnapHandlerForU);
|
|
_curveEditCanvas = new InlineCurveArea(this, _timelineCurveEditArea, _horizontalRaster);
|
|
_inlineDataClipArea = new InlineDataClipArea(this);
|
|
_detailsArea = new TimelineDetailsArea(this, _curveEditCanvas, _inlineDataClipArea);
|
|
|
|
SnapHandlerForV.AddSnapAttractor(_horizontalRaster);
|
|
SnapHandlerForU.AddSnapAttractor(_clipRange);
|
|
SnapHandlerForU.AddSnapAttractor(_loopRange);
|
|
SnapHandlerForU.AddSnapAttractor(_timeRasterSwitcher);
|
|
SnapHandlerForU.AddSnapAttractor(_currentTimeMarker);
|
|
SnapHandlerForU.AddSnapAttractor(ClipArea);
|
|
SnapHandlerForU.AddSnapAttractor(_selectionRangeIndicator);
|
|
_selectionDragSnapExclusions = [_selectionRangeIndicator];
|
|
|
|
KeyframeEditors = new KeyframeEditorGroup(_activeKeyframeEditors);
|
|
|
|
FoldingHeight = new TimelineHeight(this);
|
|
Playback = null!;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Snap-attractors to skip while dragging selected keyframes or keyset-indicator clusters.
|
|
/// The <see cref="SelectionRangeIndicator"/> anchors at the first/last selected-keyframe U,
|
|
/// so snapping to it during such a drag forms a feedback loop that stutters the boundary keys.
|
|
/// </summary>
|
|
internal IValueSnapAttractor[] SelectionDragSnapExclusions => _selectionDragSnapExclusions;
|
|
|
|
/// <summary>
|
|
/// Every currently-active animation-parameter editor on the timeline. Today this is always
|
|
/// a single editor (DopeSheetArea in DopeView mode, TimelineCurveEditor in CurveEditor mode);
|
|
/// future split-view will expose both simultaneously. Cross-mode components (SRI, TimeSelectionArea,
|
|
/// TimeWarpDrag) aggregate through <see cref="KeyframeEditors"/> so they don't need to pick one.
|
|
/// </summary>
|
|
public readonly KeyframeEditorGroup KeyframeEditors;
|
|
|
|
/// <summary>
|
|
/// Invoked when the keyframe selection is explicitly replaced (not merely added to / removed from).
|
|
/// Lets the SRI drop its TimeWarp handles since they were configured for the previous selection.
|
|
/// </summary>
|
|
internal void OnKeyframeSelectionReplaced() => _selectionRangeIndicator.ClearTimeWarpHandles();
|
|
|
|
public NodeSelection NodeSelection => _nodeSelection;
|
|
|
|
private int RulerHeight => (int)(28 * T3Ui.UiScaleFactor);
|
|
private int SummaryHeight => (int)(11 * T3Ui.UiScaleFactor);
|
|
|
|
public void Draw(ProjectView projectView, Playback playback)
|
|
{
|
|
Debug.Assert(projectView.CompositionInstance != null);
|
|
|
|
var compositionOp = projectView.CompositionInstance;
|
|
Current = this;
|
|
Playback = playback;
|
|
SyncStateWithComposition(compositionOp);
|
|
|
|
_selectedAnimationParameters = GetAnimationParametersForSelectedNodes(compositionOp);
|
|
|
|
PruneExpandedForMissingParams();
|
|
|
|
// Very ugly hack to prevent scaling the output above window size
|
|
var keepScale = T3Ui.UiScaleFactor;
|
|
|
|
ScrollToTimeAfterStopped();
|
|
|
|
var modeChanged = UpdateMode();
|
|
SyncInlineCurveEditorRegistration();
|
|
|
|
// Details pane (curve editor OR DataClip editor) takes over the bottom strip of
|
|
// the timeline body when it's active. The outer canvas suppresses its fence in
|
|
// that case so clicks inside the details pane don't bubble up and clear the
|
|
// clip / keyframe selection that drove the pane open in the first place; a
|
|
// dope-local fence inside the top pane covers the rubber-band-select use case.
|
|
var detailsActive = _detailsArea.IsActive(compositionOp);
|
|
var outerFlags = T3Ui.EditingFlags.AllowHoveredChildWindows;
|
|
if (detailsActive && CurveEditAreaScreenRect.HasValue
|
|
&& CurveEditAreaScreenRect.Value.Contains(ImGui.GetMousePos()))
|
|
{
|
|
// Curve editor's sub-canvas owns wheel / RMB while the cursor is inside it;
|
|
// ceding here keeps zoom / pan from double-processing on the outer canvas.
|
|
outerFlags |= T3Ui.EditingFlags.PreventZoomWithMouseWheel
|
|
| T3Ui.EditingFlags.PreventPanningWithMouse;
|
|
}
|
|
|
|
DrawAnimationCanvas(drawAdditionalCanvasContent: DrawCanvasContent,
|
|
detailsActive ? null : _selectionFence,
|
|
0,
|
|
outerFlags,
|
|
drawVSnapIndicator: !detailsActive);
|
|
Current = null;
|
|
|
|
T3Ui.UiScaleFactor = keepScale;
|
|
return;
|
|
|
|
void DrawCanvasContent(InteractionState interactionState)
|
|
{
|
|
// Cross-view hover state is rebuilt each frame by whichever renderer's hit-test
|
|
// sets it. Stale values would leak hover fade to the next frame on mouse-exit.
|
|
HoveredParameterHash = null;
|
|
HoveredComponentBit = 0;
|
|
HoveredKeyframeUniqueId = null;
|
|
|
|
ImGui.SetCursorPosY(ImGui.GetCursorPosY() );
|
|
if (PlaybackUtils.TryFindingSoundtrack(out var soundtrack, out var composition))
|
|
{
|
|
TimeLineImage.Draw(Drawlist, soundtrack);
|
|
}
|
|
|
|
_timeRasterSwitcher.Draw(this);
|
|
|
|
// Ruler
|
|
{
|
|
ImGui.BeginChild("##ruler", new Vector2(0,RulerHeight), ImGuiChildFlags.None, ImGuiWindowFlags.NoScrollbar);
|
|
DrawTimeRuler(interactionState.MouseState.Position.X);
|
|
_selectionRangeIndicator.Draw(compositionOp, ImGui.GetWindowDrawList());
|
|
ImGui.EndChild();
|
|
}
|
|
|
|
|
|
// Selection Area (summary strip below ruler)
|
|
{
|
|
ImGui.PushStyleColor(ImGuiCol.ChildBg, UiColors.GridLines.Fade(0.20f).Rgba);
|
|
ImGui.BeginChild("##selectionArea", new Vector2(0,SummaryHeight));
|
|
_timeSelectionArea.Draw(compositionOp, _selectedAnimationParameters, KeyframeEditors, ImGui.GetWindowDrawList());
|
|
ImGui.EndChild();
|
|
ImGui.PopStyleColor();
|
|
}
|
|
|
|
// SRI and SA may have mutated keyframe U values via TimeWarpDrag / the SA's ApplyKeyframeTimeOffset.
|
|
// Rebuild each active editor's curve tables once, centrally, so downstream editor draws see sorted curves.
|
|
KeyframeEditors.ProcessPendingCurveTableRebuild();
|
|
|
|
HandleDeferredActions();
|
|
|
|
ImGui.BeginChild(ImGuiTitle, new Vector2(0, 0), ImGuiChildFlags.Borders,
|
|
ImGuiWindowFlags.NoMove
|
|
| ImGuiWindowFlags.NoBackground
|
|
| ImGuiWindowFlags.NoScrollWithMouse);
|
|
|
|
{
|
|
if (KeyActionHandling.Triggered(UserActions.DeleteSelection))
|
|
DeleteSelectedElements(compositionOp);
|
|
|
|
// Layout: top pane (dope + clips) | resize handle | details pane.
|
|
// The 8 px handle gap sits outside any child's hit rect so ImGui routes
|
|
// clicks to the handle; the two ItemSpacing.Y values close out the math
|
|
// so the three stacked items consume exactly rawAvailHeight.
|
|
var detailsActive = _detailsArea.IsActive(compositionOp);
|
|
var rawAvailHeight = ImGui.GetContentRegionAvail().Y;
|
|
if (detailsActive)
|
|
DetailsAreaHeight = MathF.Min(MathF.Max(DetailsAreaHeight, 80f), MathF.Max(80f, rawAvailHeight - 80f));
|
|
|
|
const float splitterReserve = 8f;
|
|
var splitterGap = detailsActive ? splitterReserve : 0f;
|
|
var spacingReserve = detailsActive ? 2f * ImGui.GetStyle().ItemSpacing.Y : 0f;
|
|
var detailsHeight = detailsActive ? DetailsAreaHeight : 0f;
|
|
var topHeight = MathF.Max(60f, rawAvailHeight - detailsHeight - splitterGap - spacingReserve);
|
|
|
|
switch (Mode)
|
|
{
|
|
case Modes.DopeView:
|
|
if (detailsActive)
|
|
{
|
|
ImGui.BeginChild("##timelineTopPane", new Vector2(0, topHeight),
|
|
ImGuiChildFlags.None,
|
|
ImGuiWindowFlags.NoBackground
|
|
| ImGuiWindowFlags.NoScrollWithMouse);
|
|
var dopeContentStartY = ImGui.GetCursorScreenPos().Y;
|
|
ClipArea.Draw(compositionOp, Playback, SnapHandlerForU);
|
|
DopeSheetArea.Draw(compositionOp, _selectedAnimationParameters);
|
|
|
|
// Dope-local fence — outer fence is suppressed while the
|
|
// details pane is up so its clicks don't bubble out and
|
|
// wipe the selection that opened the pane. Delegate to the
|
|
// shared UpdateSelectionForArea so background clicks clear
|
|
// every manipulator (keyframes AND clips), matching the
|
|
// outer-fence behaviour the user expects.
|
|
if (!T3Ui.IsAnyPopupOpen)
|
|
{
|
|
switch (_dopeFence.UpdateAndDraw(out var selectMode))
|
|
{
|
|
case SelectionFence.States.Updated:
|
|
case SelectionFence.States.CompletedAsClick:
|
|
UpdateSelectionForArea(_dopeFence.BoundsInScreen, selectMode);
|
|
break;
|
|
}
|
|
}
|
|
|
|
CustomComponents.HandleDragScrolling(this);
|
|
_lastDopeContentHeight = MathF.Max(0f, ImGui.GetCursorScreenPos().Y - dopeContentStartY);
|
|
ImGui.EndChild();
|
|
|
|
_detailsArea.DrawResizeHandle(splitterReserve);
|
|
|
|
ImGui.PushStyleColor(ImGuiCol.ChildBg, UiColors.BackgroundFull.Fade(0.2f).Rgba);
|
|
_detailsArea.Draw(compositionOp, _selectedAnimationParameters,
|
|
detailsHeight, detailsHeight, modeChanged);
|
|
ImGui.PopStyleColor();
|
|
}
|
|
else
|
|
{
|
|
ClipArea.Draw(compositionOp, Playback, SnapHandlerForU);
|
|
DopeSheetArea.Draw(compositionOp, _selectedAnimationParameters);
|
|
}
|
|
break;
|
|
case Modes.CurveEditor:
|
|
{
|
|
_horizontalRaster.Draw(this);
|
|
var heightChanged = Math.Abs(ImGui.GetWindowHeight() - _lastCurveEditorHeight) > 1f;
|
|
_lastCurveEditorHeight = ImGui.GetWindowHeight();
|
|
|
|
var selectionHash = ComputeSelectionHash();
|
|
var selectionChanged = selectionHash != _lastSelectionHash;
|
|
_lastSelectionHash = selectionHash;
|
|
|
|
_timelineCurveEditArea.Draw(compositionOp, _selectedAnimationParameters,
|
|
fitVerticalOnly: modeChanged || selectionChanged || heightChanged);
|
|
break;
|
|
}
|
|
}
|
|
|
|
var compositionTimeClip = Structure.GetCompositionTimeClip(compositionOp);
|
|
|
|
if (Playback.IsLooping)
|
|
{
|
|
_loopRange.Draw(this, Playback, Drawlist, SnapHandlerForU);
|
|
}
|
|
else if (compositionTimeClip != null)
|
|
{
|
|
_clipRange.Draw(this, compositionTimeClip, Drawlist, SnapHandlerForU);
|
|
}
|
|
|
|
// When the details pane is up, the top-pane child already handles its
|
|
// own drag-scroll; outer call would hit ImGuiTitle (no overflow).
|
|
if (!detailsActive)
|
|
CustomComponents.HandleDragScrolling(this);
|
|
}
|
|
|
|
ImGui.EndChild();
|
|
|
|
_currentTimeMarker.Draw(Playback.TimeInBars, this);
|
|
_timeSelectionRange.Draw(compositionOp, Drawlist);
|
|
|
|
if (_selectionFence.State == SelectionFence.States.CompletedAsClick)
|
|
{
|
|
var newTime = InverseTransformPositionFloat(ImGui.GetMousePos()).X;
|
|
Playback.TimeInBars = newTime;
|
|
|
|
// Background click clears keyframe selection (both panes).
|
|
if (SharedSelectedKeyframes.Count > 0)
|
|
{
|
|
SharedSelectedKeyframes.Clear();
|
|
OnKeyframeSelectionReplaced();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Keeps TimelineCurveEditor registered with the snap handler and keyframe-editor group
|
|
/// while the inline curve pane is visible (DopeView + any expanded parameter). We do NOT
|
|
/// add it to <see cref="AnimationCanvas.TimeObjectManipulators"/>: that list dispatches
|
|
/// drag / selection mutations to every entry, and both editors share the same
|
|
/// <c>SelectedKeyframes</c> set — so double-registering makes every <c>UpdateDragCommand</c>
|
|
/// apply U += dt twice per frame (oscillating keyframe jitter). DopeSheetArea is the single
|
|
/// drag dispatcher; curve-pane visuals pick up changes via the shared selection set.
|
|
/// </summary>
|
|
private void SyncInlineCurveEditorRegistration()
|
|
{
|
|
var shouldBeActive = Mode == Modes.DopeView && CurveEditingParamHashes.Count > 0;
|
|
if (shouldBeActive && !_curveEditorRegisteredInline)
|
|
{
|
|
SnapHandlerForU.AddSnapAttractor(_timelineCurveEditArea);
|
|
_activeKeyframeEditors.Add(_timelineCurveEditArea);
|
|
_curveEditorRegisteredInline = true;
|
|
}
|
|
else if (!shouldBeActive && _curveEditorRegisteredInline)
|
|
{
|
|
SnapHandlerForU.RemoveSnapAttractor(_timelineCurveEditArea);
|
|
_activeKeyframeEditors.Remove(_timelineCurveEditArea);
|
|
_curveEditorRegisteredInline = false;
|
|
}
|
|
}
|
|
|
|
private bool _curveEditorRegisteredInline;
|
|
|
|
/// <summary>
|
|
/// In the inline curve-edit layout the timeline canvas becomes the U-axis authority and
|
|
/// the curve-edit sub-canvas owns V. Constrain wheel zoom to U here so DSA wheel-zoom
|
|
/// doesn't incidentally scale V (which outer canvas doesn't visibly render anyway, but we
|
|
/// don't want stray ScrollTarget.Y updates either). Outside the inline layout, fall back
|
|
/// to the base behavior.
|
|
/// </summary>
|
|
protected override void ApplyZoomDelta(Vector2 position, float zoomDelta, out bool zoomed)
|
|
{
|
|
if (Mode != Modes.DopeView || CurveEditingParamHashes.Count == 0)
|
|
{
|
|
base.ApplyZoomDelta(position, zoomDelta, out zoomed);
|
|
return;
|
|
}
|
|
|
|
zoomed = false;
|
|
if (Math.Abs(zoomDelta - 1) < 0.001f)
|
|
return;
|
|
var clamped = ClampScaleToValidRange(ScaleTarget * zoomDelta);
|
|
if (clamped == ScaleTarget)
|
|
return;
|
|
|
|
var zoom = new Vector2(zoomDelta, 1f);
|
|
ScaleTarget *= zoom;
|
|
if (Math.Abs(zoomDelta) > 0.1f)
|
|
zoomed = true;
|
|
|
|
var focus = InverseTransformPositionFloat(position);
|
|
ScrollTarget += (focus - ScrollTarget) * (zoom - Vector2.One) / zoom;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Drops any curve-editing hash whose parameter is no longer among the current
|
|
/// selection's animated parameters. If the selection no longer includes an expanded
|
|
/// param (e.g. the user selected a different node in the graph), the inline curve
|
|
/// area would otherwise linger empty; pruning closes it automatically when the last
|
|
/// expanded param disappears.
|
|
/// </summary>
|
|
private void PruneExpandedForMissingParams()
|
|
{
|
|
if (CurveEditingParamHashes.Count == 0)
|
|
return;
|
|
|
|
CurveEditingParamHashes.RemoveWhere(hash => !ContainsHash(_selectedAnimationParameters, hash));
|
|
|
|
// Drop orphaned component-mask entries (small alloc only when a hash was actually removed).
|
|
if (VisibleComponentMask.Count > 0)
|
|
{
|
|
foreach (var h in VisibleComponentMask.Keys.ToList())
|
|
{
|
|
if (!CurveEditingParamHashes.Contains(h))
|
|
VisibleComponentMask.Remove(h);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static bool ContainsHash(List<AnimationParameter> list, int hash)
|
|
{
|
|
for (var i = 0; i < list.Count; i++)
|
|
{
|
|
if (list[i].Hash == hash)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
//
|
|
// #region handle nested timelines ----------------------------------
|
|
// public override void UpdateScaleAndTranslation(Instance compositionOp, ScalableCanvas.Transition transition)
|
|
// {
|
|
// if (transition == ScalableCanvas.Transition.Instant)
|
|
// return;
|
|
//
|
|
// // remember the old scroll state
|
|
// var oldScale = Scale;
|
|
// var oldScroll = Scroll;
|
|
//
|
|
// var clip = Structure.GetCompositionTimeClip(compositionOp);
|
|
// if (clip == null) return;
|
|
//
|
|
// // determine scaling factor
|
|
// TimeRange sourceRange, targetRange;
|
|
// if (transition == ScalableCanvas.Transition.JumpIn)
|
|
// {
|
|
// sourceRange = clip.TimeRange;
|
|
// targetRange = clip.SourceRange;
|
|
// }
|
|
// else
|
|
// {
|
|
// sourceRange = clip.SourceRange;
|
|
// targetRange = clip.TimeRange;
|
|
// }
|
|
//
|
|
// float scale = targetRange.Duration / sourceRange.Duration;
|
|
//
|
|
// // remove scrolling, then determine where the time clip is centered
|
|
// Scroll = new Vector2(0, Scroll.Y);
|
|
// var centerOfSourceRange = (sourceRange.Start + sourceRange.End) * 0.5f;
|
|
// var originalScreenPos = TransformX(centerOfSourceRange);
|
|
//
|
|
// // now apply scaling and determine where the source clip is centered
|
|
// Scale /= scale;
|
|
// var centerOfTargetRange = (targetRange.Start + targetRange.End) * 0.5f;
|
|
// var newScreenPos = TransformX(centerOfTargetRange);
|
|
//
|
|
// // set final scale and "undo" the movement of the position
|
|
// ScaleTarget.X = Scale.X;
|
|
// var positionDelta = new Vector2(newScreenPos - originalScreenPos, 0f);
|
|
// ScrollTarget.X = oldScroll.X * scale + InverseTransformDirection(positionDelta).X;
|
|
//
|
|
// // restore the old scale and scroll state
|
|
// Scale = oldScale;
|
|
// Scroll = oldScroll;
|
|
// }
|
|
// #endregion
|
|
|
|
private void HandleDeferredActions()
|
|
{
|
|
if (UserActionRegistry.WasActionQueued(UserActions.PlaybackJumpToNextKeyframe))
|
|
{
|
|
var bestNextTime = double.PositiveInfinity;
|
|
var foundNext = false;
|
|
var time = Playback.TimeInBars + 0.001f;
|
|
foreach (var next in _selectedAnimationParameters)
|
|
{
|
|
foreach (var curve in next.Curves)
|
|
{
|
|
if (!curve.TryGetNextKey(time, out var key)
|
|
|| key.U > bestNextTime)
|
|
continue;
|
|
|
|
foundNext = true;
|
|
bestNextTime = key.U;
|
|
}
|
|
}
|
|
|
|
if (foundNext)
|
|
Playback.TimeInBars = bestNextTime;
|
|
}
|
|
|
|
if (UserActionRegistry.WasActionQueued(UserActions.PlaybackJumpToPreviousKeyframe))
|
|
{
|
|
var bestPreviousTime = double.NegativeInfinity;
|
|
var foundNext = false;
|
|
|
|
var time = Playback.TimeInBars - 0.001f;
|
|
foreach (var next in _selectedAnimationParameters)
|
|
{
|
|
foreach (var curve in next.Curves)
|
|
{
|
|
if (!curve.TryGetPreviousKey(time, out var key)
|
|
|| key.U < bestPreviousTime)
|
|
continue;
|
|
|
|
foundNext = true;
|
|
bestPreviousTime = key.U;
|
|
}
|
|
}
|
|
|
|
if (foundNext)
|
|
Playback.TimeInBars = bestPreviousTime;
|
|
}
|
|
}
|
|
|
|
private void DrawTimeRuler(float mouseX)
|
|
{
|
|
var max = ImGui.GetWindowSize();
|
|
var clampedSize = max;
|
|
clampedSize.Y = Math.Min(TimeLineDragHeight, max.Y - 1);
|
|
|
|
ImGui.SetCursorPos(new Vector2(0, max.Y - clampedSize.Y));
|
|
|
|
// Allow the SelectionRangeIndicator (emitted later in the same ruler child) to steal hover/press in its overlapping area.
|
|
ImGui.SetNextItemAllowOverlap();
|
|
ImGui.InvisibleButton("##TimeDrag", clampedSize);
|
|
|
|
if (ImGui.IsItemHovered())
|
|
{
|
|
ImGui.SetMouseCursor(ImGuiMouseCursor.ResizeEW);
|
|
}
|
|
|
|
if (ImGui.IsItemActive() && ImGui.IsMouseDragging(ImGuiMouseButton.Left) || ImGui.IsItemClicked())
|
|
{
|
|
var draggedTime = InverseTransformX(mouseX);
|
|
if (ImGui.GetIO().KeyShift)
|
|
{
|
|
if (SnapHandlerForU.TryCheckForSnapping(draggedTime, out var snappedValue, Scale.X, [_currentTimeMarker]))
|
|
{
|
|
draggedTime = (float)snappedValue;
|
|
}
|
|
}
|
|
|
|
Playback.TimeInBars = draggedTime;
|
|
}
|
|
|
|
ImGui.SetCursorPos(Vector2.Zero);
|
|
}
|
|
|
|
private void ScrollToTimeAfterStopped()
|
|
{
|
|
var isPlaying = Math.Abs(Playback.PlaybackSpeed) > 0.01f;
|
|
var wasPlaying = Math.Abs(_lastPlaybackSpeed) > 0.01f;
|
|
|
|
if (!isPlaying && wasPlaying)
|
|
{
|
|
if (!IsCurrentTimeVisible())
|
|
{
|
|
// assume we are not scrolling, what screen position would the playhead be at?
|
|
var oldScroll = Scroll;
|
|
Scroll = new Vector2(0, Scroll.Y);
|
|
var posScreen = TransformX((float)Playback.TimeInBars);
|
|
// position that playhead in the center of the window
|
|
ScrollTarget.X = InverseTransformX(posScreen - WindowSize.X * 0.5f);
|
|
// restore old state of scrolling
|
|
Scroll = oldScroll;
|
|
}
|
|
}
|
|
|
|
_lastPlaybackSpeed = Playback.PlaybackSpeed;
|
|
}
|
|
|
|
private bool IsCurrentTimeVisible()
|
|
{
|
|
var timePosInScreen = TransformPosition(new Vector2((float)this.Playback.TimeInBars, 0));
|
|
var timelineArea = ImRect.RectWithSize(WindowPos, WindowSize);
|
|
timePosInScreen.Y = timelineArea.GetCenter().Y; // Adjust potential vertical scrolling of timeline area
|
|
return timelineArea.Contains(timePosInScreen);
|
|
}
|
|
|
|
#region view modes
|
|
private bool UpdateMode()
|
|
{
|
|
if (Mode == _lastMode)
|
|
return false;
|
|
|
|
// Tear down previous mode (skip on first call when _lastMode is null)
|
|
switch (_lastMode)
|
|
{
|
|
case Modes.DopeView:
|
|
TimeObjectManipulators.Remove(DopeSheetArea);
|
|
TimeObjectManipulators.Remove(ClipArea);
|
|
SnapHandlerForU.RemoveSnapAttractor(DopeSheetArea);
|
|
_activeKeyframeEditors.Remove(DopeSheetArea);
|
|
break;
|
|
|
|
case Modes.CurveEditor:
|
|
TimeObjectManipulators.Remove(_timelineCurveEditArea);
|
|
SnapHandlerForU.RemoveSnapAttractor(_timelineCurveEditArea);
|
|
_activeKeyframeEditors.Remove(_timelineCurveEditArea);
|
|
break;
|
|
}
|
|
|
|
switch (Mode)
|
|
{
|
|
case Modes.DopeView:
|
|
TimeObjectManipulators.Add(DopeSheetArea);
|
|
TimeObjectManipulators.Add(ClipArea);
|
|
SnapHandlerForU.AddSnapAttractor(DopeSheetArea);
|
|
_activeKeyframeEditors.Add(DopeSheetArea);
|
|
break;
|
|
|
|
case Modes.CurveEditor:
|
|
TimeObjectManipulators.Add(_timelineCurveEditArea);
|
|
SnapHandlerForU.AddSnapAttractor(_timelineCurveEditArea);
|
|
_activeKeyframeEditors.Add(_timelineCurveEditArea);
|
|
break;
|
|
|
|
case Modes.Undefined:
|
|
Mode = Modes.DopeView;
|
|
goto case Modes.DopeView;
|
|
}
|
|
|
|
_lastMode = Mode;
|
|
return true;
|
|
}
|
|
|
|
public enum Modes
|
|
{
|
|
Undefined,
|
|
DopeView,
|
|
CurveEditor,
|
|
}
|
|
|
|
public Modes Mode = Modes.DopeView;
|
|
private Modes _lastMode = Modes.Undefined;
|
|
private float _lastCurveEditorHeight;
|
|
private int _lastSelectionHash;
|
|
|
|
// Per-parameter curve-expand state, populated by the curve-toggle icon on each dope-sheet row.
|
|
// When non-empty in DopeView mode, the timeline body splits into dope-sheet (top) + curve-editor (below).
|
|
internal readonly HashSet<int> CurveEditingParamHashes = new();
|
|
|
|
// paramHash -> visible-component bitmask; missing entry = "all components visible".
|
|
// Cleared when a parameter is un-expanded so re-expanding resets to all-on.
|
|
internal readonly Dictionary<int, int> VisibleComponentMask = new();
|
|
|
|
// Cross-view hover link (Phase 3). Written by whichever view the mouse is over;
|
|
// both views read these to render matching emphasis.
|
|
internal int? HoveredParameterHash;
|
|
internal int HoveredComponentBit;
|
|
internal int? HoveredKeyframeUniqueId;
|
|
|
|
internal bool NormalizeCurveView;
|
|
|
|
// Published by InlineCurveArea each frame it draws; null when the pane isn't visible.
|
|
// TimeLineCanvas.Draw reads this at the top of the next frame to cede wheel/pan to the
|
|
// curve-area sub-canvas when the mouse is inside it.
|
|
internal ImRect? CurveEditAreaScreenRect;
|
|
|
|
// Shared keyframe selection — DopeSheetArea and TimelineCurveEditor both receive this
|
|
// via CurveEditing's shared-selection ctor, so edits in one view reflect in the other
|
|
// (and in the SRI / SelectionArea aggregators).
|
|
internal readonly VersionedKeyframeSet SharedSelectedKeyframes = new();
|
|
|
|
private int ComputeSelectionHash()
|
|
{
|
|
var hash = _selectedAnimationParameters.Count;
|
|
for (var i = 0; i < _selectedAnimationParameters.Count; i++)
|
|
{
|
|
hash = hash * 397 ^ _selectedAnimationParameters[i].Hash;
|
|
}
|
|
return hash;
|
|
}
|
|
|
|
private void SyncStateWithComposition(Instance compositionOp)
|
|
{
|
|
var symbolId = compositionOp.Symbol.Id;
|
|
if (symbolId == _lastSyncedSymbolId)
|
|
{
|
|
// Sync copy fields every frame so saves capture current values
|
|
var currentSymbolUi = compositionOp.Symbol.GetSymbolUi();
|
|
if (currentSymbolUi != null)
|
|
{
|
|
currentSymbolUi.TimelineState ??= new TimelineState();
|
|
SaveStateTo(currentSymbolUi.TimelineState);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Save to previous composition. Read-only symbols keep the state in memory but must not be
|
|
// flagged as modified — merely viewing them would prompt to save them as a copy.
|
|
if (_lastSyncedSymbolUi != null)
|
|
{
|
|
_lastSyncedSymbolUi.TimelineState ??= new TimelineState();
|
|
SaveStateTo(_lastSyncedSymbolUi.TimelineState);
|
|
if (!_lastSyncedSymbolUi.ReadOnly)
|
|
{
|
|
_lastSyncedSymbolUi.FlagAsModified();
|
|
}
|
|
}
|
|
|
|
_lastSyncedSymbolId = symbolId;
|
|
_lastSyncedSymbolUi = compositionOp.Symbol.GetSymbolUi();
|
|
|
|
// Load from new composition
|
|
if (_lastSyncedSymbolUi?.TimelineState is { } state)
|
|
{
|
|
LoadStateFrom(state);
|
|
}
|
|
}
|
|
|
|
private Guid _lastSyncedSymbolId;
|
|
private SymbolUi? _lastSyncedSymbolUi;
|
|
|
|
internal void SaveStateTo(TimelineState state)
|
|
{
|
|
state.ScaleX = Scale.X;
|
|
state.ScrollX = Scroll.X;
|
|
state.Mode = Mode;
|
|
state.TimelineHeight = FoldingHeight._customTimeLineHeight;
|
|
state.InlineDataClipEditEnabled = InlineDataClipEditEnabled;
|
|
state.DetailsAreaHeight = DetailsAreaHeight;
|
|
}
|
|
|
|
internal void LoadStateFrom(TimelineState state)
|
|
{
|
|
ScaleTarget = new Vector2(state.ScaleX, ScaleTarget.Y);
|
|
Scale = new Vector2(state.ScaleX, Scale.Y);
|
|
ScrollTarget = new Vector2(state.ScrollX, ScrollTarget.Y);
|
|
Scroll = new Vector2(state.ScrollX, Scroll.Y);
|
|
Mode = state.Mode;
|
|
FoldingHeight._customTimeLineHeight = state.TimelineHeight;
|
|
InlineDataClipEditEnabled = state.InlineDataClipEditEnabled;
|
|
DetailsAreaHeight = state.DetailsAreaHeight;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Toggle for the inline DataClip edit area. Driven by the AudioFile icon button next
|
|
/// to the Record toggle on the timeline toolbar. When on AND a TimeClip with a
|
|
/// <c>DataClip</c> output is selected, the inline area renders below the dope sheet.
|
|
/// </summary>
|
|
internal bool InlineDataClipEditEnabled;
|
|
|
|
/// <summary>
|
|
/// User-controlled height of the inline details pane (curve editor OR DataClip
|
|
/// editor — both share one pane). Persisted with <see cref="TimelineState"/> and
|
|
/// resized via the splitter shown above the pane. Clamped at layout time so a value
|
|
/// saved from a taller window can't starve the dope sheet on a smaller monitor.
|
|
/// </summary>
|
|
internal float DetailsAreaHeight = 200f;
|
|
|
|
/// <summary>Forwards a mouse-wheel zoom from an embedded pane to this canvas's X axis.</summary>
|
|
internal void ZoomXFromEmbedded(float wheelDelta, Vector2 mouseScreenPos)
|
|
{
|
|
if (Math.Abs(wheelDelta) < 0.0001f)
|
|
return;
|
|
var mouseState = new MouseState(mouseScreenPos, ImGui.GetIO().MouseDelta, wheelDelta);
|
|
ZoomWithMouseWheel(mouseState, out _);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Pans this canvas's X scroll by a screen-pixel delta measured from a drag-start
|
|
/// snapshot. Embedded panes capture <see cref="Scroll"/>.X on RMB-down then call
|
|
/// this each frame so cumulative drag deltas don't over-accumulate.
|
|
/// </summary>
|
|
internal void PanXFromEmbedded(float startScrollX, float screenDeltaX)
|
|
{
|
|
if (Scale.X <= 0)
|
|
return;
|
|
var canvasDelta = screenDeltaX / Scale.X;
|
|
Scroll = new Vector2(startScrollX - canvasDelta, Scroll.Y);
|
|
ScrollTarget = new Vector2(startScrollX - canvasDelta, ScrollTarget.Y);
|
|
}
|
|
|
|
#endregion
|
|
|
|
// TODO: this is horrible and should be refactored
|
|
private List<AnimationParameter> GetAnimationParametersForSelectedNodes(Instance compositionOp)
|
|
{
|
|
var symbolUi = compositionOp.GetSymbolUi();
|
|
var animator = symbolUi.Symbol.Animator;
|
|
|
|
// Copy objects to reuse if possible
|
|
_tmpAnimationParameters.Clear();
|
|
_tmpAnimationParameters.AddRange(_pinnedParams);
|
|
|
|
_pinnedParams.Clear();
|
|
_curvesForSelection.Clear();
|
|
|
|
var children = compositionOp.Children.Values;
|
|
foreach (var child in children)
|
|
{
|
|
var isChildSelected = Selected.Unknown;
|
|
|
|
for (var inputIndex = 0; inputIndex < child.Inputs.Count; inputIndex++)
|
|
{
|
|
var input = child.Inputs[inputIndex];
|
|
if (!animator.IsInputSlotAnimated(input))
|
|
continue;
|
|
|
|
// Test if child is selected only once and only if required
|
|
if (isChildSelected == Selected.Unknown)
|
|
{
|
|
isChildSelected = Selected.No;
|
|
foreach (var s in _nodeSelection.Selection)
|
|
{
|
|
if (s.Id != child.SymbolChildId)
|
|
continue;
|
|
|
|
isChildSelected = Selected.Yes;
|
|
break;
|
|
}
|
|
}
|
|
|
|
var paramHash = input.GetChildSlotHash();
|
|
var isPinned = false;
|
|
|
|
// Collect pinned
|
|
foreach (var pinnedInputSlot in DopeSheetArea.PinnedParametersHashes)
|
|
{
|
|
if (pinnedInputSlot != input.GetChildSlotHash())
|
|
continue;
|
|
|
|
if (!TryGetParamFromSpan(paramHash, out var param))
|
|
{
|
|
if (!animator.TryGetCurvesForInputSlot(input, out var curves))
|
|
{
|
|
Log.Warning("Can't find curves for animated parameter?");
|
|
continue;
|
|
}
|
|
|
|
param = new AnimationParameter
|
|
{
|
|
Instance = child,
|
|
Input = input,
|
|
Curves = curves,
|
|
ChildUi = symbolUi.ChildUis[child.SymbolChildId],
|
|
Hash = paramHash,
|
|
};
|
|
}
|
|
|
|
_pinnedParams.Add(param);
|
|
isPinned = true;
|
|
}
|
|
|
|
if (isPinned || isChildSelected != Selected.Yes)
|
|
continue;
|
|
|
|
{
|
|
if (!TryGetParamFromSpan(paramHash, out var param))
|
|
{
|
|
if (!animator.TryGetCurvesForInputSlot(input, out var curves))
|
|
{
|
|
Log.Warning("Can't find curves for animated parameter?");
|
|
continue;
|
|
}
|
|
|
|
param = new AnimationParameter
|
|
{
|
|
Instance = child,
|
|
Input = input,
|
|
Curves = curves,
|
|
ChildUi = symbolUi.ChildUis[child.SymbolChildId],
|
|
Hash = paramHash,
|
|
};
|
|
}
|
|
|
|
_curvesForSelection.Add(param);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Merge collections
|
|
_pinnedParams.AddRange(_curvesForSelection.FindAll(sp => _pinnedParams.All(pp => pp.Input != sp.Input)));
|
|
return _pinnedParams;
|
|
}
|
|
|
|
private static bool TryGetParamFromSpan(int paramHash, [NotNullWhen(true)] out AnimationParameter? parameter)
|
|
{
|
|
parameter = null;
|
|
foreach (var p in _tmpAnimationParameters)
|
|
{
|
|
if (p.Hash != paramHash)
|
|
continue;
|
|
|
|
parameter = p;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
internal Playback Playback;
|
|
public readonly DopeSheetArea DopeSheetArea;
|
|
public readonly ClipArea ClipArea;
|
|
public static TimeLineCanvas? Current;
|
|
|
|
private enum Selected
|
|
{
|
|
Yes,
|
|
No,
|
|
Unknown,
|
|
}
|
|
|
|
|
|
|
|
/** Only used to avoid allocations */
|
|
private static readonly List<AnimationParameter> _tmpAnimationParameters = [];
|
|
|
|
private List<AnimationParameter> _selectedAnimationParameters = [];
|
|
|
|
private readonly TimeRasterSwitcher _timeRasterSwitcher = new();
|
|
private readonly HorizontalRaster _horizontalRaster = new();
|
|
private readonly ClipRange _clipRange = new();
|
|
private readonly LoopRange _loopRange = new();
|
|
|
|
private readonly TimelineCurveEditor _timelineCurveEditArea;
|
|
private readonly InlineCurveArea _curveEditCanvas;
|
|
private readonly InlineDataClipArea _inlineDataClipArea;
|
|
private readonly TimelineDetailsArea _detailsArea;
|
|
|
|
private readonly CurrentTimeMarker _currentTimeMarker = new();
|
|
private readonly TimeSelectionRange _timeSelectionRange;
|
|
private readonly SelectionRangeIndicator _selectionRangeIndicator;
|
|
private readonly TimeSelectionArea _timeSelectionArea;
|
|
private readonly IValueSnapAttractor[] _selectionDragSnapExclusions;
|
|
private readonly List<AnimationParameterEditing> _activeKeyframeEditors = new(2);
|
|
private readonly NodeSelection _nodeSelection;
|
|
|
|
private double _lastPlaybackSpeed;
|
|
private readonly List<AnimationParameter> _pinnedParams = new(20);
|
|
private readonly List<AnimationParameter> _curvesForSelection = new(64);
|
|
private readonly SelectionFence _selectionFence = new();
|
|
private readonly SelectionFence _dopeFence = new();
|
|
|
|
// Measured dope-pane content height from the previous frame (ClipArea + DSA rows + any
|
|
// other interactive content drawn in that child). Drives the inline-layout split so the
|
|
// dope pane takes only what it needs, capped at 50% of available height.
|
|
private float _lastDopeContentHeight = 120f;
|
|
|
|
// Styling
|
|
private const float TimeLineDragHeight = 30;
|
|
|
|
internal readonly TimelineHeight FoldingHeight;
|
|
|
|
|
|
public sealed class AnimationParameter
|
|
{
|
|
public required Curve[] Curves;
|
|
public required IInputSlot Input;
|
|
public required Instance Instance;
|
|
public required SymbolUi.Child ChildUi;
|
|
|
|
public required int Hash;
|
|
public float DampedMinValue;
|
|
public float DampedMaxValue;
|
|
}
|
|
|
|
internal sealed class TimelineHeight
|
|
{
|
|
public TimelineHeight(TimeLineCanvas timeline)
|
|
{
|
|
_timeline = timeline;
|
|
}
|
|
|
|
public void DrawSplit(out int newContentHeight)
|
|
{
|
|
var currentTimelineHeight = _timeline.FoldingHeight.CurrentHeight;
|
|
if (CustomComponents.SplitFromBottom(ref currentTimelineHeight))
|
|
{
|
|
_customTimeLineHeight = (int)currentTimelineHeight;
|
|
}
|
|
|
|
newContentHeight = (int)ImGui.GetWindowHeight() - (int)currentTimelineHeight -
|
|
4; // Hack that also depends on when a window-title is being rendered
|
|
}
|
|
|
|
private const int UseComputedHeight = -1;
|
|
internal int _customTimeLineHeight = UseComputedHeight;
|
|
private readonly TimeLineCanvas _timeline;
|
|
public bool UsingCustomTimelineHeight => _customTimeLineHeight > UseComputedHeight;
|
|
|
|
private float CurrentHeight => UsingCustomTimelineHeight ? _customTimeLineHeight : ComputedTimelineHeight;
|
|
|
|
private float ComputedTimelineHeight => MathF.Min( _timeline._selectedAnimationParameters.Count * DopeSheetArea.LayerHeight
|
|
+ _timeline.ClipArea.LastHeight
|
|
+ TimeLineDragHeight
|
|
+ 10, 200 * T3Ui.UiScaleFactor);
|
|
|
|
public void Toggle()
|
|
{
|
|
_customTimeLineHeight = UsingCustomTimelineHeight ? UseComputedHeight : 200;
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum FrameStepAmount
|
|
{
|
|
FrameAt60Fps,
|
|
FrameAt30Fps,
|
|
FrameAt15Fps,
|
|
Bar,
|
|
Beat,
|
|
Tick,
|
|
} |