@3driseai/3drise-viewer 0.1.4 → 0.1.6

package/dist/shaders/VoronoiGridMaterial.d.ts

@@ -0,0 +1,73 @@
+import * as THREE from 'three';
+export interface VoronoiGridMaterialUniforms {
+    u_time: number;
+    /** average cell width, in world units */
+    u_cellSize: number;
+    /** cell-edge thickness, in pixels */
+    u_lineWidth: number;
+    /** how many cells make one accent group */
+    u_sectionSize: number;
+    /** nucleus size; 0 hides the nuclei */
+    u_sectionWidth: number;
+    u_lineColor: THREE.Color;
+    u_sectionColor: THREE.Color;
+    u_cellColor: THREE.Color;
+    u_glowColor: THREE.Color;
+    u_bgColor: THREE.Color;
+    u_bgOpacity: number;
+    u_lineMode: number;
+    u_cellMode: number;
+    u_animSpeed: number;
+    u_animScale: number;
+    u_animIntensity: number;
+    u_fadeDistance: number;
+    u_fadeStrength: number;
+    u_focus: THREE.Vector2;
+    u_mouse: THREE.Vector2;
+    u_displace: number;
+    /**
+     * 0..1 assemble/dissolve. The build boundary sweeps outward from u_focus
+     * with a bright leading edge; 1 is fully built, 0 is gone. Animate it
+     * downward to dissolve.
+     */
+    u_reveal: number;
+    /** 0 = regular square lattice, 1 = fully scattered seeds */
+    u_jitter: number;
+    /** how far the seeds wander over time; 0 freezes the lattice */
+    u_drift: number;
+}
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        voronoiGridMaterial: ThreeElements['shaderMaterial'] & Partial<VoronoiGridMaterialUniforms>;
+    }
+}
+export declare const voronoiGridMaterialDefaults: VoronoiGridMaterialUniforms;
+export declare const VoronoiGridMaterial: import("@react-three/fiber").ConstructorRepresentation<THREE.ShaderMaterial & {
+    u_time: number;
+    u_cellSize: number;
+    u_lineWidth: number;
+    u_sectionSize: number;
+    u_sectionWidth: number;
+    u_lineColor: THREE.Color;
+    u_sectionColor: THREE.Color;
+    u_cellColor: THREE.Color;
+    u_glowColor: THREE.Color;
+    u_bgColor: THREE.Color;
+    u_bgOpacity: number;
+    u_lineMode: number;
+    u_cellMode: number;
+    u_animSpeed: number;
+    u_animScale: number;
+    u_animIntensity: number;
+    u_fadeDistance: number;
+    u_fadeStrength: number;
+    u_focus: THREE.Vector2;
+    u_mouse: THREE.Vector2;
+    u_displace: number;
+    u_reveal: number;
+    u_jitter: number;
+    u_drift: number;
+}> & {
+    key: string;
+};
+//# sourceMappingURL=VoronoiGridMaterial.d.ts.map

package/dist/shaders/VoronoiGridMaterial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VoronoiGridMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/VoronoiGridMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,MAAM,WAAW,2BAA2B;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,yCAAyC;IACzC,UAAU,EAAE,MAAM,CAAC;IACnB,qCAAqC;IACrC,WAAW,EAAE,MAAM,CAAC;IACpB,2CAA2C;IAC3C,aAAa,EAAE,MAAM,CAAC;IACtB,uCAAuC;IACvC,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,KAAK,CAAC,KAAK,CAAC;IACzB,cAAc,EAAE,KAAK,CAAC,KAAK,CAAC;IAC5B,WAAW,EAAE,KAAK,CAAC,KAAK,CAAC;IACzB,WAAW,EAAE,KAAK,CAAC,KAAK,CAAC;IACzB,SAAS,EAAE,KAAK,CAAC,KAAK,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC;IACvB,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB,4DAA4D;IAC5D,QAAQ,EAAE,MAAM,CAAC;IACjB,gEAAgE;IAChE,OAAO,EAAE,MAAM,CAAC;CACnB;AAED,OAAO,QAAQ,oBAAoB,CAAC;IAChC,UAAU,aAAa;QACnB,mBAAmB,EAAE,aAAa,CAAC,gBAAgB,CAAC,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAAC;KAC/F;CACJ;AAED,eAAO,MAAM,2BAA2B,EAAE,2BAyBzC,CAAC;AAuNF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6B/B,CAAC"}

