Curve editor

The numbers stay the file

A damage falloff, an easing, an XP table: each is a vector of points, and each point is a few numbers a text editor shows but does not draw. Put the cursor anywhere inside the list and :set editor curve opens the tool on it.

std::vector<Point> damage = {
    {0.0f, 0.0f, 1.0f, 1.0f},
    {0.5f, 0.8f, 0.0f, 0.0f},      // the cursor is anywhere in here
    {1.0f, 1.0f, 1.0f, 1.0f},
};

Three windows come up, and they are the arrangement every editor tool uses: the source you started from, the plot split to its right, and a form down the right edge. Focus lands on the plot, because that is where the keys are. Esc closes both and puts the cursor back in the code.

tuning.c In and out of the curve editor 1 / 5 play

1. start Plain C. jump_arc is four rows of four numbers, and the cursor is in the list. This file is the only copy of the curve there is.
2. 1 :set editor curveEnter The plot splits off to the right and the form goes down the edge. Nothing was imported: bi read the numbers under the cursor.
3. 2 :tool curve play offEnter The playhead starts with the tool. Stop it while you tune, so the picture holds still.
4. 3 Tab×2k×2 Tab walks the points and k lifts the one it is on. Watch line 14, not the plot: 0.980f became 1.180f as the point rose.
5. 4 Esc Esc closes the plot and the form and leaves the cursor in the code. Line 14 carries the new number, the status row says [+], and the git sign counts one changed line: it was the file being edited all along.

The picture is a view of the file. Every key that changes something is one edit of the source buffer and one undo step of it — u on the plot and u in the code are the same history, and editing a number by hand redraws the plot. There is nothing to import, nothing to export and no second copy to keep in step: the demo above never wrote a file, and the [+] on the way out is the same [+] a typed character would have left.

Once you are in, the plot is where the work happens.

tuning.c The curve editor 1 / 4 play

1. start :set editor curve with the cursor in the key list: the plot beside the code, the form at the edge.
2. 1 Tab Tab picks the next point — the handles show its tangents.
3. 2 kkk hjkl and the arrows move the selected point, rewriting the numbers in the code as they go.
4. 3 a a adds a point; x takes one away, and the two ends stay.

What a point is

Four numbers, in Unity’s keyframe order: x is time, y is value, in and out are the tangents as slopes. The struct in your code decides what each number means, and the tool is told the order once:

A point with fewer numbers than the layout names has zero tangents, and the tool leaves them alone. An empty list is not a dead end: :set editor curve with the cursor in {} seeds the linear preset — (0, 0) to (1, 1) — as one undo step, and from then on it is a list like any other.

The plot is the 0,0 to 1,1 square at a fixed 512 pixels a side, so a curve looks the same every time you open it; a point outside the square stretches the picture to take it in at the same scale. Grid lines run every tenth, with a label every fifth.

Moving points

The plot reads the normal keymap — a rebound j still means down, and the arrows work — plus Tab and Enter, which nothing in normal mode claims for a picture.

x is clamped inside 0..1 and between the point’s neighbours, which is the engine’s own rule for time, so the list an engine reads never needs sorting. y is free. A point added with a takes the curve’s value and slope where it lands, so it never bends the curve — it gives you a handle where there was none. From the last point, a adds halfway back to the previous one.

Tangents

A tangent is a slope, and a slope is an angle, so r turns the plot into a dial: while rotation is on, the keys that moved the point turn its tangent instead, by one angle step — five degrees by default — per press.

A slope is clamped between -89° and 89°, because the engine’s tangent is dy/dx and a vertical one is not a number. The turned value is written with three decimals, one undo step, through the same path every other key takes.

Joined or split is the editor’s, not the file’s. An engine reads four numbers and nothing else, so the file decides it by agreement: a point whose in and out slopes match is joined, one whose slopes differ is split. A joined point turns both tangents together; a split point turns the one Tab picked.

