diff --git a/src/Titano.Ui/Visuals/CurveEditor.cs b/src/Titano.Ui/Visuals/CurveEditor.cs
new file mode 100644
index 00000000..c90ebff3
--- /dev/null
+++ b/src/Titano.Ui/Visuals/CurveEditor.cs
@@ -0,0 +1,379 @@
+using System.Collections.Specialized;
+using System.Windows;
+using System.Windows.Input;
+using System.Windows.Media;
+using Titano.Core.Localization;
+
+namespace Titano.Ui.Visuals;
+
+/// Editing rules of a .
+public enum CurveEditMode
+{
+ /// Keyframes ordered by time (virtual camera): X stays increasing, the ends may move.
+ Keyframes,
+
+ /// Time remap: X stays increasing and the end points are pinned to X = 0 and X = 1.
+ TimeRemap,
+}
+
+///
+/// Spline/keyframe editor in normalised [0, 1]² space (BRIEF §12.3: Time remap curve, Camera keyframes).
+/// Control points come from and are edited in place (double-click adds, drag moves with the
+/// X order constrained by , Delete removes, arrows nudge); the curve itself is drawn by
+/// sampling once per device-pixel column, so the engine's Fritsch–Carlson spline is what
+/// the user sees. Grid, optional identity diagonal and a playhead are drawn; hovering or dragging a point reads
+/// out its coordinates. fires after each add, delete, nudge or finished drag.
+///
+public sealed class CurveEditor : DrawingElement
+{
+ public static readonly DependencyProperty PointsProperty = DependencyProperty.Register(
+ nameof(Points), typeof(IList), typeof(CurveEditor), new PropertyMetadata(null, OnDataPropertyChanged));
+
+ public static readonly DependencyProperty EvaluatorProperty = DependencyProperty.Register(
+ nameof(Evaluator), typeof(Func), typeof(CurveEditor), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsRender));
+
+ public static readonly DependencyProperty ModeProperty = DependencyProperty.Register(
+ nameof(Mode), typeof(CurveEditMode), typeof(CurveEditor), new PropertyMetadata(CurveEditMode.Keyframes));
+
+ public static readonly DependencyProperty SelectedIndexProperty = DependencyProperty.Register(
+ nameof(SelectedIndex), typeof(int), typeof(CurveEditor),
+ new FrameworkPropertyMetadata(-1, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault | FrameworkPropertyMetadataOptions.AffectsRender, null, CoerceSelectedIndex));
+
+ public static readonly DependencyProperty PlayheadPositionProperty = DependencyProperty.Register(
+ nameof(PlayheadPosition), typeof(double), typeof(CurveEditor), new PropertyMetadata(double.NaN, (d, _) => ((CurveEditor)d).RenderOverlay()));
+
+ public static readonly DependencyProperty ShowDiagonalProperty = DependencyProperty.Register(
+ nameof(ShowDiagonal), typeof(bool), typeof(CurveEditor), new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.AffectsRender));
+
+ public static readonly DependencyProperty MinimumGapProperty = DependencyProperty.Register(
+ nameof(MinimumGap), typeof(double), typeof(CurveEditor), new PropertyMetadata(CurveMath.DefaultMinGap));
+
+ public static readonly DependencyProperty XLabelFormatterProperty = DependencyProperty.Register(
+ nameof(XLabelFormatter), typeof(Func), typeof(CurveEditor), new PropertyMetadata(null));
+
+ public static readonly DependencyProperty YLabelFormatterProperty = DependencyProperty.Register(
+ nameof(YLabelFormatter), typeof(Func), typeof(CurveEditor), new PropertyMetadata(null));
+
+ public static readonly RoutedEvent EditCompletedEvent = EventManager.RegisterRoutedEvent(
+ nameof(EditCompleted), RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(CurveEditor));
+
+ private const double Inset = 7;
+ private const double PointRadius = 4.5;
+ private const double HitRadius = 8;
+
+ private double[] _xs = [];
+ private double[] _ys = [];
+ private double[] _viewX = [];
+ private double[] _viewY = [];
+ private int _count;
+ private Rect _plot;
+ private int _hover = -1;
+ private bool _dragging;
+ private bool _moved;
+
+ static CurveEditor()
+ {
+ FocusableProperty.OverrideMetadata(typeof(CurveEditor), new FrameworkPropertyMetadata(true));
+ }
+
+ public CurveEditor()
+ : base(hasOverlay: true)
+ {
+ }
+
+ /// Control points in [0, 1]², ordered by X; edited in place unless the list is read-only.
+ public IList? Points { get => (IList?)GetValue(PointsProperty); set => SetValue(PointsProperty, value); }
+
+ /// The curve through the points (x → y in [0, 1]); null draws straight segments.
+ public Func? Evaluator { get => (Func?)GetValue(EvaluatorProperty); set => SetValue(EvaluatorProperty, value); }
+
+ public CurveEditMode Mode { get => (CurveEditMode)GetValue(ModeProperty); set => SetValue(ModeProperty, value); }
+
+ /// Selected point (two-way); −1 = none.
+ public int SelectedIndex { get => (int)GetValue(SelectedIndexProperty); set => SetValue(SelectedIndexProperty, value); }
+
+ /// Playhead X in [0, 1]; NaN hides it.
+ public double PlayheadPosition { get => (double)GetValue(PlayheadPositionProperty); set => SetValue(PlayheadPositionProperty, value); }
+
+ /// Dashed identity line (y = x), the "no remap" reference.
+ public bool ShowDiagonal { get => (bool)GetValue(ShowDiagonalProperty); set => SetValue(ShowDiagonalProperty, value); }
+
+ /// Minimum X distance between neighbouring points.
+ public double MinimumGap { get => (double)GetValue(MinimumGapProperty); set => SetValue(MinimumGapProperty, value); }
+
+ /// Culture-aware formatting of X in readouts (e.g. output time).
+ public Func? XLabelFormatter { get => (Func?)GetValue(XLabelFormatterProperty); set => SetValue(XLabelFormatterProperty, value); }
+
+ /// Culture-aware formatting of Y in readouts (e.g. source time).
+ public Func? YLabelFormatter { get => (Func?)GetValue(YLabelFormatterProperty); set => SetValue(YLabelFormatterProperty, value); }
+
+ public event RoutedEventHandler EditCompleted
+ {
+ add => AddHandler(EditCompletedEvent, value);
+ remove => RemoveHandler(EditCompletedEvent, value);
+ }
+
+ private bool PinEnds => Mode == CurveEditMode.TimeRemap;
+
+ private bool IsEditable => Points is { IsReadOnly: false };
+
+ protected override Size MeasureOverride(Size availableSize) => new(0, 160);
+
+ protected override void OnDataChanged()
+ {
+ var points = Points;
+ _count = points?.Count ?? 0;
+ if (_xs.Length < _count)
+ {
+ _xs = new double[_count];
+ _ys = new double[_count];
+ _viewX = new double[_count];
+ _viewY = new double[_count];
+ }
+ for (var i = 0; i < _count; i++)
+ {
+ _xs[i] = points![i].X;
+ _ys[i] = points[i].Y;
+ }
+ _hover = -1;
+ CoerceValue(SelectedIndexProperty);
+ base.OnDataChanged();
+ }
+
+ protected override void OnRender(DrawingContext dc)
+ {
+ DrawHitArea(dc);
+ _plot = new Rect(Inset, Inset, Math.Max(0, ActualWidth - 2 * Inset), Math.Max(0, ActualHeight - 2 * Inset));
+ if (_plot.Width < 1 || _plot.Height < 1) return;
+ var scale = PixelScale;
+ var grid = GetHairline("Brush.Stroke");
+ for (var i = 0; i <= 4; i++)
+ {
+ var x = PixelGrid.SnapLine(X(i / 4.0), grid.Thickness, scale);
+ var y = PixelGrid.SnapLine(Y(i / 4.0), grid.Thickness, scale);
+ dc.DrawLine(grid, new Point(x, _plot.Top), new Point(x, _plot.Bottom));
+ dc.DrawLine(grid, new Point(_plot.Left, y), new Point(_plot.Right, y));
+ }
+ if (ShowDiagonal) dc.DrawLine(GetPen("Brush.TextFaint", 1, LineDash.Dashed), new Point(X(0), Y(0)), new Point(X(1), Y(1)));
+
+ dc.PushClip(new RectangleGeometry(new Rect(0, 0, ActualWidth, ActualHeight)));
+ DrawCurve(dc, scale);
+ dc.Pop();
+
+ var fill = GetBrush("Brush.Surface");
+ var accent = GetBrush("Brush.Accent");
+ var stroke = GetPen("Brush.Accent", 1.5);
+ for (var i = 0; i < _count; i++)
+ {
+ var selected = i == SelectedIndex;
+ var radius = i == _hover || selected ? PointRadius + 1 : PointRadius;
+ dc.DrawEllipse(selected ? accent : fill, stroke, new Point(X(_xs[i]), Y(_ys[i])), radius, radius);
+ }
+ RenderOverlay();
+ }
+
+ protected override void OnRenderOverlay(DrawingContext dc)
+ {
+ var position = PlayheadPosition;
+ if (!double.IsFinite(position) || _plot.Width < 1) return;
+ var pen = GetHairline("Brush.Accent");
+ var x = PixelGrid.SnapLine(X(Math.Clamp(position, 0, 1)), pen.Thickness, PixelScale);
+ dc.DrawLine(pen, new Point(x, _plot.Top), new Point(x, _plot.Bottom));
+ }
+
+ protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e)
+ {
+ base.OnMouseLeftButtonDown(e);
+ Focus();
+ var p = e.GetPosition(this);
+ var hit = HitTest(p);
+ if (hit >= 0)
+ {
+ SetCurrentValue(SelectedIndexProperty, hit);
+ _moved = false;
+ _dragging = IsEditable && CaptureMouse();
+ }
+ else if (e.ClickCount == 2)
+ {
+ Add(p);
+ }
+ else
+ {
+ SetCurrentValue(SelectedIndexProperty, -1);
+ }
+ e.Handled = true;
+ }
+
+ protected override void OnMouseMove(MouseEventArgs e)
+ {
+ base.OnMouseMove(e);
+ var p = e.GetPosition(this);
+ if (_dragging && SelectedIndex >= 0)
+ {
+ _moved |= Move(SelectedIndex, ToX(p.X), ToY(p.Y));
+ Readout.Show(ReadoutText(SelectedIndex), p);
+ return;
+ }
+ var hover = HitTest(p);
+ if (hover != _hover)
+ {
+ _hover = hover;
+ InvalidateVisual();
+ }
+ Readout.Show(hover >= 0 ? ReadoutText(hover) : null, p);
+ }
+
+ protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e)
+ {
+ base.OnMouseLeftButtonUp(e);
+ if (_dragging) ReleaseMouseCapture();
+ }
+
+ protected override void OnLostMouseCapture(MouseEventArgs e)
+ {
+ base.OnLostMouseCapture(e);
+ if (!_dragging) return;
+ _dragging = false;
+ if (_moved) RaiseEvent(new RoutedEventArgs(EditCompletedEvent));
+ _moved = false;
+ }
+
+ protected override void OnMouseLeave(MouseEventArgs e)
+ {
+ base.OnMouseLeave(e);
+ if (_dragging) return;
+ Readout.Hide();
+ if (_hover < 0) return;
+ _hover = -1;
+ InvalidateVisual();
+ }
+
+ protected override void OnQueryCursor(QueryCursorEventArgs e)
+ {
+ base.OnQueryCursor(e);
+ if (e.Handled || (!_dragging && _hover < 0)) return;
+ e.Cursor = _dragging ? Cursors.SizeAll : Cursors.Hand;
+ e.Handled = true;
+ }
+
+ protected override void OnKeyDown(KeyEventArgs e)
+ {
+ base.OnKeyDown(e);
+ var index = SelectedIndex;
+ if (e.Handled || index < 0 || index >= _count || !IsEditable) return;
+ var step = (Keyboard.Modifiers & ModifierKeys.Shift) != 0 ? 0.1 : 0.01;
+ var changed = e.Key switch
+ {
+ Key.Delete or Key.Back => Remove(index),
+ Key.Left => Move(index, _xs[index] - step, _ys[index]),
+ Key.Right => Move(index, _xs[index] + step, _ys[index]),
+ Key.Up => Move(index, _xs[index], _ys[index] + step),
+ Key.Down => Move(index, _xs[index], _ys[index] - step),
+ _ => (bool?)null,
+ };
+ if (changed is null) return;
+ e.Handled = true;
+ if (changed.Value) RaiseEvent(new RoutedEventArgs(EditCompletedEvent));
+ }
+
+ private static object CoerceSelectedIndex(DependencyObject d, object value)
+ {
+ var index = (int)value;
+ return index >= 0 && index < ((CurveEditor)d)._count ? index : -1;
+ }
+
+ private double X(double x) => _plot.Left + x * _plot.Width;
+
+ private double Y(double y) => _plot.Bottom - y * _plot.Height;
+
+ private double ToX(double x) => _plot.Width > 0 ? (x - _plot.Left) / _plot.Width : 0;
+
+ private double ToY(double y) => _plot.Height > 0 ? (_plot.Bottom - y) / _plot.Height : 0;
+
+ private void DrawCurve(DrawingContext dc, double scale)
+ {
+ var evaluator = Evaluator;
+ if (evaluator is null && _count < 2) return;
+ var geometry = new StreamGeometry();
+ using (var ctx = geometry.Open())
+ {
+ if (evaluator is not null)
+ {
+ var columns = Math.Max(2, (int)Math.Ceiling(_plot.Width * scale) + 1);
+ for (var c = 0; c < columns; c++)
+ {
+ var x = c / (double)(columns - 1);
+ var p = new Point(X(x), Y(evaluator(x)));
+ if (c == 0) ctx.BeginFigure(p, false, false);
+ else ctx.LineTo(p, true, true);
+ }
+ }
+ else
+ {
+ ctx.BeginFigure(new Point(X(_xs[0]), Y(_ys[0])), false, false);
+ for (var i = 1; i < _count; i++) ctx.LineTo(new Point(X(_xs[i]), Y(_ys[i])), true, true);
+ }
+ }
+ geometry.Freeze();
+ dc.DrawGeometry(null, GetPen("Brush.Accent", 2), geometry);
+ }
+
+ private int HitTest(Point p)
+ {
+ if (_count == 0 || _plot.Width < 1) return -1;
+ for (var i = 0; i < _count; i++)
+ {
+ _viewX[i] = X(_xs[i]);
+ _viewY[i] = Y(_ys[i]);
+ }
+ return CurveMath.HitTest(_viewX.AsSpan(0, _count), _viewY.AsSpan(0, _count), p.X, p.Y, HitRadius);
+ }
+
+ /// Moves point towards (x, y) within the constraints; true when it changed.
+ private bool Move(int index, double x, double y)
+ {
+ if (Points is not { IsReadOnly: false } points) return false;
+ var cx = CurveMath.ConstrainX(_xs.AsSpan(0, _count), index, x, MinimumGap, PinEnds);
+ var cy = CurveMath.ConstrainY(y);
+ if (cx == _xs[index] && cy == _ys[index]) return false;
+ points[index] = new Point(cx, cy);
+ AfterEdit(points);
+ return true;
+ }
+
+ private void Add(Point at)
+ {
+ if (Points is not { IsReadOnly: false } points) return;
+ var x = ToX(at.X);
+ var index = CurveMath.InsertionIndex(_xs.AsSpan(0, _count), x, MinimumGap, PinEnds);
+ if (index < 0) return;
+ points.Insert(index, new Point(x, CurveMath.ConstrainY(ToY(at.Y))));
+ AfterEdit(points);
+ SetCurrentValue(SelectedIndexProperty, index);
+ RaiseEvent(new RoutedEventArgs(EditCompletedEvent));
+ }
+
+ private bool Remove(int index)
+ {
+ if (Points is not { IsReadOnly: false } points || !CurveMath.CanRemove(_count, index, PinEnds)) return false;
+ points.RemoveAt(index);
+ AfterEdit(points);
+ SetCurrentValue(SelectedIndexProperty, Math.Min(index, _count - 1));
+ return true;
+ }
+
+ /// Observable lists notify through the collection watcher; plain lists are re-read here.
+ private void AfterEdit(IList points)
+ {
+ if (points is not INotifyCollectionChanged) OnDataChanged();
+ }
+
+ private string ReadoutText(int index)
+ {
+ var x = XLabelFormatter ?? DefaultFormat;
+ var y = YLabelFormatter ?? DefaultFormat;
+ return x(_xs[index]) + " → " + y(_ys[index]);
+ }
+
+ private static string DefaultFormat(double value) => value.ToString("0.###", Loc.Culture);
+}