Point Transform

Each frame the node extracts a [SIMD3] cloud from its Points input (the extractor understands live SIMD arrays, [x, y(, z)] number tuples, and nested dictionaries with x/y/z keys, so Vision landmarks and JSON-shaped data work too) and applies one rigid pipeline per point:

p' = R_z · R_y · R_x · (S · (p - pivot)) + pivot + position

In order:

1. Pivot subtraction — the pivot is the origin (0, 0, 0), or the cloud's own centroid when Center is enabled (computed fresh each frame as the average of all points).
2. Scale — non-uniform, per axis (Scale X / Y / Z).
3. Rotation — around X, then Y, then Z, in degrees. Rotation Z is the screen-plane spin; Rotation X and Y tilt the cloud in 3D, which downstream 3D-aware renderers (Plexus and Points Visualize with perspective) turn into real depth.
4. Translation — the pivot is added back, then Position X / Y / Z shifts the result.

Two behaviors are worth knowing:

• Identity pass-through: when Scale is (1, 1, 1), all rotations are 0, and Position is (0, 0, 0), the cloud passes through completely untouched — even with Center enabled. Center is a pivot choice, not a recentering operation: it only matters once some transform is actually applied.
• Live re-evaluation: the node is marked for continuous processing because its source may be live (animated clouds, tracking data). It re-transforms every frame, so feeding any of its float inputs from an LFO, Mouse, Time, or Audio FFT gives immediate motion.

An empty or missing input yields an empty cloud and Count 0 — downstream nodes receive a valid (if empty) structure, never a stall.

• Points (Structure) — the input cloud. Coordinates are in Grafit units (origin at screen center, shortest viewport edge spanning -1…+1).
• Position X / Position Y / Position Z (Float, default 0) — translation in Grafit units, applied last. Position Z moves the cloud toward (+) or away from (-) the camera plane for 3D consumers.
• Rotation X / Rotation Y / Rotation Z (Float, default 0) — rotation in degrees, applied in X → Y → Z order. Positive values follow the Grafit clockwise convention. Rotating a flat (z = 0) cloud around X or Y gives it real Z variation — a cheap way to lay a 2D shape "on the floor" in 3D.
• Scale X / Scale Y / Scale Z (Float, default 1) — non-uniform scale per axis, applied first (before rotation, so the axes scale in the cloud's local frame). Values above 1 enlarge, between 0 and 1 shrink, and negative values mirror the cloud across the corresponding plane.
• Center (Bool, default false) — pivot selection. Off: scale and rotation happen around the world origin, so an off-center cloud sweeps through space when rotated (orbit-like motion). On: the pivot is the cloud's live centroid, so the cloud spins and scales in place wherever it currently sits. Because the centroid is recomputed each frame, this stays correct even for moving or morphing clouds.

Outputs: Points (the transformed cloud) and Count (its point count, unchanged from the input).

• Turntable 3D shape — Geometry to Points (Cube, Edges) → Point Transform (Rotation Y from an LFO in 0–360) → Points Visualize → Canvas. A continuously rotating wireframe; enable Center if the cube isn't at the origin.
• Placing merged compositions — two Geometry to Points nodes → Points Merge → Point Transform (Scale + Position) → Plexus → Canvas. Build a compound figure at the origin, then move and scale it as one unit.
• Orbit vs. spin — Geometry to Points (Circle) → Point Transform with Position X = 0.6 and animated Rotation Z. With Center off the ring orbits the screen center; with Center on it spins in place at x = 0.6. Same node, two motion designs.
• Mirroring tracked bodies — Vision Tracking → Landmarks to Points → Point Transform (Scale X = -1) → Plexus → Canvas. Flip camera-space landmarks horizontally to match the mirrored preview the performer expects.
• Tilting a 2D layout into 3D — Geometry to Points (Grid) → Point Transform (Rotation X = 60) → Point Animation (Wave) → Points Visualize → Canvas. The flat grid gains Z depth from the tilt, and the Wave mode then animates it as a true 3D surface.
• Audio-driven pulse — Audio FFT → Smooth → Remap (to 0.8…1.3) → Point Transform Scale X and Scale Y (Center on) → Plexus → Canvas. The whole constellation breathes with the bass without drifting off-center.

• Transform order is fixed: Scale, then Rotate X → Y → Z, then Translate. To rotate in a different axis order, chain two Point Transform nodes — clouds pass between nodes as live arrays, so stacking transforms is cheap.
• Negative scale is a legitimate mirror: Scale X = -1 flips left/right, Scale Y = -1 flips vertically. Combine with Center to mirror in place.
• Center recomputes the centroid every frame from the actual points; on an animated cloud the pivot therefore follows the cloud. If you need a fixed pivot instead, leave Center off and position the cloud so your pivot sits at the origin, transforming afterward.
• The node re-runs each frame by design; at typical cloud sizes (hundreds to a few thousand points) this is negligible, but if the source is static and huge, consider transforming at the source (Geometry to Points has its own Rotate/Position inputs).
• Prefer this node over per-source transforms when the same placement must apply to several merged sources at once — one transform after Points Merge beats keeping three source transforms in sync.
• Related nodes: Geometry to Points (built-in source transform), Points Merge (combine before transforming), Point Animation (adds motion rather than placement), Point Density (change resolution without moving anything).