@dopaminefx/effect-dots 0.1.0

package/dist/index.js

@@ -0,0 +1,35 @@
+/**
+ * Dots (the calm ambient "thinking" indicator) as an `EffectFactory` on the
+ * Dopamine backbone.
+ *
+ * FULLY DATA-DRIVEN: everything that isn't the GLSL lives in dots.dope.json —
+ * the mood→params mapping + OKLCH palette (the loader), AND the per-frame logic:
+ * `tempo.frame` (the steady periodic breathe gate), `render.shadowHeightFrac`
+ * (the dots' outer reach), `render.consts` (MAX_DOTS/MIN_DOTS), `render.config`
+ * and the uniform `binding` contract. `registerDopeEffect` interprets that data
+ * through the generic pass runner; this module is just the dot-row SHADER + the
+ * registration call. No swift/ or android/ folder — those factories + the MSL /
+ * Kotlin shaders are generated from this one .dope plus the GLSL source.
+ *
+ * CONTINUOUS / LOOPING. Dots is Dopamine's second continuous effect (after halo):
+ * it declares the first-class `tempo.loop` contract (`periodMs = 1000`): the
+ * parser validates the seam invariants (the period is exactly 12
+ * "animate-on-twos" steps and `durationMs = 4000` is exactly 4 periods), the
+ * runner derives the standard periodic clocks `uPhase`/`uLoopS` every frame, and
+ * `tempo.frame.amp` is a STEADY periodic breathe of that phase —
+ * `0.85 + 0.15·sin(2π·phase)` — so the frame at `t == durationMs` matches
+ * `t == 0` at every whimsy. The conductor re-arms it at every `durationMs` seam;
+ * the host stops it (and can pause/resume it) via the handle `play()` returns.
+ */
+import { DOTS_FRAGMENT_SRC, DOTS_VERTEX_SRC } from "./dots-shader.js";
+import { parseDope, registerDopeEffect } from "@dopaminefx/core";
+import doc from "./dots.dope.json";
+const DOPE = parseDope(doc);
+// The whole factory (resolve / create / reducedMotion / program registration)
+// is data: dots.dope.json interpreted by the core backbone.
+export const dots = registerDopeEffect(DOPE, {
+    vertex: DOTS_VERTEX_SRC,
+    fragment: DOTS_FRAGMENT_SRC,
+});
+export default dots;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAuC,MAAM,kBAAkB,CAAC;AACtG,OAAO,GAAG,MAAM,kBAAkB,CAAC;AAEnC,MAAM,IAAI,GAAG,SAAS,CAAC,GAAa,CAAC,CAAC;AActC,8EAA8E;AAC9E,4DAA4D;AAC5D,MAAM,CAAC,MAAM,IAAI,GAAG,kBAAkB,CAAC,IAAI,EAAE;IAC3C,MAAM,EAAE,eAAe;IACvB,QAAQ,EAAE,iBAAiB;CAC5B,CAA2D,CAAC;AAE7D,eAAe,IAAI,CAAC"}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@dopaminefx/effect-dots",
+  "version": "0.1.0",
+  "description": "Dots — a calm ambient looping 'thinking' dot-row indicator for Dopamine.",
+  "keywords": [
+    "dopamine-effect"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "sideEffects": [
+    "./src/index.ts",
+    "./dist/index.js"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "@dopaminefx/core": "^0.1.0"
+  },
+  "license": "MIT",
+  "author": "10in30",
+  "homepage": "https://github.com/10in30/dopamine#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/10in30/dopamine.git",
+    "directory": "effects/dots/web"
+  },
+  "bugs": {
+    "url": "https://github.com/10in30/dopamine/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/dots-shader.ts

@@ -0,0 +1,239 @@
+/**
+ * GLSL ES 3.00 source for **Dots** — Dopamine's calm ambient "thinking" indicator.
+ *
+ * Governing metaphor: a centred ROW of soft luminous dots, centred on the action
+ * point (`uOrigin`). They gently BREATHE together (a slow sine on radius +
+ * brightness) while a brightness PULSE travels across the row in sequence (the
+ * classic "typing… / loading…" read). Electric / serene OKLCH hues from the
+ * seeded palette.
+ *
+ * Dopamine's SECOND CONTINUOUS effect (after halo). Like halo it rides the
+ * first-class `tempo.loop` contract:
+ *   - The `.dope` declares `tempo.loop.periodMs = 1000`; the runner derives the
+ *     standard periodic clocks from it each frame — `uPhase` (normalized loop
+ *     phase in [0, 1)) and `uLoopS` (seconds within the loop) — off the SAME
+ *     "animate on twos"-snapped clock as `uTimeS`. The parser validates the seam
+ *     invariants (the period is 12 on-twos steps; `durationMs` 4000 = 4 whole
+ *     periods), so the frame at `t == durationMs` equals `t == 0` at EVERY whimsy.
+ *   - ALL animation here is a periodic function of `uPhase`: `sin(TAU·uPhase)`
+ *     for the breathe, and a chase whose head position is `fract(uPhase)` so it
+ *     winds exactly ONE turn around the row per period and rejoins seamlessly.
+ *     Nothing reads a monotonic clock (`uLife`/`uTimeS`), so every period
+ *     boundary is seamless.
+ *   - `frame()` returns a STEADY periodic `amp = 0.85 + 0.15·sin(TAU·phase)`
+ *     (never `envelope(life)`), so there is no one-shot fade to break the seam.
+ *   - The conductor re-arms the effect at `durationMs` instead of tearing down;
+ *     the host stops it via the play handle (and can pause/resume it drift-free).
+ *
+ * whimsy == uStyle:
+ *   0 = photoreal soft glow — gaussian dots + a smooth feathered chase.
+ *   1 = cel / flat — the dots become hard flat discs and the chase snaps into a
+ *       single posterized "lit" dot stepping along the row.
+ */
+
+import {
+  GLSL_CONSTANTS,
+  GLSL_DITHER,
+  GLSL_HASH,
+  GLSL_PALETTE_MIX,
+  GLSL_TONEMAP_ACES,
+} from "@dopaminefx/core";
+
+/** Compile-time cap on the dot count: BOTH the GLSL `#define MAX_DOTS` (below)
+ * and the integer-clamp const the `.dope` mapping references (`MAX_DOTS`). */
+export const MAX_DOTS = 7;
+
+export const DOTS_VERTEX_SRC = /* glsl */ `#version 300 es
+out vec2 vUv;
+void main() {
+  // Single full-screen triangle from gl_VertexID — no vertex buffers needed.
+  vec2 pos = vec2(float((gl_VertexID << 1) & 2), float(gl_VertexID & 2));
+  vUv = pos;
+  gl_Position = vec4(pos * 2.0 - 1.0, 0.0, 1.0);
+}`;
+
+export const DOTS_FRAGMENT_SRC = /* glsl */ `#version 300 es
+precision highp float;
+out vec4 fragColor;
+
+uniform vec2  uResolution;    // device pixels
+uniform vec2  uOrigin;        // row centre, gl coords (y up)
+uniform float uAmp;           // STEADY periodic breathe gate (~0.85..1.0), not an envelope
+uniform float uPhase;         // normalized loop phase [0,1) (tempo.loop) — drives ALL motion
+uniform float uLoopS;         // seconds within the current loop (the dither's temporal seed)
+uniform float uExposure;
+uniform float uDotCount;      // number of dots in the row (clamped to MAX_DOTS)
+uniform float uDotRadius;     // dot radius as a fraction of min viewport dim
+uniform float uDotGap;        // centre-to-centre spacing as a fraction of min viewport dim
+uniform float uBreathe;       // 0..1 breathe depth (radius/brightness sine swing)
+uniform float uChase;         // 0..1+ sharpness of the traveling pulse (tighter = livelier)
+uniform float uGlow;          // 0..1 ambient under-glow brightness
+uniform float uStyle;         // 0..1 photoreal soft glow -> cel/flat discs (whimsy)
+uniform float uShadow;        // 0 = light pass (screen), 1 = shadow pass (multiply)
+uniform vec2  uShadowOffset;  // device-px offset of the cast silhouette (away from light)
+uniform float uShadowSoft;    // penumbra softness in device px (blur tap radius)
+uniform float uShadowStrength;// 0..1 max darkening of the multiply layer
+uniform vec3  uC0;            // dot core color
+uniform vec3  uC1;            // mid
+uniform vec3  uC2;            // pulse accent
+
+#define MAX_DOTS ${MAX_DOTS}
+
+${GLSL_CONSTANTS}
+${GLSL_HASH}
+${GLSL_PALETTE_MIX}
+${GLSL_TONEMAP_ACES}
+${GLSL_DITHER}
+
+// The live count, clamped to the compile-time cap so the loop bound is constant.
+int dotCount(){
+  return int(clamp(uDotCount, 1.0, float(MAX_DOTS)) + 0.5);
+}
+
+// The breathing dot radius. One slow sine per loop period swings the radius by
+// ±uBreathe·radius around the base — the gentle pulse "breath". Periodic in
+// uPhase, so it returns to its t=0 value at every seam.
+float liveRadius(){
+  return uDotRadius * (1.0 + sin(TAU * uPhase) * uBreathe * 0.45);
+}
+
+// The normalized x-centre of dot i: a row of dotCount dots, spaced uDotGap apart,
+// centred on the origin (so the whole row is symmetric about x = 0).
+float dotCenterX(int i, int count){
+  float c = float(count);
+  return (float(i) - (c - 1.0) * 0.5) * uDotGap;
+}
+
+// 0..1 "lit" weight of dot i under the traveling pulse. The pulse HEAD winds one
+// full turn around the row per period (head = fract(uPhase) -> seamless); each
+// dot lights as the head sweeps over its slot, with a comet-like falloff set by
+// uChase. Wrapped distance keeps it continuous across the seam.
+float pulseLit(int i, int count){
+  float head = fract(uPhase) * float(count);          // 0..count head position
+  float d = abs(float(i) + 0.5 - head);
+  d = min(d, float(count) - d);                        // wrap around the row
+  float sharp = mix(0.9, 2.4, clamp(uChase, 0.0, 1.5) / 1.5);
+  return exp(-(d * d) * sharp);
+}
+
+// The whole row's emitted light at a fragment.
+vec3 dotsLight(vec2 frag, float minDim){
+  vec2 rel = (frag - uOrigin) / minDim;       // normalized, row-centred (y up)
+  int count = dotCount();
+  float radius = max(liveRadius(), 1e-3);
+
+  // The breathe also gently modulates overall brightness (brighter on the inhale).
+  float breatheB = 1.0 + sin(TAU * uPhase) * uBreathe * 0.5;
+  float gain = uAmp * uExposure * breatheB;
+
+  vec3 col = vec3(0.0);
+  for (int i = 0; i < MAX_DOTS; i++) {
+    if (i >= count) break;
+    float cx = dotCenterX(i, count);
+    vec2 dpos = rel - vec2(cx, 0.0);
+    float dist = length(dpos);
+
+    // Per-dot hue register: stops walk along the row (C0 -> C1 -> C2), so the row
+    // reads as a coherent gradient rather than identical clones.
+    float tcol = (count > 1) ? float(i) / float(count - 1) : 0.5;
+    vec3 dotCol = paletteMix(clamp(tcol, 0.0, 1.0));
+
+    // The pulse brightens whichever dot the head is sweeping over.
+    float lit = pulseLit(i, count);
+    float bright = 0.35 + 0.65 * lit;          // dim base, bright under the pulse
+
+    // 1. CORE: a soft gaussian dot.
+    float cov = exp(-(dist * dist) / (2.0 * radius * radius));
+    col += dotCol * cov * gain * bright;
+
+    // 2. GLOW: a wider, dim ambient halo under each dot.
+    float gr = radius * 2.6;
+    float glow = exp(-(dist * dist) / (2.0 * gr * gr));
+    col += mix(dotCol, uC2, lit * 0.4) * glow * uGlow * gain * 0.3 * bright;
+  }
+  return col;
+}
+
+// ---------------------------------------------------------------------------
+// SHADOW silhouette — the dots are small floating discs, so each casts a faint
+// soft occlusion. Sample the row coverage at the offset shadow point and darken
+// in proportion, kept subtle (small discs throw little shadow).
+float dotsOcclusion(vec2 frag, float minDim){
+  vec2 rel = (frag - uOrigin) / minDim;
+  int count = dotCount();
+  float radius = max(liveRadius(), 1e-3);
+  float occ = 0.0;
+  for (int i = 0; i < MAX_DOTS; i++) {
+    if (i >= count) break;
+    vec2 dpos = rel - vec2(dotCenterX(i, count), 0.0);
+    float dist = length(dpos);
+    occ = max(occ, exp(-(dist * dist) / (2.0 * radius * radius)));
+  }
+  return clamp(occ * uAmp, 0.0, 1.0);
+}
+
+vec4 dotsShadowColor(vec2 frag, float minDim){
+  vec2 sp = frag - uShadowOffset;
+  float soft = uShadowSoft;
+  float occ = dotsOcclusion(sp, minDim);
+  occ += dotsOcclusion(sp + vec2( soft, 0.0), minDim);
+  occ += dotsOcclusion(sp + vec2(-soft, 0.0), minDim);
+  occ += dotsOcclusion(sp + vec2(0.0,  soft), minDim);
+  occ += dotsOcclusion(sp + vec2(0.0, -soft), minDim);
+  occ /= 5.0;
+  float dark = clamp(occ, 0.0, 1.0) * uShadowStrength * 0.5;
+  vec3 tint = mix(vec3(1.0), 0.6 + 0.4 * normalize(uC0 + 1e-3), 0.2);
+  vec3 mul = mix(vec3(1.0), tint, dark);
+  return vec4(mul, 1.0);
+}
+
+void main(){
+  vec2 frag = gl_FragCoord.xy;
+  vec2 res = uResolution;
+  float minDim = min(res.x, res.y);
+
+  if (uShadow > 0.5) {
+    fragColor = dotsShadowColor(frag, minDim);
+    return;
+  }
+
+  vec3 col = dotsLight(frag, minDim);
+
+  // ---- Tone + finishing ----
+  col = tonemapACES(col * 0.95);
+
+  // ---- Non-photoreal pass: cel / flat discs (whimsy). ----
+  // Toward the cel end the soft gaussians become hard flat DISCS and the chase
+  // snaps to a single posterized "lit" dot. The pass-runner already steps the
+  // clock "on twos" (periodic — tempo.loop tiles the grid — so the loop seam
+  // survives); here we flatten the tone.
+  if (uStyle > 0.001) {
+    vec2 rel = (frag - uOrigin) / minDim;
+    int count = dotCount();
+    float radius = max(liveRadius(), 1e-3);
+    float breatheB = 1.0 + sin(TAU * uPhase) * uBreathe * 0.5;
+    float gain = uAmp * uExposure * breatheB;
+    vec3 cel = vec3(0.0);
+    for (int i = 0; i < MAX_DOTS; i++) {
+      if (i >= count) break;
+      vec2 dpos = rel - vec2(dotCenterX(i, count), 0.0);
+      float dist = length(dpos);
+      float disc = 1.0 - smoothstep(radius * 0.85, radius, dist);   // hard flat disc
+      float tcol = (count > 1) ? float(i) / float(count - 1) : 0.5;
+      vec3 dotCol = clamp(paletteMix(clamp(tcol, 0.0, 1.0)) * 1.25, 0.0, 1.2);
+      float lit = pulseLit(i, count);
+      float litStep = step(0.6, lit);                                // one dot lit at a time
+      cel += dotCol * disc * (0.4 + 0.6 * litStep)
+           + mix(uC2, vec3(1.0), 0.5) * disc * litStep * 0.4;
+    }
+    cel *= gain;
+    col = mix(col, cel, uStyle);
+  }
+
+  // Ordered dither (~1/255) to kill banding the screen blend reveals; faded out
+  // toward the cel end where hard discs are intended. Seeded by the LOOP clock,
+  // so even the dither field repeats exactly at the seam.
+  col = ditherAdd(col, frag, uLoopS, 1.0 - uStyle);
+
+  fragColor = vec4(max(col, 0.0), 1.0);
+}`;

package/src/dots.dope.json

@@ -0,0 +1,331 @@
+{
+  "fmt": "dopamine-effect",
+  "v": "1.0.0",
+  "id": "dopamine.loading.dots",
+  "meta": {
+    "name": "Dots",
+    "description": "A calm ambient 'thinking' indicator: a centred row of soft luminous dots that gently breathe while a brightness PULSE travels across them in sequence (the classic typing / loading read). Dopamine's second CONTINUOUS effect — like halo it LOOPS SEAMLESSLY via the first-class tempo.loop contract: all motion is driven by the standard periodic clocks uPhase/uLoopS the runners derive from tempo.loop.periodMs (1000 ms). The parser validates the seam invariants (the period is exactly 12 'animate-on-twos' steps, NPR_TIME_STEP_MS = 1000/12, and durationMs 4000 is exactly 4 periods), so the frame at t==durationMs matches t==0 at every whimsy. The conductor re-arms at durationMs until the host stops the play handle; amp is a steady gentle periodic breathe of phase (NOT envelope(life)), so there is no one-shot fade to break the seam. Fully declarative — no swift/ or android/ folder; the toolchain generates the Metal + Kotlin factories and shaders from this one .dope plus the single GLSL ES 3.00 source.",
+    "tags": [
+      "loading",
+      "ambient",
+      "continuous",
+      "looping",
+      "thinking"
+    ]
+  },
+  "controls": {
+    "mood": {
+      "type": "enum",
+      "default": "celebratory",
+      "options": [
+        "serene",
+        "celebratory",
+        "electric"
+      ],
+      "ui": "segmented"
+    },
+    "intensity": {
+      "type": "scalar",
+      "default": 0.7,
+      "min": 0,
+      "max": 1,
+      "step": 0.01,
+      "ui": "slider"
+    },
+    "whimsy": {
+      "type": "scalar",
+      "default": 0.5,
+      "min": 0,
+      "max": 1,
+      "step": 0.01,
+      "ui": "slider"
+    },
+    "seed": {
+      "type": "int",
+      "default": null,
+      "nullable": true
+    },
+    "origin": {
+      "type": "point",
+      "default": "center"
+    },
+    "target": {
+      "type": "selector",
+      "default": "document.body"
+    }
+  },
+  "baselines": {
+    "serene": {
+      "durationMs": 4000,
+      "lightness": 0.86,
+      "chroma": 0.08,
+      "hueCenter": 225,
+      "hueRange": 110,
+      "dotCount": 3,
+      "dotRadius": 0.032,
+      "dotGap": 0.11,
+      "breathe": 0.16,
+      "chase": 0.6,
+      "glow": 0.5
+    },
+    "celebratory": {
+      "durationMs": 4000,
+      "lightness": 0.82,
+      "chroma": 0.15,
+      "hueCenter": 200,
+      "hueRange": 280,
+      "dotCount": 4,
+      "dotRadius": 0.03,
+      "dotGap": 0.1,
+      "breathe": 0.2,
+      "chase": 0.85,
+      "glow": 0.65
+    },
+    "electric": {
+      "durationMs": 4000,
+      "lightness": 0.8,
+      "chroma": 0.22,
+      "hueCenter": 195,
+      "hueRange": 160,
+      "dotCount": 5,
+      "dotRadius": 0.026,
+      "dotGap": 0.092,
+      "breathe": 0.24,
+      "chase": 1.1,
+      "glow": 0.9
+    }
+  },
+  "palette": {
+    "model": "oklch",
+    "space": "linear-srgb",
+    "generator": "golden-angle",
+    "goldenAngleDeg": 137.50776405003785,
+    "stops": 3,
+    "hueSpread": 0.55,
+    "lightness": {
+      "baseline": "lightness",
+      "perStop": [
+        0,
+        0.06,
+        -0.05
+      ]
+    },
+    "chroma": {
+      "from": {
+        "mul": [
+          {
+            "baseline": "chroma"
+          },
+          {
+            "lerp": [
+              "intensity",
+              0.7,
+              1.5
+            ]
+          }
+        ]
+      },
+      "perStop": [
+        0,
+        0.02,
+        -0.01
+      ]
+    },
+    "seed": {
+      "deterministic": true,
+      "source": "controls.seed",
+      "prng": "mulberry32"
+    },
+    "perMood": {
+      "serene": {
+        "hueCenter": 225,
+        "hueRange": 110,
+        "lightness": 0.86,
+        "chroma": 0.08
+      },
+      "celebratory": {
+        "hueCenter": 200,
+        "hueRange": 280,
+        "lightness": 0.82,
+        "chroma": 0.15
+      },
+      "electric": {
+        "hueCenter": 195,
+        "hueRange": 160,
+        "lightness": 0.8,
+        "chroma": 0.22
+      }
+    }
+  },
+  "tempo": {
+    "durationMs": {
+      "from": {
+        "baseline": "durationMs"
+      }
+    },
+    "loop": {
+      "periodMs": 1000
+    },
+    "frame": {
+      "amp": {
+        "add": [
+          0.85,
+          {
+            "mul": [
+              0.15,
+              {
+                "sin": {
+                  "mul": [
+                    6.283185307179586,
+                    {
+                      "input": "phase"
+                    }
+                  ]
+                }
+              }
+            ]
+          }
+        ]
+      },
+      "extras": {}
+    },
+    "reducedMotion": {
+      "peakMs": 0,
+      "holdMs": 600
+    }
+  },
+  "render": {
+    "params": {
+      "exposure": {
+        "type": "float",
+        "from": {
+          "lerp": [
+            "intensity",
+            0.7,
+            1.45
+          ]
+        }
+      },
+      "dotCount": {
+        "type": "int",
+        "from": {
+          "round": {
+            "baseline": "dotCount"
+          }
+        },
+        "clampMax": "MAX_DOTS",
+        "clampMin": "MIN_DOTS"
+      },
+      "dotRadius": {
+        "type": "float",
+        "from": {
+          "mul": [
+            {
+              "baseline": "dotRadius"
+            },
+            {
+              "lerp": [
+                "intensity",
+                1.2,
+                0.82
+              ]
+            }
+          ]
+        }
+      },
+      "dotGap": {
+        "type": "float",
+        "from": {
+          "baseline": "dotGap"
+        }
+      },
+      "breathe": {
+        "type": "float",
+        "from": {
+          "baseline": "breathe"
+        }
+      },
+      "chase": {
+        "type": "float",
+        "from": {
+          "mul": [
+            {
+              "baseline": "chase"
+            },
+            {
+              "lerp": [
+                "intensity",
+                0.8,
+                1.25
+              ]
+            }
+          ]
+        }
+      },
+      "glow": {
+        "type": "float",
+        "from": {
+          "mul": [
+            {
+              "baseline": "glow"
+            },
+            {
+              "lerp": [
+                "intensity",
+                0.6,
+                1.3
+              ]
+            }
+          ]
+        }
+      },
+      "style": {
+        "type": "float",
+        "from": {
+          "control": "whimsy"
+        }
+      }
+    },
+    "shadowHeightFrac": {
+      "min": [
+        {
+          "add": [
+            {
+              "param": "dotRadius"
+            },
+            0.04
+          ]
+        },
+        1
+      ]
+    },
+    "consts": {
+      "MAX_DOTS": 7,
+      "MIN_DOTS": 2
+    },
+    "config": {
+      "usesOrigin": true
+    },
+    "backends": {
+      "webgl2": {
+        "stage": "fullscreen-triangle",
+        "blend": "screen",
+        "shader": {
+          "program": "dots"
+        }
+      }
+    },
+    "fallbackOrder": [
+      "webgl2"
+    ]
+  },
+  "binding": {
+    "note": "CROSS-PLATFORM uniform-binding contract; SHIPS in the portable .dope. dotsSeed feeds the seeded palette only (no scatterWeb — the shader reads no seed uniform). dotCount is an integer uniform the shader reads to lay out the row. style is whimsy (set automatically), never a uniform.",
+    "excludeParams": [
+      "style"
+    ],
+    "scatterKey": "dotsSeed",
+    "extras": [],
+    "samplers": []
+  }
+}