Points Visualize

Each frame the node resolves its Points input and flattens it into a flat list of 3D positions. The extractor is universal: it accepts live point arrays, arrays of [x, y] or [x, y, z] number tuples, and nested structures or JSON where any dictionary with numeric x and y keys (z optional) counts as one point. Up to 200,000 points are accepted; anything beyond that hard ceiling is truncated.

The entire cloud renders in one instanced GPU draw call — one quad per point, expanded in the vertex shader. There is no CPU loop over points at draw time; the CPU only uploads positions into a per-node double-buffered MTLBuffer and computes cloud statistics (bounding box, centroid, maximum radius) that the color and size modes need. All per-point math — size, rotation, jitter, color, opacity — runs in the vertex shader.

Positions are in Grafit units: origin (0,0) at the viewport center, shorter viewport edge mapped to [-1, 1]. Shapes are drawn as signed-distance fields in the fragment shader, edge-feathered by the global AA multiplier (or by Softness when it is above zero, which replaces AA feathering with a wide artistic falloff). The output texture is premultiplied alpha, ready for a Canvas node. Width/Height report the full viewport-fit size, Count reports how many points were actually drawn. When Enable is false or the cloud is empty, the texture is cleared — Canvas shows nothing, never a stale frame.

Shape selects the sprite drawn at every point:

For Custom Image, an Image node source is sampled from its raw pixels so the sprite keeps its true proportions; any other generator's texture is used as-is. The sprite quad's geometry is stretched by the source aspect ratio while the tint (Color × Opacity) still applies.

Color Mode maps each point to a color. Mode 0 uses the flat Color; every other mode samples the connected Gradient (up to 16 stops) at a parameter t derived from the cloud's own statistics:

Size Mode scales each point's size on top of the base Size (all variable modes span ×0.35 at the low end to ×1.65 at the high end via 0.35 + 1.3·t):

All variance parameters (Size Variance, Rotation Variance, Opacity Variance, Color Variance, Jitter) are computed on the GPU from deterministic PCG hashes of (point index, Seed). The same Seed always produces the exact same cloud — no per-frame flicker, no CPU random state, fully reproducible patches.

Interactions worth knowing: Softness > 0 replaces the AA edge entirely, so it also dominates Outline Width visually at high values. Fill Mode = Outline converts any shape to a stroked version of thickness Outline Width — except Ring (which is inherently a stroke) and Custom Image. Gradient color modes fall back to plain white if no Gradient is connected while a gradient mode is selected.

• Point-cloud portrait: Image node → Geometry to Points → Points Visualize (Additive on, small Size) → Canvas — an image rebuilt from glowing dots.
• Animated particle constellations: Geometry to Points → Point Animation → Points Visualize → Canvas, with Color Mode = Gradient: Depth so points shift color as they move in Z.
• Bokeh backdrops: any sparse cloud → Points Visualize with Softness ≈ 0.8, high Size Variance, Opacity Variance, and Additive — layer behind the main scene on a lower Canvas layer.
• Hand/body tracking dots: Camera Input → Vision tracking node → Points Visualize (Shape = Ring) → Canvas — live landmark overlays.
• Custom sprite scatter: Image node (a snowflake PNG) → Points Visualize Image input, Shape = Custom Image, Rotation Variance and Jitter up → falling-snow fields when the cloud is animated.
• Star field: Point Density or a random cloud → Points Visualize, Shape = Star, Color Mode = Gradient: Random, tiny Size with high Size Variance.

• Like every generator, the output only appears on screen through a Canvas node; the Image port carries an offscreen texture.
• Additive blending plus a dark background is the cheapest "glow" there is — overlaps brighten naturally without any post-processing.
• Variance is deterministic: animating Seed with a Counter or stepped Time value re-rolls the whole cloud in discrete jumps, which reads as intentional shuffling rather than noise.
• Directional and radial color modes are computed from the cloud's own bounding box and centroid each frame — a moving cloud renormalizes its gradient continuously.
• Performance: 200,000 points is the hard cap and one draw call handles all of them; the per-frame CPU cost is only the O(n) upload and statistics pass. Prefer trimming the cloud upstream (Point Density) over pushing the cap.
• For connecting the same cloud with lines instead of dots, use Lines Visualize; for proximity meshes use the Plexus family.