{
  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
  "name": "textura-magnet",
  "title": "Textura Magnet",
  "author": "Visant Labs <visantsupply@gmail.com>",
  "description": "Limalha de ferro em traços curtos que se alinham ao campo de um ímã preso ao cursor.",
  "dependencies": [],
  "registryDependencies": [
    "utils",
    "@visant/css-color"
  ],
  "files": [
    {
      "path": "registry/visant/ui/textura-magnet.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 Magnet — limalha de ferro sobre papel: traços curtos numa malha que\n * giram com as linhas de campo de um ímã preso ao cursor. Perto dele a limalha\n * ganha tinta e comprimento; longe, ela apaga, mas continua alinhada ao campo.\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. **Um ímã de barra, não um ponto.** Um polo só daria traços radiais, uma\n *    estrela sem graça. Com dois polos (norte e sul) a um palmo um do outro,\n *    o campo de dipolo faz os arcos de livro de física, e é isso que se lê\n *    como \"limalha\".\n * 2. **Rotação regular por padrão.** Com `scatter` em 0, o ângulo de cada traço\n *    vem só do campo, e os traços ficam numa malha: é o desenho das linhas de\n *    força que se lê, não o sorteio. Subir `scatter` devolve a bagunça de limalha\n *    caída ao acaso. A direção sorteada soma por vetor, nunca por ângulo, para\n *    evitar o salto de 359° para 0° e deixar a transição contínua.\n * 3. **Linha de campo não tem sentido.** O traço é um segmento centrado, então\n *    norte e sul desenham igual; não há seta para trair a física.\n * 4. **Vizinhos entram na conta.** Traço girado passa da própria célula, então\n *    cada pixel olha as 3×3 células em volta e fica com a tinta mais forte;\n *    sem isso os traços sairiam cortados na quina.\n * 5. **Sem laço à toa.** Limalha parada não pede quadro. O laço só vive\n *    enquanto o ímã ainda está chegando no cursor (ou voltando ao centro, ao\n *    sair), e com movimento reduzido ele pula direto.\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 float uCell;\nuniform float uLen;\nuniform float uForca;\nuniform float uSolto;\nuniform vec2 uIma;\nuniform vec3 uFundo;\nuniform vec3 uLimalha;\n\nvec2 hash(vec2 p){\n  p=vec2(dot(p,vec2(127.1,311.7)),dot(p,vec2(269.5,183.3)));\n  return fract(sin(p)*43758.5453);\n}\nfloat seg(vec2 p,vec2 a,vec2 b){\n  vec2 pa=p-a,ba=b-a;\n  float h=clamp(dot(pa,ba)/dot(ba,ba),0.,1.);\n  return length(pa-ba*h);\n}\n\nvoid main(){\n  vec2 px=vec2(gl_FragCoord.x,uRes.y-gl_FragCoord.y);\n  vec2 ip=floor(px/uCell);\n  float sep=uRes.y*.09;\n  float aa=1.2;\n  float w=max(.8,uCell*.045);\n  float tinta=0.;\n  for(int y=-1;y<=1;y++)\n  for(int x=-1;x<=1;x++){\n    vec2 id=ip+vec2(float(x),float(y));\n    vec2 hz=hash(id);\n    vec2 c=(id+.5+(hz-.5)*.7*uSolto)*uCell;\n    vec2 r1=(c-uIma-vec2(sep,0.))/uRes.y;\n    vec2 r2=(c-uIma+vec2(sep,0.))/uRes.y;\n    float l1=max(length(r1),.01);\n    float l2=max(length(r2),.01);\n    vec2 B=r1/(l1*l1*l1)-r2/(l2*l2*l2);\n    float m=length(B);\n    float peso=smoothstep(0.,1.,sqrt(m)*uForca*.25);\n    float ang=hash(id+4.1).x*6.2832;\n    vec2 solto=vec2(cos(ang),sin(ang));\n    vec2 campo=m>0.?B/m:solto;\n    vec2 dir=solto*(1.-peso)*uSolto+campo*(peso+(1.-peso)*(1.-uSolto));\n    float dl=length(dir);\n    dir=dl>.001?dir/dl:campo;\n    float meia=uCell*uLen*(.75+.35*peso)*(1.+(.6*hz.y-.3)*uSolto)*.5;\n    float d=seg(px,c-dir*meia,c+dir*meia);\n    float t=(1.-smoothstep(w-aa,w+aa,d))*(.3+.7*peso);\n    tinta=max(tinta,t);\n  }\n  gl_FragColor=vec4(mix(uFundo,uLimalha,tinta),1.);\n}\n`;\n\n/** Paradas padrão: papel e limalha. Tudo token. */\nconst CORES_PADRAO = [\"var(--background)\", \"var(--brand)\"];\n\nexport interface TexturaMagnetProps extends Omit<React.HTMLAttributes<HTMLDivElement>, \"children\"> {\n  /**\n   * Quantos grãos de limalha na altura.\n   * @min 10\n   * @max 60\n   * @step 1\n   */\n  density?: number;\n  /**\n   * Comprimento de cada traço.\n   * @min 0\n   * @max 100\n   * @step 1\n   */\n  length?: number;\n  /**\n   * Força do ímã: até onde a limalha se alinha.\n   * @min 0\n   * @max 100\n   * @step 1\n   */\n  strength?: number;\n  /**\n   * Bagunça: 0 é malha regular com todo traço girando pelo campo; 100 é limalha\n   * caída ao acaso, com ângulo, posição e comprimento sorteados.\n   * @min 0\n   * @max 100\n   * @step 1\n   */\n  scatter?: number;\n  /** Paradas: papel e limalha. 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 TexturaMagnet({\n  density = 30,\n  length = 55,\n  strength = 60,\n  scatter = 0,\n  colors,\n  className,\n  ...props\n}: TexturaMagnetProps) {\n  const wrapRef = React.useRef<HTMLDivElement>(null);\n  const params = React.useRef({ density, length, strength, scatter });\n  params.current = { density, length, strength, scatter };\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      cell: u(\"uCell\"),\n      len: u(\"uLen\"),\n      forca: u(\"uForca\"),\n      solto: u(\"uSolto\"),\n      ima: u(\"uIma\"),\n      fundo: u(\"uFundo\"),\n      limalha: u(\"uLimalha\"),\n    };\n\n    const mq = window.matchMedia(\"(prefers-reduced-motion: reduce)\");\n    let dpr = 1;\n    let raf = 0;\n    let ultimo = 0;\n    let dentro = false;\n    const alvo = { x: 0, y: 0 };\n    const ima = { x: 0, y: 0 };\n\n    const cores = () => {\n      const [a, b] = coresChave.split(\"|\").map((cor) => resolveCssColor(cor, wrap));\n      gl.uniform3fv(U.fundo, a);\n      gl.uniform3fv(U.limalha, b ?? a);\n    };\n\n    // Em repouso o ímã fica no meio do palco: o primeiro quadro já mostra o campo.\n    const repousar = () => {\n      alvo.x = canvas.width / 2;\n      alvo.y = canvas.height / 2;\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      if (!dentro) {\n        repousar();\n        Object.assign(ima, alvo);\n      }\n    };\n\n    const desenhar = () => {\n      const p = params.current;\n      gl.uniform2f(U.res, canvas.width, canvas.height);\n      gl.uniform1f(U.cell, canvas.height / Math.max(10, Math.min(60, p.density)));\n      gl.uniform1f(U.len, 0.45 + (p.length / 100) * 0.75);\n      gl.uniform1f(U.forca, 0.25 + (p.strength / 100) * 0.75);\n      gl.uniform1f(U.solto, Math.max(0, Math.min(1, p.scatter / 100)));\n      gl.uniform2f(U.ima, ima.x, ima.y);\n      gl.drawArrays(gl.TRIANGLES, 0, 3);\n    };\n\n    // O laço só vive enquanto o ímã ainda está chegando.\n    const quadro = (agora: number) => {\n      const dt = ultimo ? Math.min(0.05, (agora - ultimo) / 1000) : 1 / 60;\n      ultimo = agora;\n      const k = 1 - Math.pow(0.84, dt * 60);\n      ima.x += (alvo.x - ima.x) * k;\n      ima.y += (alvo.y - ima.y) * k;\n      if (Math.hypot(alvo.x - ima.x, alvo.y - ima.y) < 0.5) Object.assign(ima, alvo);\n      desenhar();\n      raf = ima.x === alvo.x && ima.y === alvo.y ? 0 : requestAnimationFrame(quadro);\n    };\n    const pedirQuadro = () => {\n      if (mq.matches) {\n        Object.assign(ima, alvo);\n        desenhar();\n      } else if (!raf) {\n        ultimo = 0;\n        raf = requestAnimationFrame(quadro);\n      }\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      dentro = true;\n      pedirQuadro();\n    };\n    const sair = () => {\n      dentro = false;\n      repousar();\n      pedirQuadro();\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 offTema = onThemeChange(() => {\n      cores();\n      desenhar();\n    });\n    wrap.addEventListener(\"pointermove\", mover);\n    wrap.addEventListener(\"pointerleave\", sair);\n\n    return () => {\n      cancelAnimationFrame(raf);\n      ro.disconnect();\n      offTema();\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  }, [density, length, strength, scatter]);\n\n  return (\n    <div\n      ref={wrapRef}\n      role=\"img\"\n      aria-label=\"Limalha de ferro alinhada ao campo de um ímã no 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 limalha de ferro que se alinha ao cursor, em landing tech, ciência ou portfólio",
      "evite": "Linhas de fluxo que desviam do cursor: textura-current; ponteiros grandes de relógio, textura-watch"
    }
  },
  "categories": [
    "efeitos",
    "textura",
    "webgl",
    "fundo",
    "ponteiro",
    "ima",
    "limalha",
    "campo"
  ],
  "type": "registry:ui"
}