@nastechai-research/ui 0.13.2

package/dist/ui/components/overlays/greys.js

@@ -0,0 +1,339 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+import * as THREE from "three";
+import { $gpuTier, useGpuTier } from "../../../hooks/use-gpu-tier.js";
+import { runRenderLoop } from "../../../hooks/use-render-loop.js";
+import { useSmoothControls } from "../../../hooks/use-smooth-controls.js";
+import { cn } from "../../../utils/index.js";
+import { BLEND_MODES } from "./blend-modes.js";
+const vert = (
+  /*glsl*/
+  `
+  varying vec2 vUv;
+  void main() {
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`
+);
+const sourceFrag = (
+  /*glsl*/
+  `
+  uniform sampler2D uTex0, uTex1, uTex2, uTex3;
+  uniform float uTime, uZoom, uSpeed, uRotate, uFolds, uDrift;
+  varying vec2 vUv;
+
+  vec3 gray(vec3 c) { return vec3(dot(c, vec3(.299, .587, .114))); }
+  vec2 rot(vec2 p, float a) { return vec2(p.x * cos(a) - p.y * sin(a), p.x * sin(a) + p.y * cos(a)); }
+
+  vec2 kaleid(vec2 p, float n) {
+    float a = mod(atan(p.y, p.x), 6.28318 / n) - 3.14159 / n;
+    return length(p) * vec2(cos(a), sin(a));
+  }
+
+  vec4 tex(int i, vec2 uv) {
+    if (i == 0) return texture2D(uTex0, uv);
+    if (i == 1) return texture2D(uTex1, uv);
+    if (i == 2) return texture2D(uTex2, uv);
+    return texture2D(uTex3, uv);
+  }
+
+  void main() {
+    vec2 uv = rot(vUv - .5, uTime * uRotate * .05);
+    if (uFolds > 1.) uv = kaleid(uv, uFolds);
+
+    float dt = uTime * uDrift * .1;
+    uv = uv / uZoom + .5 + vec2(sin(dt * .7) * cos(dt * .3), cos(dt * .5) * sin(dt * .9)) * .15 * uDrift;
+
+    float cycle = mod(uTime * uSpeed * .01, 4.);
+    int i0 = int(floor(cycle)), i1 = int(mod(float(i0) + 1., 4.));
+    float t = smoothstep(0., 1., fract(cycle));
+
+    vec3 base = mix(gray(vec3(1.) - tex(i0, uv).rgb), gray(vec3(1.) - tex(i1, uv).rgb), t);
+    vec2 uvF = vec2(1. - uv.x, uv.y);
+    vec3 flip = mix(gray(vec3(1.) - tex(i0, uvF).rgb), gray(vec3(1.) - tex(i1, uvF).rgb), t);
+
+    gl_FragColor = vec4(mix(base, flip, .3 + sin(uTime * .2) * .2), 1.);
+  }
+`
+);
+const moshFrag = (
+  /*glsl*/
+  `
+  uniform sampler2D uCurrent, uPrev, uTex0, uTex1, uTex2, uTex3;
+  uniform float uTime, uIntensity, uMotion, uZoom, uSpeed;
+  uniform vec2 uRes;
+  varying vec2 vUv;
+
+  float hash(vec2 p) { return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453); }
+  vec2 hash2(vec2 p) { return fract(sin(vec2(dot(p, vec2(127.1, 311.7)), dot(p, vec2(269.5, 183.3)))) * 43758.5453); }
+
+  float noise(vec2 p) {
+    vec2 i = floor(p), f = fract(p) * fract(p) * (3. - 2. * fract(p));
+    return mix(mix(hash(i), hash(i + vec2(1., 0.)), f.x), mix(hash(i + vec2(0., 1.)), hash(i + vec2(1., 1.)), f.x), f.y);
+  }
+
+  vec3 gray(vec3 c) { return vec3(dot(c, vec3(.299, .587, .114))); }
+
+  vec2 distort(vec2 uv, float k, float t) {
+    float n1 = noise(uv * 8. + t * .5), n2 = noise(uv * 12. + t * .7), flow = noise(uv * 4. + t * .3);
+    return uv + vec2(cos(n1 * 6.28 + t * 1.2), sin(n2 * 6.28 + t * .9)) * .02 * k
+             + vec2(cos(flow * 6.28 + uv.y * 10.), sin(flow * 6.28 + uv.x * 10.)) * .015 * k;
+  }
+
+  vec3 tex(int i, vec2 uv) {
+    vec2 zuv = (uv - .5) / uZoom + .5;
+    if (i == 0) return gray(vec3(1.) - texture2D(uTex0, zuv).rgb);
+    if (i == 1) return gray(vec3(1.) - texture2D(uTex1, zuv).rgb);
+    if (i == 2) return gray(vec3(1.) - texture2D(uTex2, zuv).rgb);
+    return gray(vec3(1.) - texture2D(uTex3, zuv).rgb);
+  }
+
+  void main() {
+    vec2 uv = vUv;
+    float t = uTime * uSpeed, tS = floor(t * .1), pS = 80.;
+    float amt = uIntensity * uMotion * .8 * (.7 + (sin(t * .5) * .5 + .5) * .3);
+
+    vec2 mUV = distort(uv, uIntensity * .4, t);
+
+    float hS = floor(uv.y * pS), hA = smoothstep(0., .8, hash(vec2(hS, tS)));
+    float hO = (hash(vec2(hS, tS + 50.)) - .5) * .25 * hA * amt;
+    float vS = floor(uv.x * pS), vA = smoothstep(0., .8, hash(vec2(vS, tS + 100.)));
+    float vO = (hash(vec2(vS, tS + 150.)) - .5) * .25 * vA * amt;
+    mUV += vec2(hO, vO);
+
+    float bS = pS * .25;
+    float hBA = step(.5, hash(vec2(floor(uv.y * bS), tS + 200.)));
+    float hBO = (hash(vec2(floor(uv.y * bS), 200.)) - .5) * .35 * hBA * amt;
+    float vBA = step(.5, hash(vec2(floor(uv.x * bS), tS + 300.)));
+    float vBO = (hash(vec2(floor(uv.x * bS), 250.)) - .5) * .35 * vBA * amt;
+    mUV += vec2(hBO, vBO);
+
+    vec2 blk = floor(uv * pS * .15);
+    mUV += (hash2(vec2(blk.x, blk.y + 500.)) - .5) * .4 * step(.7, hash(vec2(blk.x, blk.y + tS))) * amt;
+    mUV = clamp(mUV, 0., 1.);
+
+    vec3 prev = texture2D(uPrev, mUV).rgb;
+    prev = mix(prev, texture2D(uPrev, clamp(uv + vec2(hBO, vBO), 0., 1.)).rgb, max(hBA, vBA) * .9);
+
+    float tY = floor(uv.y * pS * .4);
+    if (hash(vec2(tY, tS + 400.)) > .75) {
+      prev = mix(prev, texture2D(uPrev, clamp(vec2(uv.x + (hash(vec2(tY, 400.)) - .5) * .5 * amt, uv.y), 0., 1.)).rgb, .85);
+    }
+
+    if (hA > 0. && amt > .01) {
+      prev = mix(prev, gray(texture2D(uPrev, clamp(vec2(uv.x + (gray(prev).r - uv.x) * amt + hO, uv.y), 0., 1.)).rgb), hA);
+    }
+
+    float d = mix(mix(.97, .99, noise(uv * 8. + t * .2)), 0., step(.994, hash(vec2(tS, 0.))));
+    gl_FragColor = vec4(mix(texture2D(uCurrent, uv).rgb, prev, d), 1.);
+  }
+`
+);
+const outputFrag = (
+  /*glsl*/
+  `
+  uniform sampler2D uInput;
+  uniform float uTime, uAlpha, uHue;
+  uniform vec3 uColor;
+  varying vec2 vUv;
+
+  float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
+
+  vec3 hueShift(vec3 c, float h) {
+    float a = h * 6.28318, s = sin(a), co = cos(a);
+    vec3 w = vec3(.299, .587, .114);
+    return clamp(vec3(
+      dot(c, w) + dot(c, vec3(.701, -.587, -.114) * co + vec3(.168, .330, -.497) * s),
+      dot(c, w) + dot(c, vec3(-.299, .413, -.114) * co + vec3(.328, .035, -.363) * s),
+      dot(c, w) + dot(c, vec3(-.299, -.587, .886) * co + vec3(-.497, .330, .168) * s)
+    ), 0., 1.);
+  }
+
+  void main() {
+    vec3 m = texture2D(uInput, vUv).rgb;
+    m *= 1. - step(.5, fract(vUv.y * 200.)) * .06 * step(.97, hash(vec2(floor(vUv.y * 30.), floor(uTime * .5))));
+
+    float lum = dot(m, vec3(.299, .587, .114));
+    gl_FragColor = vec4(hueShift(mix(vec3(lum), uColor * lum * 2., length(uColor)), uHue) * uAlpha, smoothstep(.08, .18, lum * uAlpha));
+  }
+`
+);
+const TEXTURES = [
+  "/anatomy/grays-0.jpg",
+  "/anatomy/grays-3.jpg",
+  "/anatomy/grays-6.jpg",
+  "/anatomy/grays-9.jpg"
+];
+export function Greys({ className, style }) {
+  const gpuTier = useGpuTier();
+  const [blendOverride, setBlendOverride] = useState(null);
+  const canvasRef = useRef(null);
+  const c = useSmoothControls(
+    "Effects/Greys",
+    {
+      alpha: { max: 1, min: 0, step: 0.01, value: 0.19 },
+      blend: { options: BLEND_MODES, value: "color-burn" },
+      color: { value: "#ffac02" },
+      drift: { max: 2, min: 0, step: 0.1, value: 0.5 },
+      enabled: { value: false },
+      folds: { max: 12, min: 1, step: 1, value: 1 },
+      hue: { max: 1, min: 0, step: 0.01, value: 0.37 },
+      intensity: { max: 3, min: 0, step: 0.1, value: 0.1 },
+      motion: { max: 2, min: 0, step: 0.1, value: 0.1 },
+      rotate: { max: 2, min: -2, step: 0.1, value: 0.3 },
+      speed: { max: 1, min: 0.01, step: 0.01, value: 0.21 },
+      zoom: { max: 4, min: 0.5, step: 0.1, value: 0.7 }
+    },
+    { collapsed: true }
+  );
+  const cRef = useRef(c);
+  cRef.current = c;
+  useEffect(() => {
+    const onKey = (e) => e.key.toLowerCase() === "x" && setBlendOverride((p) => p === "screen" ? null : "screen");
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, []);
+  const enabled = c.enabled && gpuTier === 2;
+  useEffect(() => {
+    if (!canvasRef.current || !enabled) {
+      return;
+    }
+    let renderer;
+    try {
+      renderer = new THREE.WebGLRenderer({
+        alpha: true,
+        canvas: canvasRef.current
+      });
+    } catch {
+      $gpuTier.set(0);
+      return;
+    }
+    const camera = new THREE.OrthographicCamera(-1, 1, 1, -1, 0, 1);
+    const geo = new THREE.PlaneGeometry(2, 2);
+    const [rtSource, rtA, rtB] = [0, 1, 2].map(
+      () => new THREE.WebGLRenderTarget(innerWidth, innerHeight, {
+        magFilter: THREE.NearestFilter,
+        minFilter: THREE.NearestFilter
+      })
+    );
+    const textures = TEXTURES.map((p) => {
+      const t = new THREE.TextureLoader().load(p);
+      t.wrapS = t.wrapT = THREE.ClampToEdgeWrapping;
+      t.minFilter = t.magFilter = THREE.LinearFilter;
+      return t;
+    });
+    const texU = Object.fromEntries(
+      textures.map((t, i) => [`uTex${i}`, { value: t }])
+    );
+    const srcU = {
+      ...texU,
+      uDrift: { value: 0 },
+      uFolds: { value: 0 },
+      uRotate: { value: 0 },
+      uSpeed: { value: 0 },
+      uTime: { value: 0 },
+      uZoom: { value: 0 }
+    };
+    const moshU = {
+      ...texU,
+      uCurrent: { value: rtSource.texture },
+      uIntensity: { value: 0 },
+      uMotion: { value: 0 },
+      uPrev: { value: rtA.texture },
+      uRes: { value: new THREE.Vector2(innerWidth, innerHeight) },
+      uSpeed: { value: 0 },
+      uTime: { value: 0 },
+      uZoom: { value: 0 }
+    };
+    const outU = {
+      uAlpha: { value: 0 },
+      uColor: { value: new THREE.Color() },
+      uHue: { value: 0 },
+      uInput: { value: rtB.texture },
+      uTime: { value: 0 }
+    };
+    const mkScene = (frag, uniforms, transparent = false) => {
+      const s = new THREE.Scene();
+      s.add(
+        new THREE.Mesh(
+          geo.clone(),
+          new THREE.ShaderMaterial({
+            fragmentShader: frag,
+            transparent,
+            uniforms,
+            vertexShader: vert
+          })
+        )
+      );
+      return s;
+    };
+    const srcScene = mkScene(sourceFrag, srcU);
+    const moshScene = mkScene(moshFrag, moshU);
+    const outScene = mkScene(outputFrag, outU, true);
+    const resize = () => {
+      renderer.setSize(innerWidth, innerHeight);
+      renderer.setPixelRatio(Math.min(devicePixelRatio, 1.5));
+      [rtSource, rtA, rtB].forEach((rt) => rt.setSize(innerWidth, innerHeight));
+      moshU.uRes.value.set(innerWidth, innerHeight);
+    };
+    resize();
+    window.addEventListener("resize", resize);
+    let ping = true, time = 0;
+    const dispose = runRenderLoop({
+      el: canvasRef.current,
+      minIntervalMs: 33,
+      onFrame: (deltaSeconds) => {
+        time += deltaSeconds;
+        const v = cRef.current;
+        srcU.uTime.value = time;
+        srcU.uSpeed.value = v.speed;
+        srcU.uZoom.value = v.zoom;
+        srcU.uRotate.value = v.rotate;
+        srcU.uFolds.value = v.folds;
+        srcU.uDrift.value = v.drift;
+        moshU.uTime.value = time;
+        moshU.uIntensity.value = v.intensity;
+        moshU.uMotion.value = v.motion;
+        moshU.uSpeed.value = v.speed;
+        moshU.uZoom.value = v.zoom;
+        outU.uTime.value = time;
+        outU.uAlpha.value = v.alpha;
+        outU.uHue.value = v.hue;
+        outU.uColor.value.set(typeof v.color === "string" ? v.color : "#fff");
+        renderer.setRenderTarget(rtSource);
+        renderer.render(srcScene, camera);
+        const [read, write] = ping ? [rtA, rtB] : [rtB, rtA];
+        moshU.uPrev.value = read.texture;
+        renderer.setRenderTarget(write);
+        renderer.render(moshScene, camera);
+        outU.uInput.value = write.texture;
+        renderer.setRenderTarget(null);
+        renderer.render(outScene, camera);
+        ping = !ping;
+      }
+    });
+    return () => {
+      window.removeEventListener("resize", resize);
+      dispose();
+      textures.forEach((t) => t.dispose());
+      [geo, rtSource, rtA, rtB, renderer].forEach((x) => x.dispose());
+    };
+  }, [enabled]);
+  if (!enabled) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(
+    "canvas",
+    {
+      className: cn("h-full w-full", className),
+      ref: canvasRef,
+      style: {
+        mixBlendMode: blendOverride ?? c.blend,
+        ...style
+      }
+    }
+  );
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["<stdin>"],
  "sourcesContent": ["'use client'\n\nimport { useEffect, useRef, useState } from 'react'\nimport * as THREE from 'three'\n\nimport { $gpuTier, useGpuTier } from '../../../hooks/use-gpu-tier'\nimport { runRenderLoop } from '../../../hooks/use-render-loop'\nimport { useSmoothControls } from '../../../hooks/use-smooth-controls'\nimport { cn } from '../../../utils'\n\nimport { BLEND_MODES } from './blend-modes'\n\nconst vert = /*glsl*/ `\n  varying vec2 vUv;\n  void main() {\n    vUv = uv;\n    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n  }\n`\n\nconst sourceFrag = /*glsl*/ `\n  uniform sampler2D uTex0, uTex1, uTex2, uTex3;\n  uniform float uTime, uZoom, uSpeed, uRotate, uFolds, uDrift;\n  varying vec2 vUv;\n\n  vec3 gray(vec3 c) { return vec3(dot(c, vec3(.299, .587, .114))); }\n  vec2 rot(vec2 p, float a) { return vec2(p.x * cos(a) - p.y * sin(a), p.x * sin(a) + p.y * cos(a)); }\n\n  vec2 kaleid(vec2 p, float n) {\n    float a = mod(atan(p.y, p.x), 6.28318 / n) - 3.14159 / n;\n    return length(p) * vec2(cos(a), sin(a));\n  }\n\n  vec4 tex(int i, vec2 uv) {\n    if (i == 0) return texture2D(uTex0, uv);\n    if (i == 1) return texture2D(uTex1, uv);\n    if (i == 2) return texture2D(uTex2, uv);\n    return texture2D(uTex3, uv);\n  }\n\n  void main() {\n    vec2 uv = rot(vUv - .5, uTime * uRotate * .05);\n    if (uFolds > 1.) uv = kaleid(uv, uFolds);\n\n    float dt = uTime * uDrift * .1;\n    uv = uv / uZoom + .5 + vec2(sin(dt * .7) * cos(dt * .3), cos(dt * .5) * sin(dt * .9)) * .15 * uDrift;\n\n    float cycle = mod(uTime * uSpeed * .01, 4.);\n    int i0 = int(floor(cycle)), i1 = int(mod(float(i0) + 1., 4.));\n    float t = smoothstep(0., 1., fract(cycle));\n\n    vec3 base = mix(gray(vec3(1.) - tex(i0, uv).rgb), gray(vec3(1.) - tex(i1, uv).rgb), t);\n    vec2 uvF = vec2(1. - uv.x, uv.y);\n    vec3 flip = mix(gray(vec3(1.) - tex(i0, uvF).rgb), gray(vec3(1.) - tex(i1, uvF).rgb), t);\n\n    gl_FragColor = vec4(mix(base, flip, .3 + sin(uTime * .2) * .2), 1.);\n  }\n`\n\nconst moshFrag = /*glsl*/ `\n  uniform sampler2D uCurrent, uPrev, uTex0, uTex1, uTex2, uTex3;\n  uniform float uTime, uIntensity, uMotion, uZoom, uSpeed;\n  uniform vec2 uRes;\n  varying vec2 vUv;\n\n  float hash(vec2 p) { return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453); }\n  vec2 hash2(vec2 p) { return fract(sin(vec2(dot(p, vec2(127.1, 311.7)), dot(p, vec2(269.5, 183.3)))) * 43758.5453); }\n\n  float noise(vec2 p) {\n    vec2 i = floor(p), f = fract(p) * fract(p) * (3. - 2. * fract(p));\n    return mix(mix(hash(i), hash(i + vec2(1., 0.)), f.x), mix(hash(i + vec2(0., 1.)), hash(i + vec2(1., 1.)), f.x), f.y);\n  }\n\n  vec3 gray(vec3 c) { return vec3(dot(c, vec3(.299, .587, .114))); }\n\n  vec2 distort(vec2 uv, float k, float t) {\n    float n1 = noise(uv * 8. + t * .5), n2 = noise(uv * 12. + t * .7), flow = noise(uv * 4. + t * .3);\n    return uv + vec2(cos(n1 * 6.28 + t * 1.2), sin(n2 * 6.28 + t * .9)) * .02 * k\n             + vec2(cos(flow * 6.28 + uv.y * 10.), sin(flow * 6.28 + uv.x * 10.)) * .015 * k;\n  }\n\n  vec3 tex(int i, vec2 uv) {\n    vec2 zuv = (uv - .5) / uZoom + .5;\n    if (i == 0) return gray(vec3(1.) - texture2D(uTex0, zuv).rgb);\n    if (i == 1) return gray(vec3(1.) - texture2D(uTex1, zuv).rgb);\n    if (i == 2) return gray(vec3(1.) - texture2D(uTex2, zuv).rgb);\n    return gray(vec3(1.) - texture2D(uTex3, zuv).rgb);\n  }\n\n  void main() {\n    vec2 uv = vUv;\n    float t = uTime * uSpeed, tS = floor(t * .1), pS = 80.;\n    float amt = uIntensity * uMotion * .8 * (.7 + (sin(t * .5) * .5 + .5) * .3);\n\n    vec2 mUV = distort(uv, uIntensity * .4, t);\n\n    float hS = floor(uv.y * pS), hA = smoothstep(0., .8, hash(vec2(hS, tS)));\n    float hO = (hash(vec2(hS, tS + 50.)) - .5) * .25 * hA * amt;\n    float vS = floor(uv.x * pS), vA = smoothstep(0., .8, hash(vec2(vS, tS + 100.)));\n    float vO = (hash(vec2(vS, tS + 150.)) - .5) * .25 * vA * amt;\n    mUV += vec2(hO, vO);\n\n    float bS = pS * .25;\n    float hBA = step(.5, hash(vec2(floor(uv.y * bS), tS + 200.)));\n    float hBO = (hash(vec2(floor(uv.y * bS), 200.)) - .5) * .35 * hBA * amt;\n    float vBA = step(.5, hash(vec2(floor(uv.x * bS), tS + 300.)));\n    float vBO = (hash(vec2(floor(uv.x * bS), 250.)) - .5) * .35 * vBA * amt;\n    mUV += vec2(hBO, vBO);\n\n    vec2 blk = floor(uv * pS * .15);\n    mUV += (hash2(vec2(blk.x, blk.y + 500.)) - .5) * .4 * step(.7, hash(vec2(blk.x, blk.y + tS))) * amt;\n    mUV = clamp(mUV, 0., 1.);\n\n    vec3 prev = texture2D(uPrev, mUV).rgb;\n    prev = mix(prev, texture2D(uPrev, clamp(uv + vec2(hBO, vBO), 0., 1.)).rgb, max(hBA, vBA) * .9);\n\n    float tY = floor(uv.y * pS * .4);\n    if (hash(vec2(tY, tS + 400.)) > .75) {\n      prev = mix(prev, texture2D(uPrev, clamp(vec2(uv.x + (hash(vec2(tY, 400.)) - .5) * .5 * amt, uv.y), 0., 1.)).rgb, .85);\n    }\n\n    if (hA > 0. && amt > .01) {\n      prev = mix(prev, gray(texture2D(uPrev, clamp(vec2(uv.x + (gray(prev).r - uv.x) * amt + hO, uv.y), 0., 1.)).rgb), hA);\n    }\n\n    float d = mix(mix(.97, .99, noise(uv * 8. + t * .2)), 0., step(.994, hash(vec2(tS, 0.))));\n    gl_FragColor = vec4(mix(texture2D(uCurrent, uv).rgb, prev, d), 1.);\n  }\n`\n\nconst outputFrag = /*glsl*/ `\n  uniform sampler2D uInput;\n  uniform float uTime, uAlpha, uHue;\n  uniform vec3 uColor;\n  varying vec2 vUv;\n\n  float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }\n\n  vec3 hueShift(vec3 c, float h) {\n    float a = h * 6.28318, s = sin(a), co = cos(a);\n    vec3 w = vec3(.299, .587, .114);\n    return clamp(vec3(\n      dot(c, w) + dot(c, vec3(.701, -.587, -.114) * co + vec3(.168, .330, -.497) * s),\n      dot(c, w) + dot(c, vec3(-.299, .413, -.114) * co + vec3(.328, .035, -.363) * s),\n      dot(c, w) + dot(c, vec3(-.299, -.587, .886) * co + vec3(-.497, .330, .168) * s)\n    ), 0., 1.);\n  }\n\n  void main() {\n    vec3 m = texture2D(uInput, vUv).rgb;\n    m *= 1. - step(.5, fract(vUv.y * 200.)) * .06 * step(.97, hash(vec2(floor(vUv.y * 30.), floor(uTime * .5))));\n\n    float lum = dot(m, vec3(.299, .587, .114));\n    gl_FragColor = vec4(hueShift(mix(vec3(lum), uColor * lum * 2., length(uColor)), uHue) * uAlpha, smoothstep(.08, .18, lum * uAlpha));\n  }\n`\n\nconst TEXTURES = [\n  '/anatomy/grays-0.jpg',\n  '/anatomy/grays-3.jpg',\n  '/anatomy/grays-6.jpg',\n  '/anatomy/grays-9.jpg'\n]\n\nexport function Greys({ className, style }: GreysProps) {\n  const gpuTier = useGpuTier()\n  const [blendOverride, setBlendOverride] = useState<string | null>(null)\n  const canvasRef = useRef<HTMLCanvasElement>(null)\n\n  const c = useSmoothControls(\n    'Effects/Greys',\n    {\n      alpha: { max: 1, min: 0, step: 0.01, value: 0.19 },\n      blend: { options: BLEND_MODES, value: 'color-burn' },\n      color: { value: '#ffac02' },\n      drift: { max: 2, min: 0, step: 0.1, value: 0.5 },\n      enabled: { value: false },\n      folds: { max: 12, min: 1, step: 1, value: 1 },\n      hue: { max: 1, min: 0, step: 0.01, value: 0.37 },\n      intensity: { max: 3, min: 0, step: 0.1, value: 0.1 },\n      motion: { max: 2, min: 0, step: 0.1, value: 0.1 },\n      rotate: { max: 2, min: -2, step: 0.1, value: 0.3 },\n      speed: { max: 1, min: 0.01, step: 0.01, value: 0.21 },\n      zoom: { max: 4, min: 0.5, step: 0.1, value: 0.7 }\n    },\n    { collapsed: true }\n  )\n\n  const cRef = useRef(c)\n  cRef.current = c\n\n  useEffect(() => {\n    const onKey = (e: KeyboardEvent) =>\n      e.key.toLowerCase() === 'x' &&\n      setBlendOverride(p => (p === 'screen' ? null : 'screen'))\n\n    window.addEventListener('keydown', onKey)\n\n    return () => window.removeEventListener('keydown', onKey)\n  }, [])\n\n  const enabled = c.enabled && gpuTier === 2\n\n  useEffect(() => {\n    if (!canvasRef.current || !enabled) {\n      return\n    }\n\n    let renderer: THREE.WebGLRenderer\n\n    try {\n      renderer = new THREE.WebGLRenderer({\n        alpha: true,\n        canvas: canvasRef.current\n      })\n    } catch {\n      // See note in noise.tsx \u2014 eager gpu-tier detection should keep us\n      // out of here, but if the driver fails the renderer constructor\n      // anyway, downgrade so other overlays stop trying too.\n      $gpuTier.set(0)\n\n      return\n    }\n\n    const camera = new THREE.OrthographicCamera(-1, 1, 1, -1, 0, 1)\n    const geo = new THREE.PlaneGeometry(2, 2)\n\n    const [rtSource, rtA, rtB] = [0, 1, 2].map(\n      () =>\n        new THREE.WebGLRenderTarget(innerWidth, innerHeight, {\n          magFilter: THREE.NearestFilter,\n          minFilter: THREE.NearestFilter\n        })\n    )\n\n    const textures = TEXTURES.map(p => {\n      const t = new THREE.TextureLoader().load(p)\n      t.wrapS = t.wrapT = THREE.ClampToEdgeWrapping\n      t.minFilter = t.magFilter = THREE.LinearFilter\n\n      return t\n    })\n\n    const texU = Object.fromEntries(\n      textures.map((t, i) => [`uTex${i}`, { value: t }])\n    )\n\n    const srcU = {\n      ...texU,\n      uDrift: { value: 0 },\n      uFolds: { value: 0 },\n      uRotate: { value: 0 },\n      uSpeed: { value: 0 },\n      uTime: { value: 0 },\n      uZoom: { value: 0 }\n    }\n\n    const moshU = {\n      ...texU,\n      uCurrent: { value: rtSource.texture },\n      uIntensity: { value: 0 },\n      uMotion: { value: 0 },\n      uPrev: { value: rtA.texture },\n      uRes: { value: new THREE.Vector2(innerWidth, innerHeight) },\n      uSpeed: { value: 0 },\n      uTime: { value: 0 },\n      uZoom: { value: 0 }\n    }\n\n    const outU = {\n      uAlpha: { value: 0 },\n      uColor: { value: new THREE.Color() },\n      uHue: { value: 0 },\n      uInput: { value: rtB.texture },\n      uTime: { value: 0 }\n    }\n\n    const mkScene = (frag: string, uniforms: object, transparent = false) => {\n      const s = new THREE.Scene()\n      s.add(\n        new THREE.Mesh(\n          geo.clone(),\n          new THREE.ShaderMaterial({\n            fragmentShader: frag,\n            transparent,\n            uniforms: uniforms as Record<string, THREE.IUniform<any>>,\n            vertexShader: vert\n          })\n        )\n      )\n\n      return s\n    }\n\n    const srcScene = mkScene(sourceFrag, srcU)\n    const moshScene = mkScene(moshFrag, moshU)\n    const outScene = mkScene(outputFrag, outU, true)\n\n    const resize = () => {\n      renderer.setSize(innerWidth, innerHeight)\n      // Cap at 1.5x \u2014 Greys does triple-buffered ping-pong rendering at\n      // every frame, so retina x2 is brutal on fillrate.\n      renderer.setPixelRatio(Math.min(devicePixelRatio, 1.5))\n      ;[rtSource, rtA, rtB].forEach(rt => rt.setSize(innerWidth, innerHeight))\n      moshU.uRes.value.set(innerWidth, innerHeight)\n    }\n\n    resize()\n    window.addEventListener('resize', resize)\n\n    let ping = true,\n      time = 0\n\n    // 30fps cap \u2014 feedback effect, no perceptual loss vs 60fps but\n    // halves the cost of the heaviest overlay we ship.\n    const dispose = runRenderLoop({\n      el: canvasRef.current,\n      minIntervalMs: 33,\n      onFrame: deltaSeconds => {\n        time += deltaSeconds\n\n        const v = cRef.current\n\n        srcU.uTime.value = time\n        srcU.uSpeed.value = v.speed\n        srcU.uZoom.value = v.zoom\n        srcU.uRotate.value = v.rotate\n        srcU.uFolds.value = v.folds\n        srcU.uDrift.value = v.drift\n\n        moshU.uTime.value = time\n        moshU.uIntensity.value = v.intensity\n        moshU.uMotion.value = v.motion\n        moshU.uSpeed.value = v.speed\n        moshU.uZoom.value = v.zoom\n\n        outU.uTime.value = time\n        outU.uAlpha.value = v.alpha\n        outU.uHue.value = v.hue\n        outU.uColor.value.set(typeof v.color === 'string' ? v.color : '#fff')\n\n        renderer.setRenderTarget(rtSource)\n        renderer.render(srcScene, camera)\n\n        const [read, write] = ping ? [rtA, rtB] : [rtB, rtA]\n        moshU.uPrev.value = read.texture\n        renderer.setRenderTarget(write)\n        renderer.render(moshScene, camera)\n\n        outU.uInput.value = write.texture\n        renderer.setRenderTarget(null)\n        renderer.render(outScene, camera)\n\n        ping = !ping\n      }\n    })\n\n    return () => {\n      window.removeEventListener('resize', resize)\n      dispose()\n      textures.forEach(t => t.dispose())\n      ;[geo, rtSource, rtA, rtB, renderer].forEach(x => x.dispose())\n    }\n  }, [enabled])\n\n  if (!enabled) {\n    return null\n  }\n\n  return (\n    <canvas\n      className={cn('h-full w-full', className)}\n      ref={canvasRef}\n      style={{\n        mixBlendMode: (blendOverride ??\n          c.blend) as React.CSSProperties['mixBlendMode'],\n        ...style\n      }}\n    />\n  )\n}\n\ninterface GreysProps {\n  className?: string\n  style?: React.CSSProperties\n}"],
  "mappings": "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",
  "names": []
}


package/dist/ui/components/overlays/index.d.ts

@@ -0,0 +1,14 @@
+import type { LensPreset } from './lens';
+export { BLEND_MODES } from './blend-modes';
+export { Glitch } from './glitch';
+export { Greys } from './greys';
+export { Lens } from './lens-layers';
+export { Noise } from './noise';
+export { Vignette } from './vignette';
+export { $lightMode, applyLens, lens0, lens5i, LENS_0, LENS_5I, LENSES, toggleLens } from './lens';
+export type { LensPreset } from './lens';
+export declare function Overlays({ dark, initial }: OverlaysProps): import("react").JSX.Element;
+interface OverlaysProps {
+    dark?: boolean;
+    initial?: LensPreset;
+}

package/dist/ui/components/overlays/index.js

@@ -0,0 +1,34 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Glitch } from "./glitch.js";
+import { Greys } from "./greys.js";
+import { Lens } from "./lens-layers.js";
+import { Noise } from "./noise.js";
+import { Vignette } from "./vignette.js";
+export { BLEND_MODES } from "./blend-modes.js";
+export { Glitch } from "./glitch.js";
+export { Greys } from "./greys.js";
+export { Lens } from "./lens-layers.js";
+export { Noise } from "./noise.js";
+export { Vignette } from "./vignette.js";
+export {
+  $lightMode,
+  applyLens,
+  lens0,
+  lens5i,
+  LENS_0,
+  LENS_5I,
+  LENSES,
+  toggleLens
+} from "./lens";
+const LAYER = "pointer-events-none fixed inset-0";
+export function Overlays({ dark, initial }) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Lens, { dark, initial }),
+    /* @__PURE__ */ jsx(Noise, { className: LAYER, style: { zIndex: 101 } }),
+    /* @__PURE__ */ jsx(Vignette, { className: LAYER, style: { zIndex: 99 } }),
+    /* @__PURE__ */ jsx(Greys, { className: LAYER, style: { zIndex: 200 } }),
+    /* @__PURE__ */ jsx(Glitch, { className: LAYER, style: { zIndex: 201 } })
+  ] });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ui/components/overlays/lens-layers.d.ts

