{
  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
  "name": "fog-tree",
  "title": "Fog Tree",
  "author": "Visant Labs <visantsupply@gmail.com>",
  "description": "Uma árvore procedural sozinha na névoa, em duotone da marca: a cena é cinza e o último passe pinta com --background e --foreground, então o tema escuro inverte a foto sem segunda paleta.",
  "dependencies": [
    "three@^0.170.0",
    "@dgreenheck/ez-tree@^1.1.0",
    "framer-motion"
  ],
  "devDependencies": [
    "@types/three@^0.170.0"
  ],
  "registryDependencies": [
    "utils",
    "@visant/css-color"
  ],
  "files": [
    {
      "path": "registry/visant/lib/fog-post.ts",
      "content": "/**\n * Fog Post — o pós-processamento comum às cenas de névoa (`fog-tree`,\n * `fog-garden`): render → rastro de longa exposição → duotone com grão.\n *\n * ── Por que duotone e não material colorido ────────────────────────────────\n *\n * A cena inteira é desenhada em CINZA (céu branco, névoa branca, tronco e copa\n * em cinzas numéricos) e só no último passe a luminância vira a mistura de dois\n * tokens: `paper` nas luzes, `ink` nas sombras. Três ganhos de uma vez:\n *\n * 1. **Nenhuma cor mora na cena.** Troca de marca é troca de dois uniforms.\n * 2. **O dark mode sai de graça.** No escuro, `--background` é escuro e\n *    `--foreground` é claro, então o mesmo passe inverte a foto: árvore clara\n *    numa névoa noturna, sem segunda paleta.\n * 3. **A névoa nunca briga com a marca.** FogExp2 tende ao branco da cena, e o\n *    branco da cena É o papel da marca depois do passe.\n *\n * ── As cores entram cruas no shader, de propósito ─────────────────────────\n *\n * `ShaderMaterial` não passa pela conversão de espaço de cor do three: o que o\n * fragment escreve vai direto para o canvas sRGB. O `resolveCssColor` já\n * devolve sRGB 0..1, então o uniform recebe esses números sem conversão\n * (`setRGB` no espaço de trabalho não converte). Passar por `Color.set(css)`\n * linearizaria o papel e ele sairia um tom mais escuro que o fundo da página —\n * a costura entre o canvas e o resto da seção fica visível.\n *\n * ── O rastro ───────────────────────────────────────────────────────────────\n *\n * `AfterimagePass` mistura o quadro novo com o anterior (`damp` 0..1). Com a\n * câmera andando, o vento nas folhas vira longa exposição em vez de tremor.\n * Com movimento reduzido o passe nem entra na cadeia: rastro sem movimento é\n * só um passe de GPU pago à toa.\n */\n\nimport * as THREE from \"three\";\nimport { EffectComposer } from \"three/examples/jsm/postprocessing/EffectComposer.js\";\nimport { RenderPass } from \"three/examples/jsm/postprocessing/RenderPass.js\";\nimport { AfterimagePass } from \"three/examples/jsm/postprocessing/AfterimagePass.js\";\nimport { ShaderPass } from \"three/examples/jsm/postprocessing/ShaderPass.js\";\n\nimport type { RGB } from \"@/lib/css-color\";\n\n/**\n * O passe final. `TAPS` amostras em círculo, com raio que cresce longe do\n * centro: a borda fica mais sonhadora que o miolo, como lente velha. O modo\n * leve corta as amostras pela metade — é o laço mais caro do quadro.\n */\nconst fragmentShader = /* glsl */ `\n  uniform sampler2D tDiffuse;\n  uniform vec3 uPaper, uInk;\n  uniform float uTime, uGrain, uVignette;\n  uniform vec2 uRes;\n  varying vec2 vUv;\n\n  float hash(vec2 p) {\n    vec3 p3 = fract(vec3(p.xyx) * 0.1031);\n    p3 += dot(p3, p3.yzx + 33.33);\n    return fract((p3.x + p3.y) * p3.z);\n  }\n\n  void main() {\n    vec2 c = vUv - 0.5;\n    float r = length(c * vec2(uRes.x / uRes.y, 1.0));\n    vec3 acc = texture2D(tDiffuse, vUv).rgb;\n    float raio = 1.6 * (1.0 + 3.0 * smoothstep(0.2, 0.9, r));\n    for (int i = 0; i < TAPS; i++) {\n      float a = float(i) * (6.2831853 / float(TAPS));\n      acc += texture2D(tDiffuse, vUv + vec2(cos(a), sin(a)) * raio / uRes).rgb;\n    }\n    float L = dot(acc / float(TAPS + 1), vec3(0.299, 0.587, 0.114));\n    L = smoothstep(0.02, 0.98, L);\n    vec3 col = mix(uInk, uPaper, L);\n    // a borda volta ao papel: a cena termina dentro da seção, sem moldura\n    col = mix(col, uPaper, smoothstep(0.55, 1.1, r) * uVignette);\n    // grão em células de 1.5px, sorteado a 24 quadros por segundo (cadência de\n    // película); por pixel e por quadro ele vira chiado de TV\n    float g = hash(floor(gl_FragCoord.xy / 1.5) + mod(floor(uTime * 24.0), 64.0) * 37.0) - 0.5;\n    gl_FragColor = vec4(col + g * uGrain, 1.0);\n  }\n`;\n\nconst vertexShader = /* glsl */ `\n  varying vec2 vUv;\n  void main() {\n    vUv = uv;\n    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n  }\n`;\n\nconst BRANCO = new THREE.Color(1, 1, 1);\n\nexport interface FogPostOptions {\n  /** Rastro (damp do AfterimagePass), 0..0.98. 0 tira o passe da cadeia. */\n  trail?: number;\n  /** Intensidade do grão, 0..0.2. */\n  grain?: number;\n  /** Quanto a borda volta ao papel, 0..1. */\n  vignette?: number;\n  /** Modo leve: metade das amostras de desfoque. */\n  light?: boolean;\n}\n\nexport interface FogPost {\n  setSize(w: number, h: number): void;\n  setColors(paper: RGB, ink: RGB): void;\n  /** Tempo em segundos — só o grão lê. Congelado, o grão fica parado. */\n  setTime(t: number): void;\n  /** Rastro ao vivo, sem refazer a cadeia. 0 desliga o passe; subir de novo liga. */\n  setTrail(damp: number): void;\n  /** Grão ao vivo. É só um uniform. */\n  setGrain(grain: number): void;\n  render(): void;\n  /**\n   * Zera o rastro. Sem isto, voltar de uma aba escondida mostra por alguns\n   * quadros o fantasma do último quadro de minutos atrás.\n   */\n  resetTrail(): void;\n  dispose(): void;\n}\n\nexport function createFogPost(\n  renderer: THREE.WebGLRenderer,\n  scene: THREE.Scene,\n  camera: THREE.Camera,\n  { trail = 0.86, grain = 0.05, vignette = 0.55, light = false }: FogPostOptions = {},\n): FogPost {\n  const composer = new EffectComposer(renderer);\n  composer.addPass(new RenderPass(scene, camera));\n\n  const damp = THREE.MathUtils.clamp(trail, 0, 0.98);\n  let rastro = damp > 0 ? new AfterimagePass(damp) : null;\n  if (rastro) composer.addPass(rastro);\n\n  const final = new ShaderPass({\n    uniforms: {\n      tDiffuse: { value: null },\n      // pretos até o primeiro setColors; a cena chama logo depois de nascer\n      uPaper: { value: new THREE.Color(1, 1, 1) },\n      uInk: { value: new THREE.Color(0, 0, 0) },\n      uTime: { value: 0 },\n      uGrain: { value: grain },\n      uVignette: { value: vignette },\n      uRes: { value: new THREE.Vector2(1, 1) },\n    },\n    defines: { TAPS: light ? 4 : 8 },\n    vertexShader,\n    fragmentShader,\n  });\n  composer.addPass(final);\n\n  return {\n    setSize(w, h) {\n      composer.setSize(w, h);\n      final.uniforms.uRes.value.set(w, h);\n    },\n    setColors(paper, ink) {\n      (final.uniforms.uPaper.value as THREE.Color).setRGB(...paper);\n      (final.uniforms.uInk.value as THREE.Color).setRGB(...ink);\n    },\n    setTime(t) {\n      final.uniforms.uTime.value = t;\n    },\n    setTrail(v) {\n      const d = THREE.MathUtils.clamp(v, 0, 0.98);\n      if (!d) {\n        if (rastro) rastro.enabled = false;\n        return;\n      }\n      if (!rastro) {\n        rastro = new AfterimagePass(d);\n        composer.insertPass(rastro, 1);\n        return;\n      }\n      rastro.uniforms.damp.value = d;\n      rastro.enabled = true;\n    },\n    setGrain(v) {\n      final.uniforms.uGrain.value = v;\n    },\n    render() {\n      composer.render();\n    },\n    resetTrail() {\n      if (!rastro) return;\n      // os dois alvos do afterimage guardam a memória; limpar ambos\n      const prev = renderer.getRenderTarget();\n      const cor = renderer.getClearColor(new THREE.Color());\n      const alfa = renderer.getClearAlpha();\n      // branco = papel depois do duotone: o rastro recomeça da névoa, não do preto\n      renderer.setClearColor(BRANCO, 1);\n      for (const rt of [rastro.textureComp, rastro.textureOld]) {\n        renderer.setRenderTarget(rt);\n        renderer.clear();\n      }\n      renderer.setRenderTarget(prev);\n      renderer.setClearColor(cor, alfa);\n    },\n    dispose() {\n      rastro?.dispose();\n      final.dispose();\n      composer.dispose();\n    },\n  };\n}\n\n/**\n * Cinza sRGB 0..1 como o número que `ez-tree` espera em `tint`.\n *\n * O ez-tree lê `tint` como inteiro de cor. Escrever o literal no código seria\n * hex numa pasta que proíbe hex — e, pior, esconderia que o valor é uma\n * LUMINÂNCIA para o duotone, não uma cor. `SRGBColorSpace` explícito para o\n * número sair igual ao que a mão escreveria; sem ele o `Color` lê os floats\n * como lineares e devolve um cinza mais claro.\n */\nexport function grayTint(v: number): number {\n  return gray(v).getHex();\n}\n\n/** Cinza sRGB 0..1 como `THREE.Color` — para chão, luz e materiais da cena. */\nexport function gray(v: number): THREE.Color {\n  return new THREE.Color().setRGB(v, v, v, THREE.SRGBColorSpace);\n}\n\n/**\n * Sombra de contato: gradiente radial num canvas, sem textura baixada.\n *\n * Na névoa não há sombra projetada que se leia — a luz é difusa. O que ancora\n * a árvore no chão é a mancha escura logo abaixo da copa, e um shadow map de\n * verdade custaria um passe de profundidade inteiro por esse efeito.\n */\nexport function contactShadowTexture(size = 256, strength = 0.38): THREE.CanvasTexture {\n  const c = document.createElement(\"canvas\");\n  c.width = c.height = size;\n  const g = c.getContext(\"2d\");\n  if (g) {\n    const h = size / 2;\n    const grd = g.createRadialGradient(h, h, 0, h, h, h);\n    grd.addColorStop(0, `rgba(0,0,0,${strength})`);\n    grd.addColorStop(0.58, `rgba(0,0,0,${strength * 0.4})`);\n    grd.addColorStop(1, \"rgba(0,0,0,0)\");\n    g.fillStyle = grd;\n    g.fillRect(0, 0, size, size);\n  }\n  return new THREE.CanvasTexture(c);\n}\n\n/** Descarta geometria e material de tudo abaixo de `root`. Textura fica: quem\n *  a criou é quem a guarda (as do ez-tree são cache de módulo, compartilhadas\n *  entre montagens — descartá-las quebraria a próxima árvore). */\nexport function disposeTree(root: THREE.Object3D) {\n  root.traverse((o) => {\n    const m = o as THREE.Mesh;\n    m.geometry?.dispose();\n    const mats = Array.isArray(m.material) ? m.material : m.material ? [m.material] : [];\n    mats.forEach((mat) => mat.dispose());\n  });\n}\n\n/**\n * Cria o renderer das cenas de névoa, ou devolve `null` se o WebGL não existir.\n *\n * `null` e não exceção: máquina sem WebGL (driver na lista negra, VM, modo de\n * economia) tem de ver a seção com o papel liso e o texto por cima, não uma\n * tela de erro. O componente já pinta o papel por baixo do canvas.\n */\nexport function createFogRenderer(canvas: HTMLCanvasElement, light: boolean) {\n  try {\n    const renderer = new THREE.WebGLRenderer({\n      canvas,\n      antialias: !light,\n      powerPreference: \"high-performance\",\n    });\n    renderer.setPixelRatio(densidadeDoCanvas(canvas, light));\n    renderer.outputColorSpace = THREE.SRGBColorSpace;\n    return renderer;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Pixels de desenho por pixel de layout, contando a escala VISUAL do canvas.\n *\n * Quem mostra a cena reduzida com `transform: scale` (uma vitrine, um card de\n * preview) não muda o tamanho de layout do canvas, só o desenhado. Com o\n * `devicePixelRatio` cheio no tamanho de layout, a cena pintava 3 a 4,4x mais\n * pixels do que apareciam. Medido sem GPU forte: a fog-tree acordada caía a\n * 9 fps, e metade dos pixels já levava de 13 a 20 fps. Desenhando no tamanho\n * que aparece, a nitidez na tela é a mesma, porque o bitmap e a redução se\n * anulam. Fora de escala (`1`), o resultado é o de antes.\n *\n * Quem chama de novo no `resize` da janela: o `ResizeObserver` não dispara\n * quando só a escala de um ancestral muda.\n */\nexport function densidadeDoCanvas(canvas: HTMLCanvasElement, light: boolean) {\n  const teto = Math.min(window.devicePixelRatio || 1, light ? 1 : 1.5);\n  const layout = canvas.offsetWidth;\n  const visivel = canvas.getBoundingClientRect().width;\n  const escala = layout > 0 && visivel > 0 ? Math.min(1, visivel / layout) : 1;\n  // Piso em 0,5: abaixo disso a cena vira borrão mesmo reduzida.\n  return Math.max(0.5, teto * escala);\n}\n\n/**\n * Devolve o contexto ao navegador já, em vez de esperar o GC.\n *\n * O teto é ≈16 contextos vivos no Chrome. Uma SPA que entra e sai de rota com\n * cena 3D estoura esse teto sem nunca ter duas cenas na tela — e o sintoma é a\n * cena MAIS ANTIGA perdendo o contexto, sem erro que aponte para cá.\n */\nexport function releaseRenderer(renderer: THREE.WebGLRenderer) {\n  renderer.dispose();\n  try {\n    // motion-lint-disable-next-line force-context-loss  só no descarte final: quem refaz a cena troca o canvas pela `key`\n    renderer.forceContextLoss();\n  } catch {\n    /* contexto já perdido */\n  }\n}\n",
      "type": "registry:lib"
    },
    {
      "path": "registry/visant/lib/fog-tree-scene.ts",
      "content": "/**\n * Fog Tree Scene — a cena do `fog-tree`, em three puro (sem react-three-fiber).\n *\n * Árvore procedural do `@dgreenheck/ez-tree` (MIT), FogExp2, rastro de longa\n * exposição e o duotone do `fog-post`. Vive num arquivo próprio para ser\n * carregada por `import()` só quando a seção chega perto da tela: o ez-tree\n * embute as texturas de casca e folha no bundle, e isso não pode entrar no\n * chunk de quem só renderiza o texto da seção.\n *\n * ── Por que three puro e não fiber ─────────────────────────────────────────\n *\n * A cena é UM objeto, sem estado React dentro: progresso, cor e arrasto chegam\n * por método, 60× por segundo, sem re-render. O fiber cobraria a reconciliação\n * e a linha de versão travada (fiber 8 × React 18, ver `book-3d`) para ganhar\n * nada aqui.\n *\n * Também exporta `growTree`, que o `fog-garden` usa para gerar as variantes do\n * jardim com os mesmos cinzas — as duas cenas têm de ser da mesma floresta.\n */\n\nimport * as THREE from \"three\";\nimport { Tree, TreePreset } from \"@dgreenheck/ez-tree\";\nimport { OrbitControls } from \"three/examples/jsm/controls/OrbitControls.js\";\n\nimport type { RGB } from \"@/lib/css-color\";\nimport {\n  contactShadowTexture,\n  createFogPost,\n  createFogRenderer,\n  densidadeDoCanvas,\n  disposeTree,\n  gray,\n  grayTint,\n  releaseRenderer,\n} from \"@/lib/fog-post\";\n\n/** Os presets do ez-tree, menos a treliça (que não é árvore). */\nexport type FogTreePreset = Exclude<keyof typeof TreePreset, \"Trellis\">;\n\ntype TreeOptions = Tree[\"options\"];\n\n/**\n * Cinzas do tronco e da copa, em luminância sRGB.\n *\n * Tronco bem escuro e copa no meio da escala: depois do duotone o tronco lê\n * como tinta e a copa como tinta diluída, que é como a névoa come a folhagem\n * antes do tronco numa foto de verdade. Copa escura demais vira um borrão\n * chapado; clara demais some na névoa antes do tronco aparecer.\n */\nexport const TREE_GRAYS = { bark: 0.165, leaves: 0.435 };\n\n/**\n * A copa redonda da referência (a árvore solitária na neblina).\n *\n * O `Oak Medium` cru sai alto e ralo; estes ajustes o deixam com a copa cheia e\n * baixa e o tronco aparente, que é o que faz a silhueta ler de longe, no meio\n * da névoa. Só se aplica ao preset padrão: nos outros, mexer em ângulo e\n * contagem de galho deforma o que o preset tem de característico.\n */\nexport function roundCrown(t: Tree) {\n  Object.assign(t.options.leaves, { count: 30, size: 3.6, angle: 50 });\n  Object.assign(t.options.branch.children, { 0: 8, 1: 5, 2: 3 });\n  Object.assign(t.options.branch.angle, { 1: 62, 2: 58, 3: 40 });\n}\n\n/**\n * Gera uma árvore em cinza, pronta para o duotone.\n *\n * `options.copy` em vez de `loadPreset`: o `loadPreset` do ez-tree já chama\n * `generate()` por dentro, e gerar de novo depois do ajuste dobrava o custo —\n * no jardim são sete variantes, e cada geração bloqueia a thread principal.\n */\nexport function growTree(\n  preset: FogTreePreset,\n  seed: number,\n  tweak?: (t: Tree) => void,\n): Tree {\n  const t = new Tree();\n  t.options.copy(TreePreset[preset] as unknown as TreeOptions);\n  t.options.seed = seed;\n  t.options.bark.tint = grayTint(TREE_GRAYS.bark);\n  t.options.leaves.tint = grayTint(TREE_GRAYS.leaves);\n  tweak?.(t);\n  t.generate();\n  return t;\n}\n\nexport interface FogTreeSceneOptions {\n  preset: FogTreePreset;\n  seed: number;\n  /** Densidade da névoa no começo e no fim do progresso (unidades relativas à\n   *  altura da árvore: 1 ≈ a árvore some na distância inicial da câmera). */\n  fog: { start: number; end: number };\n  trail: number;\n  grain: number;\n  draggable: boolean;\n  reduce: boolean;\n  /** Toque ou tela pequena: menos folhas, pixel ratio 1, desfoque mais barato. */\n  light: boolean;\n}\n\nexport interface FogTreeScene {\n  setProgress(p: number): void;\n  setColors(paper: RGB, ink: RGB): void;\n  setRunning(on: boolean): void;\n  setDraggable(on: boolean): void;\n  setFog(fog: { start: number; end: number }): void;\n  setTrail(trail: number): void;\n  setGrain(grain: number): void;\n  dispose(): void;\n}\n\n/** `null` quando não há WebGL — o componente fica com o papel liso. */\nexport function createFogTreeScene(\n  canvas: HTMLCanvasElement,\n  opts: FogTreeSceneOptions,\n): FogTreeScene | null {\n  const renderer = createFogRenderer(canvas, opts.light);\n  if (!renderer) return null;\n\n  const scene = new THREE.Scene();\n  const branco = gray(1);\n  scene.background = branco;\n  const fog = new THREE.FogExp2(branco, 0.02);\n  scene.fog = fog;\n\n  const camera = new THREE.PerspectiveCamera(32, 1, 0.1, 2000);\n  scene.add(new THREE.HemisphereLight(branco, gray(0.604), 2.2));\n  const sol = new THREE.DirectionalLight(branco, 1.2);\n  sol.position.set(20, 60, 30);\n  scene.add(sol);\n\n  const tree = growTree(opts.preset, opts.seed, (t) => {\n    if (opts.preset === \"Oak Medium\") roundCrown(t);\n    // menos folha no modo leve: é a maior contagem de vértice da cena\n    if (opts.light) t.options.leaves.count = Math.round(t.options.leaves.count * 0.6);\n  });\n  scene.add(tree);\n\n  const box = new THREE.Box3().setFromObject(tree);\n  const size = box.getSize(new THREE.Vector3());\n  const altura = size.y;\n  const copaY = box.min.y + altura * 0.62;\n\n  // Chão quase branco: depois do duotone vira papel, e a linha do horizonte\n  // dissolve na névoa em vez de cortar a cena.\n  const chaoGeo = new THREE.PlaneGeometry(altura * 40, altura * 40);\n  const chaoMat = new THREE.MeshBasicMaterial({ color: gray(0.957) });\n  const chao = new THREE.Mesh(chaoGeo, chaoMat);\n  chao.rotation.x = -Math.PI / 2;\n  chao.position.y = box.min.y;\n  scene.add(chao);\n\n  const sombraTex = contactShadowTexture(256, 0.38);\n  const sombraGeo = new THREE.PlaneGeometry(size.x * 1.5, size.x * 1.1);\n  const sombraMat = new THREE.MeshBasicMaterial({\n    map: sombraTex,\n    transparent: true,\n    depthWrite: false,\n  });\n  const sombra = new THREE.Mesh(sombraGeo, sombraMat);\n  sombra.rotation.x = -Math.PI / 2;\n  sombra.position.y = box.min.y + 0.05;\n  scene.add(sombra);\n\n  const post = createFogPost(renderer, scene, camera, {\n    trail: opts.reduce ? 0 : opts.trail,\n    grain: opts.grain,\n    light: opts.light,\n  });\n\n  /*\n   * Órbita: o controle decide só o ÂNGULO. A distância é do progresso (abaixo),\n   * reescrita a cada quadro — por isso zoom e pan desligados, e o polar preso\n   * numa faixa estreita: abaixo dela a câmera entra no chão, acima ela vira\n   * planta baixa e a árvore perde a silhueta.\n   *\n   * Sem `domElement` quando não é arrastável. O OrbitControls põe\n   * `touch-action: none` no elemento ao conectar, e isso mata o scroll vertical\n   * de quem encosta o dedo na árvore — no celular, a seção vira uma armadilha.\n   * O giro ocioso continua: ele roda no `update()`, não depende de evento.\n   */\n  const foco = new THREE.Vector3(0, copaY * 0.82, 0);\n  camera.position.set(0, copaY * 0.55, altura * 3.6);\n  const controls = new OrbitControls(camera, null);\n  controls.target.copy(foco);\n  controls.enableZoom = false;\n  controls.enablePan = false;\n  controls.enableDamping = !opts.reduce;\n  controls.dampingFactor = 0.05;\n  controls.rotateSpeed = 0.45;\n  controls.minPolarAngle = Math.PI * 0.36;\n  controls.maxPolarAngle = Math.PI * 0.53;\n  controls.autoRotate = !opts.reduce;\n  controls.autoRotateSpeed = 0.25;\n  let arrastando = false;\n  const pegar = () => {\n    arrastando = true;\n    controls.autoRotate = false;\n  };\n  const soltar = () => {\n    arrastando = false;\n    controls.autoRotate = !opts.reduce;\n  };\n  controls.addEventListener(\"start\", pegar);\n  controls.addEventListener(\"end\", soltar);\n  // com movimento reduzido não há laço: cada arrasto pede o seu quadro\n  controls.addEventListener(\"change\", () => pedir());\n\n  let conectado = false;\n  const setDraggable = (on: boolean) => {\n    if (on === conectado) return;\n    conectado = on;\n    if (on) {\n      controls.domElement = canvas;\n      controls.connect();\n      // O `connect` escreve `none`: de lado gira, em pé a seção não vira armadilha.\n      canvas.style.touchAction = \"pan-y\";\n    } else {\n      controls.disconnect();\n      soltar();\n    }\n  };\n  setDraggable(opts.draggable);\n\n  const resize = () => {\n    const w = Math.max(1, canvas.clientWidth);\n    const h = Math.max(1, canvas.clientHeight);\n    renderer.setPixelRatio(densidadeDoCanvas(canvas, opts.light));\n    renderer.setSize(w, h, false);\n    post.setSize(w, h);\n    camera.aspect = w / h;\n    camera.updateProjectionMatrix();\n    pedir();\n  };\n  const ro = new ResizeObserver(resize);\n  ro.observe(canvas);\n  // A escala do palco muda com a janela sem mudar o tamanho de layout do canvas.\n  window.addEventListener(\"resize\", resize);\n\n  const alvo = { p: 0 };\n  const atual = { p: 0 };\n  const dir = new THREE.Vector3();\n  const relogio = new THREE.Clock();\n  let visivel = false;\n  let raf = 0;\n\n  const quadro = () => {\n    const t = relogio.getElapsedTime();\n    // O progresso chega com inércia própria além da mola do componente: a mola\n    // suaviza o scroll, esta suaviza o progresso passado à mão (número cru).\n    atual.p += (alvo.p - atual.p) * (opts.reduce ? 1 : 0.06);\n\n    controls.update();\n    // Retrato: a copa é mais larga que a tela estreita e sairia cortada nos\n    // lados. Recuar pela raiz da proporção devolve a silhueta sem afastar a\n    // árvore tanto que ela vire um ponto.\n    const retrato = camera.aspect < 0.8 ? Math.sqrt(0.8 / camera.aspect) : 1;\n    const dist = THREE.MathUtils.lerp(altura * 3.1, altura * 2.2, atual.p) * retrato;\n    dir.subVectors(camera.position, foco).normalize();\n    camera.position.copy(foco).addScaledVector(dir, dist);\n    camera.lookAt(foco);\n    fog.density = THREE.MathUtils.lerp(opts.fog.start, opts.fog.end, atual.p) / (altura * 3);\n\n    if (!opts.reduce) {\n      // a árvore inteira balança quase nada, além do vento do shader nas folhas\n      tree.rotation.z = Math.sin(t * 0.6) * 0.012;\n      tree.update(t);\n      post.setTime(t);\n    }\n    post.render();\n  };\n\n  const animando = () =>\n    visivel && (!opts.reduce || arrastando || Math.abs(alvo.p - atual.p) > 1e-4);\n\n  // `raf` só zera DEPOIS do quadro: o `controls.update()` lá dentro dispara\n  // \"change\", que chama `pedir()` — com `raf` já zerado, cada quadro agendaria\n  // dois, e o laço dobraria a cada volta.\n  const tick = () => {\n    quadro();\n    raf = animando() ? requestAnimationFrame(tick) : 0;\n  };\n  function pedir() {\n    if (visivel && !raf) raf = requestAnimationFrame(tick);\n  }\n\n  resize();\n\n  return {\n    setProgress(p) {\n      alvo.p = THREE.MathUtils.clamp(p, 0, 1);\n      pedir();\n    },\n    setColors(paper, ink) {\n      post.setColors(paper, ink);\n      pedir();\n    },\n    setRunning(on) {\n      if (on === visivel) return;\n      visivel = on;\n      if (on) {\n        post.resetTrail();\n        pedir();\n      } else if (raf) {\n        cancelAnimationFrame(raf);\n        raf = 0;\n      }\n    },\n    setDraggable,\n    setFog(v) {\n      opts.fog = v;\n      pedir();\n    },\n    setTrail(v) {\n      // movimento reduzido fica sem rastro: é a mesma regra de quando a cena nasce\n      if (opts.reduce) return;\n      post.setTrail(v);\n      pedir();\n    },\n    setGrain(v) {\n      post.setGrain(v);\n      pedir();\n    },\n    dispose() {\n      visivel = false;\n      if (raf) cancelAnimationFrame(raf);\n      ro.disconnect();\n      window.removeEventListener(\"resize\", resize);\n      controls.removeEventListener(\"start\", pegar);\n      controls.removeEventListener(\"end\", soltar);\n      controls.dispose();\n      disposeTree(tree);\n      chaoGeo.dispose();\n      chaoMat.dispose();\n      sombraGeo.dispose();\n      sombraMat.dispose();\n      sombraTex.dispose();\n      post.dispose();\n      releaseRenderer(renderer);\n    },\n  };\n}\n",
      "type": "registry:lib"
    },
    {
      "path": "registry/visant/ui/fog-tree.tsx",
      "content": "\"use client\";\n\n/**\n * Fog Tree — uma árvore procedural sozinha na névoa, em duotone da marca.\n *\n * Colhido de um site de cliente (2026-10), onde a seção do tema central leva a câmera\n * para dentro do jardim com o scroll enquanto a névoa abre. A peça vale fora\n * dali porque o efeito é de marca nenhuma: a cena é desenhada em cinza e só o\n * último passe pinta com `--background` (papel) e `--foreground` (tinta). Troca\n * de tema inverte a foto inteira; troca de marca troca dois tokens.\n *\n * Decisões que sobrevivem à colheita:\n *\n * 1. **O WebGL só desce perto da tela.** A cena mora em `@/lib/fog-tree-scene`\n *    e entra por `import()` quando a peça passa a 400px da viewport. O ez-tree\n *    embute as texturas no bundle; quem nunca rola até a seção não paga.\n * 2. **Fora da tela e com a aba escondida, zero quadro.** O laço para (não\n *    \"renderiza menos\"): GPU de notebook esquenta com cena parada rodando atrás\n *    do texto que a pessoa está lendo.\n * 3. **Arrastar só com ponteiro fino, por padrão.** O OrbitControls trava o\n *    `touch-action` do canvas, e no celular encostar na árvore deixaria de\n *    rolar a página. `draggable` força qualquer um dos lados.\n * 4. **Mola ANTES de qualquer transform, no modo `scroll`.** `useScroll` +\n *    `useTransform` direto é acelerado pelo ScrollTimeline nativo e erra a\n *    faixa dentro de `position: sticky` — medido no site de origem. A mola tira\n *    a cadeia do caminho nativo e ainda dá peso à câmera.\n * 5. **Movimento reduzido não é cena congelada às cegas.** Sem giro ocioso, sem\n *    vento, sem rastro e sem grão animado — mas o scroll ainda aproxima a câmera\n *    (é posição, não animação) e o arrasto ainda gira, quadro a quadro, sem\n *    laço contínuo.\n * 6. **Sem WebGL, o papel.** Se o contexto não nasce, a seção fica com o fundo\n *    do token e o texto por cima — nunca uma caixa de erro.\n *\n * Requer `three`, `@dgreenheck/ez-tree` e `framer-motion`.\n */\n\nimport * as React from \"react\";\nimport {\n  isMotionValue,\n  useMotionValue,\n  useReducedMotion,\n  useScroll,\n  useSpring,\n  type MotionValue,\n} from \"framer-motion\";\n\nimport { cn } from \"@/lib/utils\";\nimport { onThemeChange, resolveCssColor } from \"@/lib/css-color\";\nimport type { FogTreePreset, FogTreeScene } from \"@/lib/fog-tree-scene\";\n\nexport type { FogTreePreset };\n\nexport interface FogTreeProps\n  extends Omit<React.HTMLAttributes<HTMLElement>, \"children\"> {\n  /**\n   * Progresso 0..1 da caminhada: 0 é a árvore inteira ao longe, 1 é a câmera\n   * debaixo da copa com a névoa aberta. Número ou `MotionValue` (o de um\n   * `useScroll` seu, por exemplo). Ignorado com `scroll`.\n   */\n  progress?: number | MotionValue<number>;\n  /**\n   * Prende o progresso ao scroll da própria seção: a peça vira uma `<section>`\n   * com `scrollLength` de altura e o palco fica preso (sticky) na tela.\n   */\n  scroll?: boolean;\n  /** Altura da seção no modo `scroll`. Quanto maior, mais lenta a caminhada. */\n  scrollLength?: string;\n  /** Cor das luzes. Qualquer cor CSS; o padrão é o token de fundo. */\n  paper?: string;\n  /** Cor das sombras. O padrão é o token de texto. */\n  ink?: string;\n  /**\n   * Semente do ez-tree. Mesma semente, mesma árvore — em toda visita.\n   * @min 1\n   * @max 9999\n   * @step 1\n   */\n  seed?: number;\n  /** Espécie (preset do ez-tree). O `Oak Medium` ganha a copa redonda. */\n  preset?: FogTreePreset;\n  /** Densidade da névoa no começo e no fim do progresso. ~0.5 a 1.5. */\n  fog?: { start?: number; end?: number };\n  /** Girar arrastando. Padrão: só com ponteiro fino (mouse, caneta). */\n  draggable?: boolean;\n  /**\n   * Rastro de longa exposição. 0 desliga.\n   * @min 0\n   * @max 0.98\n   * @step 0.01\n   */\n  trail?: number;\n  /**\n   * Grão de película.\n   * @min 0\n   * @max 0.2\n   * @step 0.01\n   */\n  grain?: number;\n  /**\n   * Camada por cima da cena, para o texto da seção. Função recebe o progresso\n   * efetivo (já com mola no modo `scroll`), para o texto chegar junto da câmera.\n   * A camada é `pointer-events: none` — dê `pointer-events-auto` ao que clica.\n   */\n  children?: React.ReactNode | ((progress: MotionValue<number>) => React.ReactNode);\n}\n\nconst prefersLight = () =>\n  window.matchMedia(\"(pointer: coarse)\").matches || window.innerWidth < 768;\n\nexport function FogTree({\n  progress,\n  scroll = false,\n  scrollLength = \"220vh\",\n  paper = \"var(--background)\",\n  ink = \"var(--foreground)\",\n  seed = 4242,\n  preset = \"Oak Medium\",\n  fog,\n  draggable,\n  trail = 0.86,\n  grain = 0.05,\n  className,\n  style,\n  children,\n  ...props\n}: FogTreeProps) {\n  const rootRef = React.useRef<HTMLElement>(null);\n  const canvasRef = React.useRef<HTMLCanvasElement>(null);\n  const sceneRef = React.useRef<FogTreeScene | null>(null);\n  const reduce = useReducedMotion() ?? false;\n\n  // ── Progresso efetivo ────────────────────────────────────────────────────\n  // Os três ganchos rodam sempre (regra dos hooks); o modo só escolhe a fonte.\n  const { scrollYProgress } = useScroll({\n    target: rootRef,\n    offset: [\"start start\", \"end end\"],\n  });\n  const sprung = useSpring(scrollYProgress, { stiffness: 120, damping: 30, restDelta: 0.0005 });\n  const own = useMotionValue(typeof progress === \"number\" ? progress : 0);\n  const effective = scroll ? sprung : isMotionValue(progress) ? progress : own;\n\n  React.useEffect(() => {\n    if (typeof progress === \"number\") own.set(progress);\n  }, [progress, own]);\n\n  React.useEffect(() => {\n    sceneRef.current?.setProgress(effective.get());\n    return effective.on(\"change\", (v) => sceneRef.current?.setProgress(v));\n  }, [effective]);\n\n  // ── Ponteiro fino (SSR devolve falso; o efeito corrige no cliente) ───────\n  const [fine, setFine] = React.useState(false);\n  React.useEffect(() => {\n    const mq = window.matchMedia(\"(pointer: fine)\");\n    const read = () => setFine(mq.matches);\n    read();\n    mq.addEventListener(\"change\", read);\n    return () => mq.removeEventListener(\"change\", read);\n  }, []);\n  const canDrag = draggable ?? fine;\n\n  // ── Cores: token → sRGB, relido quando o tema muda ───────────────────────\n  const applyColors = React.useCallback(() => {\n    const el = rootRef.current;\n    if (!el || !sceneRef.current) return;\n    sceneRef.current.setColors(resolveCssColor(paper, el), resolveCssColor(ink, el));\n  }, [paper, ink]);\n  const applyRef = React.useRef(applyColors);\n  applyRef.current = applyColors;\n\n  React.useEffect(() => {\n    applyColors();\n    // Tema por classe/atributo no <html> E tema por media query: os dois\n    // existem por aí, e só um deles dispara o MutationObserver.\n    const off = onThemeChange(applyColors);\n    const mq = window.matchMedia(\"(prefers-color-scheme: dark)\");\n    mq.addEventListener(\"change\", applyColors);\n    return () => {\n      off();\n      mq.removeEventListener(\"change\", applyColors);\n    };\n  }, [applyColors]);\n\n  // ── Ciclo de vida da cena ────────────────────────────────────────────────\n  const fogStart = fog?.start ?? 0.85;\n  const fogEnd = fog?.end ?? 0.6;\n  const dragRef = React.useRef(canDrag);\n  dragRef.current = canDrag;\n  const liveRef = React.useRef({ fog: { start: fogStart, end: fogEnd }, trail, grain });\n  liveRef.current = { fog: { start: fogStart, end: fogEnd }, trail, grain };\n\n  React.useEffect(() => {\n    const canvas = canvasRef.current;\n    const root = rootRef.current;\n    if (!canvas || !root) return;\n    let alive = true;\n    let loading = false;\n    let near = false;\n\n    const running = () => near && document.visibilityState === \"visible\";\n    const sync = () => sceneRef.current?.setRunning(running());\n\n    const io = new IntersectionObserver(\n      ([e]) => {\n        near = !!e?.isIntersecting;\n        if (near && !sceneRef.current && !loading) {\n          loading = true;\n          import(\"@/lib/fog-tree-scene\")\n            .then(({ createFogTreeScene }) => {\n              if (!alive) return;\n              const scene = createFogTreeScene(canvas, {\n                preset,\n                seed,\n                ...liveRef.current,\n                draggable: dragRef.current,\n                reduce,\n                light: prefersLight(),\n              });\n              sceneRef.current = scene;\n              if (!scene) return;\n              applyRef.current();\n              scene.setProgress(effective.get());\n              sync();\n            })\n            // chunk que não desce (rede caiu, deploy novo) deixa o papel liso\n            .catch(() => {});\n        }\n        sync();\n      },\n      { rootMargin: \"400px 0px\" },\n    );\n    io.observe(root);\n    document.addEventListener(\"visibilitychange\", sync);\n\n    return () => {\n      alive = false;\n      io.disconnect();\n      document.removeEventListener(\"visibilitychange\", sync);\n      sceneRef.current?.dispose();\n      sceneRef.current = null;\n    };\n    // `effective` fica de fora: trocar a fonte do progresso não regera a árvore,\n    // o efeito acima já reassina. Só o que muda a geometria regera; névoa, rastro e\n    // grão chegam por método, senão cada tique de um slider refazia a árvore e o\n    // `forceContextLoss` do descarte deixava o canvas morto. Por isso o canvas tem `key`.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [preset, seed, reduce]);\n\n  React.useEffect(() => sceneRef.current?.setFog({ start: fogStart, end: fogEnd }), [fogStart, fogEnd]);\n  React.useEffect(() => sceneRef.current?.setTrail(trail), [trail]);\n  React.useEffect(() => sceneRef.current?.setGrain(grain), [grain]);\n\n  React.useEffect(() => {\n    sceneRef.current?.setDraggable(canDrag);\n  }, [canDrag]);\n\n  const content = typeof children === \"function\" ? children(effective) : children;\n\n  const stage = (\n    <>\n      <canvas\n        key={`${preset}|${seed}|${reduce}`}\n        ref={canvasRef}\n        aria-hidden\n        className={cn(\n          \"absolute inset-0 block h-full w-full\",\n          canDrag ? \"cursor-grab active:cursor-grabbing\" : \"pointer-events-none\",\n        )}\n      />\n      {content != null && (\n        <div className=\"pointer-events-none relative h-full w-full\">{content}</div>\n      )}\n    </>\n  );\n\n  if (scroll) {\n    return (\n      <section\n        ref={rootRef}\n        className={cn(\"relative\", className)}\n        style={{ height: scrollLength, background: paper, ...style }}\n        {...props}\n      >\n        <div className=\"sticky top-0 h-svh overflow-hidden\">{stage}</div>\n      </section>\n    );\n  }\n\n  return (\n    <div\n      ref={rootRef as React.RefObject<HTMLDivElement>}\n      className={cn(\"relative isolate h-[70svh] min-h-[420px] w-full overflow-hidden\", className)}\n      style={{ background: paper, ...style }}\n      {...props}\n    >\n      {stage}\n    </div>\n  );\n}\n\nexport default FogTree;\n",
      "type": "registry:ui"
    }
  ],
  "meta": {
    "uso": {
      "quando": "Abertura ou dobra de marca com uma árvore 3D na névoa em duotone que acompanha o scroll",
      "evite": "Percurso com várias paradas de texto: fog-garden; hero com vídeo, fog-hero"
    }
  },
  "categories": [
    "efeitos",
    "3d",
    "webgl",
    "nevoa",
    "arvore",
    "scroll",
    "duotone",
    "ez-tree"
  ],
  "type": "registry:ui"
}