Unity VFX (real-time VFX artist)

Expert VFX serves the game first: the player must read what happens, where the danger is and when it ends, on the target device, with the real number of copies on screen. Craft (layers, contrast, motion, textures) and budget (fill, particles, draw calls, memory) are both measured here: every effect is stepped frame by frame offscreen, looked at, and counted. Target: Unity 6000.3.21f1, URP 17.3, VFX Graph 17.3.0, macOS Apple Silicon. If a sibling skill named here is missing from your available skills, ask the user to install it (npx skills add scenario-labs/skills --skill <name>); unattended, proceed from tool schemas and flag the gap.

REQUIRED BACKGROUND: scenario-unity-expert (channels, review loop, 6.3 traps, ut_run, ut_review, ut_stat, AgentKit).

Status (2026-09-24, after the blind-grade refactor): every procedure ran in Unity 6000.3.21f1 through tests/code/unity-vfx/ (results in archive/tests/unity-vfx/live_results.jsonl, numbers in references/procedures.md).

Stance (the expert delta)

1. Gameplay before beauty (Jason Keyser, ex-Riot). The primary shape equals the gameplay boundary; brightness is a budget spent by importance (idle and basic attacks subdued, game changers and ultimates bright); effects end with the gameplay state; review with N copies, not one. Tag every root with VfxTier and check the ladder (ut_vfx.importance_ladder; observed: slash 0.39 < muzzle 0.46 < impact 1.50 < shockwave 2.60 < explosion 5.99), the crowd (crowd_readability: 20 explosions at gameplay spacing read as 20 shapes, packed 2.2 m apart only 6) and the tail after a stop.
2. On mobile, a texture moving over a mesh beats a particle cloud (Nikola Damjanov, Nordeus: about 90% of shipped effects; particles are fluff, 100 per emitter max; overdraw hurts more than draw calls). Observed: the same shockwave as one ring mesh drew 1 layer everywhere, 0.037 full-screen equivalents (FSE) at peak, versus 5 to 7 layers where they cover and 0.35 FSE for 36 puffs. Measure fill per frame, not particle counts.
3. Choose the system by platform and data flow. Every target phone, WebGL, per-particle C#, Unity physics collisions: the Particle System, scriptable module by module. Thousands to millions of GPU particles, depth-buffer collisions, decals, six-way smoke, GPU events: VFX Graph, which needs compute and runs on Android only on a subset of high-end URP devices (e-book) and on the Web only through WebGPU, experimental in 6.3.
4. One uber material, per-particle data from Custom Data. Nordeus's uber shader: grayscale R colored by a LUT ramp, G emission, B alpha override, linear fade, erosion, second alpha, Blend and Cull per material. AgentKit/VFX/Uber is that shader as text; per-instance variation (erosion curve, random UV offset, wipe) comes from the Custom Data module through custom vertex streams (Hovl Studio: "a random number cannot be made in a shader"), so one material serves every variant and the SRP Batcher stays on. Stream order is a contract the audit checks.
5. A VFX Graph is a black box with a public API (VFX Graph e-book; Orson Favrel, Unity). Copy a template, expose a few properties and events, drive them with cached IDs; commands are deferred and aliveParticleCount reads -1 until the first readback, then refreshes every 60 frames (observed). Memory is capacity x stored attributes; bounds decide culling; sorting costs a dispatch; a point cache when particles only need positions, an SDF to conform or collide (both scriptable, P8, P12).
6. Layers with one job each, contrast, order, motion (Sirhaian, Gabriel Aguiar, Nordeus). Dark alpha body under additive heat, glow on top, distinct sorting orders for stacked alpha layers; no linear curves except loops, fast and slow elements mixed, a burst when a loop starts, something always moving; a variant sheet plays as a random fixed frame per particle, never as animation; sparks shrink while fire grows; every layer fades in and out.
7. Do not paint what you can borrow or compute; import at the size the screen shows (Simon Trümpler; Nordeus 256 typical, 512 max). Borrowed flipbooks get blending and a decelerating frame curve; simple shapes are generated; sprites get soft edges from motion blur, not Gaussian, and keep their values off the border; channel-packed data textures import linear (as sRGB a 0.5 gray reads 0.21, observed); LUTs stay uncompressed.
8. In 6.3, Shader Graph particle shaders drop GPU instancing on mesh particles silently (Fred Moreau, Unity): +69% main-thread time at 5,000 cubes with identical draw calls (observed). The audit flags it; the fix comes from scenario-unity-shaders.