Draw Points

Rasterizes a point cloud into a texture — every point becomes a circle, a square, or a sprite image, drawn in one GPU pass. Reads per-point attributes for scale, rotation, opacity, and color. Where points overlap they stack (Normal) or add light (Add, Screen).

Category: Render Menu path: Render > DrawPoints

Ports

Port	Type	Direction	Description
points_in	points	input	Point cloud to rasterize
sprite_in	imageRgba16f	input	Optional sprite image, used when shape is Sprite. The image's own content (an ImageSource's pixels, or the comp area for a generator / effect chain) is stamped at every point
out	imageRgba16f	output	Rasterized image

Parameters

Param	Type	Default	Description
color	color	white	Base color for all points. For sprites: an RGB tint (multiplies the sprite) and an alpha multiplier
pointSize	scalar	4	Base diameter in comp pixels. For sprites: the sprite's larger dimension; the other side follows the sprite's aspect ratio
shape	enum	Circle	Circle · Square · Sprite. Sprite with nothing wired to sprite_in draws circles. Files saved before this param existed render as Circle
blend	enum	Normal	How overlapping points combine: Normal (later points cover earlier ones), Add (light sums — sparks, fire, bokeh), Screen (brightens but never past white). See Blend below. Files saved before this param existed render as Normal
selection	string	(empty)	Apply To — limits the node to a selection over any point attribute or intrinsic. Only selected points draw; the rest stay in the stream for downstream nodes but render nothing. 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

DrawPoints turns every point into one instance of a small quad and draws the whole cloud in a single GPU draw call — 500 000 points render in a few milliseconds. There is no multisampling; edges are anti-aliased analytically in the shader, so a 1-pixel dot is a proportionally faint pixel rather than a jagged one.

Per-point attributes (set upstream by PointAttributes, a Point Solver, or any attribute-writing node) modify each individual point:

