Grid

Generates a distribution of points, centered at the origin. Six pattern modes: axis-aligned grid, radial, hex, sunflower, jittered, and concentric rings.

Category: Points Menu path: Points > Grid

Ports

Port	Type	Direction	Description
out	points	output	Generated point distribution

Parameters

Param	Type	Default	Description
pattern	enum	Grid	Distribution pattern: Grid / Radial / Hex / Sunflower / Jittered / Concentric
sizeMode	enum	Spacing	Grid pattern only -- Spacing (explicit px gap) or Size (fit bounding box)
rows	scalar	5	Rows (Grid / Hex / Jittered)
columns	scalar	5	Columns (Grid / Hex / Jittered)
spacingX	scalar	50	Horizontal distance (Grid Spacing / Jittered)
spacingY	scalar	50	Vertical distance (Grid Spacing / Jittered)
boundsWidth	scalar	200	Total width (Grid Size mode)
boundsHeight	scalar	200	Total height (Grid Size mode)
count	scalar	12	Total points (Radial / Sunflower)
radius	scalar	150	Radius (Radial / Sunflower) or outer radius (Concentric)
innerRadius	scalar	0	Inner ring radius (Concentric -- 0 collapses innermost to a single center point)
startAngle	scalar	0	Starting angle in degrees (Radial)
span	scalar	360	Arc span in degrees; 360 = full circle, 180 = half-circle arc with endpoints at both ends (Radial)
cellSize	scalar	50	Horizontal cell size; vertical spacing is cellSize * sqrt(3)/2 (Hex)
rings	scalar	4	Number of concentric rings (Concentric)
pointsPerRing	scalar	12	Points on each ring (Concentric)
jitter	scalar	0.5	Displacement [0,1] scaled by cell size (Jittered)
seed	scalar	0	Integer seed for deterministic jitter (Jittered)

Expose Channels

When enabled (E button on node header), adds input ports that override params via edge connections. The exposed ports are pattern-aware — switching pattern swaps the surface, so you only see the channels the active pattern actually consumes. Switching pattern prunes edges to ports the new pattern doesn't have.

Pattern	Exposed channels
Grid (Spacing mode)	rows_in, columns_in, spacingX_in, spacingY_in
Grid (Size mode)	rows_in, columns_in, boundsWidth_in, boundsHeight_in
Hex	rows_in, columns_in, cellSize_in
Radial	count_in, radius_in, startAngle_in, span_in
Sunflower	count_in, radius_in
Jittered	rows_in, columns_in, spacingX_in, spacingY_in, jitter_in, seed_in
Concentric	rings_in, pointsPerRing_in, innerRadius_in, radius_in

All channels are scalar.

How It Works

Grid (default)

Axis-aligned rows x columns. In Spacing mode you set the exact pixel distance. In Size mode you set the total bounding width and height, and spacing is computed automatically.

Radial

count points equally spaced around a circle of radius. If span < 360 the layout becomes an arc with endpoints placed at both ends (divides by count - 1). Full circle distributes by count so the last point doesn't overlap the first.

Hex

rows x columns honeycomb. Every other row is shifted horizontally by half a cell so each point has six equidistant neighbors. Vertical spacing is cellSize * sqrt(3)/2.

Sunflower (phyllotaxis)

count points arranged on a golden-angle spiral scaled to radius. Produces the organic, non-overlapping arrangement seen in sunflowers, pinecones, and pineapples.

Jittered

Regular grid with per-cell deterministic random displacement. jitter = 0 is identical to Grid with the same spacing. jitter = 1 lets each point move up to a full cell in any direction. Same seed produces identical output across evaluations -- useful for cache keys.

Concentric

Multiple rings, each with pointsPerRing points, radii evenly spaced between innerRadius and radius. If innerRadius = 0 the innermost ring collapses to a single center point.

All patterns output points in local space (1 px = 1 unit) centered at the origin. Use a Transform2D node downstream to position the distribution in composition space.

Usage Examples

Radial menu / compass layout

Grid (pattern=Radial, count=8, radius=200) -> CloneToPoints (source: Arrow shape) -> DrawShape -> Output.

Hex honeycomb dot pattern

Grid (pattern=Hex, rows=10, columns=10, cellSize=30) -> DrawPoints (pointSize=8) -> Transform2D -> Output.

Sunflower particle seed

Grid (pattern=Sunflower, count=500, radius=400) -> PointAttributes (scale from Noise.scalarField) -> DrawPoints -> Output. The phyllotaxis distribution avoids visible grid artifacts for large point counts.

Jittered scatter

Grid (pattern=Jittered, rows=20, columns=20, jitter=0.8) -> PointAdvect (field from Noise.vectorField) -> PointTrail -> DrawShape -> Output.

Concentric ripple

Grid (pattern=Concentric, rings=8, innerRadius=0, radius=400, pointsPerRing=20) -> PointAttributes (opacity from DistanceField.scalarField) -> DrawPoints -> Output.

Animated arc sweep

Grid (pattern=Radial). Keyframe span from 0 to 360 for a sweeping reveal. Keyframe startAngle for rotation.

Tips

• Pattern modes share rows/columns/spacingX/spacingY where they overlap, so you can switch between Grid, Hex, and Jittered without losing settings.
• span = 360 (Radial) evenly distributes including no overlap at 0 deg. span < 360 turns the layout into a finite arc with explicit endpoints -- useful for half-rings and sweeping menus.
• Sunflower is stable at high counts (tested to 10,000+). Golden-angle spacing prevents radial gaps or concentric bands.
• Jittered with seed locked gives reproducible "organic" scatter; animate seed as an integer for a twitchy shuffle or keep constant for stable animation.
• Concentric with innerRadius = 0 collapses the innermost ring to a single point, which is often what you want for radial particle bursts.
• All pattern outputs auto-populate the index attribute [0 .. n-1], available downstream via AttributeToField or PointAttributes (Index source).

Related Nodes

• PointAdvect -- advect grid points through a vector field
• PointAttributes -- set per-point scale, opacity, rotation, or color
• PointDeform -- displace points via field or value
• DrawPoints -- rasterize points to a texture
• CloneToPoints -- instance a shape at every point position