package/dist/shaders/VoronoiGridMaterial.js

@@ -0,0 +1,266 @@
+import * as THREE from 'three';
+import { shaderMaterial } from '@react-three/drei';
+import { extend } from '@react-three/fiber';
+export const voronoiGridMaterialDefaults = {
+    u_time: 0,
+    u_cellSize: 2.0,
+    u_lineWidth: 1.4,
+    u_sectionSize: 4.0,
+    u_sectionWidth: 1.0,
+    u_lineColor: new THREE.Color(0.35, 0.2, 0.62),
+    u_sectionColor: new THREE.Color(0.85, 0.6, 1.0),
+    u_cellColor: new THREE.Color(0.12, 0.05, 0.28),
+    u_glowColor: new THREE.Color(0.7, 0.4, 1.0),
+    u_bgColor: new THREE.Color(0.02, 0.01, 0.05),
+    u_bgOpacity: 0.0,
+    u_lineMode: 1,
+    u_cellMode: 2,
+    u_animSpeed: 1.0,
+    u_animScale: 0.5,
+    u_animIntensity: 1.0,
+    u_fadeDistance: 25.0,
+    u_fadeStrength: 0.7,
+    u_focus: new THREE.Vector2(0, 0),
+    u_mouse: new THREE.Vector2(0, 0),
+    u_displace: 0.0,
+    u_reveal: 1.0,
+    u_jitter: 0.9,
+    u_drift: 0.5,
+};
+/**
+ * Shared by both stages.
+ *
+ * One 3x3 pass yields both the nearest seed distance (F1) and the runner-up
+ * (F2). `F2 - F1` goes to zero exactly on a cell boundary, which is the edge
+ * field — cheaper than a second pass and stable under animation, since it never
+ * has to decide which of two equidistant seeds "won".
+ */
+const voronoiCommon = /*glsl*/ `
+  const float TAU = 6.28318530718;
+
+  vec2 hash22(vec2 p){
+    p = vec2(dot(p, vec2(127.1, 311.7)), dot(p, vec2(269.5, 183.3)));
+    return fract(sin(p) * 43758.5453123);
+  }
+
+  /** x = F1, y = F2, zw = the winning cell's id */
+  vec4 voronoi(vec2 x, float jitter, float drift, float t){
+    vec2 n = floor(x);
+    vec2 f = x - n;
+    float f1 = 8.0;
+    float f2 = 8.0;
+    vec2 winner = n;
+
+    for (int j = -1; j <= 1; j++){
+      for (int i = -1; i <= 1; i++){
+        vec2 g = vec2(float(i), float(j));
+        vec2 h = hash22(n + g);
+        vec2 off = (h - 0.5) * clamp(jitter, 0.0, 1.0);
+        if (drift > 0.0){
+          off += drift * 0.22 * vec2(
+            sin(t * (0.4 + h.x * 0.8) + h.y * TAU),
+            cos(t * (0.4 + h.y * 0.8) + h.x * TAU)
+          );
+        }
+        // Keeping every seed inside its own cell is what makes the 3x3
+        // neighbourhood sufficient — without the clamp, jitter plus drift can
+        // push a seed far enough out that the true nearest one is never tested.
+        vec2 o = vec2(0.5) + clamp(off, vec2(-0.49), vec2(0.49));
+        vec2 r = g + o - f;
+        float d = dot(r, r);
+        if (d < f1){ f2 = f1; f1 = d; winner = n + g; }
+        else if (d < f2){ f2 = d; }
+      }
+    }
+    return vec4(sqrt(f1), sqrt(f2), winner);
+  }
+`;
+const vertex = /*glsl*/ `
+  uniform float u_time;
+  uniform float u_cellSize;
+  uniform float u_displace;
+  uniform float u_animSpeed;
+  uniform float u_animScale;
+  uniform float u_jitter;
+  uniform float u_drift;
+
+  varying vec2 vGridPos;
+
+  ${voronoiCommon}
+
+  void main(){
+    vGridPos = position.xy;
+    vec3 pos = position;
+    if (u_displace > 0.0){
+      float t = u_time * u_animSpeed;
+      vec2 coord = position.xy / max(u_cellSize, 1e-4);
+      vec4 v = voronoi(coord, u_jitter, u_drift, t);
+      vec2 h = hash22(v.zw);
+      // One height per cell, so the surface breaks into irregular plates. The
+      // height rides a smooth field with only a hashed nudge per cell —
+      // uncorrelated neighbours would shred the mesh — and the plate ramps back
+      // to that field near the membrane, so the walls bevel instead of
+      // sawtoothing across whatever triangles straddle the boundary.
+      float smoothLift = 0.5 + 0.5 * sin(length(coord) * u_animScale - t);
+      float plate = clamp(smoothLift + (h.x - 0.5) * 0.5, 0.0, 1.0);
+      float flatness = smoothstep(0.0, 0.3, v.y - v.x);
+      pos.z += mix(smoothLift, plate, flatness) * u_displace;
+    }
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(pos, 1.0);
+  }
+`;
+const fragment = /*glsl*/ `
+  precision highp float;
+
+  uniform float u_time;
+  uniform float u_cellSize;
+  uniform float u_lineWidth;
+  uniform float u_sectionSize;
+  uniform float u_sectionWidth;
+  uniform vec3  u_lineColor;
+  uniform vec3  u_sectionColor;
+  uniform vec3  u_cellColor;
+  uniform vec3  u_glowColor;
+  uniform vec3  u_bgColor;
+  uniform float u_bgOpacity;
+  uniform float u_lineMode;
+  uniform float u_cellMode;
+  uniform float u_animSpeed;
+  uniform float u_animScale;
+  uniform float u_animIntensity;
+  uniform float u_fadeDistance;
+  uniform float u_fadeStrength;
+  uniform vec2  u_focus;
+  uniform float u_reveal;
+  uniform float u_jitter;
+  uniform float u_drift;
+
+  varying vec2 vGridPos;
+
+  ${voronoiCommon}
+
+  void main(){
+    vec2 coord = vGridPos / max(u_cellSize, 1e-4);
+    vec2 focus = u_focus / max(u_cellSize, 1e-4);
+    float t  = u_time * u_animSpeed;
+    float px = max(length(fwidth(coord)), 1e-6);
+
+    vec4 v = voronoi(coord, u_jitter, u_drift, t);
+    float f1 = v.x;
+    float f2 = v.y;
+    vec2 id = v.zw;
+    vec2 h  = hash22(id);
+
+    // membrane between cells
+    float edge = 1.0 - smoothstep(0.0, px * max(u_lineWidth, 0.05) * 2.0, f2 - f1);
+
+    // accent membranes: whole clusters of cells share one group id
+    float group = 0.0;
+    if (u_sectionSize > 0.0){
+      vec2 gid = floor(id / u_sectionSize);
+      group = step(0.5, hash22(gid).x);
+    }
+
+    // ---- membrane animation ---------------------------------------------
+    float lineAnim = 1.0;
+    if (u_lineMode > 0.5 && u_lineMode < 1.5){
+      lineAnim = 0.5 + 0.5 * sin(length(id + 0.5 - focus) * u_animScale - t);
+    } else if (u_lineMode < 2.5){
+      // charge running along the membranes
+      lineAnim = 0.35 + 0.65 * pow(fract(dot(coord, vec2(0.35, 0.2)) * u_animScale - t * 0.25), 6.0);
+    } else if (u_lineMode < 3.5){
+      float s = fract((coord.x + coord.y) * 0.05 * u_animScale - t * 0.15);
+      lineAnim = 0.25 + smoothstep(0.0, 0.15, s) * (1.0 - smoothstep(0.15, 0.35, s));
+    } else if (u_lineMode < 4.5){
+      lineAnim = 0.5 + 0.5 * sin(t);
+    }
+    lineAnim = mix(1.0, lineAnim, u_animIntensity);
+
+    // ---- cell fill ------------------------------------------------------
+    float cell = 0.0;
+    if (u_cellMode > 0.5 && u_cellMode < 1.5){
+      cell = 0.5 + 0.5 * sin(dot(id, vec2(0.7, 0.3)) * u_animScale - t);
+    } else if (u_cellMode < 2.5){
+      cell = 0.5 + 0.5 * sin(t * (0.6 + h.x) + h.y * TAU);
+    } else if (u_cellMode < 3.5){
+      // cells fire in rings out from the focus, like a signal propagating
+      cell = smoothstep(0.6, 1.0, sin(length(id + 0.5 - focus) * u_animScale - t));
+    } else if (u_cellMode < 4.5){
+      cell = step(0.5, h.x) * (0.5 + 0.5 * sin(t));
+    }
+    cell *= u_animIntensity;
+    // brighten the fill toward the nucleus, so each cell reads as a volume
+    // rather than a flat patch
+    cell *= mix(0.45, 1.0, 1.0 - smoothstep(0.0, 0.7, f1));
+
+    // ---- nuclei ---------------------------------------------------------
+    float nucleus = 0.0;
+    if (u_sectionWidth > 0.0){
+      float nr = 0.05 * u_sectionWidth;
+      nucleus = 1.0 - smoothstep(nr, nr + px * 2.0, f1);
+    }
+
+    float r = length(vGridPos) / max(u_fadeDistance, 1e-4);
+    float fade = 1.0 - smoothstep(1.0 - u_fadeStrength, 1.0, r);
+
+    vec3 col = u_bgColor * u_bgOpacity;
+    float a  = u_bgOpacity;
+
+    col += u_cellColor * cell;                        a = max(a, cell * 0.9);
+    float edgeI = edge * lineAnim;
+    col += mix(u_lineColor, u_sectionColor, group) * edgeI;
+    a = max(a, edgeI);
+    float nucI = nucleus * (0.4 + 0.6 * cell + 0.4 * lineAnim);
+    col += u_sectionColor * nucI;                     a = max(a, nucI);
+    col += u_glowColor * (edgeI * 0.25 + nucI * 0.8 + cell * 0.2) * u_animIntensity;
+
+    col *= fade;
+    a   *= fade;
+
+    // ---- reveal ----------------------------------------------------------
+    // The build boundary sweeps outward from the focus point. Its leading band
+    // mostly brightens whatever is already there rather than painting a solid
+    // disc, so the grid reads as assembling itself rather than fading in.
+    if (u_reveal < 0.999){
+      float rd = length(vGridPos - u_focus) / max(u_fadeDistance, 1e-4);
+      // 1.1, not 1.25: the boundary has to clear the fade radius by just the
+      // width of its own soft edge. Overshooting further finishes the build
+      // before reveal reaches 1 and leaves the tail of the range doing nothing.
+      float edge = u_reveal * 1.1;
+      float mask = 1.0 - smoothstep(edge - 0.05, edge, rd);
+      float front = mask * smoothstep(edge - 0.22, edge - 0.05, rd);
+      col = col * mask + u_glowColor * front * (a * 1.8 + 0.08);
+      a   = max(a * mask, front * 0.10);
+    }
+
+    if (a < 0.002) discard;
+    gl_FragColor = vec4(col, a);
+  }
+`;
+export const VoronoiGridMaterial = shaderMaterial({
+    u_time: voronoiGridMaterialDefaults.u_time,
+    u_cellSize: voronoiGridMaterialDefaults.u_cellSize,
+    u_lineWidth: voronoiGridMaterialDefaults.u_lineWidth,
+    u_sectionSize: voronoiGridMaterialDefaults.u_sectionSize,
+    u_sectionWidth: voronoiGridMaterialDefaults.u_sectionWidth,
+    u_lineColor: voronoiGridMaterialDefaults.u_lineColor.clone(),
+    u_sectionColor: voronoiGridMaterialDefaults.u_sectionColor.clone(),
+    u_cellColor: voronoiGridMaterialDefaults.u_cellColor.clone(),
+    u_glowColor: voronoiGridMaterialDefaults.u_glowColor.clone(),
+    u_bgColor: voronoiGridMaterialDefaults.u_bgColor.clone(),
+    u_bgOpacity: voronoiGridMaterialDefaults.u_bgOpacity,
+    u_lineMode: voronoiGridMaterialDefaults.u_lineMode,
+    u_cellMode: voronoiGridMaterialDefaults.u_cellMode,
+    u_animSpeed: voronoiGridMaterialDefaults.u_animSpeed,
+    u_animScale: voronoiGridMaterialDefaults.u_animScale,
+    u_animIntensity: voronoiGridMaterialDefaults.u_animIntensity,
+    u_fadeDistance: voronoiGridMaterialDefaults.u_fadeDistance,
+    u_fadeStrength: voronoiGridMaterialDefaults.u_fadeStrength,
+    u_focus: voronoiGridMaterialDefaults.u_focus.clone(),
+    u_mouse: voronoiGridMaterialDefaults.u_mouse.clone(),
+    u_displace: voronoiGridMaterialDefaults.u_displace,
+    u_reveal: voronoiGridMaterialDefaults.u_reveal,
+    u_jitter: voronoiGridMaterialDefaults.u_jitter,
+    u_drift: voronoiGridMaterialDefaults.u_drift,
+}, vertex, fragment);
+extend({ VoronoiGridMaterial });