• scale — multiplies pointSize. A per-axis scale (PointAttributes' Scale X/Y target) renders the point as an ellipse or rectangle, or stretches a sprite
• rotation — radians; rotates the point about its centre. Invisible on plain circles, visible on ellipses, squares and sprites
• opacity — multiplies the alpha (0–1)
• color — overrides the node color entirely, alpha included (then opacity still multiplies)

Points missing attributes use backward-compatible defaults (scale 1.0, rotation 0, opacity 1.0, node color).

Colour rule. Two renderers read the same color attribute and treat it differently, on purpose: DrawPoints overrides (the attribute replaces the node colour — a coloured particle system needs no white base), while DrawInstances tints (the attribute multiplies the source image's pixels). Sprites follow the override rule and then use that colour as a tint on the sprite: per-point colour RGB multiplies the sprite, its alpha multiplies the sprite's alpha.

Sizes and quality levels. A point's radius is pointSize × scale / 2, never smaller than half a comp pixel. Draft, Preview and Full agree once the resolution divisor is accounted for: a dot that is a faint sub-pixel speck at Full is the same speck — not a bigger, dimmer blob — at Draft, so a particle look can be judged while scrubbing.

Sprites. The sprite_in image is bound directly with a full mip chain, so small particles average their texels instead of shimmering. It is a self-contained lookup — the sprite keeps its own aspect ratio and is never aligned to the canvas — so an image larger than the composition is stamped as the part that fits the comp.

Blend — what happens where points overlap. Each point is drawn with its own coverage and colour; blend decides how a point combines with the points already drawn underneath it:

• Normal — ordinary stacking. A later point covers an earlier one, exactly as before this param existed. Point order is paint order: later points in the stream land on top.
• Add — light sums. Two overlapping points are twice as bright as one; ten sparks crossing make a hot core. This is how real light behaves, which is why it reads as fire, sparks, embers, plasma, and out-of-focus highlights (bokeh). The result is not limited to white: in Caddis' linear-light pipeline the summed values are kept above 1.0 all the way to the layer's output, so a Glow or Levels downstream still sees the extra energy.
• Screen — the bounded relative. 1 − (1 − a)(1 − b) per channel: overlaps brighten, but the total can never exceed 1.0. Use it when Add blows out too fast — soft particle clouds, dust, a gentle firefly glow — or whenever you want brightening without HDR values leaving the node.

In every mode the point's coverage (alpha) accumulates the same way, as the union of all the points at that pixel, so the layer composites correctly over whatever is below it — Add and Screen change the colour that lands, not where it lands. The node's straight-alpha output means the colour channels are what carry the extra light: after Add, a pixel covered twice by a half-opaque 50 % grey reads as 75 % coverage of a brighter grey, not as 100 % coverage.

Order. Add and Screen are commutative, so with them draw order is irrelevant — reversing the stream, shuffling it, or merging two clouds in either order renders the same image. (Strictly: identical to within one 8-bit step on a scattering of pixels where several points pile up, because the GPU sums them in floating point and rounds after each one.) Only Normal depends on order.

Saturation. Add on a bright colour saturates quickly: two fully opaque white points are already 2.0, and a dense emitter reaches "solid white blob" within a few overlaps. Tame it with the particles' own opacity rather than the node colour — a PointAttributes with source Age and target Opacity (curve 1 → 0) gives each particle a fade over its life, so only the freshest few overlap at full strength — and pick a colour well below white (Add of a 0.3 orange takes seven overlaps to reach 1.0 in the brightest channel). Dim, many, and additive is the recipe; bright, few, and additive is a white disc.

CPU fallback. With CADMIUM_DRAW_POINTS_CPU=1 (the previous rasterizer, kept for one release) only Normal is available: Add and Screen render as Normal there and a warning is logged once.

Usage Examples

Basic: Visualize a grid

Grid → DrawPoints → Output. Adjust pointSize to control dot size. Each grid point renders as a white circle.

Field-driven particle sizes

Grid → PointAttributes (target: Scale, field: Noise.scalarField) → DrawPoints. Each point's radius varies with the noise field value at its position, creating an organic dot pattern.

Colored particle system

Grid → PointAdvect (field: Noise.vectorField) → PointAttributes (target: Color, field: Gradient.colorField) → DrawPoints. Points flow through a noise field and pick up colors from a gradient based on their position.

Sprite particles

ImageSource (a soft glow PNG) → DrawPoints sprite_in; PointScatter → PointAttributes (target: Rotation, field: Random.scalarField) → DrawPoints points_in; shape = Sprite, pointSize = 24. Every point stamps the glow at its own rotation, sized so the glow's larger side is 24 px. Set color to tint all sprites at once, or write a per-point color upstream for individual tints.

Confetti

Grid → PointAttributes (Scale X/Y, valueXY 1 × 0.4) → PointAttributes (Rotation, field: Random.scalarField) → DrawPoints shape = Square. Flat rectangles at random angles.

Sparks

PointEmitter (rate 400, life 40, lifeVariation 0.5, velocityMode Direction, direction −90, spread 60, speed 600, speedVariation 0.5) → PointSolver (gravity 0, 900 · drag 0.3) → PointAttributes (target Opacity, source Age, curve 1 → 0) → DrawPoints (color a deep orange around 0.9, 0.35, 0.05 · pointSize 3 · blend Add) → Glow (threshold 0.6, blur 30, falloff Long Tail) → Output.

Every spark is a small additive dot fading out over its life. Where the stream is dense — right above the emitter — the dots pile up into a hot yellow-white core; further out they thin into single orange embers. Add is what makes the core glow instead of just going opaque, the Age→Opacity ramp keeps the core from saturating to a flat white disc, and the Glow picks up the summed light (including the values above 1.0) and spreads it into a halo. For a cooler, softer look switch the same chain to Screen.

Tips

• Per-point scale is a multiplier on pointSize — a scale of 2.0 with pointSize 4 gives an 8 px dot
• Squares and sprites rotate; circles only appear to rotate once they are stretched into ellipses with a per-axis scale
• The layer's content bounds grow with pointSize × scale, so large points are not clipped at the comp edge. A rotated square's corners can reach up to 41 % beyond that radius; if one sits right on the content edge, add a little pointSize headroom
• Up to 4 000 000 points draw per node; beyond that the excess is skipped and a warning is logged
• Add and Screen only change pixels where points overlap — a sparse cloud looks identical in all three modes. If switching to Add does nothing, the points are not touching
• With Add, keep the node color (or per-point colours) well below white and give particles an opacity fade over life; brightness should come from overlap density, not from the base colour
• CADMIUM_DRAW_POINTS_CPU=1 in the environment restores the previous CPU rasterizer for one release (circles only, no rotation, no sprites, Normal blend only)

Related Nodes

• DrawInstances — stamps a full texture chain per point with palettes, cell fitting and time offsets; tints rather than overrides colour
• DrawShape — rasterizes shape geometry (polygons, paths) instead of points
• PointAttributes — sets per-point scale, opacity, color, rotation; its Age source is the opacity-over-life ramp that keeps Add from saturating
• PointEmitter / PointSolver — the particle system that feeds a sparks / fire chain
• Glow — spreads the summed light of an Add render into a halo
• Grid — generates point clouds
• PointAdvect — moves points through a vector field over time