Point Advect

Moves points through a vector field over time using Euler integration. Stateful -- positions accumulate frame by frame.

Category: Point Ops Menu path: Point Ops > Point Advect

Ports

Port	Type	Direction	Description
points_in	points	input	Source points (seed positions come from layer start frame)
field_in	vectorField	input	Vector field that drives point motion
out	points	output	Advected points at the current frame

Parameters

Param	Type	Default	Description
speed	scalar	100	Velocity multiplier applied to the field
substeps	scalar	1	Integration substeps per frame (higher = more accurate in fast-changing fields)
selection	string	(empty)	Apply To — limits the node to a selection over any point attribute or intrinsic. Only selected points advect; unselected points hold position but stay in the stream. Membership is effectively frozen at layer start (the sim state carries the seed's attributes), and changing any of the three params re-seeds the whole simulation. Empty = whole stream. With the default rule (Member) a bare name reads as group membership (> 0.5); an unresolvable name selects nothing.
selectionRule	enum	Member	How selection's value decides membership: Member (> 0.5), Greater Than, Less Than. Shown once a name is set
selectionValue	scalar	0	Comparison threshold for Greater Than / Less Than. Hidden under Member

How It Works

PointAdvect is a stateful node. At the layer's start frame, it reads the upstream points as seed positions. On each subsequent frame, it evaluates the vector field at each point's current position and moves the point by field_value * speed * dt, using forward Euler integration.

The simulation is deterministic: the state at frame N is a pure function of the seed at layer start plus the field and params at every frame in between. Animating the field behaves physically — keyframing a field's strength down to zero slows the points and leaves them where they are; it never snaps them back toward their seed positions. When a cache miss forces a history rebuild (cold scrub, seek, project reload), the field is re-evaluated at each past frame, so scrubbing or exporting from any frame reproduces sequential playback exactly.

Results are stored in a SimulationCache keyed by (composition, node, frame). This means:

• Sequential playback builds on the previous frame's result (fast — one step per frame, no history re-evaluation).
• Scrubbing to an arbitrary frame replays from the nearest cached frame, re-evaluating the field at each intermediate frame.
• Editing the system (different seed source, field wiring, params, or keyframes anywhere upstream of points_in / field_in) re-seeds the simulation via a time-independent definition hash. Note this replays history with the new settings — lowering a static (un-keyframed) field strength re-simulates as if it had always been that weak. Keyframe the field if you want the change to happen in time.

Use resetSimulation (or the reset button in the UI) to clear the cache and start fresh.

Usage Examples

Basic: Flowing particles

Grid -> PointAdvect (field: Noise.vectorField, Curl type) -> DrawPoints -> Transform2D -> Output. Points drift along a smooth, swirling flow field.

Trails

Grid -> PointAdvect -> PointTrail -> DrawShape -> Transform2D -> Output. Each point leaves a polyline trail showing its path history.

Controlled speed

Connect a Time or Math node to drive speed via keyframes. Ramp speed from 0 to 200 over the first second for a gradual start.

Tips

• Use Curl noise type for the field -- it produces divergence-free flow that avoids clumping and convergence points
• Increase substeps when the field changes rapidly in space (tight vortices) to prevent points from jumping through features
• The simulation snaps comp_frame to integer for cache lookup, so sub-frame motion blur sampling still uses the integer-frame simulation state
• Scrub, seek, or export from any frame -- the result is always the same as playing through sequentially (cold scrubs pay a one-time rebuild cost proportional to the target frame)
• resetSimulation clears both SimulationCache and TrailCache
• Pair with a FileCache to bake the advected points to disk for instant playback of heavy simulations

Related Nodes

• Grid -- common seed point source
• Noise -- vectorField output drives the flow
• PointTrail -- record advected positions as polyline trails
• PointAttributes -- set per-point attributes before or after advection
• DistanceField -- shape-based vector field for advection around geometry