{
  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
  "name": "textura-current",
  "title": "Textura Current",
  "author": "Visant Labs <visantsupply@gmail.com>",
  "description": "Linhas de correnteza com traços que descem pela água e abrem caminho em volta do cursor como de uma pedra.",
  "dependencies": [],
  "registryDependencies": [
    "utils",
    "@visant/css-color"
  ],
  "files": [
    {
      "path": "registry/visant/ui/textura-current.tsx",
      "content": "\"use client\";\n\nimport * as React from \"react\";\n\nimport { cn } from \"@/lib/utils\";\nimport { onThemeChange, resolveCssColor } from \"@/lib/css-color\";\n\n/**\n * Textura Current — linhas de fluxo como correnteza de rio, com traços que\n * descem pela água, e que abrem caminho em volta do ponteiro como em volta de\n * uma pedra. Fundo de dobra de produto que \"flui\", de dado em movimento, de\n * logística.\n *\n * Original da Visant Labs, família texturas: superfície que reage ao ponteiro,\n * um gesto só.\n *\n * ── As decisões que não se veem ────────────────────────────────────────────\n *\n * 1. **Física de livro, não ruído.** As linhas são curvas de nível da função\n *    de corrente do escoamento potencial em volta de um cilindro (ψ = y −\n *    R²·y/r²). Por isso elas contornam o ponteiro sem nunca se cruzar e se\n *    apertam nas laterais da pedra, onde a água corre mais rápido.\n * 2. **ψ absoluto, não relativo.** O termo da pedra é relativo ao ponteiro,\n *    mas o `y` é o da tela: longe da pedra cada linha fica no seu lugar. Com\n *    `y` relativo, todas as linhas subiriam e desceriam junto com o cursor.\n * 3. **Espessura constante pelo gradiente.** A distância até a linha mais\n *    próxima é |ψ − linha| dividida por |∇ψ|, calculado à mão. Sem isso a\n *    linha engordaria nos remansos e afinaria nas corredeiras.\n * 4. **Os traços correm pelo potencial.** O desenho que desce é um tracejado\n *    sobre φ = x + R²·x/r², que acompanha a velocidade: perto da pedra ele\n *    acelera nas laterais e quase para na frente dela, sem simulação.\n * 5. **O laço dorme.** O tracejado pede tempo, então há laço, mas ele para\n *    fora da tela. Com movimento reduzido: um quadro parado, que só refaz\n *    quando o ponteiro mexe. Sem ponteiro, a pedra encolhe e o rio fica reto.\n */\n\nconst VERT = `attribute vec2 a_pos;void main(){gl_Position=vec4(a_pos,0.0,1.0);}`;\n\nconst FRAG = `\n#ifdef GL_FRAGMENT_PRECISION_HIGH\nprecision highp float;\n#else\nprecision mediump float;\n#endif\nuniform vec2 uRes;\nuniform vec2 uPedra;\nuniform float uR;\nuniform float uLinhas;\nuniform float uTime;\nuniform float uPeso;\nuniform vec3 uFundo;\nuniform vec3 uLinha;\nuniform vec3 uTraco;\n\nfloat hash(float n){return fract(sin(n*127.1)*43758.5453);}\n\nvoid main(){\n  vec2 px=vec2(gl_FragCoord.x,uRes.y-gl_FragCoord.y);\n  vec2 p=px/uRes.y;\n  vec2 r=p-uPedra/uRes.y;\n  float r2=max(dot(r,r),1e-5);\n  float k=uR*uR;\n  float onda=.03*sin(p.x*2.3+uTime*.25)+.012*sin(p.x*6.1-uTime*.4+p.y*3.);\n  float psi=p.y+onda-k*r.y/r2;\n  float phi=p.x+k*r.x/r2;\n  float gx=2.*k*r.x*r.y/(r2*r2);\n  float gy=1.-k*(r2-2.*r.y*r.y)/(r2*r2);\n  float g=max(length(vec2(gx,gy)),.25);\n\n  float s=psi*uLinhas;\n  float idx=floor(s+.5);\n  float dist=abs(s-idx)/uLinhas/g*uRes.y;\n  float aa=1.2;\n  float linha=1.-smoothstep(uPeso-aa,uPeso+aa,dist);\n  float largo=1.-smoothstep(uPeso*2.2-aa,uPeso*2.2+aa,dist);\n\n  float h=hash(idx);\n  float t=fract(phi*(2.5+h*1.5)-uTime*(.35+h*.25)+h);\n  float traco=smoothstep(0.,.08,t)*(1.-smoothstep(.22,.32,t));\n\n  float fora=smoothstep(k*.85,k*1.25,r2);\n  vec3 col=mix(uFundo,uLinha,linha*fora*.8);\n  col=mix(col,uTraco,largo*traco*fora);\n  gl_FragColor=vec4(col,1.);\n}\n`;\n\n/** Paradas padrão: água, linha, traço. Tudo token. */\nconst CORES_PADRAO = [\n  \"var(--background)\",\n  \"color-mix(in oklab, var(--brand) 32%, var(--background))\",\n  \"var(--brand)\",\n];\n\nexport interface TexturaCurrentProps extends Omit<React.HTMLAttributes<HTMLDivElement>, \"children\"> {\n  /**\n   * Quantas linhas de corrente na altura.\n   * @min 6\n   * @max 40\n   * @step 1\n   */\n  lines?: number;\n  /**\n   * Tamanho da pedra que o ponteiro põe na água.\n   * @min 0\n   * @max 100\n   * @step 1\n   */\n  wake?: number;\n  /**\n   * Velocidade da correnteza.\n   * @min 0\n   * @max 100\n   * @step 1\n   */\n  speed?: number;\n  /** Paradas: água, linha e traço. Qualquer cor CSS ou token. */\n  colors?: string[];\n}\n\nfunction compilar(gl: WebGLRenderingContext, frag: string): WebGLProgram | null {\n  const shader = (tipo: number, src: string) => {\n    const s = gl.createShader(tipo);\n    if (!s) return null;\n    gl.shaderSource(s, src);\n    gl.compileShader(s);\n    return gl.getShaderParameter(s, gl.COMPILE_STATUS) ? s : null;\n  };\n  const vs = shader(gl.VERTEX_SHADER, VERT);\n  const fs = shader(gl.FRAGMENT_SHADER, frag);\n  const p = gl.createProgram();\n  if (!vs || !fs || !p) return null;\n  gl.attachShader(p, vs);\n  gl.attachShader(p, fs);\n  gl.linkProgram(p);\n  gl.deleteShader(vs);\n  gl.deleteShader(fs);\n  return gl.getProgramParameter(p, gl.LINK_STATUS) ? p : null;\n}\n\nexport function TexturaCurrent({\n  lines = 16,\n  wake = 45,\n  speed = 35,\n  colors,\n  className,\n  ...props\n}: TexturaCurrentProps) {\n  const wrapRef = React.useRef<HTMLDivElement>(null);\n  const params = React.useRef({ lines, wake, speed });\n  params.current = { lines, wake, speed };\n  const redesenhar = React.useRef<() => void>(() => {});\n  const coresChave = (colors ?? CORES_PADRAO).join(\"|\");\n\n  React.useEffect(() => {\n    const wrap = wrapRef.current;\n    if (!wrap) return;\n    const canvas = document.createElement(\"canvas\");\n    canvas.setAttribute(\"aria-hidden\", \"true\");\n    canvas.className = \"absolute inset-0 block h-full w-full\";\n    wrap.appendChild(canvas);\n    const gl = canvas.getContext(\"webgl\", { antialias: false, alpha: false });\n    const prog = gl && compilar(gl, FRAG);\n    if (!gl || !prog) {\n      canvas.remove();\n      return;\n    }\n\n    const buf = gl.createBuffer();\n    gl.bindBuffer(gl.ARRAY_BUFFER, buf);\n    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1, -1, 3, -1, -1, 3]), gl.STATIC_DRAW);\n    gl.useProgram(prog);\n    const aPos = gl.getAttribLocation(prog, \"a_pos\");\n    gl.enableVertexAttribArray(aPos);\n    gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, 0, 0);\n    const u = (n: string) => gl.getUniformLocation(prog, n);\n    const U = {\n      res: u(\"uRes\"),\n      pedra: u(\"uPedra\"),\n      r: u(\"uR\"),\n      linhas: u(\"uLinhas\"),\n      time: u(\"uTime\"),\n      peso: u(\"uPeso\"),\n      fundo: u(\"uFundo\"),\n      linha: u(\"uLinha\"),\n      traco: u(\"uTraco\"),\n    };\n\n    const mq = window.matchMedia(\"(prefers-reduced-motion: reduce)\");\n    let reduzido = mq.matches;\n    let visivel = false;\n    let raf = 0;\n    let ultimo = 0;\n    let tempo = 4;\n    let dpr = 1;\n    const alvo = { x: 0, y: 0, f: 0 };\n    const pedra = { x: 0, y: 0, f: 0 };\n\n    const cores = () => {\n      const [a, b, c] = coresChave.split(\"|\").map((cor) => resolveCssColor(cor, wrap));\n      gl.uniform3fv(U.fundo, a);\n      gl.uniform3fv(U.linha, b ?? a);\n      gl.uniform3fv(U.traco, c ?? b ?? a);\n    };\n\n    const medir = () => {\n      dpr = Math.min(2, window.devicePixelRatio || 1);\n      canvas.width = Math.max(1, Math.round(wrap.offsetWidth * dpr));\n      canvas.height = Math.max(1, Math.round(wrap.offsetHeight * dpr));\n      gl.viewport(0, 0, canvas.width, canvas.height);\n    };\n\n    const desenhar = () => {\n      const p = params.current;\n      gl.uniform2f(U.res, canvas.width, canvas.height);\n      gl.uniform2f(U.pedra, pedra.x, pedra.y);\n      // Raio da pedra em alturas: 0 → 0,06, 100 → 0,3\n      gl.uniform1f(U.r, (0.06 + (p.wake / 100) * 0.24) * pedra.f);\n      gl.uniform1f(U.linhas, Math.max(6, Math.min(40, p.lines)));\n      gl.uniform1f(U.time, tempo);\n      gl.uniform1f(U.peso, Math.max(0.6, 0.7 * dpr));\n      gl.drawArrays(gl.TRIANGLES, 0, 3);\n    };\n\n    const quadro = (agora: number) => {\n      const dt = ultimo ? Math.min(0.05, (agora - ultimo) / 1000) : 0;\n      ultimo = agora;\n      tempo += dt * (0.1 + (params.current.speed / 100) * 2.2);\n      const k = 1 - Math.pow(0.88, dt * 60);\n      pedra.x += (alvo.x - pedra.x) * k;\n      pedra.y += (alvo.y - pedra.y) * k;\n      pedra.f += (alvo.f - pedra.f) * k * 0.7;\n      desenhar();\n      raf = visivel && !reduzido ? requestAnimationFrame(quadro) : 0;\n    };\n\n    const ligar = () => {\n      if (!raf && visivel && !reduzido) {\n        ultimo = 0;\n        raf = requestAnimationFrame(quadro);\n      }\n    };\n    const desligar = () => {\n      cancelAnimationFrame(raf);\n      raf = 0;\n    };\n\n    redesenhar.current = () => {\n      if (!raf) desenhar();\n    };\n\n    const mover = (e: PointerEvent) => {\n      // Ponteiro em px locais: a vitrine escala o palco com transform.\n      const r = wrap.getBoundingClientRect();\n      const k = r.width ? wrap.offsetWidth / r.width : 1;\n      alvo.x = (e.clientX - r.left) * k * dpr;\n      alvo.y = (e.clientY - r.top) * k * dpr;\n      alvo.f = 1;\n      // A pedra nasce onde o ponteiro entrou, não desliza do canto.\n      if (pedra.f < 0.02) {\n        pedra.x = alvo.x;\n        pedra.y = alvo.y;\n      }\n      if (reduzido) {\n        Object.assign(pedra, alvo);\n        desenhar();\n      }\n    };\n    const sair = () => {\n      alvo.f = 0;\n      if (reduzido) {\n        pedra.f = 0;\n        desenhar();\n      }\n    };\n    const trocarMovimento = () => {\n      reduzido = mq.matches;\n      if (reduzido) {\n        desligar();\n        desenhar();\n      } else ligar();\n    };\n\n    cores();\n    medir();\n    desenhar();\n\n    const ro = new ResizeObserver(() => {\n      medir();\n      desenhar();\n    });\n    ro.observe(wrap);\n    const io = new IntersectionObserver(([e]) => {\n      visivel = e.isIntersecting;\n      if (visivel) ligar();\n      else desligar();\n    });\n    io.observe(wrap);\n    const offTema = onThemeChange(() => {\n      cores();\n      desenhar();\n    });\n    mq.addEventListener(\"change\", trocarMovimento);\n    wrap.addEventListener(\"pointermove\", mover);\n    wrap.addEventListener(\"pointerleave\", sair);\n\n    return () => {\n      desligar();\n      ro.disconnect();\n      io.disconnect();\n      offTema();\n      mq.removeEventListener(\"change\", trocarMovimento);\n      wrap.removeEventListener(\"pointermove\", mover);\n      wrap.removeEventListener(\"pointerleave\", sair);\n      redesenhar.current = () => {};\n      gl.deleteBuffer(buf);\n      gl.deleteProgram(prog);\n      gl.getExtension(\"WEBGL_lose_context\")?.loseContext();\n      canvas.remove();\n    };\n  }, [coresChave]);\n\n  React.useEffect(() => {\n    redesenhar.current();\n  }, [lines, wake, speed]);\n\n  return (\n    <div\n      ref={wrapRef}\n      role=\"img\"\n      aria-label=\"Linhas de correnteza que desviam do cursor\"\n      className={cn(\"relative block aspect-[16/10] w-full overflow-hidden bg-background\", className)}\n      {...props}\n    />\n  );\n}\n",
      "type": "registry:ui"
    }
  ],
  "meta": {
    "uso": {
      "quando": "Fundo de hero com linhas de correnteza que abrem caminho em volta do cursor, em landing de dados, clima ou viagem",
      "evite": "Limalha parada alinhada ao campo: textura-magnet; névoa leve sem WebGL, turbulence-field"
    }
  },
  "categories": [
    "efeitos",
    "textura",
    "webgl",
    "fundo",
    "ponteiro",
    "fluxo",
    "correnteza",
    "linhas"
  ],
  "type": "registry:ui"
}