@3driseai/3drise-core 1.0.1

package/dist/shaders/FlareMaterial.d.ts

@@ -0,0 +1,79 @@
+import { Vector2, Vector3 } from "three";
+import type { Texture } from 'three';
+export interface FlareMaterialUniforms {
+    u_time: {
+        value: number;
+    };
+    u_speed: {
+        value: number;
+    };
+    u_frequency: {
+        value: number;
+    };
+    u_reach: {
+        value: number;
+    };
+    u_intensity: {
+        value: number;
+    };
+    u_decay: {
+        value: number;
+    };
+    u_widthScale: {
+        value: number;
+    };
+    u_fringeIntensity: {
+        value: number;
+    };
+    u_rootColor: {
+        value: Vector3;
+    };
+    u_tipColor: {
+        value: Vector3;
+    };
+    u_shootEnabled: {
+        value: number;
+    };
+    u_shootSpread: {
+        value: number;
+    };
+    u_maskEnabled: {
+        value: number;
+    };
+    u_mask: {
+        type: string;
+        value: Texture | null;
+    };
+    u_resolution: {
+        value: Vector2;
+    };
+    u_center: {
+        value: Vector2;
+    };
+    u_limbScreen: {
+        value: number;
+    };
+}
+declare const FlareMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    u_time: number;
+    u_speed: number;
+    u_frequency: number;
+    u_reach: number;
+    u_intensity: number;
+    u_decay: number;
+    u_widthScale: number;
+    u_fringeIntensity: number;
+    u_rootColor: Vector3;
+    u_tipColor: Vector3;
+    u_shootEnabled: number;
+    u_shootSpread: number;
+    u_maskEnabled: number;
+    u_mask: any;
+    u_resolution: Vector2;
+    u_center: Vector2;
+    u_limbScreen: number;
+}> & {
+    key: string;
+};
+export { FlareMaterial };
+//# sourceMappingURL=FlareMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FlareMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/FlareMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AACzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAIrC,MAAM,WAAW,qBAAqB;IAClC,MAAM,EAAE;QACJ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,OAAO,EAAE;QACL,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,OAAO,EAAE;QACL,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,OAAO,EAAE;QACL,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,iBAAiB,EAAE;QACf,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,UAAU,EAAE;QACR,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,cAAc,EAAE;QACZ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,aAAa,EAAE;QACX,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,aAAa,EAAE;QACX,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,MAAM,EAAE;QACJ,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;KACzB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,QAAQ,EAAE;QACN,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;CACL;AAgKD,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;CAkBa,CAAC;AAGjC,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/shaders/FlareMaterial.js