A remembered split lasts only while that point stays selected: pick another point and come back, and equal tangents read as joined again, which is what they look like. With a layout that names no in or out, s says so and turns nothing.

The picture says which state you are in before you press anything: the two handles are one straight stroke through the anchor when joined, and two strokes in a second colour when split. In rotation mode a ring is drawn around the anchor, the turning handle is longer and in the selection’s colour, and the status row says ROTATE instead of CURVE, carrying the slopes — point 2 of 3 x 0.500 y 0.800 out 1.000 in 1.000, with the turning tangent in brackets.

tuning.c Tangents 1 / 4 play

1. start A point with its two tangents joined — they agree, so the file says joined.
2. 1 r r turns the plot into a dial.
3. 2 lll h and l turn the tangent by an angle step; a joined point turns both.
4. 3 s s splits the pair, so the next turn moves one side only. s again joins them.

The playhead

A curve is a motion, so the plot plays it. A lane stands to the left of the square and a filled disc in it rises and falls with the curve’s real eval while a thin red line sweeps the square left to right — two seconds a pass, around again without end. An overshoot bounces and a flat lands the way the engine will land it.

Opening the tool starts it. A paused plot asks for no frames, so a still editor still blocks on the keyboard.

tuning.c The playhead 1 / 3 play

1. start The playhead: a red line sweeps the square while the disc in the lane at its left rises and falls with eval(x) — two seconds a pass, on the editor’s redraw clock.
2. 1 Space Space pauses it where it is, and Space again sets it going.
3. 2 :tool curve play offEnter :tool curve play off stops it for good — worth doing while you tune a tangent.

Every move as a command

The same moves typed, for exact values and for scripts:

:tool curve alone lists them, and a value that does not parse is refused naming what the field takes.

The form

A readout, plus the three steps:

Point     2                         read-only
X         0.500                     read-only
Y         0.800
In        0.000
Out       0.000
X step    ━●━━━━━━━━   0.010
Y step    ━●━━━━━━━━   0.010
Angle     ━●━━━━━━━━   5

Point, X, Y, In and Out mirror the selected point and nothing in the form turns them: a point has rules — sorted x, clamped to its neighbours, two points at least — that the plot’s keys keep and a freely dragged slider would break. Only the steps turn, with h and l, or Enter to put :tool curve xstep <value> on the ex line. u in the form undoes the source buffer, as on the plot.

Which list the tool found

The literal is found by a bracket scan rather than by tree-sitter, so it works in any language that spells a list with brackets. From the cursor it walks out to the innermost group whose children are groups of at least two numbers, and inside a child it takes the numbers, true and false in the order they appear and ignores everything else. These all read as the same points:

{ {0.0f, 0.0f, 1.0f, 1.0f, false}, {0.5f, 0.8f, 0.0f, 0.0f, true} }

vec![Point { x: 0.0, y: 0.0, in_: 1.0, out: 1.0 }, …]

[(0.0, 0.0), (0.5, 0.8), (1.0, 1.0)]

Writing back rewrites tokens and never the text around them. A number keeps its suffix and at least the decimals it had, so 0.5f moved by 0.01 becomes 0.51f; a bool keeps its spelling. a copies the point’s text — brackets, a glued name like Point { … }, the separator after it — so a one-per-line list stays one per line.

The tool remembers the byte of the outer open bracket and re-reads from there after every change. Delete the list by hand and it says curve lost, leaving the plot blank until the next :set editor curve.

Closing it

:w and :q belong to the code: :w from the plot or the form writes the source buffer, and :q from either closes the plot and the form and puts the cursor back in the code. Esc is :q for the hand already on the keyboard. Closing one of the two by any other route — Ctrl-W q, :close — closes the other, because a plot with no form is half a tool.

A curve field in a .bidata is this same literal spelled in JSON, and Enter on its row in the property view opens this tool over the value, with the view standing where the source window stands.