@3driseai/3drise-core 1.0.1 → 1.0.2

package/dist/shaders/QuasiGridMaterial.d.ts

@@ -0,0 +1,76 @@
+import * as THREE from 'three';
+export interface QuasiGridMaterialUniforms {
+    u_time: number;
+    /** spacing between the lines of each family, in world units */
+    u_cellSize: number;
+    /** line thickness, in pixels */
+    u_lineWidth: number;
+    /** every Nth line of each family is an accent line */
+    u_sectionSize: number;
+    /** accent thickness, in pixels; 0 disables the layer */
+    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;
+    /**
+     * 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.
+     */
+    u_symmetry: number;
+    /** shifts every family's offset together, sliding the pattern through itself */
+    u_phase: number;
+}
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        quasiGridMaterial: ThreeElements['shaderMaterial'] & Partial<QuasiGridMaterialUniforms>;
+    }
+}
+export declare const quasiGridMaterialDefaults: QuasiGridMaterialUniforms;
+export declare const QuasiGridMaterial: 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_symmetry: number;
+    u_phase: number;
+}> & {
+    key: string;
+};
+//# sourceMappingURL=QuasiGridMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"QuasiGridMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/QuasiGridMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,MAAM,WAAW,yBAAyB;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,+DAA+D;IAC/D,UAAU,EAAE,MAAM,CAAC;IACnB,gCAAgC;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,sDAAsD;IACtD,aAAa,EAAE,MAAM,CAAC;IACtB,wDAAwD;IACxD,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;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB,gFAAgF;IAChF,OAAO,EAAE,MAAM,CAAC;CACnB;AAED,OAAO,QAAQ,oBAAoB,CAAC;IAChC,UAAU,aAAa;QACnB,iBAAiB,EAAE,aAAa,CAAC,gBAAgB,CAAC,GAAG,OAAO,CAAC,yBAAyB,CAAC,CAAC;KAC3F;CACJ;AAED,eAAO,MAAM,yBAAyB,EAAE,yBAyBvC,CAAC;AA2LF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6B7B,CAAC"}

package/dist/shaders/QuasiGridMaterial.js