@@ -0,0 +1,184 @@
+import { Vector2, Vector3 } from "three";
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+import { NOISE_GLSL } from "./sunNoise.js";
+// Vertex shader
+const vertexShader = /*glsl*/ `
+  varying vec2 vLocal;
+  void main() {
+    // Plane geometry is 4.4x4.4 -> vLocal in [-2.2, 2.2] core radii.
+    vLocal = position.xy;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+// Fragment shader
+const fragmentShader = /*glsl*/ `
+  uniform float u_time;
+  uniform float u_speed;
+  uniform float u_frequency;
+  uniform float u_reach;
+  uniform float u_intensity;
+  uniform float u_decay;
+  uniform float u_widthScale;
+  uniform float u_fringeIntensity;
+  uniform vec3 u_rootColor;
+  uniform vec3 u_tipColor;
+  uniform float u_shootEnabled;
+  uniform float u_shootSpread;
+  uniform float u_maskEnabled;
+  uniform sampler2D u_mask;
+  uniform vec2 u_resolution;
+  uniform vec2 u_center;
+  uniform float u_limbScreen;
+  varying vec2 vLocal;
+
+  ${NOISE_GLSL}
+
+  float hash1(float n){ return fract(sin(n) * 43758.5453123); }
+
+  // One full burst system (5 explosive slots + fringe) for a given radial
+  // frame: r is distance in limb units (root at 1), dir/a the direction.
+  // seedOff decouples burst schedules between layers.
+  vec4 burstField(float r, vec2 dir, float a, float t, float seedOff) {
+    vec3 acc = vec3(0.0);
+    float alpha = 0.0;
+
+    for (int i = 0; i < 5; i++) {
+      float fi = float(i) + seedOff;
+      float period = 4.5 + 3.5 * hash1(fi * 7.31 + 1.7);
+      float ph = t * u_frequency / period + hash1(fi * 3.71);
+      float cyc = floor(ph);
+      float s = fract(ph);                 // 0..1 through this burst's life
+      float seed = fi * 19.3 + cyc * 7.07; // new angle/size every cycle
+
+      float ang = hash1(seed) * 6.2831853;
+      float width = (0.10 + 0.10 * hash1(seed + 2.0)) * u_widthScale;
+      float reach = (0.45 + 0.60 * hash1(seed + 4.0)) * u_reach;
+
+      // Explosive envelope: ~0.05s attack, then decay.
+      float env = smoothstep(0.0, 0.05, s) * pow(1.0 - s, u_decay);
+      if (env < 0.01) continue;
+
+      // Decelerating ejection front (fast at launch, slows down).
+      float front = 1.0 + reach * (1.0 - pow(1.0 - s, 2.0));
+
+      float da = a - ang;
+      da = atan(sin(da), cos(da));
+      float angProf = exp(-(da * da) / (2.0 * width * width));
+
+      // Ragged plasma texture streaming outward fast.
+      float rag = 0.6 + 0.4 * (fbm(vec3(dir * 4.0, r * 3.0 - t * 1.2 + fi * 9.0)) * 0.5 + 0.5);
+
+      // Bright shock blob at the front + trailing column back to the root.
+      float blob = exp(-pow((r - front) / 0.12, 2.0));
+      float column = (1.0 - smoothstep(front - 0.5, front + 0.03, r)) * smoothstep(0.95, 1.05, r);
+
+      float e = env * angProf * rag * (blob * 1.8 + column * 0.7) * u_intensity;
+
+      float f = clamp((r - 1.0) / max(front - 1.0, 0.05), 0.0, 1.0);
+      vec3 c = mix(u_rootColor, u_tipColor, f * 0.8);
+
+      acc += c * e;
+      alpha += e;
+    }
+
+    // Faint baseline fringe at the root.
+    float n = fbm(vec3(dir * 3.0, r * 2.2 - t * 0.45)) * 0.5 + 0.5;
+    float f2 = clamp((r - 0.98) / (0.10 + 0.10 * n), 0.0, 1.0);
+    float fringe = (1.0 - f2);
+    fringe *= fringe * n * u_fringeIntensity;
+    acc += mix(u_rootColor * 0.85, u_tipColor * 0.7, f2) * fringe;
+    alpha += fringe;
+
+    return vec4(acc, alpha);
+  }
+
+  void main() {
+    float t = u_time * u_speed;
+
+    // One burst system; u_shootEnabled selects where it roots:
+    // center (shooting) vs limb (circular or silhouette).
+    float r = 0.0;
+    vec2 dir = vec2(1.0, 0.0);
+    bool limbValid = false;
+
+    if (u_shootEnabled > 0.5) {
+      // --- Shooting mode: bursts root at the plane center. With
+      // u_shootSpread = 1.0 a burst travels exactly the same plane
+      // distance as it would from the limb — only the root moves. ---
+      float len = length(vLocal);
+      dir = vLocal / max(len, 1e-4);
+      r = 1.0 + len * u_shootSpread;
+      limbValid = true;
+    } else if (u_maskEnabled > 0.5) {
+      // --- Silhouette mode: the limb is wherever the host's screen-space
+      // mask ends along this fragment's direction from the host center. ---
+      vec2 uv = gl_FragCoord.xy / u_resolution;
+      float aspect = u_resolution.x / u_resolution.y;
+      vec2 p2 = (uv - u_center) * vec2(aspect, 1.0);
+      float dist = length(p2);
+      if (dist > 1e-4) {
+        dir = p2 / dist;
+
+        // FIXED-RANGE march out to the bounding silhouette — never just to
+        // the fragment, or interior fragments find themselves as the edge.
+        float hi = u_limbScreen * 1.05;
+        float stepLen = hi / 32.0;
+        float edge = 0.0;
+        for (int i = 1; i <= 32; i++) {
+          float s = stepLen * float(i);
+          vec2 su = u_center + (dir * s) / vec2(aspect, 1.0);
+          if (texture2D(u_mask, su).r > 0.5) edge = s;
+        }
+        if (edge > 1e-4) {
+          // Binary-search refinement -> sub-pixel edge, smooth limb.
+          float lo2 = edge;
+          float hi2 = min(edge + stepLen, hi);
+          for (int j = 0; j < 6; j++) {
+            float m = 0.5 * (lo2 + hi2);
+            vec2 su = u_center + (dir * m) / vec2(aspect, 1.0);
+            if (texture2D(u_mask, su).r > 0.5) lo2 = m; else hi2 = m;
+          }
+          edge = 0.5 * (lo2 + hi2);
+          r = dist / edge;
+          limbValid = true;
+        }
+      }
+    } else {
+      // --- Circular mode: limb at radius 1 in billboard units. ---
+      r = length(vLocal);
+      dir = vLocal / max(r, 1e-4);
+      limbValid = true;
+    }
+
+    if (!limbValid || r < 0.92 || r > 2.15) discard;
+
+    vec4 b = burstField(r, dir, atan(dir.y, dir.x), t, 0.0);
+    float alpha = clamp(b.a, 0.0, 1.0);
+    if (alpha < 0.01) discard;
+    gl_FragColor = vec4(b.rgb, alpha);
+  }
+`;
+// Create the shader material with uniforms
+const FlareMaterial = shaderMaterial({
+    u_time: 0,
+    u_speed: 1.0,
+    u_frequency: 1.0,
+    u_reach: 1.0,
+    u_intensity: 1.0,
+    u_decay: 2.2,
+    u_widthScale: 1.0,
+    u_fringeIntensity: 0.3,
+    u_rootColor: new Vector3(1.0, 0.92, 0.65),
+    u_tipColor: new Vector3(1.0, 0.35, 0.04),
+    u_shootEnabled: 0.0,
+    u_shootSpread: 1.0,
+    u_maskEnabled: 0.0,
+    u_mask: null,
+    u_resolution: new Vector2(1, 1),
+    u_center: new Vector2(0.5, 0.5),
+    u_limbScreen: 0.25
+}, vertexShader, fragmentShader);
+// Extend the material for use in React Three Fiber
+extend({ FlareMaterial });
+export { FlareMaterial };

package/dist/shaders/GlowMaterial.d.ts

@@ -0,0 +1,41 @@
+import { Vector3 } from "three";
+export interface GlowMaterialUniforms {
+    u_time: {
+        value: number;
+    };
+    u_intensity: {
+        value: number;
+    };
+    u_falloff: {
+        value: number;
+    };
+    u_pulseSpeed: {
+        value: number;
+    };
+    u_pulseAmount: {
+        value: number;
+    };
+    u_shellScale: {
+        value: number;
+    };
+    u_innerColor: {
+        value: Vector3;
+    };
+    u_outerColor: {
+        value: Vector3;
+    };
+}
+declare const GlowMaterial: import("@react-three/fiber").ConstructorRepresentation<import("three").ShaderMaterial & {
+    u_time: number;
+    u_intensity: number;
+    u_falloff: number;
+    u_pulseSpeed: number;
+    u_pulseAmount: number;
+    u_shellScale: number;
+    u_innerColor: Vector3;
+    u_outerColor: Vector3;
+}> & {
+    key: string;
+};
+export { GlowMaterial };
+//# sourceMappingURL=GlowMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GlowMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/GlowMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAGhC,MAAM,WAAW,oBAAoB;IACjC,MAAM,EAAE;QACJ,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,SAAS,EAAE;QACP,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,aAAa,EAAE;QACX,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,OAAO,CAAC;KAClB,CAAC;CACL;AAwCD,QAAA,MAAM,YAAY;;;;;;;;;;;CASc,CAAC;AAGjC,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/shaders/GlowMaterial.js

@@ -0,0 +1,54 @@
+import { Vector3 } from "three";
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+// Vertex shader
+const vertexShader = /*glsl*/ `
+  varying vec3 vNormal;
+  varying vec3 vViewDir;
+  void main() {
+    vNormal = normalize(normalMatrix * normal);
+    vec4 mv = modelViewMatrix * vec4(position, 1.0);
+    vViewDir = normalize(-mv.xyz);
+    gl_Position = projectionMatrix * mv;
+  }
+`;
+// Fragment shader
+const fragmentShader = /*glsl*/ `
+  uniform float u_time;
+  uniform float u_intensity;
+  uniform float u_falloff;
+  uniform float u_pulseSpeed;
+  uniform float u_pulseAmount;
+  uniform float u_shellScale;
+  uniform vec3 u_innerColor;
+  uniform vec3 u_outerColor;
+  varying vec3 vNormal;
+  varying vec3 vViewDir;
+  void main() {
+    // Rendered on a BackSide shell: visible fragments face AWAY from the
+    // camera, so the dot is negative. -dot is 0 at the outer silhouette and
+    // maximal at the core limb. The max depends on the shell scale, so it is
+    // derived from u_shellScale: sqrt(1 - 1/scale^2).
+    float facing = -dot(normalize(vNormal), normalize(vViewDir));
+    float maxFacing = sqrt(max(1.0 - 1.0 / (u_shellScale * u_shellScale), 0.05));
+    float t2 = clamp(facing / maxFacing, 0.0, 1.0);
+    float intensity = pow(t2, u_falloff);
+    intensity *= (1.0 - u_pulseAmount) + u_pulseAmount * (0.5 + 0.5 * sin(u_time * u_pulseSpeed));
+    vec3 col = mix(u_innerColor, u_outerColor, t2);
+    gl_FragColor = vec4(col * intensity * u_intensity, intensity);
+  }
+`;
+// Create the shader material with uniforms
+const GlowMaterial = shaderMaterial({
+    u_time: 0,
+    u_intensity: 1.5,
+    u_falloff: 1.8,
+    u_pulseSpeed: 0.7,
+    u_pulseAmount: 0.3,
+    u_shellScale: 1.25,
+    u_innerColor: new Vector3(1.0, 0.3, 0.03),
+    u_outerColor: new Vector3(1.0, 0.62, 0.22)
+}, vertexShader, fragmentShader);
+// Extend the material for use in React Three Fiber
+extend({ GlowMaterial });
+export { GlowMaterial };

package/dist/shaders/GlyphRingMaterial.d.ts

@@ -0,0 +1,72 @@
+import * as THREE from "three";
+export interface GlyphRingMaterialUniforms {
+    uTime: {
+        value: number;
+    };
+    uRotation: {
+        value: number;
+    };
+    uGlyphCount: {
+        value: number;
+    };
+    uMorphSpeed: {
+        value: number;
+    };
+    uIntensity: {
+        value: number;
+    };
+    uOpacity: {
+        value: number;
+    };
+    uRingColor: {
+        value: THREE.Color;
+    };
+    uGlyphsColor: {
+        value: THREE.Color;
+    };
+    uShadesMultiplier: {
+        value: number;
+    };
+    /** Color a glyph shifts toward when the cursor is hovering near it. */
+    uHoverColor: {
+        value: THREE.Color;
+    };
+    /** Radius of the hover-glow falloff, in NDC units (0..~1.4). */
+    uHoverRadius: {
+        value: number;
+    };
+    /** Strength of the hover effect. 0 = off; 1 = full color swap + glow; higher = brighter. */
+    uHoverIntensity: {
+        value: number;
+    };
+    /** Auto-populated each frame by animateUniforms (NDC pointer, -1..1). */
+    u_mouse: {
+        value: THREE.Vector2;
+    };
+}
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            glyphRingMaterial: any;
+        }
+    }
+}
+declare const GlyphRingMaterial: import("@react-three/fiber").ConstructorRepresentation<THREE.ShaderMaterial & {
+    uTime: number;
+    uRotation: number;
+    uGlyphCount: number;
+    uMorphSpeed: number;
+    uIntensity: number;
+    uOpacity: number;
+    uRingColor: THREE.Color;
+    uGlyphsColor: THREE.Color;
+    uShadesMultiplier: number;
+    uHoverColor: THREE.Color;
+    uHoverRadius: number;
+    uHoverIntensity: number;
+    u_mouse: THREE.Vector2;
+}> & {
+    key: string;
+};
+export { GlyphRingMaterial };
+//# sourceMappingURL=GlyphRingMaterial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GlyphRingMaterial.d.ts","sourceRoot":"","sources":["../../src/shaders/GlyphRingMaterial.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,MAAM,WAAW,yBAAyB;IACtC,KAAK,EAAE;QACH,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,SAAS,EAAE;QACP,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,WAAW,EAAE;QACT,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,UAAU,EAAE;QACR,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,QAAQ,EAAE;QACN,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,UAAU,EAAE;QACR,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC;KACtB,CAAC;IACF,YAAY,EAAE;QACV,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC;KACtB,CAAC;IACF,iBAAiB,EAAE;QACf,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,uEAAuE;IACvE,WAAW,EAAE;QACT,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC;KACtB,CAAC;IACF,gEAAgE;IAChE,YAAY,EAAE;QACV,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,4FAA4F;IAC5F,eAAe,EAAE;QACb,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,yEAAyE;IACzE,OAAO,EAAE;QACL,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC;KACxB,CAAC;CACL;AAED,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,GAAG,CAAC;QACV,UAAU,iBAAiB;YACvB,iBAAiB,EAAE,GAAG,CAAC;SAC1B;KACJ;CACJ;AAsID,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;CAcS,CAAC;AAEjC,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/shaders/GlyphRingMaterial.js

@@ -0,0 +1,152 @@
+import { extend } from "@react-three/fiber";
+import { shaderMaterial } from "@react-three/drei";
+import * as THREE from "three";
+const vertexShader = /* glsl */ `
+  varying vec2 vUv;
+  varying vec4 vClipPos;
+  void main() {
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+    vClipPos = gl_Position;
+  }
+`;
+const fragmentShader = /* glsl */ `
+  uniform float uTime;
+  uniform float uRotation;
+  uniform float uGlyphCount;
+  uniform float uMorphSpeed;
+  uniform float uIntensity;
+  uniform float uOpacity;
+  uniform vec3  uRingColor;
+  uniform vec3  uGlyphsColor;
+  uniform float uShadesMultiplier;
+  uniform vec3  uHoverColor;
+  uniform float uHoverRadius;
+  uniform float uHoverIntensity;
+  uniform vec2  u_mouse;
+  varying vec2  vUv;
+  varying vec4  vClipPos;
+
+  float glyph(vec2 p, float seed) {
+    vec2 ap = abs(p);
+    float bar    = step(ap.x, 0.18) * step(ap.y, 0.78);
+    float ring   = step(abs(length(p) - 0.55), 0.07);
+    float diag   = step(abs(p.x - p.y * sign(seed * 7.0 - 1.0)), 0.12);
+    float cross  = step(ap.y, 0.10) * step(ap.x, 0.78);
+    float spoke  = step(abs(p.y), 0.10) + step(abs(p.x), 0.10);
+    spoke = clamp(spoke, 0.0, 1.0);
+    float s1 = fract(sin(seed * 12.9898) * 43758.5453);
+    float s2 = fract(sin(seed * 78.233)  * 12345.6789);
+    float s3 = fract(sin(seed * 4.821)   * 91812.234);
+    float s4 = fract(sin(seed * 22.1)    * 5532.111);
+    float g = 0.0;
+    g = max(g, bar   * step(0.5, s1));
+    g = max(g, ring  * step(0.4, s2));
+    g = max(g, diag  * step(0.5, s3));
+    g = max(g, cross * step(0.6, s4));
+    g = max(g, spoke * step(0.7, s1 * s4));
+    return g;
+  }
+
+  void main() {
+    vec2 p = vUv * 2.0 - 1.0;
+    float r = length(p);
+    float theta = atan(p.y, p.x);
+    float a = theta / (2.0 * 3.141592653589793) + 0.5 + uRotation;
+    a = fract(a);
+
+    float bandWidth = 0.16;
+    float ringR = 0.55;
+    float ringMask = smoothstep(ringR - bandWidth, ringR - 0.02, r) * (1.0 - smoothstep(ringR + 0.02, ringR + bandWidth, r));
+    if (ringMask < 0.01) discard;
+
+    float cell = floor(a * uGlyphCount);
+    float local = fract(a * uGlyphCount) * 2.0 - 1.0;
+    float radial = (r - ringR) / bandWidth;
+
+    // Discrete morph with crossfade. Each cell picks a new random seed every
+    // tick; we then evaluate the glyph at both the current and next seed and
+    // smoothly mix between them over the back half of the tick. Smooth
+    // interpolation in *seed* space is chaotic (the hash isn't continuous),
+    // but mixing the resulting glyph *masks* gives clean dissolves.
+    // Per-cell phase prevents all cells from morphing in sync.
+    float cellPhase = fract(sin(cell * 91.23) * 5471.31);
+    float morphT = uTime * uMorphSpeed + cellPhase;
+    float morphTick = floor(morphT);
+    float morphMix = smoothstep(0.35, 0.85, fract(morphT));
+
+    float seedA = cell + 1.0 + fract(sin(morphTick * 17.31 + cell * 1.79) * 4391.27) * 7.0;
+    float seedB = cell + 1.0 + fract(sin((morphTick + 1.0) * 17.31 + cell * 1.79) * 4391.27) * 7.0;
+    float gA = glyph(vec2(local, radial * 0.8), seedA);
+    float gB = glyph(vec2(local, radial * 0.8), seedB);
+    float g = mix(gA, gB, morphMix);
+
+    float underline = smoothstep(ringR - 0.06, ringR - 0.02, r) * (1.0 - smoothstep(ringR + 0.02, ringR + 0.06, r));
+
+    // Per-cell shade modulation. Each cell gets three independent signed
+    // offsets per RGB channel (±0.5), scaled by uShadesMultiplier. At 0
+    // there's no variation; at 1 each channel deviates up to ±50% from
+    // glyphsColor; higher values push the tint further. Crucially, the
+    // intensity multiplier is also attenuated proportional to
+    // uShadesMultiplier so the per-cell hue actually survives additive
+    // blending (otherwise everything clamps to white).
+    float dR = (fract(sin(cell * 12.9898 + 1.3) * 43758.5453) - 0.5) * uShadesMultiplier;
+    float dG = (fract(sin(cell * 78.233  + 5.1) * 12345.6789) - 0.5) * uShadesMultiplier;
+    float dB = (fract(sin(cell * 39.346  + 9.7) * 91812.234)  - 0.5) * uShadesMultiplier;
+    vec3 tint = clamp(vec3(1.0) + vec3(dR, dG, dB), 0.0, 1.5);
+    vec3 glyphCol = uGlyphsColor * tint;
+
+    // Hover: per-fragment NDC distance to the cursor with a smoothstep
+    // falloff — 1.0 at the cursor, 0.0 at the radius edge. The color blend
+    // and the brightness boost both use this gradient, so glyphs near the
+    // cursor are fully uHoverColor + bright, glyphs at the radius edge are
+    // fully original. NDC mouse is auto-fed by animateUniforms.
+    vec2 fragNdc = vClipPos.xy / vClipPos.w;
+    float mouseDist = length(fragNdc - u_mouse);
+    float radius = max(uHoverRadius, 0.0001);
+    float hoverActive = step(0.0001, uHoverIntensity);
+    float hoverFalloff = (1.0 - smoothstep(0.0, radius, mouseDist)) * hoverActive;
+    float hoverEffect = hoverFalloff * uHoverIntensity;
+    vec3 hoveredGlyphCol = mix(glyphCol, uHoverColor, hoverFalloff);
+
+    // Color composition: glyph strokes contribute hoveredGlyphCol; the soft
+    // underline contributes uRingColor (unmodulated). Weight by their masks
+    // and normalize.
+    float wG = g;
+    float wR = underline * 0.18;
+    float wTotal = max(wG + wR, 0.0001);
+    vec3 baseColor = (hoveredGlyphCol * wG + uRingColor * wR) / wTotal;
+
+    // Damp the intensity blowout when shades are on so per-cell tints stay
+    // visible instead of saturating to white. Strength scales with
+    // uShadesMultiplier (0 = no damping → normal glow; 1 = ~70% damping).
+    float shadeStrength = clamp(uShadesMultiplier, 0.0, 1.0);
+    float intensityBoost = uIntensity * mix(1.0, 0.3, shadeStrength);
+
+    // Hover boosts the glyph weight (not the underline) so the highlight
+    // reads as "that glyph is lit up" rather than a halo over the ring.
+    float intensity = g * (1.0 + hoverEffect * 2.0) + underline * 0.18;
+    float alpha = ringMask * intensity * uOpacity;
+    if (alpha < 0.005) discard;
+
+    vec3 col = baseColor * (1.0 + intensity * intensityBoost);
+    gl_FragColor = vec4(col, alpha);
+  }
+`;
+const GlyphRingMaterial = shaderMaterial({
+    uTime: 0,
+    uRotation: 0,
+    uGlyphCount: 12,
+    uMorphSpeed: 0.4,
+    uIntensity: 1.5,
+    uOpacity: 1.0,
+    uRingColor: new THREE.Color('#88ccff'),
+    uGlyphsColor: new THREE.Color('#88ccff'),
+    uShadesMultiplier: 0.0,
+    uHoverColor: new THREE.Color('#ffffff'),
+    uHoverRadius: 0.3,
+    uHoverIntensity: 0.0,
+    u_mouse: new THREE.Vector2(0, 0),
+}, vertexShader, fragmentShader);
+extend({ GlyphRingMaterial });
+export { GlyphRingMaterial };