package/dist/types/gridConfigs.d.ts

@@ -0,0 +1,202 @@
+/**
+ * Config shapes for the shader-plane grids that live in this package.
+ *
+ * `MyGridConfig` (the square `superGrid`) is owned by `@3driseai/3drise-core`.
+ * These four are declared locally, but they deliberately reuse its field names
+ * — `cellSize`, `lineMode`, `cellMode`, `lineWidth`, `sectionSize`,
+ * `sectionWidth`, `anim*`, `fade*`, `displace` and the colour set — so a
+ * controller panel built for `superGrid` drives all of them with the same
+ * knobs, and presets read the same way across grid types.
+ */
+/** Animation mode for the line/edge layer. Same vocabulary in every grid. */
+export type GridLineMode = 
+/** static */
+0
+/** ripple outward from the focus point */
+ | 1
+/** flow — a travelling wave across the surface */
+ | 2
+/** scan — a bright band sweeping through */
+ | 3
+/** pulse — the whole surface breathes together */
+ | 4;
+/** Animation mode for the cell/fill layer. Same vocabulary in every grid. */
+export type GridCellMode = 
+/** off */
+0
+/** wave — cells light in a smooth gradient */
+ | 1
+/** twinkle — each cell on its own hashed phase */
+ | 2
+/** ripple — cells fire in rings out from the focus point */
+ | 3
+/** alternate — a checker/parity pattern that breathes */
+ | 4;
+/** Fields every shader-plane grid shares, whatever its tiling. */
+export interface GridSurfaceConfig {
+    /** world size of the plane, per side */
+    size: number;
+    /** plane subdivisions per side; auto-derived when omitted, bumped when `displace > 0` */
+    segments?: number;
+    /** lay flat on XZ (true) or stand upright on XY (false) */
+    flat: boolean;
+    /** base size of one tile in world units */
+    cellSize: number;
+    lineMode: GridLineMode;
+    cellMode: GridCellMode;
+    /** line/edge thickness, in pixels */
+    lineWidth: number;
+    /** how many base tiles make one accent group */
+    sectionSize: number;
+    /** accent thickness, in pixels; 0 disables the accent layer */
+    sectionWidth: number;
+    animSpeed: number;
+    animScale: number;
+    animIntensity: number;
+    /** radius at which the grid fades out; defaults to half `size` */
+    fadeDistance?: number;
+    fadeStrength: number;
+    /** vertex displacement along the plane normal; needs a segmented plane */
+    displace: number;
+    lineColor: string;
+    sectionColor: string;
+    cellColor: string;
+    glowColor: string;
+    bgColor: string;
+    bgOpacity: number;
+    /** project the pointer onto the plane and feed it to the focus point */
+    followMouse: boolean;
+    /**
+     * 0..1 assemble amount. The build boundary sweeps outward from the focus
+     * point with a bright leading edge. Defaults to 1 (fully built); animate it
+     * down to 0 to dissolve.
+     */
+    reveal?: number;
+    /**
+     * Seconds to travel the full 0..1 reveal range. Defaults to 0, which
+     * applies `reveal` immediately — a grid does not animate itself in unless
+     * asked. Set ~1.2 for a build-in on mount.
+     */
+    revealDuration?: number;
+}
+/**
+ * Honeycomb tiling. `cellSize` is the hex's flat-to-flat width, `sectionSize`
+ * groups hexes into super-hexes drawn in `sectionColor`.
+ */
+export interface HexGridConfig extends GridSurfaceConfig {
+    /**
+     * With `displace > 0`, each hex lifts to its own height instead of riding a
+     * smooth wave — a plated, tessellated-terrain look with vertical walls.
+     */
+    plateau: boolean;
+}
+/**
+ * Truchet circuit board. Each tile picks one of two arc rotations, so traces
+ * connect across tiles into long meandering paths.
+ */
+export interface CircuitGridConfig extends GridSurfaceConfig {
+    /** 0..1 — fraction of tiles that carry a powered trace */
+    powered: number;
+    /** 0..1 — fraction of tiles replaced by an IC package. 0 disables chips */
+    chipChance: number;
+    /** solder-pad radius as a fraction of a tile; 0 disables pads */
+    padSize: number;
+}
+/**
+ * Voronoi lattice — irregular cells that drift and morph. `cellSize` is the
+ * average cell width; `sectionColor`/`sectionWidth` draw the cell nuclei.
+ */
+export interface VoronoiGridConfig extends GridSurfaceConfig {
+    /** 0 = regular square lattice, 1 = fully scattered seeds */
+    jitter: number;
+    /** how far the seeds wander over time; 0 freezes the lattice */
+    drift: number;
+}
+/**
+ * Polar HUD. `cellSize` is the ring spacing, `sectionSize` marks every Nth ring
+ * as a major ring, and the surface is masked to a disc of `fadeDistance`.
+ */
+export interface RadarGridConfig extends GridSurfaceConfig {
+    /** number of radial spokes; 0 disables them */
+    spokes: number;
+    /** angular length of the sweep trail, as a fraction of a full turn; 0 disables the sweep */
+    sweepWidth: number;
+    /** 0..1 — chance that any given ring/spoke sector holds a blip */
+    blipDensity: number;
+}
+/**
+ * Two overlaid lattices whose near-coincidence produces the interference
+ * pattern. `cellSize` is the base spacing; the second layer differs from the
+ * first by `layerAngle` and `layerScale`.
+ */
+export interface MoireGridConfig extends GridSurfaceConfig {
+    /** lattice shape for both layers */
+    shape: 'square' | 'hex' | 'rings';
+    /** fixed angle between the two layers, in radians. Small values beat slowly */
+    layerAngle: number;
+    /** spacing ratio of the second layer; near 1 gives long, slow beats */
+    layerScale: number;
+    /** counter-rotation speed; 0 freezes the pattern at `layerAngle` */
+    spin: number;
+}
+/**
+ * A quadtree that subdivides toward the focus point, so the lattice is fine
+ * where you are pointing and coarse at the edges. `cellSize` is the level-0
+ * cell; each level halves it.
+ */
+export interface FractalGridConfig extends GridSurfaceConfig {
+    /** maximum subdivision levels, 1..6 */
+    depth: number;
+    /** radius around the focus, in level-0 cells, inside which cells subdivide */
+    splitRadius: number;
+    /** 0..1 — how much the split radius wobbles per cell, for an organic edge */
+    splitJitter: number;
+}
+/**
+ * Topographic iso-lines over an animated terrain field. `cellSize` is the
+ * horizontal scale of the terrain; `sectionSize` marks index contours.
+ *
+ * `displace` is literal here rather than decorative: the vertex stage raises
+ * the surface to exactly the elevation the contours describe.
+ */
+export interface ContourGridConfig extends GridSurfaceConfig {
+    /** number of contour steps across the full height range */
+    levels: number;
+    /** fbm gain — 0.35 rolling, 0.65 craggy */
+    roughness: number;
+    /** domain warp; bends the contours into ridges and valleys */
+    warp: number;
+}
+/**
+ * An aperiodic de Bruijn multigrid — Penrose at the default 5-fold symmetry.
+ * The intersections never repeat, so the pattern never tiles back on itself
+ * however far the camera travels.
+ */
+export interface QuasiGridConfig extends GridSurfaceConfig {
+    /**
+     * How many line families, 3..9. 5 is Penrose. 4 and 6 divide the half-turn
+     * evenly and so come out periodic; everything else is quasiperiodic.
+     */
+    symmetry: number;
+    /** shifts every family's offset together, sliding the pattern through itself */
+    phase: number;
+}
+/** Every grid config this package can render, tagged by `type`. */
+export type AnyGridConfig = (HexGridConfig & {
+    type: 'hexGrid';
+}) | (CircuitGridConfig & {
+    type: 'circuitGrid';
+}) | (VoronoiGridConfig & {
+    type: 'voronoiGrid';
+}) | (RadarGridConfig & {
+    type: 'radarGrid';
+}) | (MoireGridConfig & {
+    type: 'moireGrid';
+}) | (FractalGridConfig & {
+    type: 'fractalGrid';
+}) | (ContourGridConfig & {
+    type: 'contourGrid';
+}) | (QuasiGridConfig & {
+    type: 'quasiGrid';
+});
+//# sourceMappingURL=gridConfigs.d.ts.map

