Record Take

Overview

Records drag operations in an editor as motion. Hand-driven paths of path points or selections are retained and become animation material through keyframe_clip. This is the entry point for creating animation with hand motion.

Usage tips

• Start the recording chain with record_take → keyframe_clip → clip_apply_path / clip_apply_image. Learn this flow as the standard pattern.
• Choose between this and pose_step_track (the still-pose version) using the "record a video / place a still frame" analogy in the main text.
• Turn repeating motion into a loop downstream with loop_fit / clip_loop_fit.

Related nodes

• pose_step_track — the still-pose counterpart
• keyframe_clip — turns the recording into a clip; the go-to next step
• layer_mixer / loop_fit — combines recordings or fits them to a loop
• clip_apply_path / clip_apply_image — final application destinations

Quick introduction

When you drag a Bezier point or selection, Record Take records:

• what you moved,
• the direction it moved, and
• how it changed from the beginning to the end of the motion.

This node does not remember only the final placement.
Record Take records intermediate changes while the element is moving.

For beginners:

• Record Take = record like a video
• Pose Step Track = record like a photograph

When to use it

Suitable uses

• Retaining the intermediate motion of a point
• Creating motion that changes smoothly from 0.0 to 1.0
• Moving path points or selections by hand and using the trajectory as animation material
• Creating continuous motion to pass later to LayerMixer or LoopFit

Typical examples

• Gradually sway the edge of a cape.
• Move a path control point smoothly.
• Slide a PixelCanvas selection from left to right.

Unsuitable uses

• Placing a sequence of still poses, where "use this pose at this time" is all you need
• Ignoring intermediate motion and remembering only the final pose

Use Pose Step Track in those cases.

Remember these points first

When using Record Take, remember these three points first:

1. The currently selected Record Take node receives the recording.
2. The stored time is normalized progress from 0.0 to 1.0, not seconds.
3. Intermediate motion is retained.

Points 2 and 3 are especially important.
Record Take does not turn a 1.2-second drag into a 1.2-second animation. It tracks the elapsed time internally, but when saving it normalizes and rearranges samples over the range from start_time to end_time.

Overview

How to use

1. Place the recording node

Place Record Take in the graph.

2. Open the source editor

These editors currently support direct recording:

• PixelCanvas
  • selection move
• BezierPath
  • point drag
  • selected points move
• MultiPath
  • point drag
  • selected points move

3. Select the Record Take node

This is important.
The currently selected Record Take node in the graph is the recording destination.

Simply opening the editor does not start recording.
Keep the source editor open, then select Record Take in the graph.

4. Manipulate the source directly

For example:

• Drag a Bezier point.
• Move a group of selected points together.
• Move a PixelCanvas selection.

5. Release the mouse to confirm

When the operation is confirmed, the motion is stored in the record_data and layer outputs.

Concrete examples for beginners

Example 1: Move a Bezier point smoothly to the right

Goal:

• Keep the initial shape at first.
• Move the point gradually to the right toward the end.

Settings:

• start_time = 0.4
• end_time = 1.0

Steps:

1. Open the Bezier Path editor.
2. Select Record Take in the graph.
3. Drag an anchor point to the right.
4. Release it to confirm.

Result:

• The point remains almost still from 0.0 to 0.4.
• The take moves it smoothly from 0.4 to 1.0.

Example 2: Slide a PixelCanvas selection

Goal:

• Move a selected part slowly from the left side of the screen to the right.

Settings:

• start_time = 0.0
• end_time = 1.0

Steps:

1. Select an area in PixelCanvas.
2. Select Record Take in the graph.
3. Drag the selection to move it.
4. Release it to confirm.

Result:

• Translation of the selection is recorded as Transform2D.
• Read value.translation to see the displacement at that point in time.

Example 3: Add a brief motion accent

Goal:

• Keep the element still most of the time and move it slightly only near the end.

Settings:

• start_time = 0.85
• end_time = 0.95

Result:

• The motion is compressed into a short interval, creating a one-action accent.

How it works

Internally, Record Take stores the following in a RecordedLayer:

• source node,
• source editor,
• the point, handle, or selection that moved, and
• a sample sequence of the change.

The important point is what it does not store:

• where you clicked, or
• which UI event occurred.

It stores the resulting change.
This makes it editable animation data rather than a replay of UI events.

Differences from Pose Step Track

Record Take

• Records the element while it is moving
• Retains intermediate changes
• Best for smooth motion

Pose Step Track

• Places the final pose as a step
• Does not retain intermediate motion
• Best for stepped switching

When in doubt:

• Need the motion itself → Record Take
• Need to arrange poses → Pose Step Track

Common misconceptions

Are start_time / end_time measured in seconds?

No. They are normalized time from 0.0 to 1.0, not seconds.

Does simply opening the source editor start recording?

No.
You must select Record Take as the recording destination node.

Can I use value directly as an image?

Generally, no. value is a Map containing transform or position data.
It is an informational output for reading the recording result, not an image.

Can it record an entire pen stroke?

Not in the current implementation. Direct recording primarily supports selection move and movement of path points / handles.

What happens if start_time and end_time are equal?

The recording effectively overlaps at that time, with no intermediate span.
For continuous motion, giving the interval at least some width is easier to understand.

Notes

• These are internal-only types. They are not exposed to variables, Switch, equality checks, or custom pins.
• Recording targets layerized changes, not UI events.
• There is no dedicated track-editing UI yet. Direct recording from a source editor is the current entry point.

Capture range and stored data

• start_time / end_time are authoring UI values read only by source-editor capture, so they cannot be promoted to wires.
• If end_time < start_time, capture swaps the two bounds and evaluation reports capture_range_swapped through warnings.
• Saving a new capture over invalid non-empty record_data is blocked instead of silently treating it as empty. Replacement happens only after an explicit reset.