@@ -0,0 +1,238 @@
+import * as THREE from 'three';
+import { shaderMaterial } from '@react-three/drei';
+import { extend } from '@react-three/fiber';
+export const quasiGridMaterialDefaults = {
+    u_time: 0,
+    u_cellSize: 3.0,
+    u_lineWidth: 1.2,
+    u_sectionSize: 5.0,
+    u_sectionWidth: 2.0,
+    u_lineColor: new THREE.Color(0.55, 0.3, 0.12),
+    u_sectionColor: new THREE.Color(1.0, 0.78, 0.35),
+    u_cellColor: new THREE.Color(0.22, 0.1, 0.03),
+    u_glowColor: new THREE.Color(1.0, 0.65, 0.25),
+    u_bgColor: new THREE.Color(0.05, 0.02, 0.01),
+    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_symmetry: 5.0,
+    u_phase: 0.2,
+};
+const quasiCommon = /*glsl*/ `
+  const float PI  = 3.14159265359;
+  const float TAU = 6.28318530718;
+
+  float hash21(vec2 p){
+    p = fract(p * vec2(123.34, 456.21));
+    p += dot(p, p + 45.32);
+    return fract(p.x * p.y);
+  }
+`;
+const vertex = /*glsl*/ `
+  uniform float u_time;
+  uniform float u_cellSize;
+  uniform float u_displace;
+  uniform float u_animSpeed;
+  uniform float u_animScale;
+
+  varying vec2 vGridPos;
+
+  ${quasiCommon}
+
+  void main(){
+    vGridPos = position.xy;
+    vec3 pos = position;
+    if (u_displace > 0.0){
+      float t = u_time * u_animSpeed;
+      float d = length(position.xy) / max(u_cellSize, 1e-4);
+      pos.z += sin(d * u_animScale - t) * 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_symmetry;
+  uniform float u_phase;
+
+  varying vec2 vGridPos;
+
+  ${quasiCommon}
+
+  float lineAt(float c, float width, float fp){
+    float d = abs(fract(c - 0.5) - 0.5);
+    return 1.0 - clamp(d / max(fp * max(width, 0.05), 1e-6), 0.0, 1.0);
+  }
+
+  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;
+
+    // de Bruijn's multigrid: N families of evenly spaced parallel lines, spread
+    // over a half turn. Where the angles do not divide the half turn evenly the
+    // intersections never repeat, so the tiling is genuinely aperiodic — pan as
+    // far as you like and the pattern never comes back around.
+    float n = clamp(u_symmetry, 3.0, 9.0);
+
+    float lines  = 0.0;
+    float accent = 0.0;
+    float dmin   = 1e9;   // distance to the nearest line, in line-spacing units
+    float idAcc  = 0.0;   // the cell's integer coordinates, folded into one number
+    vec2  cpos   = vec2(0.0);
+
+    for (int j = 0; j < 9; j++){
+      float fj = float(j);
+      float on = step(fj, n - 0.5);
+
+      float ang = PI * fj / n;
+      vec2  e   = vec2(cos(ang), sin(ang));
+      float d   = dot(coord, e) + u_phase + fj * 0.2;
+      float fp  = max(fwidth(d), 1e-6);
+
+      lines = max(lines, lineAt(d, u_lineWidth, fp) * on);
+
+      if (u_sectionWidth > 0.0 && u_sectionSize > 0.0){
+        float md = d / u_sectionSize;
+        accent = max(accent, lineAt(md, u_sectionWidth, max(fwidth(md), 1e-6)) * on);
+      }
+
+      float k = floor(d);
+      idAcc += on * k * (1.0 + fj * 7.13);
+      cpos  += on * (k + 0.5) * e;
+
+      float fr = fract(d);
+      dmin = min(dmin, mix(1e9, min(fr, 1.0 - fr), on));
+    }
+
+    // Summing dot(p, e_j) * e_j over evenly spread directions returns n/2 times
+    // the original point, so scaling by 2/n puts the cell centre back into the
+    // same units as coord and the ripple distances stay meaningful.
+    vec2 cellPos = cpos * (2.0 / n);
+    float cellH  = hash21(vec2(idAcc * 0.137, idAcc * 0.041 + 7.7));
+
+    // ---- line animation --------------------------------------------------
+    float lineAnim = 1.0;
+    if (u_lineMode > 0.5 && u_lineMode < 1.5){
+      lineAnim = 0.5 + 0.5 * sin(length(cellPos - focus) * u_animScale - t);
+    } else if (u_lineMode < 2.5){
+      lineAnim = 0.5 + 0.5 * sin(dot(cellPos, vec2(0.5, 0.5)) * u_animScale - t);
+    } 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);
+
+    // ---- rhomb fill ------------------------------------------------------
+    float cell = 0.0;
+    if (u_cellMode > 0.5 && u_cellMode < 1.5){
+      cell = 0.5 + 0.5 * sin(idAcc * 0.05 * u_animScale - t);
+    } else if (u_cellMode < 2.5){
+      cell = 0.5 + 0.5 * sin(t * (0.6 + cellH) + cellH * TAU);
+    } else if (u_cellMode < 3.5){
+      cell = smoothstep(0.6, 1.0, sin(length(cellPos - focus) * u_animScale - t));
+    } else if (u_cellMode < 4.5){
+      cell = step(0.5, cellH) * (0.5 + 0.5 * sin(t));
+    }
+    cell *= u_animIntensity;
+    cell *= smoothstep(0.0, 0.16, dmin); // keep the fill off its own edges
+
+    // two rhomb tones, the fat/thin split a Penrose tiling reads by
+    float tone = step(0.55, cellH);
+
+    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 += mix(u_cellColor, u_cellColor * 2.2, tone) * cell;
+    a = max(a, cell * 0.9);
+    float linesI = lines * lineAnim;
+    col += u_lineColor * linesI;            a = max(a, linesI);
+    float accentI = accent * lineAnim;
+    col += u_sectionColor * accentI;        a = max(a, accentI);
+    col += u_glowColor * (linesI * 0.2 + cell * 0.35) * 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 QuasiGridMaterial = shaderMaterial({
+    u_time: quasiGridMaterialDefaults.u_time,
+    u_cellSize: quasiGridMaterialDefaults.u_cellSize,
+    u_lineWidth: quasiGridMaterialDefaults.u_lineWidth,
+    u_sectionSize: quasiGridMaterialDefaults.u_sectionSize,
+    u_sectionWidth: quasiGridMaterialDefaults.u_sectionWidth,
+    u_lineColor: quasiGridMaterialDefaults.u_lineColor.clone(),
+    u_sectionColor: quasiGridMaterialDefaults.u_sectionColor.clone(),
+    u_cellColor: quasiGridMaterialDefaults.u_cellColor.clone(),
+    u_glowColor: quasiGridMaterialDefaults.u_glowColor.clone(),
+    u_bgColor: quasiGridMaterialDefaults.u_bgColor.clone(),
+    u_bgOpacity: quasiGridMaterialDefaults.u_bgOpacity,
+    u_lineMode: quasiGridMaterialDefaults.u_lineMode,
+    u_cellMode: quasiGridMaterialDefaults.u_cellMode,
+    u_animSpeed: quasiGridMaterialDefaults.u_animSpeed,
+    u_animScale: quasiGridMaterialDefaults.u_animScale,
+    u_animIntensity: quasiGridMaterialDefaults.u_animIntensity,
+    u_fadeDistance: quasiGridMaterialDefaults.u_fadeDistance,
+    u_fadeStrength: quasiGridMaterialDefaults.u_fadeStrength,
+    u_focus: quasiGridMaterialDefaults.u_focus.clone(),
+    u_mouse: quasiGridMaterialDefaults.u_mouse.clone(),
+    u_displace: quasiGridMaterialDefaults.u_displace,
+    u_reveal: quasiGridMaterialDefaults.u_reveal,
+    u_symmetry: quasiGridMaterialDefaults.u_symmetry,
+    u_phase: quasiGridMaterialDefaults.u_phase,
+}, vertex, fragment);
+extend({ QuasiGridMaterial });

package/dist/shaders/RadarGridMaterial.d.ts

@@ -0,0 +1,77 @@
+import * as THREE from 'three';
+export interface RadarGridMaterialUniforms {
+    u_time: number;
+    /** spacing between rings, in world units */
+    u_cellSize: number;
+    /** ring/spoke thickness, in pixels */
+    u_lineWidth: number;
+    /** every Nth ring is drawn as a major ring */
+    u_sectionSize: number;
+    /** major-ring, bezel and crosshair thickness, in pixels; 0 hides them */
+    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;
+    /** doubles as the disc radius — the surface is masked to it */
+    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;
+    /** number of radial spokes; 0 disables them */
+    u_spokes: number;
+    /** angular length of the sweep trail, as a fraction of a turn; 0 disables the sweep */
+    u_sweepWidth: number;
+    /** 0..1 — chance that a ring/spoke sector holds a blip */
+    u_blipDensity: number;
+}
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        radarGridMaterial: ThreeElements['shaderMaterial'] & Partial<RadarGridMaterialUniforms>;
+    }
+}
+export declare const radarGridMaterialDefaults: RadarGridMaterialUniforms;
+export declare const RadarGridMaterial: 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_spokes: number;
+    u_sweepWidth: number;
+    u_blipDensity: number;
+}> & {
+    key: string;
+};
+//# sourceMappingURL=RadarGridMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RadarGridMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/RadarGridMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,MAAM,WAAW,yBAAyB;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,4CAA4C;IAC5C,UAAU,EAAE,MAAM,CAAC;IACnB,sCAAsC;IACtC,WAAW,EAAE,MAAM,CAAC;IACpB,8CAA8C;IAC9C,aAAa,EAAE,MAAM,CAAC;IACtB,yEAAyE;IACzE,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,+DAA+D;IAC/D,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,+CAA+C;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,uFAAuF;IACvF,YAAY,EAAE,MAAM,CAAC;IACrB,0DAA0D;IAC1D,aAAa,EAAE,MAAM,CAAC;CACzB;AAED,OAAO,QAAQ,oBAAoB,CAAC;IAChC,UAAU,aAAa;QACnB,iBAAiB,EAAE,aAAa,CAAC,gBAAgB,CAAC,GAAG,OAAO,CAAC,yBAAyB,CAAC,CAAC;KAC3F;CACJ;AAED,eAAO,MAAM,yBAAyB,EAAE,yBA0BvC,CAAC;AA8OF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8B7B,CAAC"}

package/dist/shaders/RadarGridMaterial.js

@@ -0,0 +1,291 @@
+import * as THREE from 'three';
+import { shaderMaterial } from '@react-three/drei';
+import { extend } from '@react-three/fiber';
+export const radarGridMaterialDefaults = {
+    u_time: 0,
+    u_cellSize: 2.5,
+    u_lineWidth: 1.0,
+    u_sectionSize: 4.0,
+    u_sectionWidth: 1.8,
+    u_lineColor: new THREE.Color(0.1, 0.5, 0.34),
+    u_sectionColor: new THREE.Color(0.5, 1.0, 0.72),
+    u_cellColor: new THREE.Color(0.05, 0.2, 0.14),
+    u_glowColor: new THREE.Color(0.35, 1.0, 0.6),
+    u_bgColor: new THREE.Color(0.01, 0.05, 0.03),
+    u_bgOpacity: 0.25,
+    u_lineMode: 1,
+    u_cellMode: 0,
+    u_animSpeed: 1.0,
+    u_animScale: 0.5,
+    u_animIntensity: 1.0,
+    u_fadeDistance: 25.0,
+    u_fadeStrength: 0.25,
+    u_focus: new THREE.Vector2(0, 0),
+    u_mouse: new THREE.Vector2(0, 0),
+    u_displace: 0.0,
+    u_reveal: 1.0,
+    u_spokes: 24.0,
+    u_sweepWidth: 0.13,
+    u_blipDensity: 0.08,
+};
+const radarCommon = /*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);
+  }
+`;
+const vertex = /*glsl*/ `
+  uniform float u_time;
+  uniform float u_cellSize;
+  uniform float u_displace;
+  uniform float u_animSpeed;
+  uniform float u_animScale;
+
+  varying vec2 vGridPos;
+
+  ${radarCommon}
+
+  void main(){
+    vGridPos = position.xy;
+    vec3 pos = position;
+    if (u_displace > 0.0){
+      float t = u_time * u_animSpeed;
+      float d = length(position.xy) / max(u_cellSize, 1e-4);
+      pos.z += sin(d * u_animScale - t) * 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_spokes;
+  uniform float u_sweepWidth;
+  uniform float u_blipDensity;
+
+  varying vec2 vGridPos;
+
+  ${radarCommon}
+
+  /** antialiased line wherever c crosses an integer; fp = footprint of c */
+  float lineAt(float c, float width, float fp){
+    float d = abs(fract(c - 0.5) - 0.5);
+    return 1.0 - clamp(d / max(fp * max(width, 0.05), 1e-6), 0.0, 1.0);
+  }
+
+  void main(){
+    vec2  p = vGridPos;
+    float r = length(p);
+    float ang = atan(p.y, p.x);
+    float radius = max(u_fadeDistance, 1e-4);
+    float rn = r / radius;
+    float t  = u_time * u_animSpeed;
+    float px = max(length(fwidth(p)), 1e-6);
+
+    // ---- rings -----------------------------------------------------------
+    float rc  = r / max(u_cellSize, 1e-4);
+    float rings = lineAt(rc, u_lineWidth, max(fwidth(rc), 1e-6));
+
+    float major = 0.0;
+    if (u_sectionWidth > 0.0 && u_sectionSize > 0.0){
+      float mc = rc / u_sectionSize;
+      major = lineAt(mc, u_sectionWidth, max(fwidth(mc), 1e-6));
+    }
+
+    // ---- spokes ----------------------------------------------------------
+    // fwidth of an angle blows up at the atan seam and at the origin, so it is
+    // clamped and the spokes are faded out of the hub.
+    float sc = 0.0;
+    float spokes = 0.0;
+    if (u_spokes >= 1.0){
+      sc = (ang / TAU + 0.5) * u_spokes;
+      float spx = clamp(fwidth(sc), 1e-6, 0.3);
+      spokes = lineAt(sc, u_lineWidth, spx) * smoothstep(0.0, u_cellSize * 0.7, r);
+    }
+
+    // ---- sweep arm -------------------------------------------------------
+    float sweepA = t * 0.5;
+    float sweep = 0.0;
+    float sweepEdge = 0.0;
+    if (u_sweepWidth > 0.0){
+      float age = fract((sweepA - ang) / TAU); // 0 right at the arm, 1 just before it
+      sweep = exp(-age / max(u_sweepWidth, 1e-3));
+      sweepEdge = 1.0 - smoothstep(0.0, 0.006, age);
+    }
+
+    // ---- contact blips ---------------------------------------------------
+    float blip = 0.0;
+    if (u_blipDensity > 0.0 && u_spokes >= 1.0){
+      vec2 pid = floor(vec2(rc, sc));
+      vec2 hh = hash22(pid);
+      float br = (pid.x + 0.25 + 0.5 * hh.y) * u_cellSize;
+      if (hh.x < u_blipDensity && br > u_cellSize * 1.5 && br < radius * 0.97){
+        float bs = pid.y + 0.25 + 0.5 * fract(hh.y * 13.71);
+        float ba = (bs / u_spokes - 0.5) * TAU;
+        vec2  bp = vec2(cos(ba), sin(ba)) * br;
+        float bRad = u_cellSize * 0.07;
+        float dot0 = 1.0 - smoothstep(bRad, bRad + px * 2.0, length(p - bp));
+        // a contact glows when the arm crosses it, then decays until it returns
+        float age = fract((sweepA - ba) / TAU);
+        blip = dot0 * (u_sweepWidth > 0.0 ? exp(-age * 5.0) : 1.0);
+      }
+    }
+
+    // ---- ring / spoke animation -----------------------------------------
+    float lineAnim = 1.0;
+    float ping = 0.0;
+    if (u_lineMode > 0.5 && u_lineMode < 1.5){
+      // ping rings expanding from the focus point
+      float pd = length(p - u_focus);
+      for (int i = 0; i < 2; i++){
+        float phase = fract(t * 0.25 + float(i) * 0.5);
+        float pr = phase * radius;
+        ping += (1.0 - smoothstep(0.0, px * 2.0 + radius * 0.003, abs(pd - pr))) * (1.0 - phase);
+      }
+    } else if (u_lineMode < 2.5){
+      lineAnim = 0.4 + 0.6 * (0.5 + 0.5 * sin(rc * u_animScale - t));
+    } else if (u_lineMode < 3.5){
+      // spokes lighting in sequence, like a sector scan
+      float s = fract(sc / max(u_spokes, 1.0) - t * 0.12);
+      lineAnim = 0.3 + smoothstep(0.0, 0.1, s) * (1.0 - smoothstep(0.1, 0.3, s));
+    } else if (u_lineMode < 4.5){
+      lineAnim = 0.5 + 0.5 * sin(t);
+    }
+    lineAnim = mix(1.0, lineAnim, u_animIntensity);
+    ping *= u_animIntensity;
+
+    // ---- sector fill -----------------------------------------------------
+    float cell = 0.0;
+    if (u_cellMode > 0.5 && u_spokes >= 1.0){
+      vec2 pid = floor(vec2(rc, sc));
+      vec2 hh = hash22(pid);
+      if (u_cellMode < 1.5){
+        cell = 0.5 + 0.5 * sin(dot(pid, vec2(0.7, 0.3)) * u_animScale - t);
+      } else if (u_cellMode < 2.5){
+        cell = 0.5 + 0.5 * sin(t * (0.6 + hh.x) + hh.y * TAU);
+      } else if (u_cellMode < 3.5){
+        float d = length(p - u_focus) / max(u_cellSize, 1e-4);
+        cell = smoothstep(0.6, 1.0, sin(d * u_animScale - t));
+      } else if (u_cellMode < 4.5){
+        cell = mod(pid.x + pid.y, 2.0) * (0.5 + 0.5 * sin(t));
+      }
+      cell *= u_animIntensity;
+      float fr = abs(fract(rc) - 0.5);
+      float fs = abs(fract(sc) - 0.5);
+      cell *= smoothstep(0.5, 0.35, max(fr, fs));
+    }
+
+    // ---- bezel, crosshair, ticks ----------------------------------------
+    float bezel = 0.0, crosshair = 0.0, ticks = 0.0;
+    if (u_sectionWidth > 0.0){
+      float bw = max(px * u_sectionWidth * 1.5, 1e-6);
+      bezel = 1.0 - clamp(abs(r - radius * 0.99) / bw, 0.0, 1.0);
+
+      vec2 cd = abs(p) / max(px * u_sectionWidth, 1e-6);
+      crosshair = (1.0 - clamp(min(cd.x, cd.y), 0.0, 1.0)) * step(r, radius * 0.99);
+
+      float tc = (ang / TAU + 0.5) * 72.0;
+      ticks = lineAt(tc, 1.0, clamp(fwidth(tc), 1e-6, 0.3))
+            * smoothstep(radius * 0.93, radius * 0.955, r)
+            * (1.0 - smoothstep(radius * 0.975, radius * 0.99, r));
+    }
+
+    float fade = 1.0 - smoothstep(1.0 - u_fadeStrength, 1.0, rn);
+    float disc = 1.0 - smoothstep(0.995, 1.005, rn);
+
+    // ---- compose ---------------------------------------------------------
+    vec3 col = u_bgColor * u_bgOpacity;
+    float a  = u_bgOpacity;
+
+    float ringI  = rings * lineAnim;
+    float majorI = major * lineAnim;
+    float spokeI = spokes * lineAnim;
+
+    col += u_cellColor * cell;                     a = max(a, cell * 0.9);
+    col += u_lineColor * (ringI + spokeI);         a = max(a, max(ringI, spokeI));
+    col += u_sectionColor * majorI;                a = max(a, majorI);
+    col += u_glowColor * sweep * 0.55;             a = max(a, sweep * 0.55);
+    col += u_sectionColor * sweepEdge * 1.2;       a = max(a, sweepEdge);
+    col += u_glowColor * blip * 2.0;               a = max(a, blip);
+    col += u_glowColor * ping * 1.4;               a = max(a, ping);
+
+    col *= fade;
+    a   *= fade;
+
+    // the instrument frame does not fade out with the field it contains
+    col += u_sectionColor * (bezel + ticks + crosshair * 0.55);
+    a = max(a, max(bezel, max(ticks, crosshair * 0.55)));
+
+    col *= disc;
+    a   *= disc;
+
+    // ---- 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 RadarGridMaterial = shaderMaterial({
+    u_time: radarGridMaterialDefaults.u_time,
+    u_cellSize: radarGridMaterialDefaults.u_cellSize,
+    u_lineWidth: radarGridMaterialDefaults.u_lineWidth,
+    u_sectionSize: radarGridMaterialDefaults.u_sectionSize,
+    u_sectionWidth: radarGridMaterialDefaults.u_sectionWidth,
+    u_lineColor: radarGridMaterialDefaults.u_lineColor.clone(),
+    u_sectionColor: radarGridMaterialDefaults.u_sectionColor.clone(),
+    u_cellColor: radarGridMaterialDefaults.u_cellColor.clone(),
+    u_glowColor: radarGridMaterialDefaults.u_glowColor.clone(),
+    u_bgColor: radarGridMaterialDefaults.u_bgColor.clone(),
+    u_bgOpacity: radarGridMaterialDefaults.u_bgOpacity,
+    u_lineMode: radarGridMaterialDefaults.u_lineMode,
+    u_cellMode: radarGridMaterialDefaults.u_cellMode,
+    u_animSpeed: radarGridMaterialDefaults.u_animSpeed,
+    u_animScale: radarGridMaterialDefaults.u_animScale,
+    u_animIntensity: radarGridMaterialDefaults.u_animIntensity,
+    u_fadeDistance: radarGridMaterialDefaults.u_fadeDistance,
+    u_fadeStrength: radarGridMaterialDefaults.u_fadeStrength,
+    u_focus: radarGridMaterialDefaults.u_focus.clone(),
+    u_mouse: radarGridMaterialDefaults.u_mouse.clone(),
+    u_displace: radarGridMaterialDefaults.u_displace,
+    u_reveal: radarGridMaterialDefaults.u_reveal,
+    u_spokes: radarGridMaterialDefaults.u_spokes,
+    u_sweepWidth: radarGridMaterialDefaults.u_sweepWidth,
+    u_blipDensity: radarGridMaterialDefaults.u_blipDensity,
+}, vertex, fragment);
+extend({ RadarGridMaterial });