package/dist/types/gridConfigs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gridConfigs.d.ts","sourceRoot":"","sources":["../../src/types/gridConfigs.ts"],"names":[],"mappings":"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"}

package/dist/types/gridConfigs.js

@@ -0,0 +1,11 @@
+/**
+ * Config shapes for the shader-plane grids that live in this package.
+ *
+ * `MyGridConfig` (the square `superGrid`) is owned by `@3driseai/3drise-core`.
+ * These four are declared locally, but they deliberately reuse its field names
+ * — `cellSize`, `lineMode`, `cellMode`, `lineWidth`, `sectionSize`,
+ * `sectionWidth`, `anim*`, `fade*`, `displace` and the colour set — so a
+ * controller panel built for `superGrid` drives all of them with the same
+ * knobs, and presets read the same way across grid types.
+ */
+export {};

package/dist/types/index.d.ts

@@ -1,2 +1,3 @@
 export type { ObjectReadyProps, ObjectReadySource, OnObjectDispose, OnObjectReady, } from './objectReady';
+export type { AnyGridConfig, CircuitGridConfig, ContourGridConfig, FractalGridConfig, GridCellMode, GridLineMode, GridSurfaceConfig, HexGridConfig, MoireGridConfig, QuasiGridConfig, RadarGridConfig, VoronoiGridConfig, } from './gridConfigs';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,EACf,aAAa,GACd,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,EACf,aAAa,GACd,MAAM,eAAe,CAAC;AAEvB,YAAY,EACV,aAAa,EACb,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,YAAY,EACZ,YAAY,EACZ,iBAAiB,EACjB,aAAa,EACb,eAAe,EACf,eAAe,EACf,eAAe,EACf,iBAAiB,GAClB,MAAM,eAAe,CAAC"}