@@ -0,0 +1,14 @@
+import { type LensPreset } from './lens';
+export declare function Lens({ dark, initial }: LensProps): import("react").JSX.Element;
+interface LensProps {
+    dark?: boolean;
+    /**
+     * Exact preset to seed the internal Leva controls with. When omitted the
+     * component falls back to `LENS_0` / `LENS_5I` based on `dark`. Pass the
+     * actual preset from a host (e.g. Storybook toolbar) to guarantee the
+     * first-paint colors match the selected lens without needing a followup
+     * `applyLens` that can be lost in useSmoothControls' startup window.
+     */
+    initial?: LensPreset;
+}
+export {};

package/dist/ui/components/overlays/lens-layers.js

@@ -0,0 +1,95 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useEffect } from "react";
+import { useSmoothControls } from "../../../hooks/use-smooth-controls.js";
+import { colorMix } from "../../../utils/color.js";
+import fillerBg from "../../../assets/filler-bg0.webp";
+import { BLEND_MODES } from "./blend-modes.js";
+import { $lightMode, LENS_0, LENS_5I, toggleLens } from "./lens.js";
+const LAYER = "pointer-events-none fixed inset-0";
+export function Lens({ dark, initial }) {
+  const base = initial?.Lens ?? (dark ? LENS_0.Lens : LENS_5I.Lens);
+  const lens = useSmoothControls(
+    "Lens",
+    {
+      bgBlend: { options: BLEND_MODES, value: base.bgBlend },
+      bgColor: { value: base.bgColor },
+      bgOpacity: { max: 1, min: 0, step: 0.01, value: base.bgOpacity },
+      fgBlend: { options: BLEND_MODES, value: "difference" },
+      fgColor: { value: base.fgColor },
+      fgOpacity: { max: 1, min: 0, step: 0.01, value: base.fgOpacity },
+      fillerBlend: { options: BLEND_MODES, value: "difference" },
+      fillerOpacity: { max: 1, min: 0, step: 0.01, value: base.fillerOpacity },
+      mgColor: { value: base.mgColor },
+      mgOpacity: { max: 1, min: 0, step: 0.01, value: base.mgOpacity }
+    },
+    { collapsed: false }
+  );
+  useEffect(() => {
+    $lightMode.set(!dark);
+  }, [dark]);
+  useEffect(() => {
+    const s = document.documentElement.style;
+    for (const [name, color, alpha] of [
+      ["foreground", lens.fgColor, lens.fgOpacity],
+      ["midground", lens.mgColor, lens.mgOpacity],
+      ["background", lens.bgColor, lens.bgOpacity]
+    ]) {
+      s.setProperty(`--${name}`, colorMix(color, alpha));
+      s.setProperty(`--${name}-base`, color);
+      s.setProperty(`--${name}-alpha`, `${alpha}`);
+    }
+  }, [lens]);
+  useEffect(() => {
+    const handle = (e) => e.key === "x" && toggleLens();
+    window.addEventListener("keydown", handle);
+    return () => window.removeEventListener("keydown", handle);
+  }, []);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: LAYER,
+        style: {
+          backgroundColor: colorMix(lens.fgColor, lens.fgOpacity),
+          mixBlendMode: lens.fgBlend,
+          zIndex: 100
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: LAYER,
+        style: {
+          mixBlendMode: lens.fillerBlend,
+          opacity: lens.fillerOpacity,
+          zIndex: 2
+        },
+        children: /* @__PURE__ */ jsx(
+          "img",
+          {
+            alt: "",
+            className: "h-[150dvh] w-auto min-w-dvw object-cover object-top-left invert",
+            fetchPriority: "low",
+            height: 1024,
+            src: fillerBg.src,
+            width: 1024
+          }
+        )
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: LAYER,
+        style: {
+          backgroundColor: colorMix(lens.bgColor, lens.bgOpacity),
+          mixBlendMode: lens.bgBlend,
+          zIndex: 1
+        }
+      }
+    )
+  ] });
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["<stdin>"],
  "sourcesContent": ["'use client'\n\nimport { useEffect } from 'react'\n\nimport { useSmoothControls } from '../../../hooks/use-smooth-controls'\nimport { colorMix } from '../../../utils/color'\n\nimport fillerBg from '../../../assets/filler-bg0.webp'\n\nimport { BLEND_MODES } from './blend-modes'\nimport { $lightMode, LENS_0, LENS_5I, type LensPreset, toggleLens } from './lens'\n\nconst LAYER = 'pointer-events-none fixed inset-0'\n\nexport function Lens({ dark, initial }: LensProps) {\n  // `initial` lets the host (e.g. Storybook) seed the Leva/atom state with\n  // the *exact* lens preset the user selected, avoiding a one-cycle lag\n  // where useSmoothControls emits old colors for the first paint (and, on\n  // Storybook's fast iframe reload, sometimes never catches up because\n  // useControls' ready-gate swallows the instant color writes).\n  const base = initial?.Lens ?? (dark ? LENS_0.Lens : LENS_5I.Lens)\n\n  const lens = useSmoothControls(\n    'Lens',\n    {\n      bgBlend: { options: BLEND_MODES, value: base.bgBlend as 'multiply' },\n      bgColor: { value: base.bgColor },\n      bgOpacity: { max: 1, min: 0, step: 0.01, value: base.bgOpacity },\n      fgBlend: { options: BLEND_MODES, value: 'difference' as const },\n      fgColor: { value: base.fgColor },\n      fgOpacity: { max: 1, min: 0, step: 0.01, value: base.fgOpacity },\n      fillerBlend: { options: BLEND_MODES, value: 'difference' as const },\n      fillerOpacity: { max: 1, min: 0, step: 0.01, value: base.fillerOpacity },\n      mgColor: { value: base.mgColor },\n      mgOpacity: { max: 1, min: 0, step: 0.01, value: base.mgOpacity }\n    },\n    { collapsed: false }\n  )\n\n  useEffect(() => {\n    $lightMode.set(!dark)\n  }, [dark])\n\n  useEffect(() => {\n    const s = document.documentElement.style\n\n    for (const [name, color, alpha] of [\n      ['foreground', lens.fgColor, lens.fgOpacity],\n      ['midground', lens.mgColor, lens.mgOpacity],\n      ['background', lens.bgColor, lens.bgOpacity]\n    ] as [string, string, number][]) {\n      s.setProperty(`--${name}`, colorMix(color, alpha))\n      s.setProperty(`--${name}-base`, color)\n      s.setProperty(`--${name}-alpha`, `${alpha}`)\n    }\n  }, [lens])\n\n  useEffect(() => {\n    const handle = (e: KeyboardEvent) => e.key === 'x' && toggleLens()\n    window.addEventListener('keydown', handle)\n    return () => window.removeEventListener('keydown', handle)\n  }, [])\n\n  // NOTE: z-index is inlined because Tailwind's JIT sometimes doesn't emit\n  // these non-default utilities (e.g. in Storybook's isolated content\n  // scan), which silently collapses the overlay stack to DOM order and\n  // breaks the mix-blend-mode inversion \u2014 producing a muddy warm wash\n  // instead of the intended clean black/white inversion.\n  return (\n    <>\n      <div\n        className={LAYER}\n        style={{\n          backgroundColor: colorMix(lens.fgColor, lens.fgOpacity),\n          mixBlendMode: lens.fgBlend,\n          zIndex: 100\n        }}\n      />\n\n      <div\n        className={LAYER}\n        style={{\n          mixBlendMode: lens.fillerBlend,\n          opacity: lens.fillerOpacity,\n          zIndex: 2\n        }}\n      >\n        {/* eslint-disable-next-line @next/next/no-img-element */}\n        <img\n          alt=\"\"\n          className=\"h-[150dvh] w-auto min-w-dvw object-cover object-top-left invert\"\n          fetchPriority=\"low\"\n          height={1024}\n          src={fillerBg.src}\n          width={1024}\n        />\n      </div>\n\n      <div\n        className={LAYER}\n        style={{\n          backgroundColor: colorMix(lens.bgColor, lens.bgOpacity),\n          mixBlendMode: lens.bgBlend,\n          zIndex: 1\n        }}\n      />\n    </>\n  )\n}\n\ninterface LensProps {\n  dark?: boolean\n  /**\n   * Exact preset to seed the internal Leva controls with. When omitted the\n   * component falls back to `LENS_0` / `LENS_5I` based on `dark`. Pass the\n   * actual preset from a host (e.g. Storybook toolbar) to guarantee the\n   * first-paint colors match the selected lens without needing a followup\n   * `applyLens` that can be lost in useSmoothControls' startup window.\n   */\n  initial?: LensPreset\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/ui/components/overlays/lens.d.ts

@@ -0,0 +1,44 @@
+export declare const LENS_0: {
+    Globe: {
+        innerColor: string;
+        innerOpacity: number;
+        outerColor: string;
+    };
+    Lens: {
+        bgBlend: string;
+        bgColor: string;
+        bgOpacity: number;
+        fgColor: string;
+        fgOpacity: number;
+        fillerOpacity: number;
+        mgColor: string;
+        mgOpacity: number;
+    };
+};
+export declare const LENS_5I: {
+    Globe: {
+        innerColor: string;
+        innerOpacity: number;
+        outerColor: string;
+    };
+    Lens: {
+        bgBlend: string;
+        bgColor: string;
+        bgOpacity: number;
+        fgColor: string;
+        fgOpacity: number;
+        fillerOpacity: number;
+        mgColor: string;
+        mgOpacity: number;
+    };
+};
+export declare const lens0: (l?: Partial<typeof LENS_0.Lens>, g?: Partial<typeof LENS_0.Globe>) => LensPreset;
+export declare const lens5i: (l?: Partial<typeof LENS_5I.Lens>, g?: Partial<typeof LENS_5I.Globe>) => LensPreset;
+export declare const LENSES: [string, LensPreset][];
+export declare const applyLens: (preset: LensPreset, animate?: boolean) => void;
+export declare const $lightMode: import("nanostores").PreinitializedWritableAtom<boolean> & object;
+export declare const toggleLens: () => void;
+export interface LensPreset {
+    Globe: typeof LENS_0.Globe;
+    Lens: typeof LENS_0.Lens;
+}