package/dist/utils/handleGenerativeEffectsAnimations.d.ts

@@ -1,5 +1,4 @@
 import * as THREE from 'three';
 import type { AnimationOptions } from "@3driseai/3drise-core";
-export declare const DEBUG_GENERATIVE_EFFECTS = false;
 export declare function applyGenerativeAnimations(materials: THREE.ShaderMaterial[], animations: AnimationOptions[] | undefined, startValuesCache: Record<string, any>, currentTime: number, hovered: boolean): void;
 //# sourceMappingURL=handleGenerativeEffectsAnimations.d.ts.map

package/dist/utils/handleGenerativeEffectsAnimations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"handleGenerativeEffectsAnimations.d.ts","sourceRoot":"","sources":["../../src/utils/handleGenerativeEffectsAnimations.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAuG9D,eAAO,MAAM,wBAAwB,QAAQ,CAAC;AAkF9C,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,KAAK,CAAC,cAAc,EAAE,EAAE,UAAU,EAAE,gBAAgB,EAAE,GAAG,SAAS,EAAE,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CA+D3M"}
+{"version":3,"file":"handleGenerativeEffectsAnimations.d.ts","sourceRoot":"","sources":["../../src/utils/handleGenerativeEffectsAnimations.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAuK9D,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,KAAK,CAAC,cAAc,EAAE,EAAE,UAAU,EAAE,gBAAgB,EAAE,GAAG,SAAS,EAAE,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAoD3M"}

package/dist/utils/handleGenerativeEffectsAnimations.js

@@ -120,24 +120,6 @@ const applyEasing = (easingName, progress) => {
 // =============================================================================
 // DEBUG
 // =============================================================================
-export const DEBUG_GENERATIVE_EFFECTS = false;
-const log = (message, ...args) => {
-    if (DEBUG_GENERATIVE_EFFECTS)
-        console.log(`[GenerativeEffectsAnimations] ${message}`, ...args);
-};
-const _loggedOnce = new Set();
-const logOnce = (key, message, ...args) => {
-    if (_loggedOnce.has(key))
-        return;
-    _loggedOnce.add(key);
-    console.log(`[GenerativeEffectsAnimations] ${message}`, ...args);
-};
-const warnOnce = (key, message, ...args) => {
-    if (_loggedOnce.has(key))
-        return;
-    _loggedOnce.add(key);
-    console.warn(`[GenerativeEffectsAnimations] ${message}`, ...args);
-};
 // =============================================================================
 // HELPERS
 // =============================================================================
@@ -207,31 +189,25 @@ export function applyGenerativeAnimations(materials, animations, startValuesCach
         return;
     if (materials.length === 0)
         return;
-    logOnce('called', `Processing ${animations.length} animation(s) across ${materials.length} material(s)`);
     for (const animation of animations) {
         try {
             const { property, to, duration, ease, loop = false, yoyo = false, active, triggerMode = 'always', } = animation;
             if (active === false) {
-                log(`Skipping "${property}": active=false`);
                 continue;
             }
             if (triggerMode === 'hover' && !hovered) {
-                log(`Skipping "${property}": triggerMode=hover but not hovered`);
                 continue;
             }
             if (to === undefined) {
-                warnOnce(`no-to-${property}`, `Skipping "${property}": no 'to' value defined`);
                 continue;
             }
             const uniformName = findUniformName(materials, property);
             if (!uniformName) {
-                warnOnce(`no-uniform-${property}`, `No uniform found for property "${property}" (tried: ${candidateUniformNames(property).join(', ')}) — available uniforms on mat[0]: ${Object.keys(materials[0]?.uniforms ?? {}).join(', ')}`);
                 continue;
             }
             if (!(property in startValuesCache)) {
                 const currentVal = readUniformValue(materials, uniformName);
                 startValuesCache[property] = animation.from !== undefined ? animation.from : currentVal;
-                log('cached start value', { property, uniformName, startValue: startValuesCache[property] });
             }
             const from = startValuesCache[property];
             if (from === undefined || from === null)
@@ -243,26 +219,21 @@ export function applyGenerativeAnimations(materials, animations, startValuesCach
             }
             if (isColorValue(from)) {
                 if (typeof to !== 'string') {
-                    warnOnce(`bad-to-${property}`, `Color property "${property}" has non-string 'to' value:`, to);
                     continue;
                 }
                 applyColorToMaterials(materials, uniformName, from, to, timeProgress);
             }
             else if (typeof from === 'number') {
                 if (typeof to !== 'number') {
-                    warnOnce(`bad-to-num-${property}`, `Numeric property "${property}" has non-numeric 'to' value:`, to);
                     continue;
                 }
                 applyNumericToMaterials(materials, uniformName, MathUtils.lerp(from, to, timeProgress));
             }
             else {
-                warnOnce(`bad-from-${property}`, `Unhandled 'from' type for property "${property}":`, typeof from, from);
                 continue;
             }
-            log('animated', { property, uniformName, from, to, timeProgress });
         }
         catch (err) {
-            console.error(`[GenerativeEffectsAnimations] Error animating property "${animation.property}":`, err);
         }
     }
 }