houdini-bridge-mcp

Controle o SideFX Houdini a partir de um chat de IA — uma superfície de controle segura e somente de dados, onde a IA cria wrangles validados, nunca código arbitrário.

GitHubExperimente este MCPPatrocinado

Documentação

houdini-bridge-mcp

Dirija o SideFX Houdini a partir de um chat de IA — uma superfície de controle somente de dados e priorizando segurança, onde a IA cria wrangles validados, nunca código arbitrário.

Um servidor MCP (Model Context Protocol) nativo do Windows que permite que um cliente de chat de IA dirija o SideFX Houdini em uma ampla faixa de sua superfície criativa — por meio de um catálogo fixo de ferramentas tipadas e validadas, sem caminho de código arbitrário. A IA constrói e inspeciona redes de nós e pode criar um wrangle validado e limitado; você dispara os cooks e renders pesados. Ela também serve como uma forma segura de aprender Houdini — cada passo é uma operação guiada, explicável e em sandbox, não uma caixa-preta. O catálogo é amplo: geometria e limpeza · instancing · simulação (FLIP/Pyro/RBD/Vellum) · rigging e animação de personagens (KineFX, Crowd, Muscle) · composição de imagens COP · look e materiais · ML/ONNX · SideFX-Labs (árvores/biomas/construção de mundos) · render e exportação — além de uma linha única de geodados do mundo real (DEM / USGS 3DEP / LIDAR) que reprojeta e posiciona elevação em escala real. Um único binário roda ao lado do Houdini e do seu cliente de IA; essa é a instalação completa.

Status: v0.1.0 lançado — endurecido para segurança, completo em funcionalidades. O executor dentro do Houdini (a superfície de ferramentas tipadas), o downloader de terreno (cobertura global + nacional) e o binário driver em Rust + pacote Houdini estão todos incluídos — baixe o gateway na página de Releases. Alvo: Houdini 21.0.671 (a versão Apprentice funciona; Houdini 22 existe mas ainda não foi adotado aqui). Windows primeiro; outras plataformas depois.

Início rápido

Novo aqui / não é programador? Comece por aqui. Muitos usuários de Houdini já vivem em código e terminal — mas você não precisa. Para começar a funcionar, basta: obter um programa, clicar em alguns botões na janela dele, iniciar o Houdini e colar um pequeno bloco de configurações no seu cliente de IA. É só isso. Os três passos abaixo são o mapa; os Passos 1–7 numerados mais adiante detalham cada um, e você só toca em uma linha de comando se escolher compilar o programa a partir do código-fonte em vez de baixá-lo.

O que você precisará ter em mãos: Houdini 21.0.671 (a edição gratuita Apprentice é suficiente), um PC com Windows e um cliente de IA que fale MCP (Claude Desktop, Cursor, etc.). Uma pasta no seu disco se torna o projeto que a IA pode tocar — escolha-a no Passo 3.

Três passos para uma instalação funcional (detalhes completos nos Passos 1–7 abaixo):

Obtenha o gateway (o único programa que conecta sua IA ao Houdini) — ou baixe o houdini-bridge-mcp.exe pré-compilado na página de Releases (sem programação), ou compile a partir do código-fonte (cd gateway && cargo build --release, requer o toolchain Rust). É um único arquivo sem dependências de runtime.
Instale e arme — execute o gateway, que abre uma pequena janela GUI. Nela: clique em Install Houdini package (configura o Houdini para conectar automaticamente), defina seu diretório de trabalho e clique em Apply (a única pasta que a IA pode ler e escrever), e ative Auto-arm. Em seguida, inicie o Houdini — o indicador de status deve mostrar Armed. Antes de permitir acesso de qualquer coisa além desta máquina, execute o script de firewall (Passo 4).
Conecte seu cliente de IA — informe ao seu cliente de IA (Claude Desktop, Cursor, …) onde o gateway está, colando um pequeno bloco JSON na configuração dele (pronto para copiar e colar no Passo 6), reinicie completamente o cliente e execute a verificação do Passo 7 para confirmar que a IA consegue ver sua cena do Houdini.

Por que é diferente

Outros servidores MCP de Houdini/Blender expõem execução arbitrária de Python ao modelo — poderoso, mas é execução remota de código por design (em todo o campo pesquisado, toda ponte comparável inclui uma ferramenta do tipo execute_code, e uma ponte Blender amplamente usada tem um problema documentado de execução remota de código). Este é o inverso:

Somente dados por construção. A IA só pode chamar um registro fixo de 1.467 operações tipadas e validadas. Deliberadamente não há ferramenta de código arbitrário, não há setter genérico de parâmetros de nós e não há caminho bruto de VEX/Python — essas coisas simplesmente não existem no catálogo, então o limite não pode ser contornado. O conjunto de coisas que o servidor pode fazer é a lista enumerada de ferramentas.
Autoria validada — o diferencial, não uma porta de escape. A única ferramenta que carrega código, set_attrib_expr (opt-in, desligada por padrão), recebe um trecho de atributo VEX e o valida contra uma allowlist antes que o Houdini o veja: sem alcance de arquivo/host/rede, apenas funções na allowlist e comprovadamente total — sempre termina. O fluxo de controle é condicionais, loops contados estaticamente limitados (for — um teto de iteração literal ou limitado por min()) e um loop de array somente-folha com instantâneo finito (foreach, cuja contagem de iterações o VEX fixa na entrada, e que não pode aninhar dentro de outro loop ou conter outro loop); while/do/gather permanecem banidos, então não existe construto de loop infinito. Três capacidades se sobrepõem atrás de seus próprios consentimentos independentes, desligados por padrão: loops limitados (allow_attrib_loops), edições de topologia de exclusão (removepoint/removeprim, allow_attrib_geoedit) e construção/crescimento (addpoint/addprim/addvertex/removevertex, allow_attrib_geogrow) — todas fixadas na geometria de trabalho do input-0, e cada consentimento é independente (ativar um nunca concede outro). A maior parte do trabalho de wrangle é coberta por operadores tipados de qualquer forma (cálculo de campos, matemática por voxel, CSG/advecção via vdb_*); vex_reference também serve como referência de funções offline para colar manualmente.

Esta é a linha que nenhum outro MCP de Houdini mantém: a IA pode criar um wrangle real e capaz sem nunca lhe entregar um shell remoto. Toda ponte de terceiros entrega execute_code/VEX bruto sem validação — RCE por design. O próprio MCP oficial que a SideFX está preparando valida depois o código gerado quanto à correção, e apenas para rigging. Este valida um subconjunto limitado da entrada, antes de executar, em todo o conjunto de ferramentas — um modelo mais restrito, não uma porta menor.
Aprenda Houdini com uma IA — com segurança, não apenas dirija-o. Cada ação é uma operação tipada, em sandbox e explicável, e a IA lhe entrega o wrangle validado exato que propõe — então ela funciona como um tutor guiado: peça para construir algo, observe como ela conecta a rede, leia o porquê. Nada do que ela faz pode executar código arbitrário na sua máquina ou tocar em trabalho fora da pasta do projeto, o que a torna tão segura para a primeira cena de um iniciante quanto para um pipeline travado. Os mesmos trilhos que a mantêm segura fazem dela um lugar de baixo risco para aprender como o Houdini realmente funciona.
Um único diretório de trabalho. Toda leitura e escrita de arquivo é confinada por realpath a uma única pasta de projeto que você escolhe. Nada fora dela é acessível, nem mesmo por symlink ou junction.
Renders são apenas via wire. A IA constrói grafos de render (Karma, texture bake); você os dispara. Ela nunca aciona um render por conta própria.
Construído para geodados do mundo real. É o único do tipo voltado para DEM / 3DEP / LIDAR: reprojeta e posiciona elevação em escala real, reconstrói nuvens de pontos em malhas limpas (plane-fit e remesh, não blobs orgânicos) e pode fixar tiles em um enquadramento correto da Terra.
Amplo, não apenas terreno. O pipeline geoespacial é a especialidade, mas a mesma superfície tipada e somente-dados abrange a maior parte do Houdini: modelagem e limpeza, os principais solvers, rigging e animação de personagens (esqueletos/capture/deform KineFX, Crowd, Muscle), composição de imagens COP, ML/ONNX e o conjunto de ferramentas SideFX-Labs de árvores/biomas/construção de mundos — tudo sob o mesmo limite de no-RCE.

Aprenda Houdini com uma IA

O Houdini é famosamente profundo, e o momento da rede em branco é onde a maioria das pessoas desiste. Esta ponte é uma forma guiada e de baixo risco de sentar e de fato aprender — você descreve o que quer, a IA constrói na sua sessão ao vivo, e você observa a rede tomar forma.

Não é um brinquedo. A superfície de ferramentas alcança uma fatia ampla e capaz do Houdini real — modelagem e limpeza, configuração de simulação de geometria (FLIP / Pyro / RBD / Vellum), rig e animação de personagens (KineFX, Crowd, Muscle), composição de imagens COP, look e materiais, e o conjunto de ferramentas SideFX-Labs de árvores/biomas/mundo. Você pode aprender um fluxo de trabalho genuíno, não uma imitação de sandbox. (Veja os números honestos de cobertura abaixo para exatamente o que está dentro e fora do escopo.)
Os endpoints tipados são o andaime de aprendizado. Cada capacidade é uma operação fixa, tipada e validada, então a IA só pode alcançar operações reais do Houdini — ela não pode vagar para fora do que o software realmente faz ou inventar um passo que não existe. A própria lista de ferramentas espelha como o Houdini é organizado (as famílias SOP/COP/DOP/KineFX, o conjunto de ferramentas Labs), então a superfície que limita a IA também ensina como o aplicativo é estruturado.
Você a observa, não a executa às cegas. Cada operação transmite ao vivo para o log de auditoria da GUI do gateway, então você vê a IA trabalhar passo a passo em uma sessão do Houdini em execução — a rede é construída diante de você, nó por nó, em vez de executada em um lote headless que você nunca observa. Esse modo ao vivo e observado é a vantagem de aprendizado. (Operação headless ainda é suportada para usuários avançados que a desejam.)
Erros viram momentos de ensino, não desastres. A IA pode errar — escolher o nó errado ou avaliar mal um parâmetro. O ponto não é que ela nunca erre; é que a superfície tipada, em sandbox e inspecionável torna qualquer erro visível, fácil de desfazer e inofensivo. Nada do que ela faz executa código arbitrário ou toca em arquivos fora da sua pasta de projeto, então um passo ruim é algo que você captura e corrige enquanto aprende o porquê, não algo que pode danificar sua máquina ou seu trabalho.
- É por isso que não foi construída sobre uma ponte execute_code existente. O design assume que o modelo pode errar, ser manipulado (prompt injection) ou apresentar mau funcionamento — e que dar a um agente código arbitrário mais um objetivo é o modo de falha de alta gravidade documentado (agentes que escapam de sua sandbox, agem de forma autônoma e não detectada e alcançam credenciais/rede/arquivos). Então, em vez de iterar a partir de um MCP de Blender/Houdini que entrega um shell ao modelo, este corta o caminho de código completamente e reconstrói somente-dados: o catálogo tipado fixo é o limite. A limitação é a propriedade de segurança. Veja SECURITY.md para a justificativa completa.

Cobertura honesta — o que está no escopo e o que não está. Por contagem bruta, o catálogo alcança uma minoria deliberada dos tipos de nós não obsoletos do Houdini — expostos como as 1.467 ferramentas tipadas do catálogo (um tipo de nó costuma ser alcançado por várias ferramentas, e famílias inteiras — VOP / SHOP / COP-interno / PDG — são excluídas por design, não por omissão). Mas esse número bruto subestima a cobertura criativa, porque é fortemente ponderado para os fluxos de trabalho que a maioria das pessoas realmente usa e deixa alguns domínios inteiros de fora de propósito:

Bem coberto (o núcleo criativo): composição COP ~84%, modelagem/geometria SOP ~49%, SideFX-Labs ~65%, rig/animação KineFX ~53%.
Deliberadamente fora do escopo (decisões de escopo, não bugs): USD / Solaris (LOP) ~10%, PDG / TOP 0% (o domínio de batch / grafo de dependências), contextos legados Cop2 e Shop, e internals de VOP (1,3% — por design: um VOP é um bloco de construção interno de grafo, não uma superfície de dados que a ponte expõe).

Em resumo: cerca de um quarto da superfície de nós do Houdini por contagem bruta, mas ponderado para os fluxos de trabalho criativos que a maioria das pessoas realmente usa, com alguns domínios inteiros (USD/Solaris, PDG) intencionalmente deixados de fora. Um recém-chegado sabe de antemão o que pode aprender aqui e o que não pode.

O que você pode fazer com ele

Uma vez instalado e armado, você pode dizer coisas assim diretamente no seu cliente de chat de IA (os caminhos são relativos ao único diretório de trabalho que você configura):

"Construa o terreno em torno de 46,5°N, 114,0°O com resolução de 10 m e coloque uma câmera nele."
"Busque elevação para esta caixa delimitadora e importe-a em escala real."
"Carregue scans/site.ply, limpe o ruído e faça a malha."
"Eroda este heightfield e depois mascarar as ravinas e as encostas sombreadas."
"Espalhe rochas pelo terreno com instancing empacotado para que o viewport permaneça leve."
"Me dê uma luz de sol para o fim da tarde e enquadre a crista."
"Configure um render Karma apontado para essa câmera — eu apertarei o botão."
"Exporte a malha do terreno como USD para a minha pasta de projeto."
"Construa um esqueleto KineFX para essa malha, capture-a e teste a deformação do bind."
"Configure uma multidão de agentes caminhando por um caminho através do terreno."
"Lance uma simulação FLIP naquela bacia e armazene em cache apenas o wire."
"O que há na cena agora, e quanta memória o Houdini está usando?"

Como funciona

  AI / MCP client  ──stdio──▶  houdini-bridge-mcp  (one binary: config + GUI + gateway)
                                        │  loopback HTTP
                                        ▼
                               a data-only executor running inside your live Houdini session

O binário é tanto uma pequena GUI (front-of-house: localiza o Houdini, define o diretório de trabalho, gera um token de sessão, mostra um log de auditoria ao vivo de cada chamada) quanto o gateway MCP headless com o qual seu cliente de IA fala via stdio.
O gateway é a porta de entrada tipada: cada tools/call é validado contra o catálogo — chaves desconhecidas rejeitadas, números limitados à faixa, enums verificados, caminhos confinados — antes de qualquer coisa ser encaminhada.
O executor é um pacote Python somente de dados que se arma automaticamente dentro da sua sessão do Houdini e executa a operação solicitada em nós reais.

O gateway e o executor compartilham um token, porta e diretório de trabalho, com fonte única a partir de um pequeno arquivo de configuração que a GUI escreve — então não há trechos de shell manuais e nenhuma dança de colisão de porta.

Requisitos

Houdini 21.0.671 — Apprentice funciona (a edição gratuita; nenhuma compra de licença necessária para testar isso).
Uma toolchain Rust (estável) — somente se você compilar o gateway você mesmo; pule se você baixar o .exe pré-compilado das Releases. rustup.rs
Python — apenas para o downloader de terreno opcional (rasterio para a etapa de preparação de dados DEM); qualquer CPython recente funciona. Não é necessário para uma primeira execução.
Windows — Windows primeiro; outras plataformas depois.

Passo 1 — Obtenha o gateway

Prefere não programar? Baixe o houdini-bridge-mcp.exe pré-compilado das Releases e vá direto para o Passo 2 — é o mesmo binário único que a compilação produz. Quer compilar a partir do código fonte em vez disso (ou não há binário pré-compilado para sua configuração ainda)? Execute:

cd gateway
cargo build --release

De qualquer forma, você acaba com um arquivo — o gateway é tanto a GUI quanto o servidor MCP headless. Qual modo ele executa é selecionado na inicialização por uma variável de ambiente, HMCP_GW_HEADLESS — não definida abre a janela da GUI, 1 executa o servidor stdio headless. (Você normalmente não define isso manualmente: dar duplo clique no arquivo abre a GUI, e o bloco de configuração no Passo 6 define o sinalizador headless para seu cliente de IA.)

Passo 2 — Instale o pacote Houdini de auto-armação

Isso coloca um pequeno package do Houdini que arma o executor automaticamente quando a GUI do Houdini inicia — então a ponte sobe pronta, sem etapa de "iniciar o servidor".

Via GUI (recomendado): inicie o binário e depois Configurações → Instalar pacote do Houdini.

Ou manualmente, copie os dois arquivos de pacote estáticos para o seu diretório de preferências do usuário do Houdini (padrão para %USERPROFILE%\Documents\houdini21.0):

houdini_package/houdini-bridge-mcp.json            →  <houdini-user-pref-dir>/packages/houdini-bridge-mcp.json
houdini_package/houdini-bridge-mcp/scripts/456.py  →  <houdini-user-pref-dir>/houdini-bridge-mcp/scripts/456.py

Os arquivos de pacote são distribuíveis — sem caminhos absolutos, nomes de usuário ou valores da máquina; tudo dinâmico é lido em tempo de execução do arquivo de configuração compartilhado.

Passo 3 — Configure via GUI

Inicie o binário com HMCP_GW_HEADLESS não definido para que a janela apareça, então:

Configurações — confirme a porta do executor e o token de sessão (os padrões são suficientes; o token é o segredo compartilhado entre as duas metades).
Diretório de trabalho — digite sua raiz do projeto. Cada subdiretório abaixo dela é alcançável; nada fora dela é. Clique em Aplicar.
De volta em Configurações, ative Auto-armar Houdini.

Aplicar + Auto-armar escrevem o arquivo de configuração compartilhado (arm.json, sob seu perfil de usuário) que a GUI, o executor e o gateway headless leem ao vivo. Alterar o diretório de trabalho depois é apenas Aplicar — sem reinicialização.

Onde arm.json vive / habilitando VEX seguro. arm.json é a raiz de confiança — diretório de trabalho, token de sessão, porta e sinalizadores de recursos — em:

%USERPROFILE%\.houdini-bridge-mcp\arm.json     (Windows)
~/.houdini-bridge-mcp/arm.json                 (macOS / Linux)

O único caminho de código opt-in, set_attrib_expr, está desligado por padrão. Para ativá-lo, abra Configurações → Safe-VEX (avançado) e alterne Habilitar safe-VEX (allow_attrib_expr) — isso tem efeito imediato (o executor relê o sinalizador a cada chamada; sem reinicialização). Esse painel também tem Abrir arm.json e Abrir pasta de configuração se você preferir editar manualmente; para habilitar manualmente, defina "allow_attrib_expr": true no arquivo. Este é um interruptor somente para operador — um agente de condução nunca pode alcançar arm.json (é mantido fora dos limites mesmo quando o diretório de trabalho está configurado incorretamente para um ancestral), então a IA não pode ativar seu próprio caminho de código. Desligue-o da mesma forma quando terminar.

Passo 4 — Reforce o firewall

O executor arma fail-closed — ele se recusa a armar a menos que uma regra de firewall bloqueie conexões de entrada para sua porta loopback. Execute o script incluído uma vez, de um shell elevado:

scripts/harden-firewall.ps1              # -Mode loopback (default): loopback-only, single machine
scripts/harden-firewall.ps1 -Mode lan    # allow a trusted studio LAN to reach the executor

Use loopback (o padrão) para uma única máquina confiável; use lan apenas em uma rede de estúdio confiável.

Passo 5 — Arme o executor

Inicie o Houdini. O pacote instalado auto-arma o executor a partir da configuração compartilhada — o console imprime:

[houdini-bridge-mcp] executor armed

O pílula de status da GUI mostra Armado com a versão do Houdini conectado — para a maioria das pessoas, essa pílula é toda a confirmação que você precisa. Nenhum trecho de shell Python é necessário. Se quiser verificar a partir de um terminal (opcional, para os curiosos — use sua porta e token configurados):

curl.exe http://127.0.0.1:8765/health -H "X-HMCP-Token: <your-token>"

→ {"ok": true, "service": "houdini-bridge-mcp", ...}

Passo 6 — Registre com seu cliente MCP

Aponte seu cliente (ex.: Claude Desktop — edite o arquivo em %APPDATA%\Claude\claude_desktop_config.json; cole esse caminho na barra de endereço do Explorador de Arquivos para encontrá-lo) para o binário do gateway em modo headless (sem janela — a IA o executa diretamente). O gateway lê o diretório de trabalho, porta e token do arquivo de configuração compartilhado, então o bloco de ambiente só precisa do sinalizador headless. Defina command como o caminho completo do .exe do Passo 1:

{
  "mcpServers": {
    "houdini-bridge-mcp": {
      "command": "<path-to-repo>\\gateway\\target\\release\\houdini-bridge-mcp.exe",
      "env": {
        "HMCP_GW_HEADLESS": "1"
      }
    }
  }
}

Use barras invertidas duplas em todos os caminhos do Windows.

Saia completamente e reabra o cliente. Em um novo chat, as ferramentas houdini-bridge-mcp aparecem.

Passo 7 — Verifique sua configuração

Confirme se o pílula de status da GUI mostra Armado com sua versão do Houdini.
Em um novo chat do cliente, peça um relatório de cena:

"Execute scene_info."

Uma resposta bem-sucedida (arquivo hip, quadro, versão do Houdini, conteúdo de /obj) confirma o link cliente → gateway → executor de ponta a ponta.
Em seguida, transforme um tile DEM preparado em um heightfield real:

"import_heightfield de terrain.npy, nomeie-o terrain e exiba-o."

Se ambos retornarem, você está conectado. Veja docs/SETUP.md para o passo a passo completo da primeira execução e docs/GUIDE.md para operação do dia a dia.

Ferramentas disponíveis

Cerca de 1.467 operações tipadas, agrupadas nas famílias abaixo (as tabelas geradas mostram o catálogo exato atual). Cada ferramenta é um manipulador validado — nenhum caminho de código livre existe. Referência completa de parâmetros: veja docs/GUIDE.md, ou pergunte à ferramenta node_reference ao vivo na sessão.

Adquirir & importar

Ferramenta	O que faz	Parâmetros-chave
`acquire_terrain`	Busca elevação do mundo real para um local e a prepara como tiles prontos para Houdini no diretório de trabalho.	11 opcionais
`create_geo`	Cria uma geometria /obj vazia, opcionalmente inicializada com um SOP primitivo inicial.	`name` (+1 opcional)
`import_pointcloud`	Carrega/importa uma NUVEM DE PONTOS .ply ou .bgeo (LIDAR, fotogrametria, pontos de varredura) em uma nova geometria /obj via um File SOP. up_axis z_up rotaciona dados de levantamento Z-up para o Y-up do Houdini; downsample mantém cada N-ésimo ponto para aliviar nuvens pesadas; recenter move para a origem.	`path`, `name` (+3 opcionais)
`import_heightfield`	Importa um DEM preparado (.npy + .json sidecar) como volume de altura do Houdini, posicionado na elevação real em uma origem de projeto compartilhada (Z negado).	`npy`, `name` (+1 opcional)
`import_ecef_tile`	Fixa um tile DEM preparado (um prep_ecef .npy de posições (H,W,3)) no globo como uma malha quádrica curva em sua posição e elevação reais.	`npy`, `name` (+1 opcional)
`list_working_dir`	Lista os arquivos e pastas no DIRETÓRIO DE TRABALHO confinado para DESCOBRIR quais ativos estão presentes antes de importar — a resposta para "você consegue ver meu arquivo?".	5 opcionais
`import_geo`	Carrega/importa um arquivo de geometria de MALHA — .obj, .bgeo/.bgeo.sc, .fbx, .stl, .ply, .geo e outros formatos do File SOP — em uma nova geometria /obj. include_prim_types carrega como geometria compactada (memória plana para ativos pesados).	`path`, `name` (+1 opcional)
`import_alembic`	Carrega/importa um arquivo Alembic (.abc) — malhas animadas/cacheadas, câmeras e transformações — em uma nova geometria /obj via um Alembic SOP. groupnames escolhe como os caminhos do arquivo se tornam grupos de primitivas; polysoup carrega polígonos como primitivas de sopa de polígonos com baixo uso de memória.	`path`, `name` (+2 opcionais)
`trace_raster`	Traça/vetoriza um raster de imagem (.png/.jpg/.tif) em CURVAS de contorno 2D via o Trace SOP — transforma um logotipo, silhueta, máscara ou mapa em curvas poligonais para extrusão/varredura.	`file`, `name` (+2 opcionais)
`osm_filter`	SideFX Labs OSM Filter — mantém apenas as classes de feições desejadas da geometria OpenStreetMap importada (entrada 0 = saída de um osm_import).	`input` (+12 opcionais)
`osm_buildings`	SideFX Labs OSM Buildings — extrui massas de edifícios 3D a partir dos polígonos de pegada fechados do OpenStreetMap na entrada 0 (saída de osm_import / osm_filter com o atributo de primitiva `building`).	`input` (+8 opcionais)
`obj_importer`	SideFX Labs OBJ Importer — uma geo /obj nova que importa um arquivo Wavefront .obj (`file`, confinado a LEITURA) com um .mtl opcional customizado (`custom_mtl`, confinado a LEITURA).	`name`, `file` (+1 opcional)
`fbx_archive_import`	SideFX Labs FBX Archive Import — uma geo /obj nova que importa um arquivo FBX (`file`, confinado a LEITURA) como geometria Houdini mesclada, opcionalmente com materiais/animação/ossos.	`name`, `file` (+10 opcionais)
`multi_file`	SideFX Labs Multi File — uma geo /obj nova que importa até oito arquivos de geometria de uma vez (`file1`..`file8`, cada um confinado a LEITURA) e os mescla, opcionalmente carimbando um atributo `name` de cada nome de arquivo.	`name`, `file1` (+9 opcionais)
`regions_from_image`	SideFX Labs Regions From Image — uma geo /obj nova que lê uma imagem (`image`, confinada a LEITURA) e gera geometria de regiões quantizada por cor (`num_colors` regiões; `smoothing` suaviza os limites).	`name` (+9 opcionais)
`trace_psd_file`	SideFX Labs Trace PSD File — uma geo /obj nova que lê uma imagem em camadas (`file`, confinada a LEITURA; um Photoshop .psd) e traça suas camadas em contornos poligonais 2D.	`name`, `file`
`las_import`	Ingestão nativa de LAS/LAZ/E57 LIDAR (o verdadeiro formato de entrega de levantamento/aéreo) em uma nova geo /obj.	`name`, `file` (+13 opcionais)
`osm_import`	Importa estradas/edifícios/pegadas do OpenStreetMap (geometria de contexto do local) em uma nova geo /obj.	`name`, `file` (+4 opcionais)
`usd_import_sop`	Importa um arquivo USD em geometria SOP dentro de uma geo /obj nova (o `usdimport` de contexto SOP — a ponte de leitura de um estágio USD para SOPs nativos do Houdini).	`file` (+12 opcionais)

Terreno & heightfields

Ferramenta	O que faz	Parâmetros-chave
`heightfield_crop`	Recorta / redimensiona / re-enquadra um volume de altura para uma caixa de tamanho em metros. sizex/sizey são a largura e o comprimento da janela; center [x,y,z] posiciona a janela (deslize-a sobre um campo maior com cropmode=replace); cropmode é intersect (corta para sobreposição, padrão), replace (usa a nova caixa, estende além do original via política de borda) ou union (bbox de ambos); voxelpad adiciona voxels de preenchimento.	`input` (+6 opcionais)
`heightfield_patch`	Transfere/mistura características de um volume de altura de patch (input1) para uma base (input0) com uma fronteira suave — mosaico de tiles DEM adjacentes ou carimba uma região mascarada. scale escala uniformemente o patch (grade + magnitude da característica) antes da transferência; heightscale escala apenas as alturas das características transferidas; tx/tz transladam e ry rotaciona em torno de Y o patch antes da transferência; centerpatch pivota essas alças na região mascarada.	`input`, `patch` (+7 opcionais)
`convert_heightfield`	Converte um volume de altura em geometria renderizável/exportável. conversion escolhe a saída (poly \| polysoup denso-não-editável \| vdb volume 3D); surftype é a conectividade do polígono (triângulos/quads são os layouts de terreno úteis); lod é Densidade = razão de resolução de saída (0.5 = meia res, 2 = 4x supersample); bake_colors assa o material do heightfield na malha como ponto Cd para que o entregável carregue o gradiente; extrude_base + depth adicionam uma base extrudada sólida (à prova d'água para impressão/CFD).	`input` (+8 opcionais)
`heightfield_morph`	Morfologia em escala de cinza na camada de altura de um heightfield /obj nomeado, construída no lado do servidor como uma cadeia de volume-wrangles separáveis de min/max (nenhum SOP nativo único). op: dilate (crescer picos) \| erode (crescer vales) \| close (preencher canais até o envelope circundante, manter picos) \| open (remover picos finos). radius_m define o raio do kernel em metros (convertido para voxels via voxelsize).	`name` (+5 opcionais)
`heightfield_fill`	Relaxamento Laplaciano mascarado, construído no lado do servidor como uma cadeia de volume-wrangles de Jacobi (nenhum SOP nativo único): preenche voxels mascarados (mask==1) calculando a média dos vizinhos enquanto mantém voxels não mascarados (mask==0) como fronteira de Dirichlet — reconstrói uma superfície suave através de um canal/buraco. iterations = passos de Jacobi (mais = preenchimento mais suave/mais distante); seed_layer opcionalmente pré-semeia os voxels mascarados.	`name` (+5 opcionais)
`heightfield_tilesplit`	Divide um heightfield em uma grade tiles_x por tiles_y (LOD nativo / streaming / exportação por tile para game engine).	`input` (+7 opcionais)
`heightfield_clip`	Recorta valores de altura para uma faixa mín/máx (clamp de outliers / achatamento de mesa). minheight/maxheight são o piso/teto do recorte (cada um ativa automaticamente seu toggle de recorte); soft_clip suaviza a transição para o valor recortado em vez de um clamp rígido (padrão ligado) e clip_strength define sua nitidez.	`input` (+5 opcionais)
`heightfield_cutout`	Recorta uma região não retangular do heightfield delimitada por geometria (input1), escrevendo a camada de exibição `Alpha` (recorte com Alpha=0.5).	`input` (+5 opcionais)
`heightfield_erode`	Erosão hidráulica + térmica em uma escala de característica escolhida (HeightField Erode 3.0).	`input` (+27 opcionais)
`heightfield_visualize`	Aplica um color ramp a um heightfield para que sua elevação (e uma tonalidade de máscara opcional) seja visível no viewport — insere no espaço de voxel nativo. layer é a camada de altura exibida como superfície 3D (parm do nó `heightvolume`); color_layer tinge uma camada de máscara sobre ela; preset escolhe um esquema difuso embutido (infrared/pink/mono/blackbody/bipartite); min_elevation/max_elevation fixam a faixa altura->ramp, ou deixe compute_range ligado (padrão) para pressionar automaticamente os botões Compute Range do SOP para que o ramp mapeie a elevação real.	`input` (+8 opcionais)
`heightfield_maskbyfeature`	Mascara o terreno por uma ou mais características (inclinação / altura / direção de face / curvatura) — isola picos, vales, linha de neve, solo plantável.	`input` (+17 opcionais)
`heightfield_maskbyocclusion`	Máscara de oclusão ambiente (cavidades / fendas / solo abrigado) na camada de máscara — oclusão é o quanto de uma esfera ao redor de cada voxel é bloqueado pelo terreno próximo (ray-cast). minexposure/maxexposure remapeiam a faixa de oclusão na máscara (abaixo de min->0, acima de max->1); dohemisphere amostra apenas o hemisfério superior (céu); viewdistance é o comprimento do raio (0=infinito, mais longo=mais preciso/mais lento).	`input` (+9 opcionais)
`heightfield_maskbyshadow`	Mascara as áreas sombreadas a partir de uma direção de sol dada (controla derretimento de neve, musgo, vestimenta de sol/sombra). lightdir é o azimute do sol em graus (0=luz ao longo de +X, +90=ao longo de -Z); lightangle é a elevação do sol em graus (menor=sombras mais longas); opacity é o valor da máscara na sombra; falloff suaviza as bordas da sombra (0=dura).	`input` (+9 opcionais)
`heightfield_maskbyobject`	Mascara uma região do heightfield a partir de outra geometria (input1, object-merged) na camada de máscara — o contorno 2D da geometria de superfície, ou a interseção de um volume de névoa/SDF (para projeção de altura 3D use heightfield_project em vez disso). method: ray (projeta uma superfície para baixo) \| volume (névoa) \| sdf; maskdir (método ray): projeta de ambos os lados \| acima \| abaixo; maxdist é a distância máxima do raio antes de um erro; value é o valor da máscara onde a geometria atinge; blurradius suaviza a máscara.	`input` (+11 opcionais)
`heightfield_flatten`	Achata uma região mascarada de um heightfield (apaga características, ou nivela a pegada de um edifício). method: value = define a área mascarada para `elevation` (definir elevação força este modo); average = nivela para a média da própria área mascarada; slope = interpola suavemente a fronteira (padrão; ignora elevação). mask_layer controla o achatamento (0=intocado, 1=totalmente plano); blurradius suaviza a borda da máscara.	`input` (+5 opcionais)
`heightfield_maskbyconcavity`	Mascara regiões côncavas (leitos de rios / vales / ravinas) em uma camada de máscara — a concavidade é medida pela visibilidade do céu (raios lançados de cada voxel). concavity/maxconcavity definem a faixa mascarada (adiciona voxels cuja concavidade é >= concavity e <= maxconcavity); invert mascara fora dessa faixa; combine mescla com uma máscara existente; viewdistance é o comprimento do raio (mais longo=mais preciso/mais lento).	`input` (+7 opcionais)
`heightfield_deform`	Deforma geometria por um heightfield EM MUDANÇA: pontos sobem/descem (e opcionalmente rotacionam para a nova inclinação) pela diferença entre o terreno em repouso e o atual — por exemplo, flutuar props empacotados em uma superfície de água, ou aplicar uma inclinação de rebote isostático.	`input` (+3 opcionais)
`heightfield_layer`	Utilitário por camada em uma camada de heightfield nomeada. op=clear define cada voxel da camada para `value`. op=prop define a política de extensão de borda da camada `border` (constant \| repeat \| streak \| sdf) — importa ao ladrilhar/mesclar campos. op=isolate copia a camada para `mask` (e opcionalmente `height` via overwrite_height/overwrite_mask) para que o viewport padrão com tint vermelho a exiba.	`input` (+7 opcionais)
`terrain_analysis`	Labs Terrain Analysis: escreve atributos de ponto de inclinação / curvatura para scattering, pathfinding e shading.	`input` (+7 opcionais)
`add_tile_packed`	Carrega um tile .bgeo(.sc) assado como uma primitiva packed-disk (carregada com atraso, custo de exibição quase zero) em um novo /obj geo — a maneira segura de memória para transmitir muitos tiles de terreno.	`name`, `path` (+3 opcionais)
`set_tile_lod`	Alterna o LOD do viewport de um tile empacotado (proxy de caixa <-> geometria completa) para uma troca hero — tem como alvo o File SOP `packed_tile` criado por add_tile_packed sob o /obj geo nomeado.	`name` (+1 opcional)
`heightfield_noise`	Adiciona ruído procedural a uma camada de heightfield (superfície de ruído completa: combine, amp/scale/offset, basis+fractal, octaves, gain/bias, clipping, lattice/gradient warp).	`input` (+32 opcionais)
`heightfield_blur`	Desfoca / desfoque de caixa / expande / encolhe / nitidifica uma camada de heightfield.	`input` (+10 opcionais)
`heightfield_flowfield`	Chuva sobre um heightfield e desliza a água ladeira abaixo para calcular camadas de fluxo / direção de fluxo (controla máscaras de erosão, deposição, vales topográficos rápidos).	`input` (+15 opcionais)
`heightfield_project`	Raycast da geometria de entrada (objeto, object-merged no input1) em uma camada de heightfield como altura 3D — carimba geometria real no terreno (para uma máscara de contorno 2D plana use heightfield_maskbyobject).	`input` (+16 opcionais)
`heightfield_scatter`	Espalha pontos marcados por um heightfield usando sua camada de máscara (colocação de assets / instâncias, heightfield_scatter 2.0).	`input` (+45 opcionais)
`heightfield_terrace`	Corta terraços escalonados / mesas em um heightfield (heightfield_terrace 2.0) com ruído de ondulação e máscaras de inclinação de mesa/penhasco.	`input` (+22 opcionais)
`heightfield_remap`	Remapeia a faixa de valores de uma CAMADA de heightfield (heightfield_remap) — reescala altura/máscara/qualquer camada escalar de [input_min,input_max] para [output_min,output_max]: normaliza um DEM para 0..1, aumenta o contraste da máscara, inverte uma camada (troca min/max de saída), comprime elevação.	`input` (+9 opcionais)
`heightfield_resample`	Reamostra um heightfield para uma nova resolução (heightfield_resample) — reduz a resolução de um DEM enorme para iteração rápida, ou aumenta antes de erosão/exportação. resolution_scale multiplica a res atual (0.5=metade, 2=dobro), ou exact_resolution + division_mode para um alvo preciso.	`input` (+7 opcionais)
`hf_combine_masks`	SideFX Labs Combine Masks — mescla e pós-processa camadas MASK de heightfield no heightfield de entrada (`input`, input 0).	`input` (+11 opcionais)
`hf_insert_mask`	SideFX Labs Insert Mask — copia uma camada MASK/altura nomeada de um segundo heightfield (`mask`, input 1) para o heightfield base (`input`, input 0).	`input`, `mask` (+4 opcionais)
`terrain_segment`	SideFX Labs Terrain Segment — divide o heightfield de entrada (`input`, input 0) em uma grade tiles_x x tiles_y de tiles de terreno meshados (sua saída SOP cozida É a geometria segmentada). doextrude+depth dão saias sólidas; flat assa para uma malha plana; iterations controla o remesh de densidade adaptativa.	`input` (+12 opcionais)
`terrain_texture`	SideFX Labs Terrain Texture — baker de mapas de terreno SOMENTE-WIRE: assa mapas de normal / altura / oclusão / cavidade / curvatura do terreno de entrada (`input`, input 0) para `outputdir`.	`input` (+15 opcionais)
`terrain_layer_export`	SideFX Labs Terrain Layer Export — SOP exportador SOMENTE-WIRE que escreve o heightfield de entrada (`input`, input 0) como heightmap de landscape Unreal/Unity + imagens de camada de pintura para `output`.	`input` (+12 opcionais)
`terrain_layer_import`	SideFX Labs Terrain Layer Import — nó SOURCE (0 entradas) que lê uma imagem de heightmap de landscape Unreal/Unity (`sHeightmap`) em um novo /obj heightfield. voxelsize define a resolução HF resultante; bFlop inverte a ordem das linhas.	`name` (+3 opcionais)
`biome_define`	SideFX Labs Biome Define — define o perfil climático de UM bioma (nome + temperatura/precipitação média + flag de solo) como um point-stream de configuração.	9 opcionais
`biome_plant_define`	SideFX Labs Biome Plant Define — define UMA espécie de planta e suas tolerâncias climáticas (temperatura & precipitação inferior/preferida/superior), hábito (Árvore/Arbusto), limites/raio do tronco, escala e densidade máxima — o registro que biome_scatter lê para colocar vegetação.	27 opcionais
`biome_definitions_file`	SideFX Labs Biome Definitions File — serializa uma biblioteca de biomas para / de JSON.	6 opcionais
`biome_plant_definitions_file`	SideFX Labs Biome Plant Definitions File — serializa a biblioteca de espécies de plantas para / de JSON (espelho de biome_definitions_file para plant_define).	6 opcionais
`biome_profile`	SideFX Labs Biome Profile — mantém/grava o PERFIL de bioma combinado (o biomeprofile.json que os nós biome_initialize / region_assign / curve consomem) com temperatura e precipitação médias por bioma.	`name` (+4 opcionais)
`biome_initialize`	SideFX Labs Biome Initialize — a entrada do pipeline: recebe um terreno e uma fonte de regiões de bioma e produz o Terrain preparado (saída 0) + Biome Regions (saída 1).	28 opcionais
`biome_region_assign`	SideFX Labs Biome Region Assign — atribui as regiões de bioma da fonte de região de entrada (`input`, entrada 0) contra a biblioteca de biomas, emitindo Biome Regions (saída 0) + Guide Geometry (saída 1).	`input` (+25 opcionais)
`biome_attributes_evolve`	SideFX Labs Biome Attributes Evolve — evolui as camadas de atributos climáticos (temperatura / precipitação / solo) sobre o terreno de entrada (`input`, entrada 0) a partir de regras físicas: a temperatura cai com a elevação (`lapserate`), a precipitação é removida no lado sotavento das montanhas (sombra de chuva: removebydir + direção rain_x/rain_z + anglespread), e o solo é eliminado em penhascos (removebyslope + inclinação mín/máx) e por ruído procedural (removebynoise + base/fractal/amp/elementsize do ruído).	`input` (+34 opcionais)
`biome_attributes_to_terrain`	SideFX Labs Biome Attributes To Terrain — grava os atributos climáticos do bioma no terreno de entrada (`input`, entrada 0) como camadas nomeadas de heightfield (temperatura / precipitação / solo / cor do bioma) prontas para sombreamento ou exportação posteriores.	`input` (+12 opcionais)
`biome_curve_setup`	SideFX Labs Biome Curve Setup — etiqueta uma CURVE de região autoral (`input`, entrada 0 — um limite desenhado à mão) com o bioma a que pertence (`biomename_curve`) e uma ordem de classificação (`biomehierarchy`), produzindo o fluxo de curvas mesclado que biome_region_assign lê no modo de curvas.	5 opcionais
`biome_curve_label`	SideFX Labs Biome Curve Label — etiqueta uma CURVE de região (`input`, entrada 0) diretamente com valores climáticos explícitos (temperatura / precipitação / solo / cor do bioma / ordem de classificação) em vez de buscá-los de um perfil — a contraparte manual de biome_curve_setup.	11 opcionais
`region_assignment_subutil`	SideFX Labs Region Assignment (subutilitário) — um auxiliar interno de encanamento usado dentro do pipeline de regiões de bioma: ele itera `lpcount` vezes sobre a geometria de entrada (`input`, entrada 0), lendo um parâmetro HDA nomeado (`hda_parm`) a cada iteração e gravando seu valor em um atributo de ponto/primitiva (`attrib_name`), indexado por `index_parm`.	`input` (+5 opcionais)
`convert_regions_to_curves_subutil`	SideFX Labs Convert Regions To Curves (subutilitário) — converte POLYGONS de região na geometria de entrada (`input`, entrada 0) em primitivas CURVE de limite, uma curva fechada por região.	`input` (+2 opcionais)

Modelo & geometria

Ferramenta	O que faz	Parâmetros-chave
`remesh`	Remesh de triangulação uniforme (Remesh 2.0) — reconstrói uma superfície triangulada / escaneada em triângulos bem formados e de tamanho uniforme para suavização, simulação ou deformação limpa. targetsize é o comprimento alvo da aresta em unidades do mundo (menor = malha mais densa, maior contagem de polígonos); sizing=uniform dá um tamanho único em todo lugar, sizing=adaptive concentra triângulos menores na curvatura (density = multiplicador adaptativo de densidade alvo). gradation tende a mistura uniform<->adaptive (0 uniforme .. 1 totalmente adaptativo à curvatura). iterations = passos de suavização/otimização; smoothing = força de relaxamento de pontos por passo. min_edge/max_edge limitam o comprimento de aresta produzido.	`input` (+13 opcionais)
`polyreduce`	Decimar (PolyReduce 2.0) — colapsa uma malha para uma fração de sua contagem de polígonos para LOD / entrega em tempo real, mantendo silhueta e características. target escolhe o alvo da redução: poly_percent / pt_percent (porcentagem, o padrão, via percentage) ou poly_count / pt_count (uma contagem final absoluta — o cavalo de batalha do LOD). qualitytolerance troca qualidade por velocidade.	`input` (+11 opcionais)
`boolean`	Booleano (CSG de malha) de A contra B (boolean::2.0) — corta/combina sólidos.	`input` (+7 opcionais)
`sweep`	Varre uma seção transversal ao longo de uma curva espinha para criar uma SUPERFÍCIE — a pedra angular curva→geometria: tubos, cabos, cordas, trilhos, fitas de estrada/rio, acabamento arquitetônico. shape=tube\|square\|ribbon usa um perfil embutido (tube: radius; square/ribbon: width; cols define densidade); shape=input varre seu próprio SOP cross_section (entrada 1).	`input` (+15 opcionais)
`polyextrude`	Extrui faces de polígonos para fora ao longo de suas normais (polyextrude::2.0) — o cavalo de batalha para edifícios a partir de pegadas, greebles, espessamento. distance = profundidade de empurrão; inset encolhe a tampa extruída para dentro; divisions adiciona loops de parede lateral; twist rotaciona a tampa (graus).	`input` (+19 opcionais)
`polybevel`	Chanfra/arredonda arestas ou pontos (polybevel::3.0) — a operação de suavização de arestas para superfícies duras (chanfros, filetes, soldas). offset = tamanho do filete; divisions = segmentos de arredondamento (1 = chanfro plano, mais = arredondamento mais suave); shape escolhe o perfil (round \| chamfer \| crease \| solid).	`input` (+8 opcionais)
`deform`	Deformador de nó único, escolhido por op: bend (dobra a geometria ao longo de um eixo, `amount` = ângulo°), twist (`amount` = força de torção°), mountain (desloca ao longo das normais por ruído fractal, `amount` = altura, `frequency` = tamanho do elemento de ruído), attribnoise (ruído em um atributo, `amount` = amplitude, `frequency` = tamanho do elemento), lattice (deformação por gaiola, defina divsx/divsy/divsz), peak (empurra pontos ao longo das normais, `amount` = distância).	`input` (+7 opcionais)
`drape`	Projeta/estende os pontos de entrada sobre uma superfície de colisão — assenta props espalhados, curvas ou uma grade sobre o terreno.	`input` (+5 opcionais)
`transform`	Move / rotaciona / escala GEOMETRIA 3D na cena (Transform SOP) — posiciona um objeto ou um grupo de pontos/primitivas no espaço 3D. translate, rotate (graus), escala uniforme + por eixo, pivot, restrição de grupo, ordem de transformação/rotação.	`input` (+15 opcionais)
`select_group`	Seleção limitada e depois exclusão inversa; bbox mantém a geometria dentro, caso contrário, pattern seleciona um grupo nomeado.	`input` (+4 opcionais)
`merge`	Mescla vários SOPs em um único fluxo.	`inputs` (+1 opcional)
`switch`	Saída de UM de vários inputs, selecionado por um índice inteiro — montagem de variantes/LOD e alternâncias A/B.	`inputs` (+2 opcionais)
`null`	Passthrough sem operação / waypoint nomeado — a convenção LANDMARK: plante um null após cada resultado significativo e nomeie-o OUT_ (um identificador de resultado estável; object_merge/refs a jusante visam o NOME, então inserir nós acima nunca os quebra), IN_ (uma entrada de geo externa), ou CONTROL (parâmetros de driver / entrada reserva).	`input` (+1 opcional)
`sort`	Reordena deterministicamente pontos e/ou primitivas — ids estáveis para determinismo de copy-stamp / instancing.	`input` (+7 opcionais)
`polysplit_loop`	Insere LOOP(s) de aresta paramétricos (modo Edge-Loop do polysplit::2.0) — adiciona loops de suporte/controle mantendo quads.	`input`, `seed_edge` (+3 opcionais)
`poly_split`	Corta um caminho de aresta de FORMA LIVRE através das faces (modo Shortest-Distance do polysplit::2.0) — roteia uma nova sequência de arestas 'para cima e sobre' n-gons / costuras booleanas para recuperar quads, o primitivo de retopologia mecânica.	`input`, `path` (+6 opcionais)
`copy_transform`	Copiar-e-Transformar (copyxform): N cópias da entrada, cada uma com uma transformação incremental CUMULATIVA (a cópia i recebe i× o translate/rotate/scale).	`input` (+14 opcionais)
`helix`	Cria um novo /obj geo com uma curva de hélice / espiral (spiral SOP) — o gerador de mola / bobina / rosca (mola de haste ejetora, rosca de parafuso, fita de DNA, guia espiral). turns=revoluções, height=subida axial (0=espiral plana), start/end_radius afunilam a bobina.	`name` (+8 opcionais)
`polywire`	Transforma uma curva / fio em geometria de tubo sólido (polywire) — molas, cabos, tubos, cordas, renders wireframe, neurônios, ramos. divisions=lados da seção transversal (mín. 3), segments=subdivisões ao longo do vão, joint_correct evita flambagem onde os fios se encontram.	`input` (+9 opcionais)
`convex_decompose`	DECOMPOSIÇÃO CONVEXA aproximada (convexdecomposition) — quebra uma malha côncava em um conjunto de peças de casca convexa, a maneira padrão de criar PROXIES DE COLISÃO baratos para RBD/física (uma casca convexa é muito mais barata de colidir do que uma malha côncava, e a maioria dos solvers quer colisores convexos). max_concavity (0..1) troca ajuste vs contagem: menor = mais apertado + MAIS cascas, maior = menos/mais solto. output=hulls (peças convexas, padrão) \| segments (superfície original particionada + etiquetada). per_piece decompõe cada ilha `piece_attrib` (ex.: `name`) independentemente — a norma após uma fratura.	`input` (+10 opcionais)
`set_color`	Atribui uma cor constante.	`input` (+3 opcionais)
`uv`	UV via modo: project (uvproject), unwrap (uvunwrap auto), layout (empacotamento de atlas uvlayout::3.0), transform (uvtransform), ou flatten (uvflatten::3.0 orientado por costura).	`input` (+17 opcionais)
`uv_transfer`	Transfere um conjunto de UV de uma malha FONTE para a geometria de entrada — restaura UVs que uma mudança de topologia (remesh/quad_remesh/polyreduce) destruiu.	`input`, `source` (+5 opcionais)
`create_primitive`	Cria um novo /obj geo com um SOP primitivo (box/grid/sphere/tube/line/circle/platonic/torus) — o bloco inicial para modelagem de superfícies duras + orgânicas.	`name` (+10 opcionais)
`skin`	Loft/skin de uma superfície através de curvas de perfil ordenadas — a entrada é um SOP contendo várias primitivas de perfil (mescle curvas paralelas primeiro); skin faz loft através delas na ordem das primitivas. output_polygons=false gera uma malha spline; v_wrap=wv fecha o loft em um loop.	`input` (+10 opcionais)
`revolve`	Torneia uma curva de perfil em torno de um eixo → uma superfície de revolução (vaso, tubo, garrafa, roda, abajur). axis+origin definem o eixo de rotação (padrão Y através da origem); divisions = lados; revolve_type=openarc\|closedarc + angle=[start,end] fazem um arco parcial; caps fecha as extremidades.	`input` (+11 opcionais)
`mirror`	Reflete a geometria através de um plano e (por padrão) solda a costura. axis=x\|y\|z é um atalho para a normal do plano (ou forneça dirx/diry/dirz + originx/originy/originz); dist desloca o plano. keep_original=false substitui apenas pelo espelho; weld funde a costura; operation=clip corta no plano em vez de refletir.	`input` (+15 opcionais)
`dissolve`	Dissolve um grupo de arestas (ou pontos), MESCLANDO as faces adjacentes — simplificação de topologia (diferente de blast, que exclui e deixa um buraco).	`input`, `group` (+6 opcionais)
`bridge`	Ponte entre dois loops de aresta em um tubo/saia de conexão (polybridge).	`input`, `src_group`, `dst_group` (+12 opcionais)
`pointdeform`	Deforma por envoltório a entrada pelo movimento de uma gaiola: rest_cage (input1) → deformed_cage (input2).	`input`, `rest_cage`, `deformed_cage` (+7 opcionais)
`crease`	Escreve creaseweight em um grupo de arestas para que um subdivide a jusante mantenha essas arestas NÍTIDAS — a chave para modelagem de superfícies duras com subdivisão de superfície crível. group = grupo de arestas, weight = valor de crease (0..10), op = addto\|set\|delete.	`input` (+5 opcionais)
`divide`	Divide/triangula polígonos. triangulate (convexo, padrão ligado) com max_sides; smooth (subdivisão estilo Catmull) com divisions; brick=true + brick_size=[x,y,z] ladrilha a malha; compute_dual constrói a malha dual; remove_shared_edges mescla.	`input` (+10 opcionais)
`polyexpand2d`	Desloca curvas 2D em contornos/fitas de largura variável — estradas a partir de curvas OSM, linhas de painel, insets. input = um SOP de curva 2D. offset = meia-largura; output=curves\|surfaces; inside/outside escolhe qual(is) lado(s) emitir; width_attrib nomeia um atributo por ponto para largura variável.	`input` (+10 opcionais)
`lsystem`	Cria um novo /obj geo com um L-system (curvas de ramificação procedural ou tubos varridos — árvores, coral, relâmpagos, crescimento). premise = o axioma; rules = uma lista de strings de produção 'A=...' (uma gramática de tartaruga INERTE, NÃO código); generations/angle/step/thickness são escalares tipados; output=skel\|tube.	`name` (+10 opcionais)
`create_curve`	Cria um novo /obj geo contendo uma curva construída a partir de pontos fornecidos pelo chamador.	`name`, `points` (+3 opcionais)
`tree_trunk_generator`	SideFX Labs Tree Trunk Generator — a RAIZ da cadeia de árvore modular.	`name` (+24 opcionais)
`tree_controller`	SideFX Labs Tree Controller — um nó FONTE (0 entradas, 1 saída) contendo configurações de toda a árvore (gravidade / dobra / tropismo de luz, booleanização de costura, LOD).	`name` (+18 opcionais)
`tree_branch_generator`	SideFX Labs Tree Branch Generator — O cavalo de batalha: cresce um nível de ramos laterais a partir de um pai.	`input` (+30 opcionais)
`tree_simple_leaf`	SideFX Labs Tree Simple Leaf — constrói um novo /obj geo contendo UM cartão de modelo de folha (ou agulha); conecte sua saída na entrada `leaf` do tree_leaf_generator para espalhá-la sobre a árvore. bend=0 dá uma agulha plana.	`name` (+11 opcionais)
`tree_leaf_generator`	SideFX Labs Tree Leaf Generator — o término da cadeia: espalha o modelo de folha sobre os ramos.	`input` (+21 opcionais)
`quick_basic_tree`	SideFX Labs Quick Basic Tree — árvore de conveniência de uma chamada, crescida a partir de `input` (uma superfície base / conjunto de pontos), complementando a cadeia modular.	`input` (+15 opcionais)
`maps_baker`	SideFX Labs Maps Baker — bake de textura de atlas LOD SOMENTE POR FIOS.	`input` (+28 opcionais)
`capsule`	SideFX Labs Capsule — um novo /obj geo contendo uma primitiva de cápsula (um corpo cilíndrico com duas tampas hemisféricas). radius/height dimensionam, sides define resolução radial, bodysegments/capsegments a resolução longitudinal, direction o eixo longo.	`name` (+6 opcionais)
`cylinder_generator`	SideFX Labs Cylinder Generator — um novo /obj geo contendo um cilindro/cone/tubo procedural com mais controle do que o tubo nativo. uniformradius amarra topo+base ao radius; desative-o para afunilar via topradius/baseradius. sides/divisions definem resolução; opencylinder + arcstart/arcend cortam um arco aberto; endcaps + fillmode tampam as extremidades.	`name` (+14 opcionais)
`disc_generator`	Gerador de Disco SideFX Labs — um novo /obj geo contendo um disco / anel / arruela plano. innerradius>0 cria um anel/arruela; outerradius é a borda externa. sides/divisions definem a resolução; arcstart/arcend cortam uma fatia de torta; orientation escolhe o plano; innerheight/outerheight transformam em um cone/funil raso.	`name` (+10 opcionais)
`hexagon_grid`	Grade Hexagonal SideFX Labs — um novo /obj geo contendo uma grade com tiles hexagonais. type=polygon constrói faces hexagonais (mesh); type=points gera apenas os centros hexagonais. gridshape define o formato da base (hexágono/triângulo/retângulo/paralelogramo), gridsize sua extensão, cellradius o tamanho de cada hexágono, cellorientation topo pontudo vs topo plano, orientation o plano. connectivity=connected funde arestas compartilhadas.	`name` (+7 opcionais)
`quad_sphere_generator`	Gerador de Esfera Quad SideFX Labs — um novo /obj geo contendo uma esfera somente com quads (cubo subdividido) com topologia limpa e uniforme (diferente da esfera nativa com pinçamento nos polos). subdivisions é EXPONENCIAL na contagem de polígonos (6*4^n quads) e é limitado rigidamente a <=7.	`name` (+3 opcionais)
`simple_shapes`	Formas Simples SideFX Labs — um novo /obj geo contendo uma de uma família de formas de perfil 2D selecionada por `shape` (triângulo/losango/retângulo/trapézio/polígono/estrela/estrela_dupla/estrela_quadrada). base/height dimensionam a família retangular; radius/sides/points/innerradius controlam as famílias de polígonos e estrelas. closed fecha o perfil em uma face; adduvs adiciona UVs.	`name` (+11 opcionais)
`superformula_shapes`	Formas Superfórmula SideFX Labs — um novo /obj geo contendo uma forma 2D da família superfórmula, selecionada por `shapeselect` (quadrado/círculo/triângulo/polígono/losango/estrela/squircle/polígono_arredondado/trevo/flor/explosão_solar/olho/lágrima/coração/personalizado). width/height dimensionam; circpointnum define a resolução do círculo/curva; polysides/starspokes+starpinchbloat/flowerspokes controlam as famílias de polígonos/estrelas/flores. fillshape preenche o perfil em uma superfície (caso contrário, uma curva de contorno); roundcorners bisela cantos.	`name` (+10 opcionais)
`quadrangulate`	Quadrangulação SideFX Labs (labs::quadrangulate::2.0) — converte uma malha triangulada em quads mesclando pares de triângulos (preservando topologia; NÃO é uma reconstrução completa como quad_remesh).	`input` (+8 opcionais)
`voxelmesh`	VoxelMesh SideFX Labs (labs::voxelmesh::2.0) — reconstrói `input` (entrada 0) em uma malha hermética rasterizando-a em um VDB com `resolution` voxels ao longo do eixo mais longo e, em seguida, gerando a superfície da malha (uma remesh baseada em volume, distinta da remesh de superfície nativa).	`input` (+11 opcionais)
`connect_polygon_neighbours`	Conectar Vizinhos de Polígonos SideFX Labs (labs::connect_polygon_neighbours::1.0) — emite um ponto em cada centroide de polígono de `input` (entrada 0) e (no modo padrão) arestas de polilinha conectando vizinhos adjacentes por face — o grafo dual/adjacência da malha.	`input` (+6 opcionais)
`edge_group_to_polylines`	Grupo de Arestas para Polilinhas SideFX Labs (labs::edge_group_to_polylines::1.0) — extrai as arestas nomeadas por `edgegroup` de `input` (entrada 0) como primitivas de polilinha individuais.	`input` (+2 opcionais)
`edgegroup_to_curve`	Grupo de Arestas para Curva SideFX Labs (labs::edgegroup_to_curve::1.1) — como edge_group_to_polylines, mas costura as arestas nomeadas por `group` em curvas conectadas e ordenadas (cadeias com extremidades compartilhadas).	`input` (+8 opcionais)
`symmetrize`	Simetrização SideFX Labs (labs::symmetrize) — espelha `input` (entrada 0) através do plano definido por `origin` + `direction` (normal) e solda as metades em uma malha simétrica.	`input` (+9 opcionais)
`thicken`	Espessamento SideFX Labs (labs::thicken::1.1) — dá espessura a uma superfície/casca aberta extrudando-a ao longo de suas normais por `depth` e criando pontes entre as paredes (solidificar).	`input` (+10 opcionais)
`boolean_curve`	Booleano de Curva SideFX Labs — booleano 2D/de curva de duas entradas de curva.	`input` (+5 opcionais)
`curve_branches`	Ramos de Curva SideFX Labs — distribui curvas de ramos filhos ao longo das curvas de entrada (entrada 0).	`input` (+14 opcionais)
`curve_resample_by_density`	Reamostragem de Curva por Densidade SideFX Labs — reamostra a curva de entrada (entrada 0) com densidade de pontos não uniforme.	`input` (+5 opcionais)
`curve_sweep`	Varredura de Curva SideFX Labs — varre uma seção transversal ao longo da curva espinha dorsal (entrada 0) para construir um tubo/fita.	`input` (+6 opcionais)
`merge_splines`	Mesclar Splines SideFX Labs — funde/mescla curvas spline sobrepostas em uma rede conectada.	`input` (+5 opcionais)
`polywire_uv`	PolyWire UV SideFX Labs — constrói tubos polywire com UV ao redor de uma rede de arestas ou curva (entrada 0).	`input` (+11 opcionais)
`progressive_resample`	Reamostragem Progressiva SideFX Labs — reamostra uniformemente a curva de entrada (entrada 0) com comprimento de segmento progressivo controlado por um atributo `pscale` por ponto.	`input` (+5 opcionais)
`spiral`	Espiral SideFX Labs — um nó FONTE (0 entradas): constrói um novo /obj geo contendo uma curva espiral/helicoidal.	`name` (+7 opcionais)
`sweep_geometry`	Varredura de Geometria SideFX Labs — instancia/varre uma MESH de seção transversal ao longo de uma curva espinha dorsal.	`input`, `curve` (+11 opcionais)
`view_vertex_order`	Ver Ordem de Vértices SideFX Labs — anota a geometria de entrada (entrada 0) com uma visualização da ordem de vértices: cor por elemento mais setas opcionais de ordem, passando a geometria de origem adiante.	`input` (+5 opcionais)
`box_clip`	Recorte de Caixa SideFX Labs — recorta `input` (entrada 0) contra uma caixa alinhada aos eixos, mantendo a geometria que sobrevive aos planos laterais habilitados (cada alternância neg/pos ativa um dos seis planos de recorte; todos os seis padrão LIGADOS). size/center (vec3 via _x/_y/_z) e scale dimensionam e posicionam a caixa de recorte — faça-a MAIOR que a geometria para manter tudo, menor para aparar. fillholes tampa o corte.	`input` (+16 opcionais)
`boxcutter`	Cortador de Caixa SideFX Labs — um cortador booleano de caixa para `input` (entrada 0): subtrai, fragmenta ou une uma caixa transformável contra a malha. boolean_op escolhe a operação; bevel_divisions/bevel_distance arredondam a caixa de corte; translate/rotate/scale (vec3 via _x/_y/_z) posicionam e dimensionam; copies (+ copy_translate/copy_rotate vec3) repetem o corte em matriz.	`input` (+20 opcionais)
`boxcutter_subutil`	Sub-Utilitário de Cortador de Caixa SideFX Labs — o cortador booleano de caixa de forma única subjacente ao boxcutter, utilizável de forma independente em `input` (entrada 0). operation escolhe subtrair/fragmentar/unir; translate/rotate/scale (vec3 via _x/_y/_z) posicionam a caixa; distance extrui o corte, divisions bisela seus cantos; copies (+ copy_translate/copy_rotate vec3) repetem em matriz. active alterna; passa a malha adiante quando inativo.	`input` (+21 opcionais)
`mesh_slice`	Fatia de Malha SideFX Labs — fatia `input` (entrada 0) com uma grade alinhada aos eixos de planos de corte (divisions_x/_y/_z planos por eixo) e (com fill_holes) tampa os cortes, produzindo peças separáveis. isolate_index + index mantêm apenas uma peça.	`input` (+7 opcionais)
`polyslice`	PolySlice SideFX Labs — fatia `input` (entrada 0) com num_slices planos paralelos, posicionados/orientados por center (vec3), size (vec3), scale e rotate (vec3). mode gera polígonos fatiados ou seções transversais de polilinha. connectivity decide como as peças fatiadas são agrupadas; divide_convex triangula faces não convexas resultantes.	`input` (+25 opcionais)
`split_prim_by_normal`	Dividir Prim por Normal SideFX Labs — seleciona as primitivas de `input` (entrada 0) cuja normal aponta ao longo de `axis` no `direction` escolhido, dentro de spread_angle graus; invert inverte a seleção.	`input` (+5 opcionais)
`polyscalpel`	PolyScalpel SideFX Labs — fatia a malha de origem `input` (entrada 0) onde quer que a geometria `cutter` obrigatória (entrada 1) a cruze. cutting_geo_type DEVE corresponder ao tipo do cortador (points / polylines / polygon_surfaces); input_geo_type corresponde à origem. surface_output escolhe pontos em arestas vs superfícies fatiadas; slicing_method escolhe o caminho exato do PolySplit ou o caminho mais rápido de Boolean-Shatter. source_group/cutting_group são NOMES de grupos de geometria limitando cada lado.	`input`, `cutter` (+14 opcionais)
`calculate_occlusion`	Calcular Oclusão SideFX Labs — análise de oclusão ambiente/cavidade: lança raios contra a superfície (e um `occluder` opcional na entrada 1) e escreve um valor de oclusão no atributo de ponto `occattr` (mais um `Cd` de exibição quando `colorout` está ativado).	`input` (+14 opcionais)
`calculate_slope`	Calcular Inclinação SideFX Labs — calcula a inclinação da superfície (ângulo da normal de cada ponto em relação ao eixo vertical) no atributo de ponto `sSlopeAttribute` (mais um `Cd` de exibição quando `bSlopeCd` está ativado).	`input` (+8 opcionais)
`calculate_thickness`	Calcular Espessura SideFX Labs — mede a espessura local da malha lançando `numrays` raios para dentro por ponto e escreve a distância no atributo de ponto `attrname` (padrão `thickness`; mais um `Cd` de exibição quando `outputcolor` está ativado).	`input` (+10 opcionais)
`distance_from_border`	Distância da Borda SideFX Labs — para cada ponto, calcula a distância até a aresta de borda/fronteira aberta mais próxima e escreve no atributo de ponto `distattr` (mais um `Cd` de exibição quando `bDistanceAsColor` está ativado).	`input` (+11 opcionais)
`edge_color`	Cor de Aresta SideFX Labs — escreve um `Cd` de exibição que destaca arestas convexas vs côncavas (uma visualização de desgaste/curvatura usada para controlar máscaras de dano de borda).	`input` (+8 opcionais)
`fast_gaussian_curvature`	Curvatura Gaussiana Rápida SideFX Labs — calcula a curvatura gaussiana discreta (defeito angular) no atributo de ponto `attribname_curv` (padrão `curvature`) mais um ângulo em `attribname_angle`.	`input` (+11 opcionais)
`measure_curvature`	Medir Curvatura SideFX Labs — mede a curvatura da superfície nos atributos de ponto `convexityattr` (padrão `convexity`) e `concavityattr` (padrão `concavity`), mais um `Cd` de exibição quando `viscolor` está ativado.	`input` (+13 opcionais)
`physical_ambient_occlusion`	Oclusão Ambiente Física SideFX Labs — um bake de AO fisicamente baseado no atributo de ponto `outputattrib` (padrão `ao_mask`; mais um `Cd` de exibição).	`input` (+18 opcionais)
`spectral_feature_extract`	Extração de Características Espectrais SideFX Labs — análise espectral de características (difusão/PDE): extrai características multiescala de um atributo de ponto de entrada e escreve atributos de ponto `outattrib_f` (padrão `extracted_float`) e `outattrib_v` (padrão `extracted_vec`).	`input` (+19 opcionais)
`validate_geometry_type`	Validar Tipo de Geometria SideFX Labs — uma SALVAGUARDA de pipeline: passa a geometria de entrada adiante inalterada enquanto valida uma regra sobre ela, gerando uma mensagem/aviso/erro se a regra falhar.	`input` (+5 opcionais)
`autouv`	Auto UV SideFX Labs — UV automático com um clique: gera costuras automáticas na malha, achata cada ilha (SCP/ABF) e as empacota em um atlas.	`input` (+25 opcionais)
`uv_unwrap_cylinder`	Desdobramento de UV Cilíndrico SideFX Labs — desdobramento de UV cilíndrico para canos / tubos / membros.	`input` (+7 opcionais)
`inside_face_uvs`	UVs de Faces Internas SideFX Labs — achata UVs nas faces internas ("interiores") de uma malha fraturada para que o interior da fratura possa ser texturizado.	`input` (+9 opcionais)
`automatic_trim_texture`	SideFX Labs Textura de Aparação Automática — ajusta de forma não interativa as ilhas UV da malha em um atlas de folha de aparação.	`input`, `trim` (+10 opcionais)
`calculate_uv_distortion`	SideFX Labs Calcular Distorção UV — mede o quanto o layout UV estica/achata cada elemento em relação ao 3D e escreve isso em `distortionattribute` (padrão uv_distortion).	`input` (+5 opcionais)
`merge_small_islands`	SideFX Labs Mesclar Ilhas Pequenas — mescla ilhas UV cuja área relativa está abaixo de `cutoff` em uma ilha adjacente e reaplana, reduzindo o número de ilhas para empacotamento mais limpo.	`input` (+7 opcionais)
`remove_uv_distortion`	SideFX Labs Remover Distorção UV — relaxa iterativamente o estiramento UV empurrando vértices distorcidos ("picos") para dentro / puxando os achatados ("buracos") para fora.	`input` (+13 opcionais)
`texel_density`	SideFX Labs Densidade de Texel — mede e (opcionalmente) equaliza texels-por-unidade em uma malha com UVs para um determinado `texturesize`.	`input` (+9 opcionais)
`uv_remove_overlap`	SideFX Labs Remover Sobreposição de UV — detecta ilhas UV sobrepostas no tile 0-1 (rasterizado em `resolution`) e, quando `repairoverlaps` estiver ativado, afasta-as; opcionalmente agrupa as prims problemáticas.	`input` (+6 opcionais)
`uv_unitize`	SideFX Labs Unitizar UV — remapeia cada primitiva (ou cada ilha UV) para que suas UVs preencham o quadrado unitário 0-1 — preparação padrão para fluxos de trabalho de folha de aparação / textura de repetição.	`input` (+8 opcionais)
`building_from_patterns`	SideFX Labs Construção a partir de Padrões — organiza MÓDULOS de construção sobre um blockout usando uma gramática de padrões de piso/módulo.	`input` (+17 opcionais)
`building_generator`	SideFX Labs Gerador de Edifícios — fatiia um blockout 3D em pisos e o reveste com módulos.	`input` (+20 opcionais)
`building_module`	SideFX Labs Módulo de Construção (labs::building_generator_utility) — marca uma malha de entrada como um MÓDULO de construção reutilizável (nome, peso, prioridade, caixa delimitadora) para o building_generator / building_from_patterns consumirem.	`input` (+9 opcionais)
`pathfinding_global`	SideFX Labs Caminho Global — calcula CAMINHOS de menor custo entre pontos finais de assentamento sobre um terreno.	`input`, `terrain` (+12 opcionais)
`road_generator`	SideFX Labs Gerador de Estradas — constrói malha de superfície de estrada com interseções a partir de CURVAS de estrada de entrada (linhas centrais).	`input` (+19 opcionais)
`settlement_connections`	SideFX Labs Conexões de Assentamento — conecta PONTOS de assentamento em um grafo de rede viária, filtrando conexões por ângulo / distância / contagem.	`input` (+13 opcionais)
`cable_generator`	SideFX Labs Gerador de Cabos — constrói malhas de cabos/fios pendurados.	`input` (+26 opcionais)
`lot_subdivision`	SideFX Labs Subdivisão de Lotes — subdivide recursivamente um bloco poligonal 2D em LOTE de construção.	`input` (+11 opcionais)
`scifi_panels`	SideFX Labs Painéis Sci-Fi — adiciona detalhes a uma malha com painéis: subdivide a superfície em lotes e então extrui painéis com bordas, entalhes/biséis.	`input` (+22 opcionais)
`simple_rope_wrap`	SideFX Labs Enrolamento de Corda Simples — varre geometria de corda/cabo sobre superfícies poligonais e a envolve em torno de um objeto de geometria.	`input`, `geometry` (+20 opcionais)
`mesh_tiler`	SideFX Labs Tiler de Malha — envolve geometria EMPACOTADA que cruza um limite de tile unitário para que ela se repita perfeitamente (peças que saem por uma borda reentram pela borda oposta).	`input` (+9 opcionais)
`dirtskirt`	SideFX Labs Saia de Sujeira — constrói uma saia espalhada de sujeira/detritos onde um objeto (`input`, entrada 0) encontra uma superfície de solo (`ground`, entrada 1) — a pequena pilha de entulho na base de uma rocha/parede. obj* controla a faixa de ruído que sobe pelo objeto; gnd* a faixa que se espalha no chão; finalcount limita a contagem de detritos espalhados; iterations cresce a faixa; threshold a aparação.	`input`, `ground` (+17 opcionais)
`snow_buildup`	SideFX Labs Acúmulo de Neve — acumula uma camada de neve nas partes voltadas para cima da superfície de entrada (`input`, entrada 0). angle é a inclinação máxima da face que retém neve; baseheight/snowheight definem a profundidade; typenoise escolhe a aparência da superfície (acúmulos / derretida / removida com pá); smoothiterations a suaviza. snow_only gera apenas o grupo de neve.	`input` (+20 opcionais)
`tree_branch_placer`	SideFX Labs Posicionador de Galhos de Árvore — cresce/posiciona galhos a partir de um tronco pai.	`input` (+25 opcionais)
`tree_hierarchy`	SideFX Labs Hierarquia de Árvore — marca os galhos de uma árvore com uma hierarquia nomeada de geração/galho (ex.: gen_0/_branch_1) para seleção, vento ou exportação posteriores.	`input` (+6 opcionais)
`cluster_refine`	SideFX Labs Refinamento de Cluster — refina uma malha em ilhas soldadas agrupando regiões conectadas e relaxando os limites dos clusters para que as emendas sejam lidas claramente.	`input` (+8 opcionais)
`edge_damage`	SideFX Labs Dano de Borda — lasca/erode arestas vivas para adicionar desgaste procedural via passada VDB; todo deslocamento é procedural ao longo das normais, NÃO a partir de uma imagem de disco.	`input` (+14 opcionais)
`edge_smooth`	SideFX Labs Suavização de Aresta — relaxa/suaviza arestas da malha (opcionalmente apenas arestas não compartilhadas/de limite), limpando facetamento em geometria biselada ou booleana.	`input` (+7 opcionais)
`mesh_sharpen`	SideFX Labs Nitidez de Malha — afia características de superfície empurrando pontos ao longo de um campo de curvatura, com uma passada opcional de suavização; acentua geometria escaneada/soft.	`input` (+12 opcionais)
`soften_normals`	SideFX Labs Suavizar Normais — recalcula normais de vértice com um ângulo de cúspide para que arestas abaixo do ângulo sejam lidas como suaves e arestas mais nítidas permaneçam duras; pode adicionalmente endurecer normais através de costuras UV.	`input` (+3 opcionais)
`extract_borders`	SideFX Labs Extrair Bordas — extrai as arestas de limite abertas de uma malha (e opcionalmente as bordas das ilhas UV) como polilinhas ou curvas.	`input` (+4 opcionais)
`extract_silhouette`	SideFX Labs Extrair Silhueta — traça a silhueta externa de uma malha ao longo de um eixo de visão e a emite como uma curva (cartões recortados / formas de aparação).	`input` (+6 opcionais)
`straight_skeleton_2d`	SideFX Labs Esqueleto Reto 2D — calcula o esqueleto reto 2D (espinha topológica tipo eixo medial) de um polígono/curva planar, útil para telhados/insetagem e análise de formas.	`input` (+7 opcionais)
`straight_skeleton_3d`	SideFX Labs Esqueleto Reto 3D — extrai uma rede de curva esqueleto reto / medial 3D de uma malha fechada via solução voxelizada.	`input` (+5 opcionais)
`dissolve_flat_edges`	SideFX Labs Dissolver Arestas Planas — remove arestas entre faces (quase) coplanares para simplificar uma malha sem alterar sua silhueta, e opcionalmente remove pontos colineares (em linha).	`input` (+8 opcionais)
`remove_inside_faces`	SideFX Labs Remover Faces Internas — exclui faces internas/ocluídas nunca visíveis de fora (ex.: geometria sobreposta de kit-bash booleana), reduzindo a contagem de polígonos.	`input` (+6 opcionais)
`path_deform`	SideFX Labs Deformação por Caminho — dobra `input` (entrada 0, a malha) ao longo do `curve` obrigatório (entrada 1, o caminho); o `banking_curve` opcional (entrada 2) define a direção para cima/inclinação.	`input`, `curve` (+12 opcionais)
`polydeform`	SideFX Labs PolyDeform — deforma a `input` de alto detalhe (entrada 0, source_mesh) para seguir o `target` esculpido/editado (entrada 1, target_mesh), transferindo a deformação de baixa resolução para a malha de resolução total.	`input`, `target` (+10 opcionais)
`sine_wave`	SideFX Labs Onda Senoidal — desloca `input` (entrada 0) com duas ondas senoidais somadas ao longo de `axis` (X\|Y\|Z).	`input` (+14 opcionais)
`decal_projector`	SideFX Labs Projetor de Decalque — projeta um decalque (cor base + mapa de altura) na superfície `input` (entrada 0, a Malha de Projeção).	`input` (+21 opcionais)
`detail_mesh`	SideFX Labs Malha de Detalhe — repete a malha de carimbo/detalhe `tile` (entrada 1) através do layout UV da superfície `input` (entrada 0, a tela), envolvendo os tiles nela (ex.: tijolos/escamas sobre uma parede).	`input`, `tile` (+10 opcionais)
`triplanar_displace`	SideFX Labs Deslocamento Triplanar — desloca `input` (entrada 0) amostrando uma `texture` de deslocamento projetada triplanarmente na malha (sem necessidade de UVs).	`input` (+22 opcionais)
`align_and_distribute`	SideFX Labs Alinhar e Distribuir — divide `input` (entrada 0) em peças (por conectividade `split_by` ou um `attribute_name` de peça), opcionalmente `sort_by` (área/contagem de polígonos/aleatório com `seed`), então as organiza com `spacing` em um `layout` (linear\|grade).	`input` (+14 opcionais)
`delight`	SideFX Labs Delight — remove iluminação/AO embutidos das cores de vértice (Cd) de `input` (entrada 0), achatando uma malha escaneada/fotografada em direção a um albedo uniforme.	`input` (+11 opcionais)
`straighten`	SideFX Labs Endireitar — reorienta `input` (entrada 0) em um quadro canônico alinhado aos eixos usando um `up_group` selecionado (e opcionalmente um `forward_group` quando `align_forward` estiver ativado) do `grouptype` dado (primitiva\|ponto\|aresta) como referência para cima/frente; `invert_up` inverte o eixo para cima.	`input` (+8 opcionais)
`axis_align`	SideFX Labs Alinhamento de Eixos — reposiciona `input` (entrada 0) em relação à origem por eixo: cada um de `x`/`y`/`z` escolhe deixar esse eixo inalterado ou ajustar o Centro, Mínimo ou Máximo de sua caixa delimitadora para 0.	`input` (+5 opcionais)
`turntable`	SideFX Labs Mesa Giratória — rotaciona `input` (entrada 0) em torno de `axis` (X\|Y\|Z) como uma função do quadro atual, completando `num_turns` rotações completas ao longo do intervalo de quadros (uma animação de pré-visualização em mesa giratória).	`input` (+4 opcionais)
`chaotic_shapes`	SideFX Labs Formas Caóticas — uma nova geo /obj contendo uma nuvem de pontos rastreada de um sistema caótico (atrator estranho).	`name` (+8 opcionais)
`mandelbulb_generator`	SideFX Labs Gerador de Mandelbulb — uma nova geo /obj contendo um fractal Mandelbulb 3D.	`name` (+10 opcionais)
`wang_tiles_sample`	SideFX Labs Amostra de Tiles Wang — uma nova geo /obj contendo uma amostragem estocástica de tiles Wang (um conjunto de sementes de tiling aperiódico que o Decodificador de Tiles Wang expande posteriormente).	`name` (+3 opcionais)
`wfc_initialize`	SideFX Labs Inicializar WFC — uma nova geo /obj contendo uma grade vazia de Colapso de Função de Onda (`rows` x `cols`, cada um limitado <=1024) que as ferramentas de amostra/pintura WFC resolvem depois.	`name` (+4 opcionais)
`wang_tiles_decoder`	SideFX Labs Decodificador de Tiles Wang — decodifica uma grade de pontos de tiles Wang (`input`, entrada 0; ex.: uma saída de wang_tiles_sample) em um tiling aperiódico de `rows` x `cols`.	`input` (+6 opcionais)
`connectivity_and_segmentation`	SideFX Labs Conectividade e Segmentação — particiona os polígonos de entrada (`input`, entrada 0) em segmentos e escreve um id de segmento em `segmentattrib`.	`input` (+15 opcionais)
`multi_bounding_box`	SideFX Labs Caixa Delimitadora Múltipla — constrói caixas delimitadoras sobre a malha de entrada (`input`, entrada 0).	`input` (+5 opcionais)
`wavefunction_collapse_2d`	SideFX Labs Colapso de Função de Onda 2D — sintetiza um tiling 2D maior que localmente se assemelha a uma pequena amostra de cor/tile.	`input`, `sample` (+9 opcionais)
`wfc_sample_paint`	SideFX Labs WFC Sample Paint — o front-end de pintura do fluxo de trabalho Wave-Function-Collapse: `input` (entrada 0) = a grade WFC (uma saída de wfc_initialize); `modules` opcional (entrada 1) = o conjunto de tiles/módulos.	`input` (+6 opcionais)
`unreal_worldcomposition_prepare`	SideFX Labs Unreal World Composition Prepare — marca um terreno/mesh de entrada (`input`, entrada 0) para Unreal World Composition; a saída do SOP cozinhada É a geometria marcada. tilenum define a contagem de tiles; levelpath/materialpath são caminhos de CONTENT do Unreal gravados como atributos de string (não caminhos de filesystem).	`input` (+12 opcionais)
`ml_cv_directory_import`	SideFX Labs ML CV Directory Import — um nó SOURCE (0 entradas) que importa geometria de ativos de um diretório correspondendo a um padrão de nome de arquivo; o ponto de entrada para staging de dados sintéticos de visão computacional.	`name` (+4 opcionais)
`ml_cv_keypoint_metadata`	SideFX Labs ML CV Keypoint Metadata — atribui metadados de ground-truth de keypoints (raio do keypoint, posições 3D, conectividade do esqueleto) à geo de entrada para dados de treinamento de estimativa de pose.	`input` (+7 opcionais)
`ml_cv_label_metadata`	SideFX Labs ML CV Label Metadata — marca geometria (ou um grupo) com um ID/nome de categoria mais um instance ID opcional para treinamento de segmentação/detecção.	`input` (+10 opcionais)
`ml_cv_promote_synth_attribute`	SideFX Labs ML CV Promote Synth Attribute — promove um atributo de dados sintéticos de uma classe de geometria para outra (ex.: primitive -> point) com um método de agregação escolhido, para que os rótulos caiam nos elementos certos.	`input` (+6 opcionais)
`ml_cv_rop_annotation_output`	SideFX Labs ML CV Annotation Output — gravador WIRE-ONLY que exporta anotações JSON no estilo COCO (IDs de categoria/instância, dados de bounding) para o frame sintético de entrada.	`input` (+10 opcionais)
`ml_cv_texture_mask`	SideFX Labs ML CV Texture Mask — atribui um texture instance ID e um ID/nome de categoria à geometria de entrada para que uma região de textura renderizada vire um mask rotulado no dataset sintético.	`input` (+4 opcionais)
`ml_cv_vector_data`	SideFX Labs ML CV Vector Data — calcula dados vetoriais por ponto (ex.: um vetor de movimento/direção em screen-space a partir de um ponto de origem) para o frame sintético.	`input` (+5 opcionais)
`ml_cv_visualize_keypoints`	SideFX Labs ML CV Visualize Keypoints — constrói geometria de guia de keypoints/conectividade de esqueleto a partir da geo de keypoint-metadata para inspecionar rótulos de dados sintéticos.	`input` (+6 opcionais)
`export_uv_wireframe`	SideFX Labs Export UV Wireframe — WIRE-ONLY: renderiza o layout de UV do mesh de entrada (wireframe + preenchimento de ilha) para um arquivo de imagem.	`input` (+10 opcionais)
`udim_tile_number`	SideFX Labs UDIM Tile Number — calcula o número do tile UDIM para cada elemento a partir de suas UVs e o grava em um atributo (padrão `udim_tile`).	`input` (+5 opcionais)
`visualize_uvs`	SideFX Labs Visualize UVs — constrói geometria de inspeção para as UVs de um mesh: aplica uma pré-visualização de textura xadrez e pode desenhar as ilhas UV + seams.	`input` (+9 opcionais)
`testgeometry_luiz`	SideFX Labs Test Geometry (Luiz) — um nó SOURCE (0 entradas) que constrói um mesh de teste/exibição pronto (o ativo 'Luiz') para prototipagem.	`name` (+1 opcional)
`testgeometry_paul`	SideFX Labs Test Geometry (Paul) — um nó SOURCE (0 entradas) que constrói um mesh de teste/exibição pronto (o ativo 'Paul') para prototipagem.	`name` (+1 opcional)
`houdini_icon`	SideFX Labs Houdini Icon — um nó SOURCE (0 entradas) que constrói o logotipo do Houdini como geometria de mesh, opcionalmente extrudado.	`name` (+2 opcionais)
`simple_retime`	SideFX Labs Simple Retime — re-temporiza uma entrada animada por um multiplicador de velocidade global (o Ramp de retime por frame permanece no padrão do HDA).	`input` (+2 opcionais)
`resample`	Reamostra curvas/polylines em segmentos uniformes (resample SOP).	`input` (+14 opcionais)
`trail`	Trail de movimento / conectividade ao longo do tempo (trail SOP): traça pontos através de frames, conecta-os como mesh/polys, ou calcula velocidade a partir do movimento.	`input` (+14 opcionais)
`timeshift`	Re-temporiza a geometria a montante — avalia o SOP de entrada como se a playbar estivesse em um frame/tempo diferente (timeshift SOP). method=byframe lê `frame` (com snap integer_frames); method=bytime lê `time` em segundos. clamp mantém a amostra no primeiro/último frame fora de um intervalo.	`input` (+6 opcionais)
`polyframe`	Constrói um frame de orientação por elemento — atributos tangent (tangentu), normal (N), bitangent (tangentv) — em uma curva ou superfície (polyframe SOP).	`input` (+13 opcionais)
`fuse`	Solda / faz snap de pontos coincidentes (Fuse 2.0) — o cavalo de batalha da limpeza de seams após heightfield_tilesplit, boolean ou merges de scan-tile. distance é a tolerância de snap 3D (unidades do mundo): pontos dentro dela são consolidados em um só, fechando rachaduras entre tiles. snap_type seleciona distancesnap (proximidade, o padrão), gridsnap (snap a uma grade) ou specified (snap via atributo alvo). delete_degenerate elimina os prims de área/comprimento zero que colapsam quando pontos se fundem; delete_unused remove pontos agora órfãos; consolidate mescla os pontos com snap em pontos únicos (padrão ativado).	`input` (+6 opcionais)
`normals`	Recalcula (ou inverte) normais via o Normal SOP. mode = a classe na qual o atributo N é gravado: point (sombreamento suave, padrão), vertex (por canto de face, bordas duras/suaves), prim (plano por face) ou detail. cusp_angle (graus) divide sombreamento suave vs facetado em bordas mais acentuadas que o ângulo. reverse inverte a direção da normal (corrige superfícies scan/boolean invertidas); normalize força comprimento unitário; weighting escolhe como as normais de faces adjacentes são calculadas pela média (0 por área .. 2).	`input` (+6 opcionais)
`facet_smooth_subdiv`	Três operadores de superfície multiplexados por op. facet (Facet SOP): re-facet / consolida — cusp_angle afia bordas, unique_points divide pontos compartilhados (visual facetado duro), make_planar achata cada face. smooth (Smooth SOP): relaxa posições de pontos sem adicionar polígonos — strength é a quantidade de suavização (0..50), method uniform\|scaledominant\|curvaturedominant, filter_quality aumenta a contagem de passadas (1..5). subdivide (Subdivide SOP): ADICIONA polígonos — iterations níveis de subdivisão (cada nível ~4x a contagem de polígonos, então 3 já é 64x; o nó tem soft-cap em 3), algorithm escolhe o esquema (osdcc = OpenSubdiv Catmull-Clark, o padrão de superfícies suaves), close_holes sela bordas abertas.	`input` (+11 opcionais)
`lod_create`	LOD / staging de primitivas empacotadas via op. lod (Labs LOD Create): constrói uma cadeia de level-of-detail — levels define o número de LODs (gerando essa quantidade de slots de redução, todos começando em 100%; refine as porcentagens por slot no nó depois). pack (Pack SOP): colapsa a entrada em primitivas empacotadas (unidades de instanciamento planas e leves em memória) — packbyname empacota uma prim por valor de atributo de nome, transfer_attributes/transfer_groups carregam padrões até as prims empacotadas, pivot define o pivô do pacote (origin\|centroid). proxy (Pack SOP): o mesmo pack, mas encenado como uma proxy barata de viewport via viewport-LOD empacotada (token lod, padrão box) — o análogo de geometria geral do set_tile_lod de terreno.	`input` (+8 opcionais)
`assemble`	Empacota peças nomeadas em primitivas PackedFragment (Assemble SOP) — o empacotamento pronto para render/sim de um mesh fraturado/nomeado. pack ativado por padrão (pack_geo é o toggle que realmente emite prims empacotadas).	`input` (+14 opcionais)
`transform_pieces`	Aplica transformações por peça de volta em peças empacotadas (Transform Pieces) — O round-trip resultado-de-sim -> geometria-empacotada.	`input` (+13 opcionais)
`for_each`	Constrói um SCAFFOLD de For-Each loop / iterar-sobre-peças (block_begin + corpo pass-through + block_end, totalmente conectado e com referências cruzadas) para fazer loop sobre geometria por peça, por ponto, ou um N fixo de vezes (count loop).	`input` (+14 opcionais)
`for_each_begin`	Cria um block_begin de For-Each — o INÍCIO / entrada do loop componível.	`input` (+4 opcionais)
`for_each_end`	Cria um block_end de For-Each — o FIM / coleta do loop componível. input = a saída do corpo do seu loop (nós a iterar), begin = o block_begin pareado, pieces = a geometria cujas peças/pontos serão iterados.	`input` (+14 opcionais)
`compile_block`	Envolve um alvo em um Compile Block (compile_begin + compile_end, com referências cruzadas) — o otimizador multithread / removedor de overhead de cook ao redor de um For-Each loop pesado (defina o multithread do for_each_end dentro dele).	`input` (+6 opcionais)
`feather_template`	Feather Template from Shape — a ENTRADA da trilha de feathers.	`name` (+10 opcionais)
`feather_template_assign`	Feather Template Assign — atribui templates de feather em pontos de pele para semear um groom.	`input` (+7 opcionais)
`feather_template_interpolate`	Feather Template Interpolate — cresce um groom completo interpolando feathers através de uma pele a partir de feathers-guia esparsas + templates.	`input` (+13 opcionais)
`feather_clump`	Feather Clump — divide e agrupa barbs para o visual característico de penas separadas e emaranhadas.	`input` (+12 opcionais)
`feather_noise`	Feather Noise — adiciona quebra natural às feathers.	`input` (+10 opcionais)
`feather_width`	Feather Width — define larguras de shaft e barb que controlam a espessura renderizada da feather.	`input` (+6 opcionais)
`feather_resample`	Feather Resample — muda a resolução de pontos dos shafts e barbs das feathers.	`input` (+13 opcionais)
`feather_deintersect`	Feather Deintersect — afasta feathers sobrepostas para que um groom denso se leia com clareza.	`input` (+12 opcionais)
`feather_normalize`	Feather Normalize — normaliza atributos de feather em uma forma de rest canônica.	`input` (+5 opcionais)
`feather_barb_transform`	Feather Barb Transform — converte posições de barb entre espaço local da feather e espaço do objeto.	`input` (+3 opcionais)
`feather_deform`	Feather Deform — captura feathers a uma pele e as deforma junto com uma pele animada.	`input` (+12 opcionais)
`feather_attrib_interpolate`	Feather Attrib Interpolate — interpola atributos de barb em feathers a partir de feathers de origem.	`input` (+9 opcionais)
`feather_surface`	Feather Surface — constrói um mesh de superfície poligonal renderizável a partir de feathers condensadas.	`input` (+10 opcionais)
`feather_surface_blend`	Feather Surface Blend — mistura uma superfície de feather em direção a uma superfície alvo (ex.: dobrar uma asa).	`input` (+13 opcionais)
`feather_convert`	Feather Convert — converte feathers condensadas em geometria explícita de curva ou superfície.	`input` (+9 opcionais)
`feather_uncondense`	Feather Uncondense — expande uma feather condensada (uma prim por feather) em geometria de curva completa por barb.	`input` (+7 opcionais)
`feather_primitive`	Feather Primitive — edita a representação de primitiva condensada da feather (resolução + nomenclatura).	`input` (+8 opcionais)
`feather_barb_tangents`	Feather Barb Tangents — calcula atributos de tangente por barb em feathers (necessários para algumas operações de estilo/sombreamento de barbs).	`input` (+1 opcional)
`feather_min_dist`	Feather Minimum Distance — calcula um atributo de distância mínima entre feathers (entrada 0) e feathers alvo (entrada 3).	`input` (+3 opcionais)
`feather_ray`	Feather Ray — projeta/raytraça feathers sobre pele ou geometria alvo, opcionalmente amostrando primnum/primuv no ponto de impacto.	`input` (+10 opcionais)
`feather_visualize`	Feather Visualize — gera geometria de visualização de viewport para feathers (barbs como curvas ou uma superfície).	`input` (+3 opcionais)
`hair_generate`	Hair Generate (hairgen::2.0) — o GERADOR de cabelo/guia programável e entrada de lane: distribua raízes em uma skin e cresça curvas, opcionalmente interpoladas a partir de um conjunto de guias.	`input` (+17 opcionais)
`fur_setup`	Fur (fur) — o gerador de Fur legado completo: gere + agrupe + separe pelos a partir de uma skin e guias em um único nó.	`input` (+15 opcionais)
`hair_growth_field`	Hair Growth Field (hairgrowthfield) — construa um campo de crescimento de cabelo / distribua raízes de guias a partir de um escalpo.	`input` (+14 opcionais)
`guide_initialize`	Guide Initialize (guideinit) — oriente guias recém-criadas (formato de vento, elevação, mistura ao longo da skin).	`input` (+11 opcionais)
`guide_reguide`	Reguide (reguide) — redistribua / reamostre o conjunto de guias (altere a densidade de guias e a contagem de segmentos).	`input` (+11 opcionais)
`guide_fill`	Guide Fill (guidefill) — preencha lacunas em um conjunto esparso de guias usando uma malha de interpolação de guias.	`input` (+7 opcionais)
`guide_grow_to_surface`	Guide Grow to Surface (guidegrowtosurface) — cresça raízes de guias até uma superfície alvo (advecte pontos de origem em uma malha).	`input` (+10 opcionais)
`guide_process`	Guide Process (guideprocess) — a principal pilha de ops de ESTILIZAÇÃO de guias: escolha uma única operação com op1 (definir direção/elevação/comprimento, deslocar, ondular, alisar, suavizar, frisar, curvar, atributo de sim).	`input` (+15 opcionais)
`hair_clump`	Hair Clump (hairclump::2.0) — agrupe cabelos/guias em mechas (o visual de cabelo característico).	`input` (+15 opcionais)
`guide_clump_center`	Guide Clump Center (guideclumpcenter) — calcule guias/atributos de centro de agrupamento que alimentam o hair_clump.	`input` (+5 opcionais)
`guide_partition`	Guide Partition (guidepartition) — crie linhas de separação que dividem o groom em regiões de partição.	`input` (+10 opcionais)
`guide_groom`	Guide Groom (guidegroom::2.0) — o nó de dados do groomer de escova.	`input` (+13 opcionais)
`hair_comb`	Comb (comb) — penteie a direção de pelo/cabelo.	`input` (+9 opcionais)
`guide_mask`	Guide Mask (guidemask) — crie máscaras (atributo/grupo) em guias/skin que todas as outras ops de groom leem.	`input` (+14 opcionais)
`guide_group`	Guide Group (guidegroup) — crie grupos de guias / linhas de separação por convenção de nomenclatura.	`input` (+5 opcionais)
`guide_find_strays`	Guide Find Strays (guidefindstrays) — detecte guias desviantes/outliers e marque-as em um grupo/atributo.	`input` (+10 opcionais)
`guide_skin_attrib_lookup`	Guide Skin Attribute Lookup (guideskinattriblookup) — copie atributos da skin para as guias via o enraizamento skinprim/skinprimuv armazenado.	`input` (+9 opcionais)
`guide_tangent_space`	Guide Tangent Space (guidetangentspace) — calcule quadros tangente/normal/bitangente/orient por guia necessários para as ops de direção.	`input` (+12 opcionais)
`guide_interpolation_mesh`	Guide Interpolation Mesh (guideinterpolationmesh) — construa a malha de interpolação (skin remalhada + pesos de guia) que o hair_generate usa para interpolar guias.	`input` (+14 opcionais)
`guide_volume`	Guide Volume (guidevolume) — construa a representação de volume de guias/skin (seções transversais / shell / remesh / tets, VDB opcional) que muitas ops de groom consomem.	`input` (+12 opcionais)
`guide_surface`	Guide Surface (guidesurface) — mova/construa uma superfície a partir de guias ao longo de uma malha de interpolação de guias.	`input` (+9 opcionais)
`guide_deform`	Guide Deform (guidedeform) — capture guias em uma skin e deforme-as com uma skin animada.	`input` (+16 opcionais)
`guide_transfer`	Guide Transfer (guidetransfer) — transfira um groom de uma skin de origem para uma skin de destino.	`input` (+11 opcionais)
`groom_blend`	Groom Blend (groomblend) — misture dois grooms completos (guias A vs guias B) por peso/máscara.	`input` (+14 opcionais)
`guide_collide_vdb`	Guide Collide With VDB (guidecollidevdb) — empurre guias para fora de um VDB de colisão.	`input` (+11 opcionais)
`guide_advect`	Guide Advect (guideadvect) — advecte guias através de um VDB de velocidade ou preencha colisões.	`input` (+13 opcionais)
`hair_card_generate`	Hair Card Generate (haircardgen) — gere CARDS de cabelo texturizados (saída para jogos / tempo real) a partir de curvas de cabelo.	`input` (+16 opcionais)
`hair_volume_rasterize`	Volume Rasterize Hair (volumerasterizehair) — rasterize curvas de cabelo em um VDB de densidade/cor/tangente (preparação para render/sim).	`input` (+10 opcionais)
`fiber_groom`	Fiber Groom (fibergroom) — grooming de FIBRAS musculares (lane de músculos KineFX, não cabelo).	`input` (+8 opcionais)
`volume_create`	Volume (volume) — GERADOR: crie um primitivo de volume escalar/vetorial novo em um novo /obj geo (uma fonte de autoria de névoa/densidade). type float/int; rank + components dimensionam o volume; volume_name nomeia a grade; initialalpha o preenchimento; zmin/zmax + use_cam_window/camera definem um volume de frustum de câmera (camera é uma referência de cena NodePath, não um arquivo).	`name` (+9 opcionais)
`vdb_create`	VDB (vdb) — GERADOR: crie uma grade VDB tipada vazia nova (level-set / fog / vector) em um novo /obj geo — a fonte de autoria de VDB. grid_class escolhe a interpretação; grid_type o tipo de voxel; grid_precision single/double; grid_name nomeia a grade.	`name` (+4 opcionais)
`volume_from_attrib`	Volume from Attribute (volumefromattrib) — rasterize um atributo de ponto/vértice em um volume.	`input` (+14 opcionais)
`points_from_volume`	Points from Volume (pointsfromvolume) — distribua pontos dentro de um volume de névoa/SDF.	`input` (+13 opcionais)
`paint_fog_volume`	Volume Paint Fog (paintfogvolume) — deposite densidade proceduralmente em um volume de névoa.	`input` (+15 opcionais)
`volume_rasterize_curve`	Volume Rasterize Curve (volumerasterizecurve) — rasterize curvas em um volume de névoa (densidade distribuída ao longo das curvas).	`input` (+14 opcionais)
`volume_convert`	Convert Volume (convertvolume) — converta um VDB/volume em uma superfície poligonal via marching cubes.	`input` (+7 opcionais)
`volume_surface`	Volume Surface (volumesurface) — construa uma superfície poligonal a partir de uma hierarquia de volumes de névoa/SDF com comprimento de aresta adaptativo.	`input` (+15 opcionais)
`extrude_volume`	Extrude Volume (extrudevolume) — extrude polígonos em um volume sólido ao longo da normal da base.	`input` (+11 opcionais)
`convert_vdb_points`	Convert VDB Points (convertvdbpoints) — converta entre nuvens de pontos e grades VDB Points.	`input` (+15 opcionais)
`volume_merge`	Volume Merge (volumemerge) — mescle/componha volumes com uma pilha completa de add-mul pré/pós.	`input` (+16 opcionais)
`vdb_merge`	VDB Merge (vdbmerge) — mescle múltiplas grades VDB de nome correspondente em uma única.	`input` (+6 opcionais)
`volume_vector_join`	Volume Vector Join (volumevectorjoin) — una três (ou quatro) volumes escalares em um volume vetorial.	`input` (+8 opcionais)
`volume_vector_split`	Volume Vector Split (volumevectorsplit) — divida um volume vetorial em três volumes escalares.	`input` (+3 opcionais)
`volume_feather`	Volume Feather (volumefeather) — suavize (feather) os valores de um volume perto de sua borda.	`input` (+12 opcionais)
`volume_ramp`	Volume Ramp (volumeramp) — remapeie os valores de um volume através de um intervalo source->dest.	`input` (+8 opcionais)
`volume_noise_fog`	Volume Noise Fog (volumenoisefog) — adicione ruído em camadas a um volume de névoa para detalhamento de densidade.	`input` (+14 opcionais)
`volume_noise_sdf`	Volume Noise SDF (volumenoisesdf) — adicione ruído em camadas a um volume SDF para detalhamento de superfície.	`input` (+14 opcionais)
`volume_adjust_fog`	Volume Adjust Fog (volumeadjustfog) — ajuste a aparência de um volume de névoa (combinação init / remap).	`input` (+13 opcionais)
`volume_resample`	Volume Resample (volumeresample) — reamostre um volume para uma nova resolução de voxel.	`input` (+10 opcionais)
`volume_resize`	Volume Resize (volumeresize) — redimensione / redefina os limites da grade de um volume.	`input` (+10 opcionais)
`volume_reduce`	Volume Reduce (volumereduce) — reduza um volume a um valor agregado (max/min/média/mediana/soma/rms...).	`input` (+8 opcionais)
`volume_bound`	Volume Bound (volumebound) — reconstrua a região ativa/limitante de um volume por limiarização.	`input` (+4 opcionais)
`volume_sdf`	Volume SDF (volumesdf) — calcule um campo de distância assinada a partir de um volume de névoa/máscara.	`input` (+9 opcionais)
`vdb_activate_sdf`	VDB Activate SDF (vdbactivatesdf) — ative / expanda a banda estreita de um SDF VDB.	`input` (+15 opcionais)
`vdb_topology_to_sdf`	VDB Topology to SDF (vdbtopologytosdf) — construa um SDF a partir da topologia de voxels ativos de um VDB.	`input` (+10 opcionais)
`vdb_occlusion_mask`	VDB Occlusion Mask (vdbocclusionmask) — construa um VDB de máscara de oclusão voltado para a câmera atrás dos VDBs de entrada.	`input` (+8 opcionais)
`volume_analysis`	Volume Analysis (volumeanalysis) — calcule uma quantidade diferencial de um volume.	`input` (+4 opcionais)
`volume_velocity_from_curves`	Volume Velocity from Curves (volumevelocityfromcurves) — construa um volume de velocidade que flui ao longo de curvas.	`input` (+17 opcionais)
`volume_velocity_from_surface`	Volume Velocity from Surface (volumevelocityfromsurface) — construa um volume de velocidade (+ colisão) a partir do movimento de uma superfície.	`input` (+9 opcionais)
`lattice_from_volume`	Lattice from Volume (latticefromvolume) — construa um lattice / grade de pontos correspondente ao layout de voxels de um volume.	`input` (+7 opcionais)
`volume_deform`	Volume Deform (volumedeform) — deforme um volume por um point-deform / lattice em movimento.	`input` (+10 opcionais)
`volume_rasterize_lattice`	Volume Rasterize Lattice (volumerasterizelattice) — rasterize um lattice em movimento de volta em um volume.	`input` (+15 opcionais)
`volume_break`	Volume Break (volumebreak) — divida / quebre geometria com um cortador de volume SDF em pedaços.	`input` (+12 opcionais)
`volume_splice`	Volume Splice (volumesplice) — emende / costure peças de volume em mosaico de volta em uma única grade.	`input` (+3 opcionais)
`volume_stamp`	Volume Stamp (volumestamp) — carimbe um volume de origem em um volume de destino em pontos.	`input` (+10 opcionais)
`volume_patch`	Volume Patch (volumepatch) — remende uma região de um volume com outro volume (mistura de Poisson).	`input` (+9 opcionais)
`volume_convolve`	Volume Convolve (volumeconvolve3) — aplique um kernel de convolução 3x3x3 a um volume.	`input` (+4 opcionais)
`volume_fft`	Volume FFT (volumefft) — FFT direta / inversa de um volume (domínio de frequência).	`input` (+7 opcionais)
`volume_normalize`	Volume Normalize Weights (volumenormalize) — normalize um conjunto de pesos / valores de volume.	`input` (+9 opcionais)
`volume_compress`	Volume Compress (volumecompress) — comprima o armazenamento de um volume (podagem de tile / constante).	`input` (+15 opcionais)
`volume_arrival_time`	Volume Arrival Time (volumearrivaltime) — calcule o tempo de chegada de propagação de frente através de um volume de velocidade.	`input` (+8 opcionais)
`volume_optical_flow`	Volume Optical Flow (volumeopticalflow) — estime movimento (fluxo óptico) entre dois volumes.	`input` (+11 opcionais)
`volume_trail`	Volume Trail (volumetrail) — advecte / rastreie pontos através de um volume de velocidade ao longo do tempo.	`input` (+16 opcionais)
`volume_ambient_occlusion`	Volume Ambient Occlusion (volumeambientocclusion) — calcule oclusão ambiente em um volume.	`input` (+7 opcionais)
`volume_bake`	Bake Volume (bakevolume) — assar iluminação / espalhamento em um volume (preparação de render).	`input` (+11 opcionais)
`volume_noise_vector`	Volume Noise Vector (volumenoisevector) — adicionar ruído em camadas a um volume vetorial (detalhamento de velocidade).	`input` (+9 opcionais)
`paint_color_volume`	Volume Paint Color (paintcolorvolume) — depositar cor (Cd) proceduralmente em um volume.	`input` (+15 opcionais)
`paint_sdf_volume`	Volume Paint SDF (paintsdfvolume) — esculpir / adicionar proceduralmente a um volume SDF.	`input` (+8 opcionais)
`vdb_convex_clip_sdf`	VDB Convex Clip SDF (vdbconvexclipsdf) — recortar convexamente um SDF VDB usando um segundo SDF convexo.	`input` (+7 opcionais)
`vdb_diagnostics`	VDB Diagnostics (vdbdiagnostics) — validar / diagnosticar um grid VDB (QC apenas de dados).	`input` (+15 opcionais)
`vdb_lod`	VDB LOD (vdblod) — construir uma pirâmide de nível de detalhe (mip) para um VDB.	`input` (+6 opcionais)
`vdb_points_delete`	VDB Points Delete (vdbpointsdelete) — excluir pontos de um grid VDB Points.	`input` (+5 opcionais)
`vdb_points_group`	VDB Points Group (vdbpointsgroup) — agrupar pontos dentro de um grid VDB Points.	`input` (+15 opcionais)
`vdb_rasterize_frustum`	VDB Rasterize Frustum (vdbrasterizefrustum) — rasterizar partículas em um VDB alinhado ao frustum da câmera.	`input` (+17 opcionais)
`vdb_visualize_tree`	VDB Visualize Tree (vdbvisualizetree) — construir geometria de visualização da estrutura interna de árvore de um VDB.	`input` (+15 opcionais)
`poly_patch`	Build a smooth polygon patch surface across a hull/cage of curves or a mesh (polypatch) — organizar uma gaiola de curvas grosseira em uma superfície limpa pronta para subdivisão. basis = base de suavização (cardinal \| bspline); connectivity = como as linhas/colunas do casco se conectam ao patch; divisions [u,v] = resolução de saída; close_u/close_v a envolvem; output_polygons emite polígonos em vez de uma primitiva de malha.	`input` (+8 opcionais)
`poly_loft`	Skin a polygon surface across a sequence of cross-section curves (polyloft) — gerar uma superfície poligonal (skin) sobre uma sequência de curvas de seção transversal.	`input` (+11 opcionais)
`poly_spline`	Fit a smooth spline through a polyline's points and re-output it as a resampled polygon curve (polyspline) — transformar um polígono de controle grosseiro em uma curva suave. spline_type = base de interpolação; closure = se deve fechar; division_method = como a densidade de amostragem é distribuída; segment_length / divisions / sample_divisions = resolução de saída; tension = tensão do CV.	`input` (+9 opcionais)
`circle_spline`	Fit circular-arc / ellipse / helix splines through a control polygon (circlespline) — curvatura perfeitamente redonda que uma spline livre não consegue oferecer. spline_type (hybrid \| circle \| ellipse \| helix); helix_type = estilo do enrolamento; reparm_strength = reparametriza para espaçamento uniforme; segment_divisions = resolução de saída; output_tangent + tangent_attrib gravam um atributo de tangente.	`input` (+8 opcionais)
`poly_cap`	Fill open polygon boundaries (unshared edges) with cap polygons (polycap) — selar a extremidade de um tubo/extrusão ou um anel de furo.	`input` (+7 opcionais)
`cap`	Add end/pole caps to NURBS/mesh surfaces and open curves, per U/V boundary (cap) — fechar as extremidades de tubos/esferas/superfícies revolvidas. first_u_cap / last_u_cap / first_v_cap / last_v_cap escolhem um estilo (none \| facet \| share \| round \| tangent); divisions_u / divisions_v = resolução da tampa arredondada; scale_u / scale_v estufam as tampas.	`input` (+10 opcionais)
`fillet`	Build a smooth transition surface between adjacent primitives / two curves (fillet) — arredondar junções duras entre superfícies.	`input` (+11 opcionais)
`stitch`	Blend/stitch two adjacent surface HULLS together along shared boundaries (stitch) — misturar/costurar dois cascos de superfície adjacentes ao longo de limites compartilhados.	`input` (+12 opcionais)
`join`	Connect a sequence of separate primitives (curves or surfaces) end-to-end into a single continuous primitive (join) — transformar muitos pedaços pequenos em uma única primitiva longa.	`input` (+10 opcionais)
`poly_hinge`	Fold/rotate polygons about a hinge edge or axis, subdividing the crease into segments (polyhinge) — abrir painéis, pétalas, dobras pop-up. group + group_type (primitive \| edge) escolhem o que dobra; pivot_mode = como a linha de dobradiça é definida; hinge_edge = a aresta da dobradiça; hinge_angle = o ângulo da dobra; divisions = os segmentos do vinco; enable_inset + inset adicionam um chanfro; output_front/back/side alternam as camadas resultantes.	`input` (+15 opcionais)
`poly_stitch`	Weld the boundaries of two polygon shells together, filling the gap with bridging polygons (polystitch) — reparar costuras / unir metades modeladas separadamente. stitch_group / corners restringem quais polígonos/pontos de borda são costurados; tolerance = distância máxima de costura; consolidate funde pontos coincidentes; find_corners + corner_angle detectam automaticamente pontos de canto.	`input` (+7 opcionais)
`poly_soup`	Collapse many polygons into a single lightweight 'polysoup' primitive (polysoup) — reduzir memória e overhead de nós para malhas estáticas densas, ótimo antes de instanciamento / alvos de espalhamento pesados. group restringe a fonte; min_polys = limite de tamanho; convex triangula em polígonos convexos; use_max_sides + max_sides limitam os lados dos polígonos; merge_vertices solda vértices idênticos; ignore_attribs / ignore_groups descartam dados por primitiva.	`input` (+9 opcionais)
`poly_cut`	Cut/split polygons along points, edges, or an attribute-crossing, optionally removing the cut region (polycut) — cortar/dividir polígonos ao longo de pontos, arestas ou cruzamento de atributo, removendo opcionalmente a região cortada. group restringe os polígonos afetados; type (points \| edges) = primitiva de corte; cut_points / cut_edges nomeiam os locais de corte; strategy (remove \| cut) = se deve excluir ou apenas dividir; cut_attrib + cut_value + cut_threshold cortam onde um atributo cruza um valor (um isocorte); keep_closed re-fecha o resultado.	`input` (+10 opcionais)
`poly_path`	Reconnect loose edges / open polylines into clean continuous paths (polypath) — organizar extrações de arestas e curvas de contorno para sweep/reamostragem posteriores. connect_ends une pontos finais próximos (dentro de max_end_dist); connect_only_to_ends restringe uniões a outros pontos finais (sem junções T no meio da curva); close_loops fecha anéis isolados.	`input` (+5 opcionais)
`convert_line`	Convert geometry edges into polyline curves (convertline) — extrair um wireframe / curvas de aresta de uma malha para polywire, reamostragem ou sweep. group restringe a fonte; connect_path encadeia arestas em caminhos contínuos; keep_order preserva a ordem do grupo; close_loops fecha anéis isolados; remove_unused descarta pontos órfãos; compute_length + length_name gravam um atributo de comprimento de repouso por primitiva.	`input` (+8 opcionais)
`circle_from_edges`	Snap a ring of points/edges onto a best-fit circle (circlefromedges) — tornar um furo de parafuso, ponta de tubo ou arco de roda perfeitamente redondo. group + group_type escolhem o anel; only_boundary usa apenas o limite do grupo; explicit_radius + radius forçam um raio (caso contrário, melhor ajuste); scale aumenta/diminui o círculo ajustado; output_edge_group nomeia as arestas resultantes.	`input` (+8 opcionais)
`orient_along_curve`	Compute per-point orientation frames (tangent/up + rotations) along curves (orientalongcurve) — o rig para sweep, cópia em curva ou torção de fita.	`input` (+17 opcionais)
`delta_mush`	Smooth a deformed mesh while preserving surface detail (deltamush) — a correção padrão para skinning irregular / deformações instáveis.	`input` (+10 opcionais)
`surface_relax`	Evenly redistribute points across a surface to relax bunched/stretched topology (surfacerelax) — melhorar a distribuição de pontos sem mudar muito a forma.	`input` (+4 opcionais)
`laplacian`	Compute the discrete Laplace operator (cotangent / mean-value / Wachspress / Tutte weights) of a mesh and store it as a sparse matrix in attributes (laplacian) — espinha dorsal de difusão, suavização e solução de processamento geométrico de malhas. mode = esquema de ponderação; separate_mass separa a matriz de massa; diffusion + diffusion_coeff constroem uma matriz de difusão; epsilon regulariza.	`input` (+6 opcionais)
`soft_transform`	Move/rotate/scale a region of points with a smooth radial falloff (softxform) — edição proporcional / arrasto de ímã.	`input` (+9 opcionais)
`soft_peak`	Push points along their normals with a smooth radial falloff (softpeak) — um pincel suave de inflar/amassar.	`input` (+7 opcionais)
`elastic_transform`	Deform a mesh as an elastic solid via a grab / twist / scale / pinch handle that propagates through the material (elastictransform) — parece puxar borracha macia.	`input` (+12 opcionais)
`magnet`	Deform `input` points by a moving 'magnet' shape whose metaball-style field falls off with distance (magnet) — esticar/comprimir, amassados, protuberâncias musculares dirigidas por uma forma de proxy.	`input` (+11 opcionais)
`bulge`	Push `input` points outward/inward along their normals where a 'magnet' shape overlaps them (bulge) — um inchaço localizado rápido dirigido por uma forma de proxy.	`input` (+7 opcionais)
`creep`	Project `input` geometry onto a surface's UV space and crawl it across that surface (creep) — colar decalques/trilhas/textos em uma malha, ou animar geometria deslizando sobre ela.	`input` (+10 opcionais)
`vector_deform`	Deform `input` by the difference between two matching point clouds (a rest set and a deformed set), interpolating that motion field onto the mesh (vectordeform) — deformação estilo gaiola/lattice a partir de pontos dirigentes arbitrários.	`input` (+9 opcionais)
`shrinkwrap`	Wrap a tight convex hull around the `input` points (shrinkwrap) — proxies de colisão rápidos, conchas delimitadoras, silhuetas simplificadas. type (xyz = casco 3D completo \| xy = casco planar 2D); shrink_amount insere o casco para dentro; plane_origin / plane_normal definem o plano de projeção para o modo 2D; preserve_attribs carrega atributos de origem; remove_inline_points limpa pontos colineares do casco.	`input` (+8 opcionais)
`detangle`	Push self-intersecting / interpenetrating geometry apart so it stops overlapping (detangle) — limpeza para malhas de tecido, cabelo ou multidão que se embaralharam.	`input` (+8 opcionais)
`tetrahedralize`	Fill a CLOSED input surface with a tetrahedral (tet) mesh (tetrahedralize) — o ponto de entrada para preparação de FEM / corpo macio / elementos finitos.	`input` (+17 opcionais)
`tet_conform`	Build a boundary-CONFORMING tet mesh whose surface matches the input polygons (tetconform) — geração de malha volumétrica de maior qualidade que um preenchimento simples quando a superfície deve ser respeitada.	`input` (+17 opcionais)
`tet_embed`	Embed the input surface inside a coarser background tet lattice (tetembed) — a preparação rápida de FEM/corpo macio quando você quer uma gaiola tet simulável AO REDOR de geometria detalhada em vez de uma malha conforme à superfície.	`input` (+17 opcionais)
`tet_layer`	Build a single tet layer of a given thickness off a surface (tetlayer) — conchas volumétricas rápidas para pele/rind de FEM ou uma faixa tet inicial.	`input` (+7 opcionais)
`tet_partition`	Split a tet mesh into named pieces using region-boundary polygons (tetpartition) — esculpir um sólido em regiões FEM / pedaços de fratura.	`input` (+5 opcionais)
`tet_surface`	Extract the outer surface polygons of a tet mesh (tetrasurface) — obter uma pele renderizável / colidível de volta de uma malha tet volumétrica.	`input` (+4 opcionais)
`tet_fracture`	Fraturar geometria em pedaços baseados em tet via uma divisão Voronoi / padrão (tetfracture) — sólidos pré-fraturados para destruição FEM/RBD.	`input` (+7 opcional)
`solid_embed`	Incorporar a geometria de entrada em uma treliça de tet sólida dimensionada por uma escala de elemento único (solidembed) — o construtor de gaiola FEM de um botão.	`input` (+2 opcional)
`topo_transfer`	Envolver uma malha TEMPLATE limpa em uma malha TARGET, transferindo a topologia do template para a forma do alvo (topotransfer) — o cavalo de batalha de retopo/personagem para combinar uma malha base rigada a um scan/esculpido.	`input` (+18 opcional)
`topo_slide`	Deslizar os pontos de uma malha alvo pela sua superfície guiado por CURVAS de referência/alvo correspondentes, ou executar uma transferência de topo guiada por curvas (toposlidebycurverefs) — ajustar o fluxo de retopo ao longo de costuras/recursos proceduralmente.	`input` (+15 opcional)
`usd_configure_sop`	Configurar como a geometria SOP será autoria para USD — definir opções de importação em todo o estágio como metadados USD na geometria (o `usdconfigure` de contexto SOP; um operador puro, SEM gravação de arquivo).	9 opcional
`usd_configure_geometry`	Autorar metadados de geometria USD por primitiva na geometria SOP (o `usdconfiguregeometry` de contexto SOP; um operador puro, SEM gravação de arquivo).	9 opcional
`usd_configure_prims_from_points`	Autorar atributos de prim USD a partir de PONTOS — transformar pontos em prims USD configurados (esferas, luzes, xforms…) com metadados por prim (o `usdconfigureprimsfrompoints` de contexto SOP; um operador puro, SEM gravação de arquivo).	12 opcional
`unpack_usd`	Desempacotar primitivas USD empacotadas em geometria nativa do Houdini (unpackusd) — transformar os prims empacotados leves de usd_import_sop (unpack=false) em polígonos/pontos editáveis.	`input` (+14 opcional)
Tool	O que faz	Parâmetros-chave
---	---	---
`attribute_normalize_float`	SideFX Labs Attribute Normalize Float — remapeia um atributo float em [out_min, out_max] (padrão 0..1) usando a faixa de valor de entrada.	`input` (+10 opcionais)
`attribute_normalize_vector`	SideFX Labs Attribute Normalize Vector — normaliza um atributo vetorial.	`input` (+11 opcionais)
`attribute_value_replace`	SideFX Labs Attribute Value Replace — renomeia um atributo e/ou planta valores padrão de inicialização/fallback nos atributos nomeados em `attribute_list` (padrão `name`).	`input` (+8 opcionais)
`color_adjustment`	SideFX Labs Color Adjustment — ajuste de brilho / contraste / saturação / gama em um atributo de cor (padrão `Cd`, ou um atributo personalizado).	`input` (+13 opcionais)
`color_blend`	SideFX Labs Color Blend — mistura dois atributos de cor com um `blend_mode` estilo Photoshop.	`input`, `input2` (+9 opcionais)
`color_gradient`	SideFX Labs Color Gradient — pinta um gradiente de cor ao longo de um `axis` (X/Y/Z, ou Custom rotacionado por `rotation_angle`) em `Cd` (ou um atributo personalizado).	`input` (+7 opcionais)
`min_max_average`	SideFX Labs Min Max Average — reduz um atributo a uma única estatística (`method`: max/min/média/mediana/soma/rms/…) e grava de volta como um atributo de detail (ou, com `detail_attribute` desativado, promovido por elemento) nomeado por `prefix`/`suffix`.	`input` (+8 opcionais)
`radial_sort`	SideFX Labs Radial Sort — reordena pontos e/ou primitivas por ângulo em torno de um eixo (`*_dir`) para que um leque/anel seja indexado em uma ordem rotacional limpa.	`input` (+16 opcionais)
`sort_geometry`	SideFX Labs Sort — reordena pontos e/ou primitivas por uma chave escolhida: eixo (byx/byy/byz), aleatório (`_seed`), deslocamento (`_offset`), ao longo de um vetor (`_dir`), localidade espacial, ou por um atributo (`_attrib`).	`input` (+17 opcionais)
`visualize_vector`	SideFX Labs Visualize Vector — constrói geometria de seta a partir de um atributo vetorial (`vector_attribute`, padrão `P`) para inspeção.	`input` (+18 opcionais)
`fast_group_unshared`	SideFX Labs Fast Group Unshared — agrupa os elementos UNSHARED (fronteira aberta / borda) da malha de entrada (entrada 0): arestas pertencentes a uma única primitiva mais os pontos/prims/vértices que as tocam.	`input` (+4 opcionais)
`group_by_attribute`	SideFX Labs Group by Attribute — cria um grupo por cada valor distinto de um atributo na entrada (entrada 0).	`input` (+5 opcionais)
`group_by_measure`	SideFX Labs Group by Measure — agrupa primitivas por uma medida de excentricidade geométrica (quão longe a forma de uma prim se afasta de um círculo/quadrado).	`input` (+5 opcionais)
`group_curve_corners`	SideFX Labs Group Curve Corners — rotula os pontos de canto das curvas de entrada (entrada 0) em um grupo `inside` (cantos convexos) e um grupo `outside` (cantos côncavos).	`input` (+6 opcionais)
`group_grow`	SideFX Labs Group Expand — expande (ou encolhe) um grupo existente através da conectividade da geometria de entrada.	`input` (+3 opcionais)
`group_invert`	SideFX Labs Group Invert — inverte grupos nomeados no lugar: cada grupo listado é substituído pelo seu complemento (todos os elementos NÃO nele).	`input` (+4 opcionais)
`loops_from_selection`	SideFX Labs Loops from Selection — cresce loops de aresta completos (ou loops de quad) a partir de um grupo de arestas semente.	`input` (+12 opcionais)
`random_selection`	SideFX Labs Random Selection — seleciona um subconjunto aleatório dos elementos da entrada e o transforma em um grupo.	`input` (+24 opcionais)
`extract_filename`	SideFX Labs Extract Filename — lê o caminho do arquivo de um File SOP upstream (`input`, ou `custom_file_sop` quando `input_mode`=custom) e escreve suas partes em atributos de string de detail (caminho completo / caminho do arquivo / nome do arquivo / diretório).	`input` (+7 opcionais)
`group_create`	Cria um grupo de pontos/prims/arestas NOMEADO e persistente (groupcreate) — a etapa de configuração para cada operação direcionada (blast, bevel em grupo, dissolve, transformar grupo).	`input`, `group_name` (+10 opcionais)
`group_promote`	Converte um grupo entre classes de elementos (grouppromote) — ex.: grupo de pontos -> grupo de prims, com opções de fronteira/unshared.	`input` (+8 opcionais)
`group_range`	Agrupa elementos por faixa de índice numérico e/ou stride de cada N (grouprange) — selecione subconjuntos de piece-id, linhas alternadas, fatias determinísticas. group_name = grupo a criar. class: points\|prims\|vertices. method: absolute (índice início..fim) \| relative (fracionário 0..1 do total) \| length \| partition (dividir em num_partitions blocos pares). start/end delimitam a janela; select_amount ('of') + select_total ('every') + select_offset dão um stride de cada N (of=1 every=3 => cada 3º). invert inverte a associação; merge combina com um grupo existente de mesmo nome.	`input` (+13 opcionais)
`group_expand`	Cresce ou encolhe um grupo por passos conectados por arestas (groupexpand) — passos negativos encolhem.	`input` (+9 opcionais)
`group_transfer`	Transfere associação de grupo de uma geometria para outra por proximidade (grouptransfer).	`input` (+11 opcionais)
`group_delete`	Remove definições de grupo (geometria intocada) — groupdelete.	`input` (+3 opcionais)
`group_rename`	Renomeia um grupo (grouprename).	`input` (+4 opcionais)
`group_geo`	Seleção geométrica profunda de grupos (groupcreate) — os modos que group_create não tem: esfera delimitadora/objeto/volume/convexo, backface por câmera, ângulo de aresta, arestas unshared/abertas.	`input` (+27 opcionais)
`blast`	Exclui geometria por grupo — a primitiva fundamental de exclusão direcionada. group = o nome/padrão do grupo (das ferramentas de grupo) ou uma faixa bruta de elementos; group_type orienta a interpretação (guess\|points\|prims\|edges\|breakpoints). delete_non_selected INVERTE: mantém SOMENTE o grupo, exclui todo o resto (o idioma de isolamento). fill_hole tampa os buracos deixados; remove_group remove a tag de grupo depois.	`input`, `group` (+5 opcionais)
`attribute_transfer`	Transfere atributos de pontos/prims de uma malha SOURCE para a entrada por proximidade (attribtransfer) — o cavalo de batalha para cor LIDAR / atributo GIS: pinte Cd de um scan em um remesh, carregue N/uv através de uma mudança de topologia.	`input`, `source` (+4 opcionais)
`attribute_create`	Cria um atributo de ponto/prim/vértice/detail tipado com valor constante (attribcreate) — a maneira tipada sem wrangle de adicionar Cd/pscale/N/id/material-index ou qualquer atributo personalizado. attrib_name = atributo a criar. type = tipo de armazenamento (float\|int\|vector\|...). class = classe de elemento. value = um número ou [x,y,z] (tipos string aceitam uma string via value como texto). size = tamanho da tupla 1..4. precision = bits de armazenamento. type_info marca a semântica de transformação para que nós downstream transformem o atributo corretamente (normal para N, color para Cd, point para posições). on_existing decide o que acontece se o nome já existir. group restringe a criação.	`input`, `attrib_name` (+9 opcionais)
`attribute_promote`	Move/agrega um atributo entre classes de elementos (attribpromote) — transforme um atributo de ponto em uma média por prim, espalhe um valor de detail em pontos, etc. attrib = nome de origem. from_class/to_class = point\|prim\|vertex\|detail. method = como valores de origem colapsam em um elemento de destino (max\|min\|mean\|mode\|median\|sum\|first\|last\|array...). out_name renomeia o resultado. piece_attrib agrega DENTRO de cada peça nomeada independentemente. delete_original: NOTE que o nó EXCLUI a origem por padrão — passe false para manter ambos.	`input`, `attrib` (+7 opcionais)
`attribute_delete`	Remove atributos por classe + padrões de nome separados por espaço (attribdelete) — limpeza para descartar Cd/N/rest/atributos temporários antes da exportação ou de um solver. point/prim/vertex/detail são cada um um padrão de nomes separados por espaço a excluir (ex.: "Cd N rest"). negate INVERTE: mantém SOMENTE os padrões listados e exclui todo o resto.	`input` (+6 opcionais)
`attribute_cast`	Converte a precisão de armazenamento de atributos (attribcast) — a otimização de redução de memória 32->16 bits para nuvens de pontos / tiles de terreno pesados. class = classe de elemento. attribs = padrões de nome separados por espaço (padrão * = todos). precision = armazenamento alvo: os floats amigáveis 16\|32\|64 mapeiam para fpreal16/32/64, ou passe um token de nó explícito (uint8\|int8\|int16\|int32\|int64\|fpreal16\|fpreal32\|fpreal64\|preferred) para casts inteiros.	`input` (+4 opcionais)
`attribute_interpolate`	Interpola atributos de uma geometria de origem nos pontos/vértices via UVW ou pesos capturados (attribinterpolate).	`input` (+16 opcionais)
`attribute_from_volume`	Amostra um campo de volume/VDB em atributos de ponto (attribfromvolume) com remap de entrada/saída.	`input` (+10 opcionais)
`attribute_blur`	Suaviza/relaxa atributos através da superfície (attribblur) — laplaciano/preservação de volume, por conectividade ou proximidade.	`input` (+15 opcionais)
`attribute_copy`	Copia atributos de uma geometria para outra (attribcopy), opcionalmente combinados por um atributo como piece.	`input` (+13 opcionais)
`attribute_randomize`	Escreve valores aleatórios em um atributo (attribrandomize) — todas as 12 distribuições incl. ramp / discreta (ponderada) / uniformdiscrete. min_limit/max_limit limitam apenas as distribuições ilimitadas (normal/exponencial/lognormal/cauchy), não um sorteio uniforme já limitado.	`input` (+26 opcionais)
`attribute_composite`	Compõe atributos através de um stream mesclado/empilhado (attribcomposite) — média/máx/mín/over/under.	`input` (+9 opcionais)
`attribute_reorient`	Reorienta atributos vetoriais/quatérnios para seguir uma deformação vs um rest/referência (attribreorient).	`input` (+6 opcionais)
`attribute_swap`	Troca / copia / move um atributo para outro nome (attribswap).	`input` (+6 opcionais)
`assign_name`	Atribui o atributo de nome de identidade da peça (Name SOP) — a preparação necessária para fragmentos importados/modelados antes de assemble/RBD.	`input` (+7 opcionais)
`enumerate`	Escreve um atributo de índice/nome por elemento ou por peça (Enumerate SOP).	`input` (+8 opcionais)
`connectivity`	Rotula cada peça conectada com um atributo de id de classe em execução (connectivity) — a entrada para blast-por-peça, despeckle-por-tamanho, randomização por peça e assemble. connect_type: point (pontos compartilhando uma aresta) \| prim (prims compartilhando um ponto). attrib_name = atributo de id de saída. attrib_type: int \| string (string prefixa `prefix`, ex.: 'piece_3'). group restringe a rotulação a um grupo de pontos/prims. by_uv divide a conectividade através de costuras UV (precisa de uv_attrib).	`input` (+8 opcionais)
`measure`	Calcula uma quantidade geométrica em um atributo (measure). measure_type: perimeter\|area\|volume\|centroid\|curvature\|gradient\|laplacian\|boundaryintegral\|surfaceintegral. attrib_name = saída. class: points\|prims — qual classe recebe o resultado. curvature_type aplica-se somente quando measure_type=curvature. src_attrib nomeia o atributo sobre o qual gradient/laplacian/*integral operam (ex.: o gradiente de um campo 'height'). total_attrib escreve o total somado (área/volume da malha inteira ou por peça) em um atributo de detail. group restringe.	`input` (+8 opcionais)
`group_combine`	Combine booleanamente dois grupos nomeados em um grupo resultante (groupcombine). result = novo nome do grupo. group_a / group_b = nomes de grupos de origem existentes. operation: union (em qualquer um) \| intersect (em ambos) \| xor (em exatamente um) \| subtract (em A, mas não em B). group_type = a classe dos três grupos (guess detecta automaticamente).	`input`, `result`, `group_a`, `group_b` (+3 opcionais)
`attrib_adjust_float`	Cria/modifica um atributo float com um padrão de valor (attribadjustfloat).	`input` (+16 opcionais)
`attrib_adjust_integer`	Cria/modifica um atributo inteiro com um padrão de valor (attribadjustinteger).	`input` (+14 opcionais)
`attrib_adjust_vector`	Cria/modifica a direção e/ou o comprimento de um atributo vetorial (attribadjustvector).	`input` (+13 opcionais)
`attrib_adjust_color`	Cria/modifica um atributo de cor (Cd) (attribadjustcolor).	`input` (+11 opcionais)
`attrib_adjust_array`	Controles de identidade/ordenação para um atributo de array (attribadjustarray).	`input` (+6 opcionais)
`attrib_adjust_dict`	Controles de alto nível para um atributo de dicionário (attribadjustdict).	`input` (+7 opcionais)
`attrib_combine`	Combina atributos em um destino por meio de uma operação matemática (attribcombine).	`input` (+12 opcionais)
`attrib_fill`	Preenche/propaga um atributo sobre uma superfície resolvendo um campo (attribfill).	`input` (+13 opcionais)
`attrib_fade`	Cria um peso de fade por ponto com rampa de entrada/manutenção/saída ao longo dos frames (attribfade), normalmente para fazer partículas/peças aparecerem e desaparecerem gradualmente.	`input` (+10 opcionais)
`attrib_remap`	Remapeia os valores de um atributo numérico de uma faixa de entrada para uma faixa de saída, opcionalmente por meio de uma rampa (attribremap).	`input` (+11 opcionais)
`attrib_sort`	Reordena pontos/vértices/primitivas pelo valor de um atributo (attribsort).	`input` (+7 opcionais)
`attrib_find`	Para cada elemento, encontra o(s) elemento(s) em uma geometria SEARCH com um valor de atributo correspondente (attribfind).	`input` (+10 opcionais)
`attrib_from_map`	Amostra uma fonte em um atributo de ponto ao longo de UVs (attribfrommap).	`input` (+10 opcionais)
`attrib_from_parm`	Importa os VALORES DE PARÂMETRO de outro nó para a geometria como atributos (attribfromparm).	`input` (+7 opcionais)
`attrib_from_pieces`	Atribui um valor de atributo por peça entre peças nomeadas (attribfrompieces).	`input` (+11 opcionais)
`attrib_mirror`	Copia/espelha um atributo de um lado da geometria para o outro (attribmirror).	`input` (+13 opcionais)
`attrib_paint`	Configura um atributo pintável (attribpaint).	`input` (+8 opcionais)
`attrib_string_edit`	Localiza/substitui valores em atributos de string (attribstringedit).	`input` (+11 opcionais)

Limpeza e malhagem

Ferramenta	O que faz	Parâmetros principais
`mesh_pointcloud`	Transforma uma nuvem de pontos em uma malha (nuvem → VDB → polígonos) com redução opcional, transferência de cor e exportação.	`name`, `input` (+6 opcionais)
`quad_remesh`	Remalhagem QUAD alinhada a campos (SOP quadremesh nativo — sem licença Labs/de terceiros): transforma uma malha triangularizada/de scan em uma malha toda em quads limpa para subdivisão ou animação. resolution escolhe como a densidade é especificada: quad_count (um target_quads absoluto, o padrão), quad_area (target_area por quad), tolerance (tolerância) ou uma escala relativa/absoluta. adaptivity (+curvature_weight) concentra quads na curvatura para que as silhuetas permaneçam nítidas com menos quads; feature_boundaries alinha o fluxo de quads às arestas duras. decimation_level pré-decima a entrada para velocidade em scans densos.	`input` (+9 opcionais)
`gameres`	SideFX Labs GameRes — reduz uma malha de alta resolução (`input`, entrada 0) para um LOD em resolução de jogo via polyreduce / Instant Meshes / voxel-remesh; a saída do SOP cozido É a malha reduzida. finalcount define o orçamento de polígonos; use_instantmeshes alterna para quad-remesh; enable_voxelization+resolution fazem uma reconstrução por voxel.	`input` (+19 opcionais)
`instant_meshes`	SideFX Labs Instant Meshes — remalhagem QUAD/tri alinhada a campos da malha de entrada via núcleo compilado do Instant Meshes (nenhum executável externo é iniciado; cook somente com dados).	`input` (+6 opcionais)
`polydoctor`	Diagnostica e repara polígonos não-manifold / malformados (PolyDoctor) — o saneador de malha pré-booleano / pré-VDB / pré-sim.	`input` (+7 opcionais)
`polyfill`	Preenche buracos de borda (falhas de LIDAR/scan, lacunas booleanas) com polígonos de patch (PolyFill). fillmode escolhe a topologia do patch: tris / trifan / quadfan / quads / gridquads (grade de quads, melhor para subdivisão posterior) ou none (apenas agrupa o buraco). smooth (+smooth_strength, até 50) relaxa o novo patch para se misturar com a superfície ao redor; tangent_strength controla o quanto o patch segue as tangentes da borda (0..2, padrão 0.4). patch_group etiqueta os polígonos de patch criados para seleção posterior.	`input` (+7 opcionais)
`mesh_repair`	Kit de reparo SideFX Labs multiplexado por op. repair (Labs Repair): fecha buracos + corrige geometria não-manifold — fillmode escolhe a topologia do patch de buraco (tris..gridquads), iterations = passagens de reparo. delete_small_parts: remove cascas lixo desconectadas — mode perimeter\|area, threshold é o corte de tamanho relativo, extract_largest mantém apenas a maior peça única (ótimo para isolar um objeto escaneado do ruído). clean_seams: dissolve arestas de emenda de ilhas UV. fast_remesh (Labs Fast Remesh): retriangulação uniforme estilo GPU — target_polycount define o tamanho da saída, iterations = passagens de remalhagem.	`input` (+8 opcionais)
`clean`	SOP Clean — limpeza paramétrica de geometria suja/de scan (o complemento orientado por toggles do polydoctor/mesh_repair).	`input` (+14 opcionais)
`point_normals`	Estima uma normal de superfície por ponto para uma nuvem de pontos bruta (scan LIDAR/fotogrametria) ajustando um plano à vizinhança de cada ponto (covariância / PCA) — necessário antes de malhar (Poisson/VDB) ou segmentar parede-vs-chão, pois scans não têm normais. radius_m = raio de busca da vizinhança (metros); maxpts limita vizinhos por ponto (custo).	`input` (+3 opcionais)
`segment_planar`	Classifica/segmenta pontos de nuvem de pontos como WALL vertical vs FLOOR/CEILING horizontal a partir da normal v@N (execute point_normals primeiro) — extração de estrutura de scan de edifícios/interiores. kwall/coshoriz são os limiares \|N.y\| (próximo de 0 = parede, próximo de 1 = horizontal).	`input` (+3 opcionais)
`despeckle`	Remove ruído de uma nuvem de pontos excluindo pontos isolados/errantes que têm menos que min_nbrs vizinhos dentro de radius — remove ruído/speckle/flyers do scanner antes de malhar. radius = distância de busca de vizinhos; min_nbrs = limiar de manutenção.	`input` (+3 opcionais)
`level`	Alinha por gravidade / endireita uma nuvem de pontos ou scan inclinado para que o chão fique plano e horizontal: ajusta por RANSAC o plano de solo dominante, refina sua normal com PCA e rotaciona toda a nuvem para que essa normal aponte para +Y (cima), via um xform de nível anexado após a entrada. threshold = distância de inlier do RANSAC.	`input` (+1 opcional)

Instância e dispersão

Ferramenta	O que faz	Parâmetros principais
`scatter_copy`	Dispersão-e-instância em uma etapa: dispersa aleatoriamente `count` pontos sobre uma superfície alvo e copia/instancia uma forma de origem em cada ponto (folhagem, rochas, blocos de gelo, detritos, greebles).	`name` (+6 opcionais)
`instance_attributes`	SideFX Labs Instance Attributes — escreve os atributos de ponto que um instancer lê (o atributo de caminho de asset `instanceattrib` + pscale/scale/orient por ponto) nos pontos de entrada (`input`, entrada 0) para que um copy/instance downstream possa vestir uma cena.	`input` (+20 opcionais)
`physics_painter`	SideFX Labs Physics Painter — dispersa objetos sobre a superfície de entrada (`input`, entrada 0) e os estabiliza com uma solução curta de Bullet para que descansem naturalmente (rochas em uma encosta, adereços em uma prateleira).	`input` (+19 opcionais)
`copy_to_points`	Copia/instancia a geometria SOP de origem em cada ponto do SOP alvo (Copy to Points 2.0) — a operação central de instância para folhagem, rochas, detritos, greebles, multidões.	`source`, `target` (+5 opcionais)
`scatter`	Dispersa/distribui aleatoriamente `count` pontos sobre a superfície da geometria de entrada (Scatter 2.0) — o conjunto de pontos sobre o qual você copia instâncias (com copy_to_points) ou usa como locais de amostragem. count é o total de pontos. density_attrib enviesa onde os pontos caem por um atributo float de ponto (máscara de heightfield / oclusão / inclinação). relax_iterations espalha pontos para um espaçamento quase uniforme de disco de Poisson (remove aglomeração). seed reorganiza.	`input` (+6 opcionais)
`pack`	Colapsa a geometria de entrada em primitivas empacotadas — uma referência leve de memória plana para a geometria que é muito mais barata de copiar/instanciar e transformar em massa (cada primitiva empacotada se comporta como um ponto que você pode mover/rotacionar/escalar). pack_by_name cria uma primitiva empacotada por valor único de atributo `name` (empacotamento por peça para geometria fraturada/etiquetada). viewportlod controla como primitivas empacotadas desenham no viewport (full/points/box/centroid/hidden) — reduza para box/points para manter uma contagem enorme de instâncias interativa.	`input` (+4 opcionais)
`unpack`	Expande primitivas empacotadas de volta para geometria bruta editável (o inverso de pack) — necessário antes de poder editar/deformar os pontos e polígonos subjacentes de instâncias empacotadas.	`input` (+2 opcionais)
`instance`	SOP Instance: etiqueta os pontos de entrada para que cada um seja expandido em uma cópia instanciada da geometria no momento do render/expansão — instância de ponto adiada que permanece barata até ser renderizada. instance_attrib nomeia o atributo de ponto string que contém o caminho SOP/geometria a instanciar por ponto (instância heterogênea). pack produz as instâncias expandidas como prims empacotados.	`input` (+3 opcionais)
`biome_scatter`	Dispersa vegetação / plantas sobre o terreno de entrada via SOP Labs Biome Plant Scatter — vestimenta de ecossistema/folhagem (grama, arbustos, árvores) com controle de densidade e espaçamento. density multiplica a contagem de plantas; spacing define a lacuna mínima entre plantas; seed reorganiza.	`input` (+4 opcionais)
`tag_radial`	Seleciona/etiqueta todos os pontos dentro de uma esfera (center + radius) escrevendo i@tag = 1 neles — uma seleção de região esférica para isolar ou mascarar parte de uma nuvem de pontos. center = centro da esfera [x,y,z].	`input` (+3 opcionais)
`point_replicate`	Replica/multiplica cada ponto de entrada em `count` novos pontos com jitter espalhados dentro de uma forma ao redor dele (SOP Point Replicate) — transforma pontos esparsos em uma nuvem mais completa para emissão de spray/nevoeiro/poeira ou dispersão-em-uma-forma. count = réplicas por ponto de entrada; shape (box/sphere/cylinder/cone/grid/circle/line) + size definem o volume de espalhamento; noise adiciona jitter posicional extra; copy_attribs carrega os atributos do ponto de origem (Cd, pscale, id...) para suas réplicas, e attribstocopy nomeia quais.	`input` (+8 opcionais)

VDB e volumes

Ferramenta	O que faz	Parâmetros principais
`vdb_transform_properties`	SideFX Labs VDB Transform Properties — re-deriva os valores de um VDB vetorial sob a própria transformação do volume.	`input` (+4 opcionais)
`volume_texture`	SideFX Labs Volume Texture — achata o volume/VDB de entrada (`input`, entrada 0) em um atlas de flipbook fatiado para um shader de textura de volume em tempo real; a saída SOP cozida é a geometria de pré-visualização das fatias. mode seleciona o empacotamento; customfield nomeia o campo de volume; slices/frameresolution definem o layout do atlas; equalizedensity/invertdensity ajustam a densidade.	`input` (+12 opcionais)
`vdb_from_particles`	Pontos/partículas -> VDB. op=particles constrói grades SDF/névoa/máscara/velocidade (vdbfromparticles); op=fluid superfícies transforma FLIP partículas em um VDB de densidade de fluido (vdbfromparticlefluid).	`input` (+26 opcionais)
`vdb_from_polygons`	Polígonos -> VDB SDF e/ou névoa (malha de ida e volta / colisão / atmosféricos) com controle de banda estreita e transferência opcional de atributos de pontos.	`input` (+16 opcionais)
`vdb_convert`	Converter VDB (o hub de ida e volta): polígonos/polysoup/vdb/volume nativo, reclassificação SDF<->névoa, mudança de precisão/tipo, controle de iso, transferência de atributos e nitidez de recursos.	`input` (+15 opcionais)
`vdb_filter`	Filtro de campo de entrada única em um VDB / volume nativo (suavizar, remodelar, renormalizar, desfocar, extrapolar).	`input` (+29 opcionais)
`volume_combine`	Combina campos VOLUME nomeados transportados em UMA entrada por uma operação (volumecombine) — dest = op(dest, source) combinados por nome: adicione dois campos de densidade, multiplique uma máscara na temperatura, combine dois sims de fumaça.	`input` (+12 opcionais)
`volume_rasterize_attributes`	Rasteriza ATRIBUTOS de ponto em VOLUMES de névoa nomeados (volumerasterizeattributes) — transforme uma nuvem de pontos com densidade/temperatura/v/Cd nos campos de volume correspondentes em UM nó (uma fonte de pyro/fumaça, ou cozinhando um sim de pontos em volumes renderizáveis).	`input` (+14 opcionais)
`volume_rasterize`	Rasteriza pontos/partículas em um volume de névoa de densidade/atributo (pontos->nuvem de densidade / fonte pyro). input=Base Volume (entrada0, define resolução); os pontos/partículas da fonte vão para a entrada1.	`input` (+34 opcionais)
`convert_volume`	Trilha de volume nativo: mode=isooffset (polígonos -> volume nativo Houdini/SDF/tetra via isooffset), tovdb/topoly (converter para tipo), ou convert (genérico).	`input` (+12 opcionais)
`vdb_analysis`	Cálculo de campos em um VDB (VDB Analysis SOP) sem VEX: gradiente/curvatura/laplaciano/ponto mais próximo/divergência/rotacional/comprimento/normalizar.	`input` (+7 opcionais)
`vdb_topology`	Operações de conjunto de voxels ativos (topologia) via op: activate (vdbactivate), clip (vdbclip), resample (vdbresample), segment (vdbsegmentbyconnectivity).	`input` (+23 opcionais)
`vdb_combine`	CSG de duas entradas / matemática de campos em VDBs (a resposta tipada para um Volume VOP, sem VEX) via op: sdf (vdbcombine), fog (volumemix), vectormerge (vdbvectormerge), vectorsplit (vdbvectorsplit). input=A (entrada0), input_b=B (entrada1).	`input` (+17 opcionais)
`vdb_advect`	Transporta um VDB por um VDB de velocidade (entrada1), sem VEX: op=points (vdbadvectpoints), sdf (vdbadvectsdf), morph (vdbmorphsdf em direção a um SDF alvo na entrada1).	`input` (+23 opcionais)
`vdb_shatter`	SDF VDB -> peças discretas / proxies de esfera, sem VEX: op=fracture (vdbfracture; geo de corte na entrada1; alimenta sim_rbd), spheres (vdbtospheres; pacote de proxy RBD).	`input` (+24 opcionais)
`volume_visualize`	Inspecionar/apresentar um volume de névoa no viewport (sem render), sem VEX: op=shade (volumevisualization sombreamento de densidade/emissão), slice (volumeslice seção transversal 2D).	`input` (+20 opcionais)
`vdb_reshape`	Remodelar um SDF VDB deslocando sua superfície (VDB Reshape SDF): dilate (crescer), erode (encolher), open (erodir-depois-dilatar — remove picos finos), close (dilatar-depois-erodir — preenche buracos/fissuras).	`input` (+6 opcionais)

Solvers & simulação

Ferramenta	O que faz	Parâmetros-chave
`rbd_guide`	Conecta um SOP de geometria guia na entrada Guide Sim (índice 4) de um rbdbulletsolver EXISTENTE para uma simulação RBD guiada / direcionada artisticamente (os parâmetros guide_* do solver controlam a mistura).	`solver`, `guide` (+1 opcional)
`rbd_attach_constraints`	Alimenta uma rede de restrições autorada (glue_cluster / rbd_constraints / set_constraint_field) na entrada Constraint (índice 1) de um rbdbulletsolver EXISTENTE — anexa restrições a um solver sim_rbd ativo.	`solver`, `constraints` (+2 opcionais)
`flowmap`	SideFX Labs Flowmap — cria um atributo de vetor de fluxo por ponto sobre uma superfície com UV (`input`, entrada 0) para dirigir distorção de material via flow map (rios, lava).	`input` (+3 opcionais)
`flowmap_guide`	SideFX Labs Flowmap Guide — direciona um flow map de superfície para curvas-guia desenhadas à mão.	`input` (+7 opcionais)
`flowmap_obstacle`	SideFX Labs Flowmap Obstacle — desvia um flow map de superfície ao redor de geometria de obstáculo.	`input` (+6 opcionais)
`flowmap_to_color`	SideFX Labs Flowmap To Color — assa um atributo de vetor de fluxo em uma cor RG(B) que o motor lê como um flow map.	`input` (+3 opcionais)
`flowmap_visualize`	SideFX Labs Flowmap Visualize — pré-visualiza um flow map animando uma distorção em `input` (entrada 0).	`input` (+7 opcionais)
`kelvin_wakes_deformer`	SideFX Labs Kelvin Wakes Deformer — deforma a superfície da água com o padrão físico de esteira de Kelvin que segue um objeto em movimento.	`input` (+15 opcionais)
`splatter`	SideFX Labs Splatter — uma fonte de respingo de fluido SPH autocontida que constrói uma nova geo /obj emitindo partículas de fluido (respingos de tinta/sangue).	`name` (+15 opcionais)
`procedural_smoke`	SideFX Labs Procedural Smoke — constrói uma nova geo /obj contendo um volume de DENSIDADE de fumaça totalmente procedural (sem simulação) dirigido por ruído em camadas.	`name` (+9 opcionais)
`volume_adjust_look`	SideFX Labs Volume Adjust Look — direciona artisticamente o ASPECTO de um volume de fumaça/pyro (multiplicadores de densidade / sombra / difusão / emissão, escala de cinza opcional).	`input` (+12 opcionais)
`destruction_cleanup`	SideFX Labs Destruction Cleanup — pós-processa a saída de simulação RBD/fratura: remove faces internas, suaviza normais, regenera nomes de peças, otimiza peças em blocos.	`input` (+11 opcionais)
`rbd_edge_strip`	SideFX Labs RBD Edge Strip — extrai faixas finas de borda ao longo das costuras de fratura de peças RBD (para lascar/ detalhar bordas).	`input` (+4 opcionais)
`loop_volume`	SideFX Labs Loop Volume — faz cross-fade de uma sequência de volume (fumaça/pyro) em um loop contínuo.	`input` (+5 opcionais)
`make_loop`	SideFX Labs Make Loop — transforma uma sequência animada em um loop contínuo (geometria, volume ou partículas).	`input` (+14 opcionais)
`lightning`	SideFX Labs Lightning — gera geometria procedural de raio/arco através de um modelo.	`input` (+16 opcionais)
`rbd_solver`	Solver Bullet puro para peças JÁ fraturadas + uma rede de restrições arbitrária — o elo que falta para que a linha de fratura granular (rbd_voronoi/vdb_shatter/rbd_constraints/set_constraint_field) possa ser REALMENTE SIMULADA, SEM re-fraturar (diferente de sim_rbd/rbd_destruction). Peças = SOP fraturado empacotado (Geometry in0); restrições = SOP de rede de restrições opcional (in1); colisor = malha/heightfield opcional (in3).	`pieces` (+50 opcionais)
`sim_rbd`	Destruição de corpo rígido (linha SOP Bullet): fonte -> rbdmaterialfracture::3.0 -> rbdbulletsolver.	`name` (+81 opcionais)
`rbd_constraint_properties`	Autorar FÍSICA de restrição RBD (o dial de quebra) na rede de cola de um solver via rbdconstraintproperties::2.0.	`solver` (+18 opcionais)
`rbd_material_fracture`	Pré-fraturar geometria por TIPO DE MATERIAL (rbdmaterialfracture::3.0) SEM solver — presets de concreto \| vidro \| madeira \| personalizado.	`input` (+31 opcionais)
`rbd_voronoi`	Fratura Voronoi bruta (voronoifracture::2.0) para controle artístico: fonte -> espalhar células -> fraturar (sem presets de material).	`name` (+18 opcionais)
`rbd_interior`	Detalhe de face interna em geo fraturada (SOP rbdinteriordetail): desloca as faces internas de trinca com ruído para que concreto/rocha quebrados pareçam realmente internos, e não cortes planos.	`input` (+18 opcionais)
`rbd_constraints`	Construir a GEOMETRIA DA REDE DE RESTRIÇÕES (grafo de ligação) a partir de peças fraturadas: método=regras (rbdconstraintsfromrules) ou método=adjacência (connectadjacentpieces).	`input` (+13 opcionais)
`rbd_configure`	Dinâmica por peça + ativação em peças fraturadas (SOP rbdconfigure): ativo/animação, densidade/restituição/atrito, minactivationimpulse (gatilho de impacto), sobreposição, presets de tipo/pintype, visualização.	`input` (+14 opcionais)
`rbd_collision`	A PONTE DE TERRENO: conecte um colisor de malha/heightfield na entrada Collision Geometry (índice 3) de um rbdbulletsolver existente para que os detritos se assentem sobre terreno capturado real.	`solver`, `collider` (+10 opcionais)
`rbd_force`	Força DOP tipada (SEM VEX) para detritos RBD além de gravidade/arrasto: vento/uniforme/ponto/vórtice/ventilador/arrasto/explosão (explosão\|explosão -> popaxisforce onda de choque radial).	12 opcionais
`rbd_cache`	CONSTRUIR (nunca escrever) um SOP File Cache 2.0 após uma simulação RBD, com um caminho de escrita explícito confinado.	`input`, `file` (+7 opcionais)
`rbd_exploded`	Depuração/inspeção: espalhe as peças fraturadas para ver a quebra (SOP rbdexplodedview).	`input` (+6 opcionais)
`rbd_destruction`	A MACRO DE DESTRUIÇÃO DE TERRENO: frature um ativo reconstruído e colapse-o sobre terreno capturado real de ponta a ponta. edifício -> rbdmaterialfracture (+cola) -> [rbdconstraintproperties] -> rbdbulletsolver com o DEM conectado como colisão.	`name` (+20 opcionais)
`sim_flip`	Líquido FLIP (container profundo + solver): constrói um flipcontainer + flipsolver alimentado por um primitivo de fonte (uma caixa padrão, ou seu `source_geo`), conectado fonte->Sources(0)/container->Container(1).	`name` (+44 opcionais)
`flip_collision`	Geometria -> volume de colisão FLIP (SOP Collision Source 2.0).	`input` (+16 opcionais)
`flip_flood`	MACRO de inundação de terreno: UMA chamada compõe um SOP DEM/heightfield (`input`) -> convertheightfield -> colisor collisionsource -> flipcontainer de tamanho automático (ajustado ao bbox do DEM + padding + espaço superior) -> flipsolver, com o colisor conectado automaticamente na entrada Collisions do solver.	`name`, `input` (+22 opcionais)
`flip_source`	Geometria -> partículas FLIP (SOP Flip Source): preenchimento inicial e/ou emissão contínua; alimenta a entrada Sources de um flipsolver.	`input` (+15 opcionais)
`flip_boundary`	Fonte/sumidouro de fronteira aberta para um container FLIP (SOP Flip Boundary): tipos de fronteira none/velocity/pressure/hydro_pressure (hydro = linha d'água costeira/inundação).	`input` (+11 opcionais)
`flip_tank`	Tanque pré-preenchido de partículas FLIP (SOP Particle Fluid Tank): um tanque/porto/reservatório que começa já cheio.	`name` (+11 opcionais)
`flip_force`	Nó de força tipada (sem VEX) para simulação FLIP/DOP: ftype -> uniformforce/vortexforce/windforce/drag/pointforce/fan/popaxisforce.	13 opcionais
`sim_pop`	Partículas POP (mestre): um dopnet SOP (entrada0=geo de emissão) envolvendo popobject -> popsolver::2.0, fonte na entrada Sources (fix de usecontextgeo='first') e uma popforce de gravidade padrão encadeada no Pre-Solve.	`name` (+38 opcionais)
`pop_source`	Adicionar um emissor de partículas tipado (popsource::2.0) em um dopnet POP existente e conectá-lo na entrada Sources do popsolver.	`dopnet` (+23 opcionais)
`pop_force`	Adicionar UMA força POP tipada em um dopnet POP e encadeá-la na entrada Pre-Solve do popsolver (as forças se encadeiam, empilhando de forma limpa).	`dopnet` (+54 opcionais)
`pop_import`	Puxar partículas POP simuladas de um dopnet de volta para SOP via dopimport::2.0 (o importador somente de dados; o menu de presets do dopio não popula em headless).	`dopnet` (+7 opcionais)
`pop_collision`	Colidir partículas contra um colisor SOP/terreno (popcollisiondetect) dentro de um dopnet POP, encadeado no Pre-Solve.	`dopnet` (+15 opcionais)
`pop_group`	Agrupar ou dividir um fluxo de partículas por regras TIPADAS (sem VEX), encadeado no Pre-Solve de um dopnet POP. op=group -> popgroup (marcar em groupname; região delimitada tipada + subconjunto aleatório + combinação booleana). op=stream -> popstream (dividir um subfluxo nomeado pelas mesmas regras tipadas).	`dopnet` (+30 opcionais)
`pop_kill`	Matar/limitar/prender partículas por regras TIPADAS (sem VEX), encadeado no Pre-Solve de um dopnet POP. op=kill -> popkill (região delimitada tipada + subconjunto aleatório). op=limit -> poplimit (caixa de domínio rígida; prender/quicar/enrolar). op=softlimit -> popsoftlimit (região de empurrão suave). op=speedlimit -> popspeedlimit (prender velocidade/rotação). enablerule/randomcode nunca definidos.	`dopnet` (+36 opcionais)
`pop_property`	Modelar atributos por partícula com nós de propriedade POP TIPADOS (sem VEX), encadeado no Pre-Solve de um dopnet POP. op=physical -> popproperty (pscale/massa/restituição/atrito/arrasto/aderência). op=color -> popcolor (constante/aleatório/rampa/mistura Cd + alpha). op=sprite -> popsprite (cartões de câmera). op=velocity -> popvelocity. op=lookat/torque -> orient.	`dopnet` (+39 opcionais)
`pop_instance`	Instanciamento / entrega de render para um dopnet POP (sem VEX). op=instance -> popinstance (escrever instancepath para que os pontos instanciem um SOP na hora do render; encadeia no Pre-Solve). op=replicate -> popreplicate (gerar filhos por pai para sprays secundários; conecta na entrada Sources).	`dopnet` (+26 opcionais)
`pop_cache`	CONSTRUIR (nunca escrever) um SOP File Cache 2.0 após um nó pop_import para armazenar em cache partículas simuladas em disco.	12 opcionais
`pop_flock`	Boids / direção para um dopnet POP (sem VEX), encadeando UM nó de comportamento no Pre-Solve. behavior seleciona popflock/popinteract/popsteer{seek,avoit,vagar,separar,coesão,alinhar,obstáculo}/popproximity. popsteercustom (VEX) é excluído; todos os campos uselocal* (incl. o preset de ruído de wander) ficam no padrão.	`dopnet`, `behavior` (+43 opcionais)
`pop_scatter_sim`	MACRO de dispersão de partículas em terreno/scan (o análogo do flip_flood): UMA chamada compõe toda a linha POP em uma nova geo /obj — geo de emissão -> dopnet(popobject+popsource) -> popsolver + um preset de força tipado -> colisão pop_collision opcional contra um colisor de terreno/scan -> dopimport de volta para SOP -> handoff de render copy_to_points opcional.	`name` (+14 opcionais)
`sim_pyro`	Pyro (fogo/fumaça): MIGRADO para a linha SOP moderna pyrosource -> SOP pyrosolver (container auto-delimitado) + colisor collisionsource::2.0 opcional.	`name` (+75 opcionais)
`pyro_source`	Fonte de emissão pyro (SOP pyrosource): rasteriza geo/pontos em campos de origem (densidade/temperatura/combustível/queima/vel) que alimentam a entrada Sources de um pyrosolver.	`input` (+10 opcionais)
`pyro_collision`	Geometria/terreno -> volume de colisão pyro (SOP Collision Source 2.0): a ponte de colisão de cena; alimente a entrada Collision de um pyrosolver para que a fumaça desvie de um DEM, edifícios ou detritos RBD.	`input` (+10 opcionais)
`pyro_ground`	Macro de solo/incêndio florestal: heightfield DEM -> colisor + pyrosource sobre uma região de emissão -> SOP pyrosolver (ajustado por tipo + vento) -> volumevisualization.	`name`, `input` (+22 opcionais)
`pyro_explosion`	Macro de explosão: ponto único de explosão no centro -> pyroburstsource (explosão + brasas) -> SOP pyrosolver (bola de fogo quente) -> volumevisualization.	`name` (+30 opcionais)
`pyro_visualize`	Visualização no viewport para um campo pyro/volume (SOP volumevisualization): apenas sombreamento barato no viewport, NÃO é um render.	`input` (+14 opcionais)
`pyro_shade`	Campos de sombreamento prontos para render de um volume pyro (SOP pyrobakevolume): o nó de preparação de render do Karma; assa a aparência de fumaça/fogo/scatter + atribui um material Pyro.	`input` (+25 opcionais)
`pyro_post`	Preparação de exportação/render para uma simulação pyro (SOP pyropostprocess::2.0): calcula min/max dos campos (o Karma precisa deles) + conversão opcional nativo->VDB para uma sequência .vdb.	`input` (+11 opcionais)
`pyro_cache`	CONSTRUIR (nunca escrever) um SOP File Cache 2.0 após uma simulação pyro, com caminho de escrita explícito confinado + tipo de arquivo bgeo/vdb.	`input`, `file` (+7 opcionais)
`whitewater_source`	Fonte de emissão de whitewater (SOP Whitewater Source 3.0): máscaras de emissão que decidem onde espuma/spray/bolhas nascem de uma simulação de líquido FLIP.	`input` (+21 opcionais)
`sim_whitewater`	Whitewater (espuma/spray/bolha): MIGRADO para a via SOP moderna whitewatersource::3.0 -> whitewatersolver (SOP) -> pós opcional.	39 opcionais
`whitewater_post`	Pós-processamento de whitewater (SOP Whitewater Post Process): molda espuma/spray/bolha resolvidos para render — rampas de densidade/pscale, saída de partículas/nevoeiro/malha, clip do contêiner.	`input` (+17 opcionais)
`fluid_surface`	Transformar partículas FLIP em uma superfície de fluido (SOP Particle Fluid Surface 3.0).	`input` (+19 opcionais)
`flip_volume_combine`	Combinar os campos de uma simulação FLIP de BAIXA resolução com detalhes de ALTA resolução para UP-RESSING (flipvolumecombine) — o fluxo de trabalho up-res do H20: simule barato em baixa resolução, misture detalhes de superfície/velocidade de alta frequência apenas onde importa. input=campos de baixa resolução (in0); high_res=campos de alta resolução (in1); container=contêiner de referência de alta resolução (in2); clip_bbox=caixa de recorte (in3), todos com ponte automática entre redes.	`input` (+14 opcionais)
`flip_cache`	CONSTRUIR (nunca escrever) um SOP File Cache 2.0 após uma simulação, com caminho de escrita explícito confinado.	`input`, `file` (+6 opcionais)
`sim_ripple`	Ondas de superfície baratas via SOP Ripple Solver em uma grade (geometria de repouso na entrada 0).	`name` (+8 opcionais)
`sim_grains`	PBD granular (areia/neve/areia molhada/detritos): um dopnet SOP (input0=geo de emissão) envolvendo popobject -> popsolver::2.0 com um solver PBD popgrains ANEXADO via a entrada 'Solvers to be attached' do solver + um popforce de gravidade padrão.	`name` (+35 opcionais)
`set_constraint_field`	Definir / criar / nomear / quebrar atributos de rede de restrições RBD (destruição de corpo rígido) por grupo, como valores LITERAIS digitados via um attribcreate::2.0 — a forma somente de dados, zero-VEX / zero-wrangle de controlar ligações de cola/dura/mole em uma fratura: constraint_name (o tipo de relacionamento que o solver mapeia — Glue/Hard/Soft ou um nome personalizado), next_constraint_name (o que uma ligação se torna quando quebra), strength (o limite de quebra), restlength (comprimento de repouso para mole/mola), broken (flag pré-quebrada 0\|1).	`input` (+8 opcionais)
`glue_cluster`	Agrupar / aglomerar peças RBD fraturadas para que uma estrutura quebre em BLOCOS ou lajes em vez de por fragmento (SOP gluecluster) — o controle de direção de arte de destruição mais usado para edifícios/paredes colapsando em seções coerentes.	`input` (+14 opcionais)
`rbd_constraints_from_curves`	Construir / rotear uma rede de restrições RBD (destruição de corpo rígido) AO LONGO de curvas do usuário (SOP rbdconstraintsfromcurves) — roteamento personalizado de ligações para vergalhões, cabos, correntes, costuras ou linhas de quebra desenhadas à mão, e o tipo de conexão HINGE (mecânica) acessível via SOP.	`input`, `curves` (+11 opcionais)
`rbd_constraints_from_lines`	Construir uma rede de restrições RBD (destruição de corpo rígido) a partir de SEGMENTOS DE LINHA explícitos (SOP rbdconstraintsfromlines) — a forma somente de dados da ferramenta interativa de linha desenhada à mão: cada linha, dada como um par de pontos literal, roteia uma ligação entre as peças fraturadas que cruza.	`input`, `lines` (+13 opcionais)
`rbd_group_constraints`	Nomear / agrupar / organizar uma rede de restrições RBD (destruição de corpo rígido) em um grupo de primitivas nomeado e direcionável (SOP rbdgroupconstraints) para que um solver, set_constraint_field ou rbd_constraint_properties possam selecionar essas ligações.	`input`, `constraints` (+6 opcionais)
`voronoi_adjacency`	Construir o grafo de ADJACÊNCIA de peças / topologia de ligações (quais peças fraturadas tocam quais) a partir de uma fratura voronoi (SOP voronoiadjacency) — as polilinhas de adjacência ao longo das quais as redes de restrições RBD (destruição de corpo rígido) são roteadas.	`input` (+1 opcional)
`sim_viscosity`	Estrutura FLIP viscosa (lama / água de degelo / mel / lava): um flipcontainer + flipsolver com força de viscosidade habilitada.	`name` (+11 opcionais)
`ocean_surface`	Superfície plana espectral de OCEANO / MAR de grande extensão — uma grade deslocada por um espectro de oceano (Ocean Evaluate 2.0) em ondas ondulantes.	`name` (+7 opcionais)
`ocean_spectrum`	Criar um ESPECTRO completo de ondas oceânicas (Ocean Spectrum) + avaliá-lo em uma grade grande — os controles profundos de 'aparência' que ocean_surface não alcança: modelo de espectro, profundidade da água, ondulação, fetch, direção/viés do vento, semente determinística + loop contínuo.	`name` (+29 opcionais)
`ocean_evaluate`	Deformar geometria ARBITRÁRIA por um ESPECTRO de oceano (Ocean Evaluate em nível de SOP).	`input`, `spectrum` (+9 opcionais)
`ocean_foam`	Gerar pontos de ESPUMA / whitewater / spray a partir da cúspide de uma superfície oceânica (SOP Ocean Foam) — a camada de espuma do mar em cristas quebrando.	`input` (+17 opcionais)
`ocean_source`	Acoplar um espectro de oceano a um tanque de fluido FLIP (Ocean Source 2.0) — a estrutura que semeia uma simulação FLIP de água espirrando / ondas quebrando a partir do oceano espectral. particlesep = separação de partículas FLIP; waterlevel = nível do mar em repouso.	`name` (+4 opcionais)
`point_velocity`	Criar o atributo de velocidade de ponto v (SOP Point Velocity) — o cavalo de batalha de velocidade inicial para FX.	`input` (+10 opcionais)
`volume_velocity`	Criar um VOLUME de velocidade (SOP Volume Velocity) — o campo de velocidade 'túnel de vento' não simulado que impulsiona spray de crista / neve / chuva via pop_force(advect). input = o volume/VDB no qual escrever; entrada opcional de pontos rasteriza v.	`input` (+9 opcionais)
`debris_source`	Emitir uma fonte de DETRITOS secundária (SOP Debris Source) a partir de uma superfície de peça fraturada/estática — o mapa de emissão por quadro (atributos de densidade/idade/distância) alimentando uma simulação secundária de 'suco' emit-RBD ou POP.	`input` (+7 opcionais)
`cloud`	Primitiva volumétrica de NUVEM (cúmulo / nuvem de céu / campo de densidade de volume de nevoeiro): geo de origem -> Cloud 2.0 (SDF/densidade/banda estreita) -> Cloud Noise (deslocamento ondulante/fino) -> opcional Cloud Adjust Density Profile (modelagem de base/bigorna).	`name` (+25 opcionais)
`cloud_shape`	Gerar uma nuvem MODERNA direcionável artisticamente com o conjunto de ferramentas Cloud Shape do H20+ (cloudshapegenerate) — o substituto para o monolítico obsoleto `cloud`.	`name` (+18 opcionais)
`cloud_billowy_noise`	Deslocamento ondulante de couve-flor em um VDB de DENSIDADE de nuvem (cloudbillowynoise) — o modificador moderno de cúmulo de alto detalhe.	`input` (+16 opcionais)
`cloud_wispy_noise`	Deslocamento fino / em faixas advectado por velocidade em um VDB de DENSIDADE de nuvem (cloudwispynoise) — cirros, bigornas esticadas, filamentos soprados pelo vento.	`input` (+11 opcionais)
`cloud_clip`	Recortar / cortar um VDB de DENSIDADE de nuvem com um plano + ruído opcional (cloudclip) — bases planas de cúmulo, bigornas cisalhadas, topos fatiados.	`input` (+11 opcionais)
`solver`	Solver genérico de feedback / loop de tempo SOP -- a primitiva iterativa de propósito geral (erosão acumulativa, crescimento, autômatos celulares, qualquer feedback por quadro), distinta da família DOP sim_*.	`input` (+6 opcionais)
`sim_vellum`	Mestre Vellum (XPBD) (SOP): origem -> Vellum Constraints -> Vellum Solver.	`name` (+65 opcionais)
`vellum_collision`	Conectar um colisor externo/terreno na entrada Collision Geometry de um solver Vellum (índice 2) e ajustar a resposta de colisão.	`solver`, `collider` (+14 opcionais)
`vellum_attach`	Anexar tecido/geometria Vellum a um RIG (em movimento) — o SOP dedicado Vellum Attach Constraints.	`input`, `rig` (+9 opcionais)
`vellum_constraint`	Adicionar uma restrição Vellum ADICIONAL a uma cadeia existente (soldas/cola/pinos/anexar/costura/estruturas) via o anexo da segunda entrada.	`solver` (+36 opcionais)
`vellum_force`	Forças externas em uma simulação Vellum.	24 opcionais
`vellum_drape`	Estado de repouso / assentamento pré-rolagem.	`solver` (+29 opcionais)
`vellum_source`	Emissão contínua / adicionar patches de restrição no meio da simulação (escopo DOP, avançado -- a única ferramenta Vellum que cai para DOP).	12 opcionais
`vellum_post`	Preparação de render para uma simulação Vellum (SOP vellumpostprocess): geração de tubos de cabelo, suavização (subdividir), desembaraçar, rigidez.	`input` (+15 opcionais)
`vellum_cache`	CONSTRUIR (nunca escrever) um SOP File Cache 2.0 após uma simulação Vellum.	`input`, `file` (+8 opcionais)
`sim_mpm`	Rede MPM (Método do Ponto Material) (SOP): origem -> mpmsource -> mpmsolver.	`name` (+24 opcionais)
`mpm_collider`	Dar a uma simulação MPM algo com que COLIDIR / INTERAGIR — conecte um colisor na entrada MPM Colliders de um mpmsolver existente (índice 1).	`solver`, `collider` (+11 opcionais)
`mpm_container`	Limitar o DOMÍNIO de uma simulação MPM e definir sua resolução MESTRA — conecte um `mpmcontainer` na entrada MPM Container de um mpmsolver existente (índice 2).	`solver` (+9 opcionais)
`mpm_surface`	Tornar uma simulação MPM RENDERIZÁVEL — gere malha / superfície das partículas da simulação construindo um `mpmsurface` depois delas.	`input` (+14 opcionais)
`mpm_postfracture`	Simular e DEPOIS fraturar uma cena de destruição MPM — frature geometria de alta resolução guiada por onde a simulação MPM realmente esticou e quebrou, para que as rachaduras sigam a deformação real (diferente de pré-fraturar).	`geo`, `particles` (+11 opcionais)
`mpm_deformpieces`	Reorientar uma simulação MPM em peças NOMEADAS pré-fraturadas — conduza pedaços rígidos ou de alta resolução para render por uma simulação MPM (mais barata) para que a geometria final deforme/mova com a solução sem simular a alta resolução diretamente.	`pieces`, `particles` (+8 opcionais)
`mpm_debrissource`	Emitir DETRITOS SECUNDÁRIOS de uma simulação MPM — gere pedaços/partículas extras onde o material estica muito, se move rápido ou está perto da superfície (a passada de estilhaços / spray / faíscas sobre uma simulação de destruição ou impacto).	`input` (+10 opcionais)
`glue_constraint`	Relacionamento de Restrição de Cola KineFX (glueconrel) — nó de dados de relacionamento de restrição DOP que cola objetos vinculados até que um impulso acima de `strength` quebre a ligação, então propaga a quebra.	10 opcionais
`hard_constraint`	Relacionamento de Restrição Rígida KineFX (hardconrel) — relacionamento DOP rígido que fixa objetos vinculados a um comprimento de repouso, com motores angulares opcionais e rigidez do solver (CFM/ERP).	14 opcionais
`no_constraint`	KineFX No Constraint Relationship (noconrel) — relacionamento DOP que torna objetos vinculados afetores mútuos SEM qualquer força de restrição (somente colisão / placeholder).	7 opcionais
`bullet_soft_constraint`	KineFX Bullet Soft Constraint Relationship (bulletsoftconrel) — relacionamento Bullet elástico com rigidez linear + amortecimento angular opcionais e plasticidade opcional (deformação permanente acima de um limite).	18 opcionais
`cone_twist_constraint`	KineFX Cone Twist Constraint Relationship (conetwistconrel) — junta de cone-twist do Bullet limitando rotação twist/out/up dentro de um cone, com limite suave e motor opcionais.	20 opcionais
`constraint_relationship`	KineFX Constraint Relationship (conrelationship) — nó de dados de relacionamento genérico que define como dois objetos vinculados se relacionam (tipo + parâmetros de quebra e mola de dois estados).	10 opcionais
`apply_constraint`	KineFX Constraint (constraint) — aplica um relacionamento de restrição nomeado entre os objetos de simulação `affected` e `affector` (o nó DOP que vincula um relacionamento a objetos).	11 opcionais
`constraint_network_relationship`	KineFX Constraint Network Relationship (constraintnetworkrelationship) — aplica um relacionamento a uma REDE de restrições, opcionalmente correspondendo objetos afetados/afetores por um atributo de ponto.	12 opcionais
`motion_data`	KineFX Motion (motion) — nó de dados DOP Motion que carrega posição / pivô / rotação e velocidade linear + angular de um objeto (o movimento inicial / alvo para um objeto RBD ou agente).	11 opcionais
`softbody_constraint`	KineFX SBD Constraint (sbdconstraint) — restrição de dinâmica de corpo macio fixando (`type` 0) ou conectando via mola (`type` 1) pontos restritos de um objeto a um objeto/pontos/localização alvo, com limites opcionais de força e comprimento.	19 opcionais
`cloth_stitch_constraint`	KineFX Cloth Stitch Constraint (clothstitchconstraint) — costura pontos restritos de um objeto de tecido a um objeto/pontos alvo com rigidez e amortecimento fornecidos (`type` 0/1).	11 opcionais
`fem_attach_constraint`	KineFX FEM Attach Constraint (femattachconstraint) — anexa pontos de um objeto FEM restrito a um objeto alvo em um deslocamento de repouso, com filtragem opcional por limite de distância.	13 opcionais
`fem_fuse_constraint`	KineFX FEM Fuse Constraint (femfuseconstraint) — funde pontos correspondentes de dois objetos FEM (correspondidos por grupo de pontos ordenado ou por atributo identificador) em uma fronteira compartilhada.	12 opcionais
`fem_region_constraint`	KineFX FEM Region Constraint (femregionconstraint) — restringe regiões tetraédricas sobrepostas de dois objetos FEM juntas, opcionalmente correspondendo partes por um atributo identificador.	10 opcionais
`fem_slide_constraint`	KineFX FEM Slide Constraint (femslideconstraint) — restringe pontos de um objeto FEM a deslizar ao longo da superfície de um objeto alvo (modelo de conexão atrair/repelir), com filtragem opcional por limite de distância.	14 opcionais
`fem_target_constraint`	KineFX FEM Target Constraint (femtargetconstraint) — puxa suavemente pontos restritos de um objeto FEM em direção às posições alvo animadas com rigidez e amortecimento fornecidos (`type` 0/1).	9 opcionais
`ragdoll_solver`	WIRE-ONLY: construir um solver de ragdoll KineFX (kinefx::ragdollsolver) na geometria do personagem/esqueleto (entrada 0).	`input` (+16 opcionais)
`muscle_solver`	WIRE-ONLY: construir um solver muscular (musclesolver) na geometria do músculo (entrada 0).	`input` (+16 opcionais)
`muscle_solver_fem`	WIRE-ONLY: construir um solver muscular FEM (musclesolverfem) na geometria do músculo (entrada 0).	`input` (+16 opcionais)
`muscle_solver_vellum`	WIRE-ONLY: construir um solver muscular Vellum (musclesolvervellum) na geometria do músculo (entrada 0).	`input` (+16 opcionais)
`tissue_solver`	WIRE-ONLY: construir um solver de tecido (FEM flesh) (tissuesolver) na geometria do tecido/pele (entrada 0).	`input` (+12 opcionais)
`tissue_solver_vellum`	WIRE-ONLY: construir um solver de tecido Vellum (tissuesolvervellum) na geometria do tecido (entrada 0).	`input` (+15 opcionais)
`skin_solver_vellum`	WIRE-ONLY: construir um solver de pele Vellum (skinsolvervellum) na geometria da pele (entrada 0).	`input` (+16 opcionais)
`armature_deform`	WIRE-ONLY: construir um solver de deformação por armação (armaturedeform) na geometria do personagem (entrada 0) — deformação quase estática de músculo/pele.	`input` (+13 opcionais)
`fem_solver`	WIRE-ONLY: construir um cluster de resolução de corpo macio FEM (femsolidobject -> femsolver) dentro de um dopnet novo.	`name` (+33 opcionais)
`solid_object_solver`	WIRE-ONLY: construir um cluster FEM sólido/tecido (solidobject -> femsolver) dentro de um dopnet novo.	`name` (+29 opcionais)
`filament_solver`	WIRE-ONLY: construir um cluster de dinâmica de filamentos/fios (filamentobject -> filamentsolver) dentro de um dopnet novo.	`name` (+19 opcionais)
`crowd_solver`	WIRE-ONLY: construir um cluster de resolução de agentes multidão/criatura (crowdobject -> crowdsolver::3.0) dentro de um dopnet novo, lendo agentes da fonte conectada (ou de um caminho SOP de geo inicial).	`name` (+39 opcionais)

KineFX

Ferramenta	O que faz	Parâmetros principais
`character_skeleton`	KineFX Skeleton — o contêiner de autoria de esqueleto (kinefx::skeleton).	`skeleton` (+4 opcionais)
`configure_joints`	KineFX Configure Joints — grava atributos de configuração de solver em um esqueleto (entrada 0) para Full Body IK / Ragdoll / Rig Pose.	`skeleton` (+15 opcionais)
`configure_joint_limits`	KineFX Configure Joint Limits — define limites de rotação/translação das juntas + exibição de guia de limites em um esqueleto (entrada 0).	`skeleton` (+14 opcionais)
`orient_joints`	KineFX Orient Joints — recalcula as orientações das juntas (o atributo de ponto `transform`) para um esqueleto (entrada 0), apontando cada junta para seu filho com um vetor de referência/up.	`skeleton` (+10 opcionais)
`parent_joints`	KineFX Parent Joints — reatribui a hierarquia de juntas em um esqueleto (entrada 0).	`skeleton` (+2 opcionais)
`delete_joints`	KineFX Delete Joints — exclui (ou mantém apenas) as juntas nomeadas por `group` de um esqueleto (entrada 0), opcionalmente em cascata para os filhos.	`skeleton` (+5 opcionais)
`group_joints`	KineFX Group Joints — cria/atualiza um grupo de pontos nomeado de juntas em um esqueleto (entrada 0) a partir de uma expressão de seleção, com mesclagem booleana contra qualquer grupo existente.	`skeleton` (+7 opcionais)
`skeleton_blend`	KineFX Skeleton Blend — combina a pose de um ou mais esqueletos em um esqueleto base.	`skeleton` (+14 opcionais)
`skeleton_mirror`	KineFX Skeleton Mirror — espelha as juntas de um esqueleto (entrada 0) através de um plano ou ponto, renomeando as juntas espelhadas via tokens de localizar/substituir (ex.: `_l` -> `_r`).	`skeleton` (+13 opcionais)
`rig_doctor`	KineFX Rig Doctor — valida e repara um esqueleto: inicializa nomes/transformações de juntas ausentes, sanitiza nomes e gera atributos de hierarquia (índice do pai, índices dos filhos, ordem de avaliação) a partir de um rig na entrada 0.	`skeleton` (+16 opcionais)
`visualize_rig`	KineFX Visualize Rig — gera geometria de visualização do rig (gnomons de juntas / links de ossos, estilizados por cor/escala) a partir de um esqueleto na entrada 0.	`skeleton` (+11 opcionais)
`rig_pose`	KineFX Rig Pose — o SOP interativo de pose FK/IK em um esqueleto (entrada 0).	`skeleton` (+16 opcionais)
`compute_rig_pose`	KineFX Compute Rig Pose — avalia uma pose de rig a partir de um esqueleto (entrada 0) e grava as transformações/atributos de parâmetro resultantes na geometria (o equivalente headless do rig_pose).	`skeleton` (+15 opcionais)
`rig_match_pose`	KineFX Rig Match Pose — posiciona `skeleton` (entrada 0, o rig de destino) para corresponder à pose de `source` (entrada 1, o rig de origem), opcionalmente alinhando por caixa delimitadora e um quadro de referência.	`skeleton`, `source` (+18 opcionais)
`rig_mirror_pose`	KineFX Rig Mirror Pose — espelha a POSE animada de um esqueleto (entrada 0) através de um eixo/plano de simetria, correspondendo juntas esquerda/direita por tokens de nome (ex.: `_l`<->`_r`) ou distância de edição.	`skeleton` (+21 opcionais)
`rig_stash_pose`	KineFX Rig Stash Pose — armazena a pose atual de um esqueleto (entrada 0) em um atributo de ponto (`mode`=store) ou restaura uma pose previamente armazenada (`mode`=restore).	`skeleton` (+12 opcionais)
`rig_copy_transforms`	KineFX Rig Copy Transforms — copia as transformações das juntas de `source` (entrada 1) para `skeleton` (entrada 0, o rig de destino), pareando juntas por um atributo de mapeamento ou um atributo de correspondência.	`skeleton`, `source` (+6 opcionais)
`ik_chains`	KineFX IK Chains — resolve cadeias IK de dois ossos em um esqueleto (entrada 0) em direção a posições-alvo fornecidas como `targets` (entrada 1).	`skeleton`, `targets` (+2 opcionais)
`full_body_ik`	KineFX Full Body IK — resolve uma pose IK de esqueleto inteiro em `skeleton` (entrada 0) para que as juntas efetoras configuradas alcancem seus alvos; o opcional `targets` (entrada 1) fornece geometria de objetivo.	`skeleton` (+25 opcionais)
`fbik_configure_targets`	KineFX Full Body IK Configure Targets — grava a configuração de alvos FBIK (offsets por junta, referência de pose de descanso, alvo de centro de massa) em um esqueleto (entrada 0); a entrada opcional 1 fornece geometria de alvo.	`skeleton` (+13 opcionais)
`spline_ik`	KineFX Spline IK — conduz uma cadeia de juntas de um esqueleto (entrada 0) ao longo de uma spline ajustada através das juntas, proporcionando controle suave baseado em curvas (espinhas, caudas, tentáculos).	`skeleton` (+17 opcionais)
`reverse_foot`	KineFX Reverse Foot — constrói uma configuração de rolagem de pé reverso em um esqueleto (entrada 0), adicionando marcadores de pivô de calcanhar/peito do pé/dedo do pé para que um pé possa rolar e pivotar.	`skeleton` (+8 opcionais)
`stabilize_joint`	KineFX Stabilize Joint — remove tremulação / trava uma junta de um esqueleto animado (entrada 0) no lugar ao longo de um intervalo de quadros, com limites de mudança de posição/ângulo e blend de entrada/saída.	`skeleton` (+21 opcionais)
`pose_difference`	KineFX Pose Difference — calcula a diferença por junta entre a pose em `skeleton` (entrada 0) e a pose `reference` (entrada 1), armazenando-a em um atributo de saída (opcionalmente apenas posição/rotação/escala, invertida ou aplicada como offset).	`skeleton`, `reference` (+12 opcionais)
`joint_capture_biharmonic`	KineFX Joint Capture Biharmonic (kinefx::jointcapturebiharmonic) — calcula pesos de skinning boneCapture suaves resolvendo funções biharmônicas sobre um `geometry` tetraedralizado internamente (entrada 0) usando o `skeleton` (entrada 1) como rig de influência.	`geometry`, `skeleton` (+22 opcionais)
`joint_capture_proximity`	KineFX Joint Capture Proximity (kinefx::jointcaptureproximity) — atribui pesos de skinning boneCapture a `geometry` (entrada 0) por proximidade aos ossos de `skeleton` (entrada 1).	`geometry`, `skeleton` (+11 opcionais)
`point_capture_biharmonic`	KineFX Point Capture Biharmonic (kinefx::pointcapturebiharmonic) — captura biharmônica de nuvem de pontos de `geometry` (entrada 0) para o `skeleton` (entrada 1).	`geometry`, `skeleton` (+3 opcionais)
`joint_capture_paint`	KineFX Joint Capture Paint (kinefx::jointcapturepaint) — inicializa / normaliza pesos boneCapture em `geometry` (entrada 0) contra o `skeleton` (entrada 1).	`geometry`, `skeleton` (+5 opcionais)
`capture_packed_geo`	KineFX Capture Packed Geo (kinefx::capturepackedgeo) — transfere/empacota a captura em `geometry` (entrada 0) contra o `skeleton` (entrada 1), opcionalmente empacotando a entrada, correspondendo por nome e desempacotando o resultado.	`geometry`, `skeleton` (+13 opcionais)
`capture_proximity`	Classic Capture Proximity (captureproximity) — captura por proximidade de `geometry` (entrada 0) para as regiões de captura em `skeleton` (entrada 1; um esqueleto KineFX cuja transformação por ponto fornece as regiões).	`geometry`, `skeleton` (+18 opcionais)
`bone_capture`	Classic Capture (capture) — atribui pesos de captura a `geometry` (entrada 0) a partir das regiões de captura em `skeleton` (entrada 1).	`geometry`, `skeleton` (+13 opcionais)
`bone_capture_lines`	Classic Bone Capture Lines (bonecapturelines) — gera geometria de linhas de região de captura clássica (carregando boneCapture) a partir do `skeleton` (entrada 0), para alimentar solvers de captura clássicos.	`skeleton` (+17 opcionais)
`capture_region`	Classic Capture Region (cregion) — uma FONTE de 0 entradas que emite uma primitiva de região de captura (um tubo com uma transformação) dentro de uma geo /obj nova.	`name` (+7 opcionais)
`capture_mirror`	Classic Capture Mirror (capturemirror) — espelha pesos de captura em `geometry` já capturado (entrada 0) através de um plano, renomeando regiões espelhadas via tokens de localizar/substituir.	`geometry` (+10 opcionais)
`capture_correct`	Classic Capture Correct (capturecorrect) — limpa pesos de captura em `geometry` já capturado (entrada 0): atualiza/remove regiões obsoletas, limita pesos negativos/positivos, limita influências por ponto e renormaliza.	`geometry` (+14 opcionais)
`capture_override`	Classic Capture Override (captureoverride) — substitui pesos de captura em `geometry` já capturado (entrada 0) para o `cregions` nomeado, aplicando uma operação em um peso definido.	`geometry` (+8 opcionais)
`name_from_capture_weight`	Labs Name From Capture Weight (labs::name_from_capture_weight::1.0) — grava um atributo de ponto `name` em `geometry` já capturado (entrada 0) a partir da região de captura dominante de cada ponto (seu peso boneCapture mais alto).	`geometry` (+3 opcionais)
`skinning_converter`	Labs Skinning Converter (labs::skinning_converter::3.0) — converte um `geometry` animado por vértices / deformável (entrada 0, dependente do tempo) em um esqueleto + pesos de skinning boneCapture (uma solução da família DemBones ao longo de frame_start..frame_end).	`geometry` (+18 opcionais)
`dembones_skinning_converter`	KineFX DemBones Skinning Converter (kinefx::dembones_skinningconverter) — SOMENTE CONEXÃO: constrói + conecta + configura a solução externa DemBones que converte uma malha deformável em cache Alembic em um esqueleto + pesos de skin, mas NUNCA a executa (espelha maps_baker — uma solução externa/pesada é disparada pelo humano).	`geometry` (+17 opcionais)
`joint_deform`	KineFX Joint Deform (kinefx::jointdeform) — deforma a pele capturada por transformações de juntas.	`skin`, `rest_skeleton`, `deform_skeleton` (+8 opcionais)
`bone_deform`	KineFX Bone Deform (bonedeform) — deforma geometria com pesos de captura usando atributos de captura de ossos/juntas.	`skin` (+12 opcionais)
`deform_skeleton_skin`	KineFX Deform Skeleton/Skin (kinefx::deformskelskin) — posiciona um esqueleto (entrada 0) e deforma a pele vinculada (entrada opcional 1) juntos, e então gera o rig/pele transformados.	`skeleton` (+12 opcionais)
`pose_space_deform_combine`	KineFX Pose-Space Deform Combine (posespacedeformcombine) — mescla múltiplas saídas de Pose-Space Deform (entrada 0..N) em um único resultado corretivo.	`geometry` (+3 opcionais)
`pose_space_edit_configure`	KineFX Pose-Space Edit Configure (posespaceeditconfigure) — define como o Pose-Space Edit calcula diferenças de forma (pré/pós-deformação, orientação) na geometria (entrada 0), opcionalmente re-deformando com captura de ossos.	`geometry` (+7 opcionais)
`character_blend_shapes_add`	KineFX Character Blend Shapes Add (kinefx::characterblendshapesadd) — empacota um novo alvo de blend-shape (ou intermediário) (entrada 1) em uma malha base (entrada 0).	`base` (+10 opcionais)
`character_blend_shapes_core`	KineFX Character Blend Shapes Core (kinefx::characterblendshapescore) — o avaliador de blend ponderado de baixo nível: entrada 0 = malha base, entrada 1 = alvos de blend empacotados + pesos.	`base`, `blend_targets` (+6 opcionais)
`character_blend_shapes_extract`	KineFX Character Blend Shapes Extract (kinefx::characterblendshapesextract) — extrai uma única malha de alvo de blend-shape (ou intermediário) nomeada de uma entrada blendshape empacotada (entrada 0).	`blendshape_geo` (+5 opcionais)
`character_blend_shape_channels`	KineFX Character Blend Shape Channels (kinefx::characterblendshapechannels) — define/atualiza a tabela de canais de blend-shape (pesos) para uma malha (entrada 0), opcionalmente inicializada a partir de uma segunda entrada.	`mesh` (+3 opcionais)
`character_blend_shapes`	KineFX Character Blend Shapes (kinefx::characterblendshapes) — o nó blendshape tudo-em-um: entrada 0 = malha base, entrada 1 = malhas de blend-shape, entrada 2 = definições de canais; aplica os blends ponderados.	`mesh`, `blend_shapes`, `channels` (+4 opcionais)
`blend_shapes`	Classic Blend Shapes (SOP blendshapes::2.0) — morph ponderado de uma malha base (entrada 0) em direção a uma ou mais formas-alvo (entrada 1..N).	`base` (+14 opcionais)
`secondary_motion`	KineFX Secondary Motion (kinefx::secondarymotion) — adiciona sobreposição/balanço/seguimento por mola a um esqueleto animado (entrada 0).	`skeleton` (+21 opcionais)
`dynamic_warp`	KineFX Dynamic Warp (kinefx::dynamicwarp) — deforma temporalmente uma animação de origem (entrada 1) para alinhá-la a uma animação de referência (entrada 0) usando dynamic time warping sobre atributos correspondentes.	`reference_motion`, `source_motion` (+12 opcionais)
`skeleton_deform`	KineFX/Classic Deform (SOP `deform`) — deforma geometria com pesos de captura (entrada 0) por um esqueleto referenciado por meio de `skel_root_path` (uma referência de nó na cena).	`skin` (+15 opcionais)
`motion_clip`	KineFX MotionClip — EMPACOTA um esqueleto animado (entrada 0) amostrado em um intervalo de frames em um motionclip empacotado de quadro único (primitivas de canal).	`skeleton` (+17 opcionais)
`motion_clip_create`	KineFX MotionClip Create — cria um motionclip a partir de um SOP ativo (modo single/fetchsop + source_sop), de uma biblioteca de clipes ou de um clipe .bgeo/FBX importado.	18 opcionais
`motion_clip_compute_create`	KineFX Compute MotionClip Create — empacota o esqueleto animado em `source_sop` (um caminho de nó do Houdini) ao longo de um intervalo de frames em um motionclip usando o compute engine (0 entradas de geometria).	`parent` (+5 opcionais)
`motion_clip_compute_retime`	KineFX Compute MotionClip Retime — reajusta o tempo de um motionclip (entrada 0) por meio do compute engine: shift / tempo absoluto / frame / velocidade, com trim opcional e reamostragem de intervalo de saída/taxa de amostragem.	`motionclip` (+22 opcionais)
`motion_clip_retime`	KineFX MotionClip Retime — reajusta o tempo de um motionclip (entrada 0): shift / tempo absoluto / frame / velocidade, com trim opcional, substituições por frame de tempo/frame/velocidade e reamostragem de intervalo de saída/taxa de amostragem.	`motionclip` (+27 opcionais)
`motion_clip_velocity`	KineFX MotionClip Compute Velocity — calcula as velocidades por junta em um motionclip (entrada 0); o opcional `rest_frame` (entrada 1) fornece a pose de descanso.	`motionclip` (+13 opcionais)
`motion_clip_cycle`	KineFX MotionClip Cycle — repete um motionclip (entrada 0) antes/depois de si mesmo para criar um loop, com continuidade de locomoção (shift/velocidade/espelhamento) e blend de poses na emenda.	`motionclip` (+18 opcionais)
`motion_clip_evaluate`	KineFX MotionClip Evaluate — amostra um motionclip (entrada 0) em um frame de volta para uma pose de esqueleto ao vivo (frame atual ou frame personalizado), com saída opcional de COM e comportamento de extremidade.	`motionclip` (+14 opcionais)
`motion_clip_extract`	KineFX MotionClip Extract — extrai poses de um motionclip (entrada 0) como esqueletos por frame ou trilhas de movimento ao longo de um intervalo de frames.	`motionclip` (+16 opcionais)
`motion_clip_key_poses`	KineFX MotionClip Extract Key Poses — reduz um motionclip (entrada 0) às suas poses-chave (por porcentagem ou contagem), extraindo-as ou marcando-as.	`motionclip` (+17 opcionais)
`motion_clip_locomotion`	KineFX MotionClip Extract Locomotion — separa a locomoção da raiz de um motionclip (entrada 0) de seu movimento no lugar (fonte compute / prim / joint), extraindo opcionalmente a trajetória do solo ou achatando o clipe no lugar.	`motionclip` (+15 opcionais)
`motion_clip_merge`	KineFX MotionClip Merge — mescla dois motionclips (entrada 0 + opcional `merge_clip` na entrada 1) em um único fluxo de clipes.	`input` (+5 opcionais)
`motion_clip_pose_delete`	KineFX MotionClip Pose Delete — exclui poses (e/ou juntas) de um motionclip (entrada 0) por intervalo de frames, padrão de frames, intervalo de poses ou grupo de poses.	`motionclip` (+13 opcionais)
`motion_clip_pose_insert`	KineFX MotionClip Pose Insert — insere uma única pose de esqueleto (`pose`, entrada 1) em um motionclip (entrada 0) em um frame.	`motionclip`, `pose` (+3 opcionais)
`motion_clip_sequence`	KineFX MotionClip Sequence — concatena dois motionclips de ponta a ponta: `first` (entrada 0) seguido por `second` (entrada 1), com continuidade de locomoção e emenda com blend.	`first`, `second` (+18 opcionais)
`motion_clip_blend`	KineFX MotionClip Blend — sobrepõe um motionclip `layer` (entrada 1) sobre um motionclip `base` (entrada 0) com envelopes de fade-in/fade-out e efeito de blend por junta.	`base`, `layer` (+19 opcionais)
`motion_clip_unpack`	KineFX MotionClip Unpack — desempacota um motionclip (entrada 0) de volta para um esqueleto animado ao vivo (quadro único / intervalo / frame atual) ou trilhas de movimento, carregando um atributo de ponto `time`.	`motionclip` (+20 opcionais)
`motion_clip_update`	KineFX MotionClip Update — atualiza um motionclip (entrada 0) com novas poses de `poses` (entrada 1) — um STREAM de esqueleto desempacotado que DEVE carregar um atributo de ponto `time` (por exemplo, uma saída de motion_clip_unpack).	`motionclip`, `poses` (+9 opcionais)
`motion_clip_info`	KineFX MotionClip Create Clip Info — garante que um motionclip (entrada opcional 0) carregue um atributo de detalhe `clipinfo`, derivando-o do atributo prim `time` do clipe quando ausente.	3 opcionais
`motion_mixer_retime`	KineFX Motion Mixer Retime — reajusta o tempo de uma cena de motion-mixer / motionclip (entrada 0) por frame absoluto, tempo, velocidade de reprodução ou hold.	`input` (+9 opcionais)
`motion_mixer_smooth`	KineFX Motion Mixer Smooth — aplica filtro Butterworth aos canais de uma cena de motion-mixer / motionclip (entrada 0) selecionados por `pattern`, sobre os componentes t/r/s.	`input` (+9 opcionais)
`motion_mixer_transform`	KineFX Motion Mixer Transform — aplica uma transformação TRS(+cisalhamento/pivô) aos canais de uma cena de motion-mixer / motionclip (entrada 0) selecionados por `group`.	`input` (+10 opcionais)
`fbx_character_import`	KineFX FBX Character Import — importa um personagem FBX completo (esqueleto na saída 0, pele na saída 1, blendshapes na saída 2), opcionalmente mesclando animação de um segundo FBX, em uma nova geo /obj.	`name`, `fbx_file` (+15 opcionais)
`fbx_anim_import`	KineFX FBX Animation Import — importa um esqueleto animado (um motion clip) de um arquivo FBX em uma nova geo /obj.	`name`, `fbx_file` (+14 opcionais)
`fbx_skin_import`	KineFX FBX Skin Import — importa a malha com skin (carregando pesos `boneCapture`) de um personagem FBX em uma nova geo /obj.	`name`, `fbx_file` (+8 opcionais)
`gltf_character_import`	KineFX glTF Character Import — importa um personagem glTF/glb completo (esqueleto na saída 0, pele na saída 1, blendshapes na saída 2) em uma nova geo /obj.	`name`, `gltf_file` (+7 opcionais)
`gltf_anim_import`	KineFX glTF Animation Import — importa um esqueleto animado (motion clip) de um arquivo glTF/glb em uma nova geo /obj.	`name`, `gltf_file` (+5 opcionais)
`gltf_skin_import`	KineFX glTF Skin Import — importa a malha com skin (carregando pesos `boneCapture`) de um personagem glTF/glb em uma nova geo /obj.	`name`, `gltf_file` (+2 opcionais)
`usd_character_import`	KineFX USD Character Import — importa um personagem USDSkel (esqueleto na saída 0, pele na saída 1, blendshapes na saída 2) de um arquivo USD em uma nova geo /obj (força a fonte do arquivo, não um LOP /stage).	`name`, `usd_file` (+7 opcionais)
`usd_anim_import`	KineFX USD Animation Import — importa um esqueleto animado (motion clip) de um arquivo USDSkel em uma nova geo /obj (força a fonte do arquivo).	`name`, `usd_file` (+7 opcionais)
`usd_skin_import`	KineFX USD Skin Import — importa a malha com skin (carregando pesos `boneCapture`) de um personagem USDSkel em uma nova geo /obj (força a fonte do arquivo).	`name`, `usd_file` (+3 opcionais)
`mocap_import`	KineFX Mocap Import — importa dados brutos de captura de movimento (Biovision BVH, Acclaim ASF+AMC ou Motion-Analysis TRC) como um esqueleto animado em uma nova geo /obj.	`name` (+20 opcionais)
`clip_import`	KineFX Clip Import — lê um motion clip CHOP .bclip/.clip do disco e (opcionalmente, quando uma entrada `skeleton` 0 é fornecida) aplica-o àquele esqueleto; caso contrário, emite o clipe em uma nova geo /obj.	`name`, `file` (+5 opcionais)
`retarget_biped_fbx`	KineFX Retarget Biped FBX — importa um FBX bípede e reorienta sua animação para o template de bípede KineFX (esqueleto na saída 0, animação na saída 1, pele na saída 2) em uma nova geo /obj.	`name`, `fbx_file` (+9 opcionais)
`character_io`	KineFX Character IO — monta um personagem KineFX a partir de suas partes: entrada0 = `geometry` de descanso, entrada1 = esqueleto `capture_pose` (opcional), entrada2 = esqueleto/motionclip `animated_pose` (opcional).	`geometry` (+13 opcionais)
`fbx_anim_export`	KineFX FBX Animation Output — APENAS WIRE.	`geometry` (+17 opcionais)
`fbx_character_export`	KineFX FBX Character Output — APENAS WIRE.	`skin_geo`, `capture_pose` (+20 opcionais)
`gltf_character_export`	KineFX glTF Character Output — APENAS WIRE.	`skin_geo`, `capture_pose` (+13 opcionais)
`clip_export`	KineFX Clip Export — APENAS WIRE.	`geometry` (+8 opcionais)
`scene_character_export`	KineFX Scene Character Export — APENAS WIRE.	`geometry`, `skeleton` (+7 opcionais)
`retarget_fbx_export`	KineFX Retarget FBX Export — APENAS WIRE.	`geometry` (+18 opcionais)
`classic_bone`	KineFX/Classic Bone (OBJ `bone`) — cria um objeto Bone clássico: um osso parametrizado por comprimento com exibição bonelink e cilindros ajustáveis de região de captura / deformação de captura (a primitiva de skinning pré-KineFX).	14 opcionais
`dembones_skinning_export`	KineFX/Classic DemBones Skinning Converter ROP (/out `dembones_skinningconverter`) — APENAS WIRE: constrói e configura a solução externa DemBones que converte um cache Alembic animado (+ FBX opcional de pose de ligação) em um FBX com esqueleto + skin com pesos, mas NUNCA o executa (espelha maps_baker — a solução externa pesada é disparada pelo humano).	19 opcionais
`deform_bone_rig_biped_arm`	KineFX/Classic Deform Bone Rig — Biped Arm (OBJ `deform_bone_rig_biped_arm`) — instancia um rig de deformação de osso clássico pronto para um braço bípede (ossos clavícula/braço superior/antebraço/pulso com regiões de captura).	9 opcionais
`deform_bone_rig_biped_hand_4f_2s`	KineFX/Classic Deform Bone Rig — Biped Hand, 4 Fingers / 2 Segments (OBJ `deform_bone_rig_biped_hand_4f_2s`) — rig de deformação de osso clássico pronto para uma mão de 4 dedos / 2 segmentos.	9 opcionais
`deform_bone_rig_biped_hand_4f_3s`	KineFX/Classic Deform Bone Rig — Biped Hand, 4 Fingers / 3 Segments (OBJ `deform_bone_rig_biped_hand_4f_3s`) — rig de deformação de osso clássico pronto para uma mão de 4 dedos / 3 segmentos.	9 opcionais
`deform_bone_rig_biped_hand_5f_3s`	KineFX/Classic Deform Bone Rig — Biped Hand, 5 Fingers / 3 Segments (OBJ `deform_bone_rig_biped_hand_5f_3s`) — rig de deformação de osso clássico pronto para uma mão completa de 5 dedos / 3 segmentos.	9 opcionais
`deform_bone_rig_biped_head_and_neck`	KineFX/Classic Deform Bone Rig — Biped Head and Neck (OBJ `deform_bone_rig_biped_head_and_neck`) — rig de deformação de osso clássico pronto para uma cabeça + cadeia de pescoço bípede.	9 opcionais
`deform_bone_rig_biped_leg`	KineFX/Classic Deform Bone Rig — Biped Leg (OBJ `deform_bone_rig_biped_leg`) — rig de deformação de osso clássico pronto para uma perna bípede (ossos coxa/canhão/pé com regiões de captura).	9 opcionais
`deform_bone_rig_biped_spine_3pc`	KineFX/Classic Deform Bone Rig — Biped Spine, 3 Pieces (OBJ `deform_bone_rig_biped_spine_3pc`) — rig de deformação de osso clássico pronto de 3 segmentos para uma coluna bípede.	9 opcionais
`deform_bone_rig_quadruped_back_leg`	KineFX/Classic Deform Bone Rig — Pata Traseira de Quadrúpede (OBJ `deform_bone_rig_quadruped_back_leg`) — rig de deformação de osso clássico pronto para uma pata traseira de quadrúpede.	9 opcional
`deform_bone_rig_quadruped_front_leg`	KineFX/Classic Deform Bone Rig — Pata Dianteira de Quadrúpede (OBJ `deform_bone_rig_quadruped_front_leg`) — rig de deformação de osso clássico pronto para uma pata dianteira de quadrúpede.	9 opcional
`deform_bone_rig_quadruped_head_and_neck`	KineFX/Classic Deform Bone Rig — Cabeça e Pescoço de Quadrúpede (OBJ `deform_bone_rig_quadruped_head_and_neck`) — rig de deformação de osso clássico pronto para uma cadeia de cabeça + pescoço de quadrúpede.	9 opcional
`deform_bone_rig_quadruped_ik_spine`	KineFX/Classic Deform Bone Rig — Coluna IK de Quadrúpede (OBJ `deform_bone_rig_quadruped_ik_spine`) — rig de deformação de osso clássico pronto para uma cadeia de coluna IK de quadrúpede.	9 opcional
`deform_bone_rig_quadruped_tail`	KineFX Deform Bone Rig Quadruped Tail — um HDA de rig de deformação de osso /obj para uma cadeia de cauda de quadrúpede (A_source: 0 entradas, cozinha um rig de guia/gancho padrão).	11 opcional
`deform_bone_rig_quadruped_toes_4f`	KineFX Deform Bone Rig Quadruped Toes (4 dedos) — um HDA de rig de deformação de osso /obj para uma pata quadrúpede de 4 dedos (A_source: 0 entradas).	11 opcional
`deform_bone_rig_quadruped_toes_5f`	KineFX Deform Bone Rig Quadruped Toes (5 dedos) — um HDA de rig de deformação de osso /obj para uma pata quadrúpede de 5 dedos (A_source: 0 entradas).	11 opcional
`deform_rig_biped_arm`	KineFX Deform Rig Biped Arm — um HDA de rig de deformação muscular /obj para um braço bípede (A_source: 0 entradas, cozinha um rig de músculo/guia padrão).	14 opcional
`deform_rig_biped_hand_4f_2s`	KineFX Deform Rig Biped Hand (4 dedos, 2 segmentos) — um HDA de rig de deformação muscular /obj para uma mão bípede (A_source: 0 entradas).	14 opcional
`deform_rig_biped_hand_4f_3s`	KineFX Deform Rig Biped Hand (4 dedos, 3 segmentos) — um HDA de rig de deformação muscular /obj para uma mão bípede (A_source: 0 entradas).	14 opcional
`deform_rig_biped_hand_5f_3s`	KineFX Deform Rig Biped Hand (5 dedos, 3 segmentos) — um HDA de rig de deformação muscular /obj para uma mão bípede (A_source: 0 entradas).	14 opcional
`deform_rig_biped_head_and_neck`	KineFX Deform Rig Biped Head and Neck — um HDA de rig de deformação muscular /obj para cabeça + pescoço bípedes (A_source: 0 entradas).	21 opcional
`deform_rig_biped_leg`	KineFX Deform Rig Biped Leg — um HDA de rig de deformação muscular /obj para uma perna bípede (A_source: 0 entradas).	14 opcional
`deform_rig_biped_spine_3pc`	KineFX Deform Rig Biped Spine (3 segmentos) — um HDA de rig de deformação muscular /obj para uma coluna bípede de 3 segmentos (A_source: 0 entradas).	14 opcional
`deform_rig_biped_spine_5pc`	KineFX Deform Rig Biped Spine (5 segmentos) — um HDA de rig de deformação muscular /obj para uma coluna bípede de 5 segmentos (A_source: 0 entradas).	14 opcional
`deform_rig_quadruped_back_leg`	KineFX Deform Rig Quadruped Back Leg — um HDA de rig de deformação muscular /obj para uma pata traseira de quadrúpede (A_source: 0 entradas).	14 opcional
`deform_rig_quadruped_front_leg`	KineFX Deform Rig Quadruped Front Leg — um HDA de rig de deformação muscular /obj para uma pata dianteira de quadrúpede (A_source: 0 entradas).	14 opcional
`deform_rig_quadruped_head_and_neck`	KineFX Deform Rig Quadruped Head and Neck — um HDA de rig de deformação muscular /obj para cabeça + pescoço de quadrúpede (A_source: 0 entradas).	21 opcional
`deform_rig_quadruped_ik_spine`	KineFX Deform Rig Quadruped IK Spine — um HDA de rig de deformação muscular /obj para uma coluna IK de quadrúpede (A_source: 0 entradas).	14 opcional
`deform_rig_quadruped_tail`	KineFX Deform Rig Quadruped Tail — um HDA de rig de deformação muscular /obj para uma cauda de quadrúpede (A_source: 0 entradas).	14 opcional
`deform_rig_quadruped_toes_4f`	KineFX Deform Rig Quadruped Toes (4 dedos) — um HDA de rig de deformação muscular /obj para uma pata quadrúpede de 4 dedos (A_source: 0 entradas).	14 opcional
`deform_rig_quadruped_toes_5f`	KineFX Deform Rig Quadruped Toes (5 dedos) — um HDA de rig de deformação muscular /obj para uma pata quadrúpede de 5 dedos (A_source: 0 entradas).	14 opcional
`toon_character_deform_rig`	KineFX Toon Character Deform Rig (toon_character_deform_rig) — um PRESET OBJ de 0 entradas que instancia o personagem toon completo pronto legado: um rig de ossos por partes do corpo (coluna / braços / pernas / cabeça + pescoço / mãos) acionando um sub-objeto `skin` capturado.	5 opcional
`bone_link`	KineFX Bone Link (bonelink) — uma FONTE de 0 entradas que emite a geometria clássica de link de osso (a forma de link afunilada desenhada entre as extremidades de um osso, com visualizações opcionais de osso empacotado / barbatana / proxy / captura) dentro de um geo /obj novo.	13 opcional
`bone_solidify`	KineFX Bone Solidify (bonesolidify) — tetraedraliza uma pele de entrada `mesh` (entrada 0) em uma malha tet sólida vinculada ao rig, para deformação de osso estilo FEM / corpo macio.	`mesh` (+19 opcional)
`capture_attribute_unpack`	KineFX Capture Attribute Unpack (captureattribunpack) — expande um atributo de captura empacotado (padrão `boneCapture`) em `geometry` (entrada 0) em atributos de componente separados `_index` + `_data` para que os pesos brutos possam ser editados por ferramentas de atributo genéricas.	`geometry` (+8 opcional)
`capture_attribute_pack`	KineFX Capture Attribute Pack (captureattribpack) — recolhe os atributos de componente de captura separados `_index` + `_data` em `geometry` (entrada 0) de volta em um único atributo de captura empacotado (padrão `boneCapture`).	`geometry` (+8 opcional)
`capture_layer_paint`	KineFX Capture Layer Paint (capturelayerpaint::2.0) — edita/normaliza pesos de captura clássicos em `geometry` (entrada 0) para as regiões de captura ativas; o pincel é uma ferramenta de viewport, então este endpoint somente de dados expõe apenas os controles de seleção / normalização de região / tipo de captura e passa o rig re-normalizado adiante.	`geometry` (+11 opcional)
`post_anim_deform`	Labs Post Animation Deform (labs::post_anim_deform) — aplica o delta de deformação entre uma malha de repouso (entrada 1) e sua versão deformada (entrada 2) em uma malha `deforming` correspondente (entrada 0), transferindo opcionalmente um atributo de orientação/transformação.	`deforming`, `rest`, `deformed` (+6 opcional)
`neuron_mocap`	Labs Neuron Mocap (labs::neuron_mocap) — uma FONTE de 0 entradas (geo /obj novo) que configura um stream de mocap ao vivo do Perception Neuron (nome do personagem / IP / porta / formato de dados / índice de ator) e emite o esqueleto recebido.	`name` (+5 opcional)
`rokoko_mocap`	Labs Rokoko Mocap (labs::rokoko_mocap) — uma FONTE de 0 entradas (geo /obj novo) que configura um stream de mocap ao vivo do Rokoko Smartsuit (IP / porta / ator / nome do traje) e um arquivo de gravação opcional, e emite o esqueleto recebido.	`name` (+6 opcional)
`dembones_skinning_external`	Labs DemBones Skinning Converter (labs::dembones_skinningconverter) — SOMENTE FIO.	`geometry` (+20 opcional)
`dembones_skinning_bake`	DemBones Skinning Converter, escritor SOP nativo (dembones_skinningconverter::1.0) — SOMENTE FIO.	`geometry` (+21 opcional)
`skin_properties`	KineFX Skin Properties (skinproperties) — cria atributos de propriedade SOLVER de músculo/pele por ponto na pele de entrada (entrada 0): rigidez / amortecimento de superfície e sólida / rigidez de dobra / densidade de massa / taxa de deslizamento, opcionalmente mascarados e mesclados, com um material `preset`.	`geometry` (+15 opcional)
`skin_solidify`	KineFX Skin Solidify (skinsolidify::2.0) — constrói uma casca tet SÓLIDA em camadas ao redor de uma superfície de pele de entrada (entrada 0) para simulação de pele estilo FEM / tecido: `skin_thickness` + `num_layers` definem a profundidade da casca, as alavancas de dimensionamento de elementos (`min_size`/`max_size`/`rel_density`/`gradation`) controlam a densidade do tet, e uma relaxação de suavização (`iterations`/`step_size`) limpa os pesos internos.	`geometry` (+15 opcional)
`skin_deform`	KineFX Skin Deform (skindeform) — finalização de pele ciente de músculos sobre uma pele de entrada (entrada 0): uma passada de desfoque muscular que suaviza os pesos da pele em direção ao movimento muscular subjacente, além de uma relaxação opcional de deslizamento da pele que permite que a pele deslize sobre os músculos, resolvida contra um quadro de referência.	`geometry` (+12 opcional)
`animation_rig_biped_arm`	KineFX Animation Rig Biped Arm — um HDA de rig de animação (controle) /obj para um braço bípede (A_source: 0 entradas, cozinha um rig de controle FK/IK padrão). control_scale/control_lod/control_color dimensionam e estilizam os controles; hook_object referencia um objeto pai na cena.	`name` (+14 opcional)
`animation_rig_biped_hand_4f_2s`	KineFX Animation Rig Biped Hand (4 dedos, 2 segmentos) — um HDA de rig de animação /obj para uma mão bípede (A_source: 0 entradas). control_scale/control_lod/control_color dimensionam e estilizam os controles; hook_object referencia um objeto pai na cena.	`name` (+14 opcional)
`animation_rig_biped_hand_4f_3s`	KineFX Animation Rig Biped Hand (4 dedos, 3 segmentos) — um HDA de rig de animação /obj para uma mão bípede (A_source: 0 entradas). control_scale/control_lod/control_color dimensionam e estilizam os controles; hook_object referencia um objeto pai na cena.	`name` (+14 opcional)
`animation_rig_biped_hand_5f_3s`	KineFX Animation Rig Biped Hand (5 dedos, 3 segmentos) — um HDA de rig de animação /obj para uma mão bípede (A_source: 0 entradas). control_scale/control_lod/control_color dimensionam e estilizam os controles; hook_object referencia um objeto pai na cena.	`name` (+14 opcional)
`animation_rig_biped_head_and_neck`	KineFX Animation Rig Biped Head and Neck — um HDA de rig de animação /obj para cabeça + pescoço bípedes (A_source: 0 entradas, cozinha controles de look-at de cabeça/pescoço/mandíbula/olhos). control_scale/control_lod/control_color dimensionam e estilizam os controles; hook_object referencia um objeto pai na cena.	`name` (+14 opcional)
`animation_rig_biped_leg`	KineFX Animation Rig Biped Leg — um HDA de rig de animação /obj para uma perna bípede (A_source: 0 entradas, cozinha um rig de controle FK/IK padrão). control_scale/control_lod/control_color dimensionam e estilizam os controles; hook_object referencia um objeto pai na cena.	`name` (+14 opcional)
`animation_rig_biped_spine_3pc`	KineFX Animation Rig Biped Spine (3 segmentos) — um HDA de rig de animação /obj para uma coluna bípede de 3 segmentos (A_source: 0 entradas). control_scale/control_lod/control_color dimensionam e estilizam os controles; hook_object referencia um objeto pai na cena.	`name` (+14 opcional)
`animation_rig_biped_spine_5pc`	KineFX Animation Rig Biped Spine (5 segmentos) — um HDA de rig de animação /obj para uma coluna bípede de 5 segmentos (A_source: 0 entradas). control_scale/control_lod/control_color dimensionam e estilizam os controles; hook_object referencia um objeto pai na cena.	`name` (+14 opcional)
`animation_rig_character_placer`	KineFX Animation Rig Character Placer — o HDA de rig de posicionamento raiz /obj que posiciona um personagem inteiro (A_source: 0 entradas). control_scale/control_lod/control_color dimensionam e estilizam os controles de posicionamento; hook_object referencia um objeto pai na cena.	`name` (+14 opcional)
`animation_rig_quadruped_back_leg`	KineFX Animation Rig Quadruped Back Leg — um HDA de rig de animação /obj para uma pata traseira de quadrúpede (A_source: 0 entradas). control_scale/control_lod/control_color dimensionam e estilizam os controles; hook_object referencia um objeto pai na cena.	`name` (+14 opcional)
`animation_rig_quadruped_front_leg`	KineFX Animation Rig Quadruped Front Leg — um HDA de rig de animação /obj para uma pata dianteira de quadrúpede (A_source: 0 entradas). control_scale/control_lod/control_color dimensionam e estilizam os controles; hook_object referencia um objeto pai na cena.	`name` (+14 opcional)
`animation_rig_quadruped_head_and_neck`	KineFX Animation Rig Quadruped Head and Neck — um HDA de rig de animação /obj para cabeça + pescoço de quadrúpede (A_source: 0 entradas). control_scale/control_lod/control_color dimensionam e estilizam os controles; hook_object referencia um objeto pai na cena.	`name` (+14 opcional)
`animation_rig_quadruped_tail`	KineFX Animation Rig Quadruped Tail — um HDA de rig de animação /obj para uma cauda de quadrúpede (A_source: 0 entradas). control_scale/control_lod/control_color dimensionam e estilizam os controles; hook_object referencia um objeto pai na cena.	`name` (+14 opcionais)
`animation_rig_quadruped_toes_4f`	KineFX Animation Rig Quadruped Toes (4 Fingers) — um HDA de rig de animação /obj para um pé de quadrúpede com 4 dedos (A_source: 0 entradas). control_scale/control_lod/control_color dimensionam e estilizam os controles; hook_object referencia um objeto pai na cena.	`name` (+14 opcionais)
`animation_rig_quadruped_toes_5f`	KineFX Animation Rig Quadruped Toes (5 Fingers) — um HDA de rig de animação /obj para um pé de quadrúpede com 5 dedos (A_source: 0 entradas). control_scale/control_lod/control_color dimensionam e estilizam os controles; hook_object referencia um objeto pai na cena.	`name` (+14 opcionais)
`auto_rig_biped_arm`	KineFX Auto Rig Biped Arm — um HDA construtor de auto-rig /obj que monta um rig de controle completo de braço bípede a partir dos padrões (A_source: 0 entradas). control_scale/control_lod/control_color dimensionam e estilizam os controles; hook_object referencia um objeto pai na cena.	`name` (+14 opcionais)
`auto_rig_biped_hand_4f_2s`	KineFX Auto Rig Biped Hand (4 Fingers, 2 Segments) — um HDA construtor de auto-rig /obj que monta um rig de controle completo de mão bípede com 4 dedos a partir dos padrões (A_source: 0 entradas). control_scale/control_lod/control_color dimensionam e estilizam os controles; hook_object referencia um objeto pai na cena.	`name` (+14 opcionais)
`auto_rig_biped_hand_4f_3s`	KineFX Auto Rig Biped Hand (4 Fingers, 3 Segments) — um HDA de auto-rig /obj que constrói um rig de controle de mão bípede padrão com 4 dedos (A_source: 0 entradas).	17 opcionais
`auto_rig_biped_hand_5f_3s`	KineFX Auto Rig Biped Hand (5 Fingers, 3 Segments) — um HDA de auto-rig /obj que constrói um rig de controle de mão bípede padrão com 5 dedos (A_source: 0 entradas).	17 opcionais
`auto_rig_biped_head_and_neck`	KineFX Auto Rig Biped Head and Neck — um HDA de auto-rig /obj que constrói um rig de controle padrão de cabeça + pescoço bípede (A_source: 0 entradas).	16 opcionais
`auto_rig_biped_leg`	KineFX Auto Rig Biped Leg — um HDA de auto-rig /obj que constrói um rig de controle padrão de perna bípede (A_source: 0 entradas).	19 opcionais
`auto_rig_biped_spine_3pc`	KineFX Auto Rig Biped Spine (3 Pieces) — um HDA de auto-rig /obj que constrói um rig de controle padrão de coluna bípede com 3 partes (A_source: 0 entradas).	15 opcionais
`auto_rig_biped_spine_5pc`	KineFX Auto Rig Biped Spine (5 Pieces) — um HDA de auto-rig /obj que constrói um rig de controle padrão de coluna bípede com 5 partes (A_source: 0 entradas).	15 opcionais
`auto_rig_quadruped_back_leg`	KineFX Auto Rig Quadruped Back Leg — um HDA de auto-rig /obj que constrói um rig de controle padrão de perna traseira de quadrúpede (A_source: 0 entradas).	19 opcionais
`auto_rig_quadruped_front_leg`	KineFX Auto Rig Quadruped Front Leg — um HDA de auto-rig /obj que constrói um rig de controle padrão de perna dianteira de quadrúpede (A_source: 0 entradas).	19 opcionais
`auto_rig_quadruped_head_and_neck`	KineFX Auto Rig Quadruped Head and Neck — um HDA de auto-rig /obj que constrói um rig de controle padrão de cabeça + pescoço de quadrúpede (A_source: 0 entradas).	18 opcionais
`auto_rig_quadruped_ik_spine`	KineFX Auto Rig Quadruped IK Spine — um HDA de auto-rig /obj que constrói um rig de controle padrão de coluna IK de quadrúpede (A_source: 0 entradas).	16 opcionais
`auto_rig_quadruped_tail`	KineFX Auto Rig Quadruped Tail — um HDA de auto-rig /obj que constrói um rig de controle padrão de cauda de quadrúpede (A_source: 0 entradas).	15 opcionais
`auto_rig_quadruped_toes_4f`	KineFX Auto Rig Quadruped Toes (4 Fingers) — um HDA de auto-rig /obj que constrói um rig de controle padrão de pé de quadrúpede com 4 dedos (A_source: 0 entradas).	18 opcionais
`auto_rig_quadruped_toes_5f`	KineFX Auto Rig Quadruped Toes (5 Fingers) — um HDA de auto-rig /obj que constrói um rig de controle padrão de pé de quadrúpede com 5 dedos (A_source: 0 entradas).	18 opcionais
`auto_rig_character_placer`	KineFX Auto Rig Character Placer — um HDA de auto-rig /obj que dispõe os guias de posicionamento a partir dos quais um rig é construído (A_source: 0 entradas).	18 opcionais
`biped_auto_rig`	KineFX Biped Auto Rig — um HDA de chamada única /obj que constrói um rig de controle bípede padrão completo (A_source: 0 entradas).	24 opcionais
`auto_rig_eye`	KineFX Auto Rig Eye — um HDA de auto-rig /obj que constrói um rig de olho único (A_source: 0 entradas).	14 opcionais
`impostor_camera_rig`	KineFX Labs Impostor Camera Rig — um HDA de rig /obj que constrói o rig de câmera multivista a partir do qual um bake de impostor é capturado (A_source: 0 entradas).	9 opcionais
`mocap_acclaim`	KineFX Mocap Acclaim — um HDA de importação de mocap /obj para captura de movimento Acclaim ASF/AMC (A_source: 0 entradas; cozinha verde vazio até que um esqueleto seja definido).	17 opcionais
`mocap_rig_biped_arm`	KineFX Mocap Rig Biped Arm — um HDA de rig de retarget de mocap /obj que controla um rig de animação de braço bípede a partir de um esqueleto de mocap (A_source: 0 entradas).	18 opcionais
`mocap_rig_biped_head_and_neck`	KineFX Mocap Rig Biped Head and Neck — um HDA de rig de retarget de mocap /obj que controla um rig de animação de cabeça + pescoço bípede a partir de um esqueleto de mocap (A_source: 0 entradas).	17 opcionais
`mocap_rig_biped_leg`	KineFX Mocap Rig Biped Leg — um HDA de rig de retarget de mocap /obj que controla um rig de animação de perna bípede a partir de um esqueleto de mocap (A_source: 0 entradas).	23 opcionais
`mocap_rig_biped_spine_3pc`	KineFX Mocap Rig Biped Spine (3 Pieces) — um HDA de rig de retarget de mocap /obj que controla um rig de animação de coluna bípede com 3 partes a partir de um esqueleto de mocap (A_source: 0 entradas).	19 opcionais
`mocap_rig_biped_spine_5pc`	KineFX Mocap Rig Biped Spine (5 Pieces) — um HDA de rig de retarget de mocap /obj que controla um rig de animação de coluna bípede com 5 partes a partir de um esqueleto de mocap (A_source: 0 entradas).	23 opcionais
`mocap_biped_1`	KineFX MoCap Biped 1 — um personagem de teste MoCap Biped pré-construído com clipes de locomoção gravados (A_source: construído puro, 0 entradas conectadas).	10 opcionais
`mocap_biped_2`	KineFX MoCap Biped 2 — um personagem de teste MoCap Biped pré-construído com uma grande biblioteca de clipes gravados (A_source: construído puro, 0 entradas conectadas).	10 opcionais
`mocap_biped_3`	KineFX MoCap Biped 3 — o personagem de teste MoCap Biped avançado pré-construído com biblioteca de clipes categorizada e motion-matching (A_source: construído puro, 0 entradas conectadas).	14 opcionais
`quadruped_auto_rig_4f`	KineFX Quadruped Auto Rig (4 Toes) — um HDA de chamada única /obj que constrói um rig de controle de quadrúpede padrão completo com 4 dedos (A_source: 0 entradas).	28 opcionais
`quadruped_auto_rig_5f`	KineFX Quadruped Auto Rig (5 Toes) — um HDA de chamada única /obj que constrói um rig de controle de quadrúpede padrão completo com 5 dedos (A_source: 0 entradas).	28 opcionais
`toon_character`	KineFX Toon Character — um HDA /obj que constrói um personagem cartoon completo pré-riggado (auto-rig + face + mocap) a partir dos padrões (A_source: 0 entradas).	18 opcionais
`constraint_begin`	KineFX Constraint Get World Space Begin (constraintbegin) — o INÍCIO de uma rede de restrições CHOP: emite a transformação de mundo de `object` como faixas t/r/s (9 faixas) que CHOPs de restrição a jusante combinam.	6 opcionais
`constraint_object`	KineFX Constraint Object (constraintobject) — emite a transformação de mundo de `target` como faixas t/r/s (9), opcionalmente expressa em relação a `reference`.	6 opcionais
`constraint_object_pretransform`	KineFX Constraint Object Pretransform (constraintobjectpretransform) — emite a pré-transformação (o offset de repouso/pivô do objeto) de `target` como faixas t/r/s (9).	5 opcionais
`constraint_object_offset`	KineFX Constraint Object Offset (constraintobjectoffset) — emite a transformação de offset de `target` em relação a `reference` como faixas t/r/s (9), mascarada por `channel_mask`.	9 opcionais
`constraint_get_world_space`	KineFX Constraint Get World Space (constraintgetworldspace) — emite a transformação no espaço MUNDIAL de `object` como faixas t/r/s (9).	5 opcionais
`constraint_get_parent_space`	KineFX Constraint Get Parent Space (constraintgetparentspace) — emite a transformação no espaço do PAI de `object` como faixas t/r/s (9); `parent_bone` seleciona a convenção de osso pai.	6 opcionais
`constraint_get_local_space`	KineFX Constraint Get Local Space (constraintgetlocalspace) — emite a transformação no espaço LOCAL de `object` como faixas t/r/s (9); `mode` escolhe a convenção de espaço local.	6 opcionais
`constraint_look_at`	KineFX Constraint Look At (constraintlookat) — emite uma rotação que aponta `look_at_axis` para uma posição de look-at enquanto mantém `look_up_axis_*` voltado para um alvo de up (9 faixas).	15 opcionais
`constraint_path`	KineFX Constraint Path (constraintpath) — emite uma transformação que se desloca ao longo da curva em `sop_path` no parâmetro `position`, orientada pelas configurações de look-at/look-up (9 faixas).	21 opcionais
`constraint_points`	KineFX Constraint Points (constraintpoints) — emite uma transformação anexada ao(s) ponto(s) do SOP em `sop_path` (um `group`, ou o mais próximo dentro de `search_distance`/`search_max_points`), orientada pelas configurações de look-at/look-up (9 faixas).	22 opcionais
`constraint_export`	KineFX Constraint Export (constraintexport) — encerra uma rede de restrições exportando a transformação combinada para o objeto de restrição em `constraints_path`; `enable_constraints` a alterna ao vivo.	4 opcionais
`constraint_blend`	KineFX Constraint Blend (constraintblend) — mescla dois ou mais fluxos de transformação de restrição.	`input` (+5 opcionais)
`constraint_sequence`	KineFX Constraint Sequence (constraintsequence) — mescla sequencialmente uma cadeia de fluxos de restrição por `blend`.	`input` (+5 opcionais)
`constraint_offset`	KineFX Constraint Offset (constraintoffset) — aplica a transformação de offset em `input1` (entrada 1) à transformação base em `input` (entrada 0) por `blend`.	`input`, `input1` (+6 opcionais)
`constraint_parent`	KineFX Constraint Parent (constraintparent) — compõe uma transformação filha sob uma transformação pai (o primitivo de parenting do CHOP).	`input` (+3 opcionais)
`constraint_parent_extended`	KineFX Constraint Parent Extended (constraintparentx) — parenting com um `write_mask` (bitmask int de canais gravados, padrão 511).	`input` (+4 opcionais)
`constraint_simple_blend`	KineFX Constraint Simple Blend (constraintsimpleblend) — uma mescla leve de dois fluxos de restrição por `blend`.	`input` (+5 opcionais)
`constraint_offset_blend`	KineFX Constraint Offset Blend (constraintoffsetblend) — mescla um offset entre até quatro fluxos de restrição por `blend`.	`input` (+7 opcionais)
`constraint_surface`	KineFX Constraint Surface (constraintsurface) — um CHOP que emite uma transformação presa à SUPERFÍCIE do SOP em `sop_path`, localizada por uma coordenada UV (`uv` em `uv_attribute`), uma posição (`p` em `position_attribute`), ou o ponto mais próximo dentro de `search_distance`/`search_max_points`, e orientada pelas configurações de look-at / look-up.	26 opcionais
`constraint_transform`	KineFX Constraint Transform (constrainttransform) — um CHOP que emite uma transformação explícita construída a partir de `translate`/`rotate`/`scale` (com `transform_order`/`rotation_order`), um pivô (`pivot` / `pivot_rotate`), e `mode`/`pivot_mode`; `invert` inverte o resultado.	15 opcionais
`constraint_pose`	KineFX Pose (pose) — um CHOP da aba Constraints que emite uma pose estática armazenada como faixas de transformação t/r/s (de `translate`/`rotate`/`scale` com `transform_order`/`rotation_order`).	8 opcionais
`jiggle`	KineFX Jiggle (jiggle) — um CHOP que adiciona movimento de balanço secundário ao fluxo de transformação em `input` (entrada 0, que DEVE conter canais tx/ty/tz).	`input` (+7 opcionais)
`lag`	KineFX Lag (lag) — um CHOP que suaviza / atrasa o fluxo de canais em `input` (entrada 0).	`input` (+8 opcionais)
`channel_spring`	KineFX Spring (spring, CHOP) — aciona o fluxo de canais em `input` (entrada 0) com um sistema massa-mola: `spring_constant`, `mass`, `damping`, `method` (disp / força), `position` / `speed` iniciais e `use_channel_condition` para semear o estado inicial a partir da entrada.	`input` (+8 opcionais)
`channel_pose_difference`	KineFX Pose Difference (posedifference, CHOP) — calcula a diferença entre o fluxo de pose em `input` (entrada 0) e uma pose de referência.	`input` (+3 opcionais)
`chop_wave`	CHOP Wave (wave) — gera um canal de forma de onda periódica (seno/triângulo/rampa/quadrada/pulso) ao longo de um intervalo de quadros.	16 opcionais
`chop_waveform`	CHOP Waveform (waveform) — gera um canal de forma de onda constante/seno/quadrada (fonte de forma de onda orientada por dados).	13 opcionais
`chop_noise`	CHOP Noise (noise) — gera um canal de ruído animado (sparse/perlin/harmonic/brownian/alligator).	14 opcionais
`chop_constant`	CHOP Constant (constant) — gera canais com valores constantes (até quatro canais nomeados).	10 opcionais
`chop_spline`	CHOP Spline (spline) — gera um canal interpolado por spline (bezier/cúbico) ao longo de um intervalo.	11 opcionais
`chop_pulse`	CHOP Pulse (pulse) — gera uma sequência de pulsos de valor ao longo de um intervalo.	13 opcionais
`chop_channel`	CHOP Channel (channel) — gera canais amostrados de canais de parâmetros / keyframes ao longo de um intervalo.	11 opcionais
`chop_oscillator`	CHOP Oscillator (oscillator) — oscilador estilo áudio acionado por um canal de entrada (REQUER um CHOP de entrada).	`input` (+15 opcionais)
`chop_math`	CHOP Math (math) — aritmética por canal e entre CHOPs, ganho e remapeamento.	`input` (+19 opcionais)
`chop_function`	CHOP Function (function) — aplica uma função matemática (sqrt/trig/log/pow/...) aos canais de entrada.	`input` (+12 opcionais)
`chop_filter`	CHOP Filter (filter) — filtro temporal (gaussiano/box/edge/sharpen/despike) nos canais de entrada.	`input` (+9 opcionais)
`chop_limit`	CHOP Limit (limit) — limita / faz loop / quantiza os valores dos canais de entrada.	`input` (+15 opcionais)
`chop_lag`	CHOP Lag (lag) — suaviza os canais de entrada com atraso/overshoot (seguimento tipo mola).	`input` (+11 opcionais)
`chop_lookup`	CHOP Lookup (lookup) — usa a entrada 0 como índice para consultar valores na entrada 1.	`input` (+9 opcionais)
`chop_cycle`	CHOP Cycle (cycle) — repete/espelha os canais de entrada antes e depois com misturas opcionais.	`input` (+13 opcionais)
`chop_blend`	CHOP Blend (blend) — mistura com pesos os canais entre as entradas conectadas.	`input` (+10 opcionais)
`chop_merge`	CHOP Merge (merge) — mescla os canais de todas as entradas conectadas em um único fluxo.	`input` (+9 opcionais)
`chop_warp`	CHOP Warp (warp) — distorce temporalmente a entrada 0 pelo canal de warp na entrada 1.	`input` (+7 opcionais)
`chop_resample`	CHOP Resample (resample) — reamostra os canais de entrada para uma nova taxa / intervalo.	`input` (+14 opcionais)
`chop_shift`	CHOP Shift (shift) — desloca / rola os canais de entrada no tempo.	`input` (+10 opcionais)
`chop_hold`	CHOP Hold (hold) — mantém (sample-and-hold) os canais de entrada.	`input` (+5 opcionais)
`chop_spectrum`	CHOP Spectrum (spectrum) — converte os canais de entrada para/do domínio da frequência.	`input` (+11 opcionais)
`chop_multiply`	CHOP Multiply (multiply) — multiplica os canais de todas as entradas conectadas.	`input` (+7 opcionais)
`chop_invert`	CHOP Invert (invert) — inverte (recíproco) os valores dos canais de entrada.	`input` (+4 opcionais)
`chop_extend`	CHOP Extend (extend) — define como os canais de entrada se estendem antes/depois do seu intervalo.	`input` (+7 opcionais)
`chop_stretch`	CHOP Stretch (stretch) — estica os canais de entrada no tempo e no valor.	`input` (+12 opcionais)
`chop_trim`	CHOP Trim (trim) — corta os canais de entrada para um sub-intervalo.	`input` (+9 opcionais)
`chop_area`	CHOP Area (area) — integra os canais de entrada (área / integral acumulada).	`input` (+13 opcionais)
`chop_envelope`	CHOP Envelope (envelope) — extrai o envelope de amplitude dos canais de entrada.	`input` (+11 opcionais)
`chop_interp`	CHOP Interpolate (interp) — interpola entre as entradas conectadas ao longo do tempo.	`input` (+11 opcionais)
`chop_delay`	CHOP Delay (delay) — adiciona ecos atrasados e com ganho dos canais de entrada.	`input` (+14 opcionais)
`chop_slope`	CHOP Slope (slope) — calcula a inclinação / aceleração (derivada) dos canais de entrada.	`input` (+6 opcionais)
`chop_fan`	CHOP Fan (fan) — distribui um canal para muitos, ou agrega muitos canais em um.	`input` (+8 opcionais)
`chop_count`	CHOP Count (count) — conta cruzamentos de limiar dos canais de entrada.	`input` (+14 opcionais)
`chop_null`	CHOP Null (null) — null de passagem (um ponto de acesso nomeado e estável no fluxo de canais).	`input` (+4 opcionais)
`chop_vector`	CHOP Vector (vector) — operações vetoriais (magnitude/normalizar/produto escalar/produto vetorial/projetar/...) em trios de canais.	`input` (+11 opcionais)
`chop_attribute`	CHOP Attribute (attribute) — gerencia atributos de transformação (ordem de rotação / slerp) nos canais.	`input` (+6 opcionais)
`chop_copy`	CHOP Copy (copy) — carimba a entrada 0 em cada amostra de gatilho da entrada 1.	`input` (+7 opcionais)
`chop_shuffle`	CHOP Shuffle (shuffle) — reordena / divide / sequencia os canais de entrada.	`input` (+6 opcionais)
`chop_reorder`	CHOP Reorder (reorder) — reordena canais por padrão numérico / de caracteres.	`input` (+10 opcionais)
`chop_rename`	CHOP Rename (rename) — renomeia canais por padrão.	`input` (+7 opcionais)
`chop_delete`	CHOP Delete (delete) — exclui canais por nome ou número.	`input` (+12 opcionais)
`chop_switch`	CHOP Switch (switch) — passa uma das entradas conectadas, selecionada por índice.	`input` (+9 opcionais)
`chop_layer`	CHOP Layer (layer) — sobrepõe as entradas conectadas com pesos por camada (a camada ativa seleciona a base).	`input` (+8 opcionais)
`chop_composite`	CHOP Composite (comp) — compõe (subida/pico/liberação aditivos) as entradas conectadas.	`input` (+18 opcionais)
`chop_trigger`	CHOP Trigger (trigger) — gera um envelope estilo ADSR acionado pelos canais de entrada.	`input` (+16 opcionais)
`chop_footplant`	CHOP Foot Plant (footplant) — detecta + trava contatos dos pés em uma animação de caminhada para eliminar deslizamento.	`input` (+11 opcionais)
`chop_iksolver`	CHOP IK Solver (iksolver) — resolve uma cadeia de ossos para alcançar um afetor final.	`input` (+11 opcionais)
`chop_inversekin`	CHOP Inverse Kinematics (inversekin) — o clássico solucionador de IK de cadeia de ossos acionado por caminhos de ossos OBJ.	11 opcionais
`chop_transform_chain`	CHOP Transform Chain (transformchain) — recompor uma cadeia de transformações em canais de saída.	`input` (+7 opcionais)
`chop_export_transforms`	CHOP Export Transforms (exporttransforms) — mapeia canais de transformação para parâmetros de nós OBJ.	`input` (+6 opcionais)
`chop_extract_bone_transforms`	CHOP Extract Bone Transforms (extractbonetransforms) — lê as transformações de ossos de um esqueleto KineFX em canais.	10 opcionais
`chop_extract_pose_drivers`	CHOP Extract Pose Drivers (extractposedrivers) — extrai canais de acionamento (transformações de juntas / parâmetros) que alimentam um deformador de espaço de pose.	9 opcionais
`chop_blendpose`	CHOP Blend Pose (blendpose) — interpolação de espaço de pose (RBF / hiperplano) que mistura poses de exemplo por valores de acionamento.	`input` (+13 opcionais)
`chop_stashpose`	CHOP Stash Pose (stashpose) — armazena a pose atual como uma pose de referência estática para fluxos de trabalho de espaço de pose.	`input` (+5 opcionais)

Multidão

Ferramenta	O que faz	Parâmetros-chave
`agent_source`	Crowd Agent (agent SOP) — cria/importa primitivas de agente. entrada=scene (um sub-rede de ossos /obj), disk (diretório de cache do agente), fbx ou usd.	16 opcionais
`agent_look_at`	Crowd Agent Look At (agentlookat::3.0) — orienta as articulações de cabeça/olhos do agente em direção a um alvo. entrada0 = agentes, entrada1 = pontos de destino (target_type=points).	`agents` (+19 opcionais)
`agent_terrain_adaptation`	Crowd Agent Terrain Adaptation (agentterrainadaptation::3.0) — microsolver de multidão do DOP: travamento do pé + ajuste do quadril dos agentes ao terreno.	17 opcionais
`agent_terrain_projection`	Crowd Agent Terrain Projection (agentterrainprojection) — microsolver de multidão do DOP que projeta partículas/pés dos agentes sobre uma superfície de terreno.	14 opcionais
`agent_look_at_apply`	Crowd Agent Look At Apply (agentlookatapply::3.0) — microsolver de multidão do DOP que aplica a mira de cabeça/olho aos agentes a cada passo da simulação.	14 opcionais
`agent_clip_layer`	Crowd Agent Clip Layer (agentcliplayer) — microsolver de multidão do DOP que camadas/mistura clipes de animação nos agentes.	15 opcionais
`agent_arcing_clip_layer`	Crowd Agent Arcing Clip Layer (agentarcingcliplayer) — microsolver de multidão do DOP que adiciona um clipe de arco/giro nos agentes.	6 opcionais
`crowd_fuzzy_logic`	Crowd Fuzzy Logic (crowdfuzzylogic) — nó do DOP que combina entradas de gatilho via lógica difusa em um atributo de gatilho.	7 opcionais
`crowd_object`	Crowd Object (crowdobject) — o objeto DOP que mantém a multidão de agentes em uma simulação de multidão.	16 opcionais
`crowd_state`	Crowd State (crowdstate::3.0) — um estado de comportamento nomeado (atribuição de clipe, marcha, modo ragdoll) em uma máquina de estados de multidão.	13 opcionais
`agent_clip`	KineFX Agent Clip (agentclip::2.0) — grava uma fonte de movimento nas primitivas de agente como um clipe nomeado. entrada0 = agentes, entrada1 = MotionClip (fonte=sop/chop).	`agents` (+16 opcionais)
`crowd_trigger`	KineFX Crowd Trigger (crowdtrigger::2.0) — avalia uma condição por agente (proximidade/atributo/velocidade/distância/...) e escreve um atributo de gatilho.	19 opcionais
`crowd_trigger_logic`	KineFX Crowd Trigger Logic (crowdtriggerlogic::2.0) — combina até dois fluxos de gatilho com uma operação booleana e escreve um atributo de gatilho.	7 opcionais
`crowd_transition`	KineFX Crowd Transition (crowdtransition::3.0) — define uma transição entre dois estados de multidão, acionada por um gatilho.	`input` (+17 opcionais)
`crowd_sop_import`	KineFX Crowd SOP Import (sopcrowdimport) — importa uma multidão SOP (primitivas de agente) no estágio USD como personagens UsdSkel. sop_path = o SOP que contém os agentes.	`sop_path` (+7 opcionais)
`crowd_render_procedural`	KineFX Crowd Render Procedural (houdinicrowdprocedural) — configura um procedural de carregamento tardio para renderização (Karma) de multidão, para que os agentes se expandam no render, não assados. entrada (opcional) = um estágio LOP com a multidão.	13 opcionais
`bake_skinning`	KineFX Bake Skinning (bakeskinning) — grava a skinning UsdSkel em um estágio de entrada para posições de pontos deformados (preparação de render de multidão após crowd_sop_import). entrada (OBRIGATÓRIA) = o estágio LOP com personagens com skin.	`input` (+1 opcional)
`agent_channels`	KineFX Agent Channels (agent CHOP) — avalia o clipe ou as transformações de pose de uma primitiva de agente em trilhas CHOP (aciona rigs/luzes/objetos a partir da animação de multidão). sop_path = o SOP que contém o agente.	`sop_path` (+13 opcionais)
`agent_camera`	KineFX Agent Cam (agentcam) — uma câmera /obj controlada pela própria definição de câmera de um agente de multidão (renderiza pelos olhos de um agente). agent_source = o SOP que contém o agente.	9 opcionais
`agent_clip_properties`	Crowd Agent Clip Properties (agentclipproperties) — grava metadados por clipe (intervalo de quadros, unidades de amostragem, clipe pré-visualizado) no catálogo de clipes de um agente. entrada0 = agentes.	`agents` (+5 opcionais)
`agent_clip_transition_graph`	Crowd Agent Clip Transition Graph (agentcliptransitiongraph) — calcula misturas de transição entre clipes para um agente. entrada0 = agentes, entrada1 = grafo de transição existente, entrada2 = propriedades de clipe.	`agents` (+8 opcionais)
`agent_collision_layer`	Crowd Agent Collision Layer (agentcollisionlayer) — constrói/marca uma camada de colisão em agentes para formas de colisão ragdoll/bullet. entrada0 = agentes.	`agents` (+9 opcionais)
`agent_configure_joints`	Crowd Agent Configure Joints (agentconfigurejoints) — configura limites ragdoll por articulação e exibição de guia nos agentes. entrada0 = agentes.	`agents` (+4 opcionais)
`agent_constraint_network`	Crowd Agent Constraint Network (agentconstraintnetwork) — constrói a rede de restrições ragdoll (ajuste de suavidade / ERP / CFM / bias) para agentes. entrada0 = agentes.	`agents` (+12 opcionais)
`agent_definition_cache`	Crowd Agent Definition Cache (agentdefinitioncache) — carrega uma definição de agente em cache (rig/camadas/formas/clipes/metadados).	19 opcionais
`agent_edit`	Crowd Agent Edit (agentedit) — substitui a camada atual/colisão de um agente, o clipe atual e o tempo do clipe. entrada0 = agentes.	`agents` (+7 opcionais)
`agent_layer`	Crowd Agent Layer (agentlayer::2.0) — adiciona/atribui camadas de forma aos agentes e define as camadas atual e de colisão. entrada0 = agentes, entrada1 = geometria de forma, entrada2 = pose de captura.	`agents` (+17 opcionais)
`agent_metadata`	Crowd Agent Metadata (agentmetadata) — lê/mescla/define dicionários de metadados tipados nos agentes. entrada0 = agentes.	`agents` (+10 opcionais)
`agent_prep`	Crowd Agent Prep (agentprep::3.0) — prepara agentes para simulação de multidão (clipe de descanso, configuração de membros, carregamento de clipe). entrada0 = agentes. cachedir + clippaths limitados ao diretório de trabalho; os botões create-chopnet/reload/save nunca são pressionados.	`agents` (+11 opcionais)
`agent_proxy`	Crowd Agent Proxy (agentproxy) — define a exibição de proxy no viewport (LOD / id / cor) para pontos de agente, para pré-visualizações rápidas de multidão. entrada0 = pontos que contêm primitivas de agente.	`agents` (+6 opcionais)
`agent_relationship`	Crowd Agent Relationship (agentrelationship) — vincula agentes filhos a um agente pai (opcionalmente a uma articulação específica) com uma restrição de posição/rotação/total. entrada0 = agentes pais, entrada1 = agentes filhos.	`agents` (+10 opcionais)
`agent_transform_group`	Crowd Agent Transform Group (agenttransformgroup) — define grupos nomeados de transformações (articulações) em agentes para deformação/mistura ponderada. entrada0 = agentes.	`agents` (+10 opcionais)
`agent_unpack`	Crowd Agent Unpack (agentunpack) — descompacta primitivas de agente em sua geometria subjacente (deformada \| descanso \| articulações \| esqueleto \| motionclips). entrada0 = agentes.	`agents` (+15 opcionais)
`agent_vellum_unpack`	Crowd Agent Vellum Unpack (agentvellumunpack) — descompacta agentes em geometria de simulação (Vellum) + descanso para configurações de tecido/corpo macio. entrada0 = agentes.	`agents` (+16 opcionais)
`crowd_assign_layers`	Crowd Assign Layers (crowdassignlayers) — atribui/aleatoriza camadas atual e de colisão em uma multidão de agentes por grupo / padrão de camada / porcentagem. entrada0 = agentes.	`agents` (+13 opcionais)
`crowd_motion_path`	Crowd Motion Path (crowdmotionpath) — gera curvas de caminho de movimento editáveis para uma multidão avaliando os clipes atribuídos de cada agente (ou uma simulação em cache) em um intervalo de quadros. entrada0 = uma multidão (pontos que contêm prims de agente).	`agents` (+15 opcionais)
`crowd_motion_path_apply_relationship`	Crowd Motion Path Apply Relationship (crowdmotionpathapplyrel) — aplica relações pai/filho do agente nos caminhos de movimento. entrada0 = caminhos de movimento, entrada1 = agentes.	`motion_paths` (+3 opcionais)
`crowd_motion_path_arcing_layer`	Crowd Motion Path Arcing Layer (crowdmotionpatharcinglayer) — adiciona clipes de giro (arco) em um caminho de movimento com base na taxa de giro. entrada0 = caminhos de movimento, entrada1 = agentes.	`motion_paths` (+11 opcionais)
`crowd_motion_path_avoid`	Crowd Motion Path Avoid (crowdmotionpathavoid) — desvia caminhos de movimento para evitar colisões, vizinhos e obstáculos. entrada0 = caminhos de movimento, entrada1 = agentes (opcional), entrada2 = obstáculos (opcional).	`motion_paths` (+18 opcionais)
`crowd_motion_path_edit`	Crowd Motion Path Edit (crowdmotionpathedit) — edição de caminhos de movimento por peso de pino / ajuste de escala (controles não-interativos de dados). entrada0 = caminhos de movimento, entrada1 = agentes.	`motion_paths` (+6 opcionais)
`crowd_motion_path_edit_core`	Crowd Motion Path Edit Core (crowdmotionpatheditcore) — o núcleo de dados da edição de caminho de movimento: aplica atributos de peso de pino / ajuste de escala aos caminhos de movimento. entrada0 = caminhos de movimento.	`motion_paths` (+9 opcionais)
`crowd_motion_path_evaluate`	Crowd Motion Path Evaluate (crowdmotionpathevaluate) — amostra os caminhos de movimento de uma multidão em um determinado quadro, produzindo os pontos de multidão posados. entrada0 = caminhos de movimento, entrada1 = agentes.	`motion_paths` (+3 opcionais)
`crowd_motion_path_evaluate_core`	Crowd Motion Path Evaluate Core (crowdmotionpathevaluatecore) — o núcleo de dados da avaliação de caminho de movimento: posa agentes a partir de caminhos de movimento em um determinado tempo.	`agents` (+4 opcionais)
`crowd_motion_path_follow`	Crowd Motion Path Follow (crowdmotionpathfollow) — deforma caminhos de movimento para seguir curvas guia. entrada0 = caminhos de movimento, entrada1 = agentes (opcional), entrada2 = curvas a seguir (opcional).	`motion_paths` (+14 opcionais)
`crowd_motion_path_layer`	Crowd Motion Path Layer (crowdmotionpathlayer) — adiciona um clipe de animação a um caminho de movimento quando acionado (via grupos de gatilho). entrada0 = caminhos de movimento, entrada1 = agentes.	`motion_paths` (+19 opcionais)
`crowd_motion_path_retime`	Crowd Motion Path Retime (crowdmotionpathretime) — retemporiza / recorta o intervalo de quadros e a velocidade de reprodução de um caminho de movimento. entrada0 = caminhos de movimento, entrada1 = agentes (opcional).	`motion_paths` (+8 opcionais)
`crowd_motion_path_transition`	Crowd Motion Path Transition (crowdmotionpathtransition) — transita um caminho de movimento do clipe atual para um novo clipe quando acionado. entrada0 = caminhos de movimento, entrada1 = agentes.	`motion_paths` (+19 opcionais)
`crowd_source`	Crowd Source (crowdsource::3.0) — gera o fluxo de pontos de multidão (grade de formação ou dispersão) que alimenta uma simulação de multidão; cada ponto gera um agente com um estado inicial / clipe / direção.	27 opcionais
`crowd_motion_path_trigger`	Crowd Motion Path Trigger (crowdmotionpathtrigger) — avalia uma condição de gatilho (tempo / limites / distância de objeto / raycast / distância de vizinho / clipe) ao longo dos caminhos de movimento e escreve um gatilho nomeado usado por transições.	`motion_paths` (+29 opcionais)
`agent_animation_unpack`	Agent Animation Unpack (kinefx::agentanimationunpack) — descompacta a animação de um agente em um esqueleto KineFX `output`: pose / pose de clipe de agente / pose de descanso / clipe de movimento / clipes de movimento compactados.	`agents` (+14 opcionais)
`agent_character_unpack`	Agent Character Unpack (kinefx::agentcharacterunpack) — descompacta um agente em sua geometria de componentes: saída 0 = formas de pele, saída 1 = esqueleto, saída 2 = pose de captura.	`agents` (+15 opcionais)
`agent_from_rig`	Agent From Rig (kinefx::agentfromrig) — converte um rig/esqueleto KineFX em uma única primitiva de Agente (pose de descanso, sem clipes).	`rig` (+10 opcionais)
`agent_pose_from_rig`	Agent Pose From Rig (kinefx::agentposefromrig) — controla a pose de um agente a partir de um rig/esqueleto KineFX (ambas as entradas OBRIGATÓRIAS).	`agents`, `rig` (+7 opcionais)
`agent_transforms`	Crowd Agent Transforms (agenttransforms) — VOP provedor de dados que lê as matrizes de transformação de uma primitiva de agente.	7 opcionais
`agent_transform_names`	Crowd Agent Transform Names (agenttransformnames) — VOP provedor de dados que lê os nomes ordenados de transformações (articulações) do rig de um agente.	6 opcionais
`agent_transform_count`	Crowd Agent Transform Count (agenttransformcount) — VOP provedor de dados que gera o número de transformações (articulações) no rig de um agente.	6 opcionais
`agent_rig_find`	Crowd Agent Rig Find (agentrigfind) — VOP provedor de dados que retorna o índice de transformação de uma junta nomeada no rig de um agente.	7 opcional
`agent_rig_children`	Crowd Agent Rig Children (agentrigchildren) — VOP provedor de dados que retorna os índices de transformação filhos de uma junta na hierarquia do rig de um agente.	7 opcional
`agent_rig_parent`	Crowd Agent Rig Parent (agentrigparent) — VOP provedor de dados que retorna o índice de transformação pai de uma junta na hierarquia do rig de um agente.	7 opcional
`agent_clip_weights`	Crowd Agent Clip Weights (agentclipweights) — VOP provedor de dados que lê os pesos de mistura ativos por clipe de um agente.	6 opcional
`agent_layers`	Crowd Agent Layers (agentlayers) — VOP provedor de dados que lê a lista de nomes de camadas em uma definição de agente.	6 opcional
`agent_layer_name`	Crowd Agent Layer Name (agentlayername) — VOP provedor de dados que resolve um nome de camada para um agente (por exemplo, camada atual / de colisão).	7 opcional
`agent_layer_bindings`	Crowd Agent Layer Bindings (agentlayerbindings) — VOP provedor de dados que lê os vínculos forma->transformação de uma camada de agente nomeada.	8 opcional
`agent_layer_shapes`	Crowd Agent Layer Shapes (agentlayershapes) — VOP provedor de dados que lê os nomes das formas em uma camada de agente nomeada, opcionalmente filtrados por tipo de forma.	8 opcional
`agent_convert_transforms`	Crowd Agent Convert Transforms (agentconverttransforms) — VOP provedor de dados que converte a matriz de transformações de um agente entre espaços (por exemplo, local <-> mundial).	7 opcional

Ferramenta	O que faz	Parâmetros-chave
`franken_muscle`	Muscle Franken Muscle (frankenmuscle) — atribui múltiplas sub-regiões `muscle_id` dentro de uma única geometria muscular, para que uma malha sólida se comporte como vários músculos independentes.	`muscle` (+10 opcionais)
`franken_muscle_paint`	Muscle Franken Muscle Paint (frankenmusclepaint) — o front-end de pintura para máscaras `muscle_id` em uma geometria muscular (entrada 0).	`muscle` (+20 opcionais)
`muscle_id`	Muscle Muscle ID (muscleid) — atribui um atributo de nome `muscle_id` por primitiva a cada aglomerado de superfície conectado, para que os SOPs musculares downstream enderecem os músculos individualmente.	`surface` (+8 opcionais)
`muscle_solidify`	Muscle Muscle Solidify (musclesolidify) — tetraedraliza uma SUPERFÍCIE muscular em um músculo sólido (carrega `muscle_id` + `maxthickness`) pronto para propriedades + simulação.	`surface` (+14 opcionais)
`muscle_properties`	Muscle Muscle Properties (muscleproperties) — cria propriedades de material sólido por músculo (forma/volume/amortecimento/massa/rigidez de fibra/tendão) e calcula o quadro de direção de fibras `materialW` em um músculo sólido.	`muscle` (+19 opcionais)
`muscle_properties_otis`	Muscle Muscle Properties OTIS (musclepropertiesotis) — a variante do solver OTIS do Muscle Properties (propriedades de material sólido por músculo para a simulação de músculo e tecido OTIS).	`muscle` (+19 opcionais)
`muscle_constraint_properties_fem`	Muscle Muscle Constraint Properties FEM (muscleconstraintpropertiesfem) — cria as propriedades de RESTRIÇÃO por músculo (rigidez, amortecimento, distância de extremidade / músculo-a-músculo / músculo-a-osso) para o solver FEM de músculo.	`muscle` (+13 opcionais)
`muscle_constraint_properties_otis`	Muscle Muscle Constraint Properties OTIS (muscleconstraintpropertiesotis) — a variante do solver OTIS do nó de criação de propriedades de RESTRIÇÃO de músculo (extremidade / cola / rigidez músculo-a-músculo + amortecimento + distância).	`muscle` (+11 opcionais)
`muscle_constraint_properties_vellum`	Muscle Muscle Constraint Properties Vellum (muscleconstraintpropertiesvellum) — a variante do solver Vellum do nó de criação de propriedades de RESTRIÇÃO de músculo (extremidade / músculo-a-músculo / músculo-a-osso: rigidez, amortecimento, distância, compressão, taxa de deslizamento).	`muscle` (+15 opcionais)
`muscle_auto_tension_lines`	Muscle Auto Tension Lines (muscleautotensionlines) — gera automaticamente uma curva de linha de tensão ao longo do eixo maior de cada região `muscle_id` (os drivers que os deformadores musculares flexionam ao longo).	`muscle` (+5 opcionais)
`muscle_tension_lines`	Muscle Tension Lines (muscletensionlines) — o nó de criação de linhas de tensão: seleciona/edita as linhas de tensão usadas para flexionar músculos, com suporte a simetria.	`muscle` (+8 opcionais)
`muscle_tension_lines_activate`	Muscle Tension Lines Activate (muscletensionlinesactivate) — ativa/anima linhas de tensão (ativação mín/máx por grupo, espelha ativação pelo corpo).	`tension_lines` (+11 opcionais)
`muscle_deform`	Muscle Muscle Deform (muscledeform::2.0) — o deformador muscular quase estático moderno: resolve o sólido muscular para seguir suas linhas de tensão com rigidez de fibra + tensão.	`muscle`, `tension_lines`, `tension_lines_anim` (+13 opcionais)
`muscle_flex`	Muscle Muscle Flex (muscleflex::2.0) — flexiona um músculo ao longo de suas linhas de tensão por mistura em escala de fibra (o abaulamento rápido, sem resolução).	`muscle` (+15 opcionais)
`muscle_preroll`	Muscle Muscle Preroll (musclepreroll) — prerola a deformação muscular a partir de uma pose de descanso em uma faixa de frames de espera + preroll, para a simulação assentar antes do início da cena.	`muscle` (+7 opcionais)
`muscle_merge`	Muscle Muscle Merge (musclemerge) — mescla até seis fluxos musculares em um único sistema muscular (mantém `muscle_id` distintos).	`muscle` (+6 opcionais)
`muscle_mirror`	Muscle Muscle Mirror (musclemirror) — espelha músculos de um lado do corpo para o outro, renomeando `muscle_id` por troca de prefixo.	`muscle` (+7 opcionais)
`muscle_deintersect`	Muscle Muscle Deintersect (muscledeintersect) — empurra músculos sobrepostos para que parem de se interpenetrar, até um deslocamento de espessura.	`muscle` (+4 opcionais)
`muscle_adjust_volume`	Muscle Muscle Adjust Volume (muscleadjustvolume) — aumenta/diminui o volume muscular ao longo da normal + tangente, com resolução opcional de colisão contra a pele.	`muscle` (+15 opcionais)
`muscle_slide_constraint`	Muscle Muscle Slide Constraint (muscleslideconstraint) — constrói restrições deslizantes que permitem que um músculo deslize sobre vizinhos / ossos enquanto resiste ao estiramento.	`muscle` (+12 opcionais)
`muscle_tpose`	Muscle Muscle T-Pose (muscletpose) — armazena/restaura a forma de descanso (T-pose) do músculo em um atributo nomeado, de modo que deformadores downstream tenham uma pose de referência estável.	`muscle` (+5 opcionais)
`otis_configure_muscle_tissue`	Muscle OTIS Configure Muscle and Tissue (otisconfiguremuscleandtissue) — monta a geometria de músculo + tecido e as restrições no payload que o solver OTIS consome (restrições músculo-extremidade / cola / tecido-a-osso, qualidade do tetraedro).	`muscle` (+19 opcionais)
`tissue_solidify`	Muscle Tissue Solidify (tissuesolidify::2.0) — constrói uma casca de tecido tetraedralizada (gordura/fáscia) de dada espessura sob uma superfície de pele/músculo.	`surface` (+16 opcionais)
`tissue_solidify_otis`	Muscle Tissue Solidify OTIS (tissuesolidifyotis) — a variante do solver OTIS: constrói o volume de tecido entre uma pele EXTERIOR e uma superfície interna encolhida.	`skin` (+14 opcionais)
`tissue_properties`	Muscle Tissue Properties (tissueproperties) — cria propriedades de material de tecido (superfície + sólido + rigidez/amortecimento/massa de deslizamento, escala de descanso) a partir de um preset ou de valores explícitos, opcionalmente mascarado.	`tissue` (+18 opcionais)
`tissue_properties_otis`	Muscle Tissue Properties OTIS (tissuepropertiesotis) — a variante do solver OTIS do Tissue Properties (rigidez/amortecimento/massa do sólido núcleo + casca, rigidez tecido-a-músculo / tecido-a-osso).	`tissue` (+20 opcionais)
`muscle_paint`	Muscle Muscle Paint (musclepaint) — o front-end de pintura para atributos / máscaras musculares em uma geometria muscular (entrada 0).	`muscle` (+18 opcionais)

VEX (safe-VEX validado)

Ferramenta	O que faz	Parâmetros-chave
`set_attrib_expr`	Executar um snippet VEX seguro em atributos de geometria via um wrangle que carrega um snippet de atributo safe-VEX VALIDADO — o único canal de código-texto na ponte.	`outputs`, `code` (+8 opcionais)

ML / inferência ONNX

Ferramenta	O que faz	Parâmetros-chave
`onnx_inference`	Executar um modelo de grafo de tensor ONNX confinado sobre atributos de pontos ou um campo de volume — super-res / denoising / segmentação aprendidos de nuvens e volumes.	`input`, `modelfile`, `input_name`, `input_type` (+8 opcionais)
`ml_regression`	Treinar inline + inferir uma regressão de atributos a partir de uma entrada de Exemplos Rotulados — previsão aprendida de máscara/rótulo/valor em nuvens de pontos e heightfields.	`input`, `examples`, `method` (+6 opcionais)
`pca`	Análise de Componentes Principais sobre atributos de pontos/volume — compressão de características, análise de espaço de formas e o front-end de pré-processamento para ml_regression.	`input` (+6 opcionais)
`ml_volume_upres`	Super-resolução volumétrica aprendida — simula grosso, aumenta detalhe (lane de conteúdo pyro/fluido). modelfile é um .onnx confinado; configurado mas NÃO cozido aqui (resolve no cook downstream com um arquivo com hash fixado).	`input`, `modelfile` (+5 opcionais)
`acquire_model`	Baixar um modelo ONNX para as ferramentas ML a partir da allowlist de hosts HuggingFace para /models/, verificado contra um sha256 fixado.	`repo`, `file`, `sha256` (+2 opcionais)
`ml_example`	Emparelhar um Componente de Entrada (entrada 0) com um Componente de Destino (entrada 1, obrigatória) em um único EXEMPLO de treinamento supervisionado (ml_example) — o átomo de um dataset de ML (features -> targets).	`input`, `target` (+5 opcionais)
`ml_extract_example`	Extrair um único exemplo de treinamento (por índice) de um stream de Exemplos (ml_extractexample) — inspecionar/pré-visualizar uma amostra.	`input` (+3 opcionais)
`ml_attrib_generate`	Sintetizar valores de atributos aleatórios em um protótipo (ml_attribgenerate) — aumentar dados de um conjunto de treinamento com entradas aleatórias controladas.	`input` (+6 opcionais)
`ml_pose_generate`	Amostrar poses de esqueleto aleatórias a partir de um Protótipo de Pose (ml_posegenerate) — o gerador de dados de treinamento para deformadores de espaço-de-pose / ML.	`input` (+4 opcionais)
`ml_pose_serialize`	Achatar uma pose de esqueleto em um ATRIBUTO de ponto serial (ml_poseserialize) — transformar uma pose de rig no vetor de características de comprimento fixo que um modelo ML consome.	`input` (+9 opcionais)
`ml_example_partition`	Dividir um stream de Exemplos em partes não maiores que max_part_size (ml_examplepartition) — agrupar um grande conjunto de treinamento em blocos gerenciáveis.	`input` (+2 opcionais)
`ml_deform`	SOMENTE WIRE: construir o deformador de personagem aprendido (ml_deform) — aplicar um modelo TREINADO para deformar uma pele, dirigido por uma pose de esqueleto.	`input`, `modelfile` (+7 opcionais)

Copernicus / COP

Ferramenta	O que faz	Parâmetros-chave
`cop_constant`	Gerador COP: uma camada de imagem de valor constante (Constant).	4 opcionais
`cop_fractal_noise`	Gerador COP: ruído fractal (Fractal Noise) — a fonte principal de textura procedural. noise_type, métrica de distância, amplitude, tamanho do elemento, oitavas, lacunaridade, rugosidade, contraste.	9 opcionais
`cop_ramp`	Gerador COP: um gradiente linear/radial (Ramp). ramp_type, número de ciclos, fase e o método de faixa externa.	5 opcionais
`cop_remap`	Filtro COP: remapear a faixa de valores de uma camada (Remap). op=remap mapeia input_min/max -> output_min/max com um método de faixa externa; op=threshold usa threshold+width+side.	`input` (+10 opcionais)
`cop_invert`	Filtro COP: inverter uma camada (Invert). method: complement (1-x), negate (-x) ou reciprocal (1/x).	`input` (+2 opcionais)
`cop_equalize`	Filtro COP: normalizar o contraste esticando/deslocando a faixa de uma camada (Equalize). mode, fit_method, tipo de luminância, pontos preto/branco, média alvo.	`input` (+7 opcionais)
`cop_blend`	Filtro COP: compor duas camadas (Blend).	`input`, `fg` (+3 opcionais)
`cop_bright`	Filtro COP: ajuste de brilho/nível (Bright). brightness multiplica, shift soma.	`input` (+3 opcionais)
`cop_hsv`	Filtro COP: ajuste de matiz/saturação/valor ou conversão RGB<->HSV (HSV Adjust). op, hue_shift, sat_scale, sat_shift, val_scale, val_shift.	`input` (+7 opcionais)
`cop_glow`	Filtro COP: bloom/brilho de áreas claras (Glow). threshold, ganho de brilho, tamanho do desfoque, filter (box/gaussian), units (image/pixels).	`input` (+7 opcionais)
`cop_quantize`	Filtro COP: posterizar uma camada em etapas discretas (Quantize). method (width/segments), contagem de segmentos ou largura, arredondamento.	`input` (+5 opcionais)
`cop_blur`	Filtro COP: desfocar uma camada (Blur). size (radius), filter (box/gaussian), units (image/pixels).	`input` (+5 opcionais)
`cop_sdf_shape`	Gerador COP: uma forma 2D de campo de distância assinada (SDF Shape) — círculo, retângulo, estrela, triângulo, squircle e dezenas de outras. shape_class escolhe a família; `shape` é o nome da forma; scale dimensiona; translate + rotate posicionam.	6 opcionais
`cop_sdf_blend`	Filtro COP: combinar duas camadas SDF (SDF Blend).	`input`, `b` (+6 opcionais)
`cop_sdf_to_mono`	Filtro COP: rasterizar um SDF em uma camada mono (SDF To Mono) — valor de preenchimento, valor de fundo, contorno opcional (largura + dentro/fora/centro), antialiasing.	`input` (+7 opcionais)
`cop_sdf_to_rgb`	Filtro COP: rasterizar um SDF em uma camada de cor (SDF To RGB) — contorno opcional (largura + dentro/fora/centro), antialiasing, deslocamento iso.	`input` (+6 opcionais)
`cop_sdf_adjust`	Filtro COP: ajustar um SDF (SDF Adjust) — iso_offset dilata/erode o campo, onion cria uma casca oca, abs torna unilateral, invert troca dentro/fora.	`input` (+5 opcionais)
`cop_id_to_sdf`	Filtro COP: construir um SDF a partir de uma camada de ID/rótulo (ID To SDF) — distância até o limite de ID mais próximo. invert inverte o sinal, iterations controla a propagação, tile_size o tamanho do bloco.	`input` (+4 opcionais)
`cop_median`	Filtro COP: filtro de mediana (Median) — remove ruído sal-e-pimenta / speckle mantendo bordas. size = três ou cinco pixels; mask mistura o resultado.	`input` (+3 opcionais)
`cop_streak_blur`	Filtro COP: desfoque direcional/de movimento ao longo de uma linha (Streak Blur). dir_type (angle/coord), angle, length, units, mode (combinação on/min/max).	`input` (+8 opcionais)
`cop_kuwahara`	Filtro COP: filtro de Kuwahara (Kuwahara Filter) — suavização pictórica com preservação de bordas. radius (tamanho da região, pixels), tipo de luminância, blend, separation.	`input` (+6 opcionais)
`cop_compare`	Filtro COP: comparar uma camada com um valor ou uma segunda camada, gerando uma máscara 0/1 (Compare).	`input` (+7 opcionais)
`cop_edge_detect`	Filtro COP: detecção de bordas (Edge Detect). preblur suaviza antes da detecção, normalize escala a saída, thresholds baixo/alto limitam bordas fracas/fortes; method + mode são seletores inteiros.	`input` (+7 opcionais)
`cop_sharpen`	Filtro COP: nitidez (Sharpen) — amplifica detalhes via máscara de nitidez. amplitude, gain, threshold, size, units (image/pixels).	`input` (+6 opcionais)
`cop_tile_pattern`	Gerador COP: um padrão de tijolo/azulejo (Tile Pattern) — stackbond, espinha de peixe, trançado, flemishbond e outros layouts de alvenaria. pattern escolhe o layout; mode (seamless/tilecount/tilesize); tiled_size a escala.	4 opcionais
`cop_sequence_blend`	Filtro COP: misturar através de uma sequência temporal (Sequence Blend) — rastro de movimento / média de quadros. blend = quantidade de mistura, invert inverte.	`input` (+3 opcionais)
`cop_wipe`	Filtro COP: transição/corte entre duas camadas (Wipe).	`input`, `b` (+6 opcionais)
`cop_chromatic_aberration`	Filtro COP: aberração cromática de lente (Chromatic Aberration) — escala/rotação por canal para franjar R/G/B. r_scale/g_scale/b_scale, overall_scale, r_angle/g_angle/b_angle, filter.	`input` (+9 opcionais)
`cop_convolve`	Filtro COP: kernel de convolução 3x3 (Convolve) — nitidez/ relevo/ borda/ personalizado.	`input` (+7 opcionais)
`cop_distort`	Filtro COP: distorcer uma camada (Distort) — empurra pixels ao longo de um ângulo (uniforme) ou por uma camada de vetor de distorção conectada como `distortion` (entrada 1). angle, scale, dir_type, filter, border.	`input` (+7 opcionais)
`cop_derivative`	Filtro COP: gradiente de imagem / inclinação (Derivative) — taxa de variação da camada, para normais / bordas / relevo. angle, scale, offset, difference_mode (central/forward/diagonal).	`input` (+5 opcionais)
`cop_segment_connectivity`	Filtro COP: rotular regiões conectadas com IDs únicos (Segment By Connectivity) — front end para id_to_sdf / operações por região. connectivity (below/above/at/levels vs threshold), threshold, offset, collapse.	`input` (+5 opcionais)
`cop_segment_value`	Filtro COP: quantizar uma camada em faixas de valores rotuladas (Segment By Value) — method (width ou segments), largura ou contagem de segmentos, faixa min/max.	`input` (+6 opcionais)
`cop_smooth_fill`	Filtro COP: preencher/estender regiões suavemente (Smooth Fill) — difunde valores de origem na fill_area (inpaint / estender limites).	`input`, `fill_area` (+4 opcionais)
`cop_fill`	Filtro COP: preenchimento por inundação de uma camada (Fill) — substituir por um valor/amostra. source (value/sample/first/last), color (valor de preenchimento), id.	`input` (+4 opcionais)
`cop_feather`	Filtro COP: suavizar bordas de máscara (Feather) — direction (diamond/square/oct/circle), decay_mode (unitdist/decay), decay, unit_distance; outside suaviza para fora.	`input` (+6 opcionais)
`cop_light`	Filtro COP: sombrear uma camada com uma camada de normais (Light).	`input`, `normals` (+4 opcionais)
`cop_bokeh`	Filtro COP: desfoque bokeh / profundidade de campo (Bokeh) — radius, gain (realce de brilho), resolução, kernel de filtro, normalize.	`input` (+6 opcionais)
`cop_dilate_erode`	Filtro COP: dilatação/erosão morfológica (Dilate Erode) — raio positivo expande áreas claras, negativo encolhe; soft_edge suaviza; fill fecha buracos.	`input` (+5 opcionais)
`cop_channel_extract`	Filtro COP: extrair um único canal em uma camada mono (Channel Extract). channel = índice (0=R,1=G,2=B,3=A).	`input` (+2 opcionais)
`cop_channel_swap`	Filtro COP: embaralhar canais (Channel Swap) — define cada canal de saída para qualquer canal de origem ou zero/um.	`input` (+5 opcionais)
`cop_mono_to_rgb`	Filtro COP: mapear uma camada mono para RGB via uma faixa de valores (Mono To RGB). input_min/max -> output_min/max, method (clamp/repeat).	`input` (+6 opcionais)
`cop_mono_to_rgba`	Filtro COP: promover uma camada para RGBA (Mono To RGBA) — alpha_mode extend (copiar valor) ou value (alpha_value constante).	`input` (+3 opcionais)
`cop_premult`	Filtro COP: pré-multiplicar / desfazer pré-multiplicação de alfa (Premult). op = mult (pré-multiplicar) ou divide (desfazer pré-multiplicação).	`input` (+2 opcionais)
`cop_crop`	Filtro COP: cortar uma camada (Crop). crop_min/crop_max = os cantos [x,y] (unidades de imagem 0..1); mode (data/both/display), tratamento de borda.	`input` (+5 opcionais)
`cop_tonemap`	Filtro COP: mapeamento de tom de HDR para faixa de exibição (Tonemap). operator = índice 0..5 (curvas estilo Reinhard / Hable / ACES), exposure ajusta pré-ganho.	`input` (+3 opcionais)
`cop_contrast`	Filtro COP: ajuste de contraste (Contrast) — força de contraste em torno de um pivô central.	`input` (+3 opcionais)
`cop_gamma`	Filtro COP: correção gama (Gamma) — valor gama, invert opcional.	`input` (+3 opcionais)
`cop_transform`	Filtro COP: transformar uma camada em 2D/3D (Transform). translate/rotate/scale_xyz/shear/pivot (cada [x,y,z]), escala uniforme, ordem de transformação+rotação, invert, tratamento de borda e filtro de reconstrução.	`input` (+12 opcionais)
`cop_color_correct`	Filtro COP: grade de cor de faixa tonal (Color Correct).	`input` (+10 opcionais)
`cop_checkerboard`	Gerador COP: padrão de teste xadrez (Checkerboard). divisões rows/cols, cores de peças pares/ímpares [r,g,b], translate/tile_size/bias ([x,y]).	8 opcionais
`cop_clamp`	Filtro COP: limitar valores a um limite inferior/superior (Clamp).	`input` (+5 opcionais)
`cop_channel_join`	Combinador COP: fundir camadas mono separadas em uma camada RGB/RGBA (Channel Join).	`inputs` (+3 opcionais)
`cop_chroma_key`	Filtro COP: keyer de tela verde/azul por faixa HSV (Chroma Key) -> máscara. hue_circle [4] (centro+largura de matiz/sat), lum_range [min,max], rolloffs suaves de hue/sat/lum, interpolação (função de rolloff 0..4), preview + preview_color [r,g,b], premult (multiplicar entrada pela máscara).	`input` (+10 opcionais)
`cop_histogram`	Filtro COP: renderizar um histograma de valores da entrada como imagem (Histogram). mode (colorbar/separatebar/graph), buckets, faixa min/max, outside (discard/clamp), scale; set_res + res [w,h] para substituir a resolução de saída.	`input` (+9 opcionais)
`cop_vignette`	Filtro COP: escurecer/clarear em direção à borda do quadro (Vignette). shape (round/rectangle/blend), brightness, circle_radius/circle_scale [x,y], quantidade de blend, rect_size [x,y]/rect_roundness, center [x,y], blur, mask.	`input` (+11 opcionais)
`cop_height_to_normal`	Filtro COP: derivar uma camada de normais de uma camada de altura mono (Height to Normal) — alimenta cop_light `normals` para sombreamento de relevo. normal_type (signed/offset), scale (ganho de altura), read_outside, kernel (distância de derivada).	`input` (+5 opcionais)
`cop_mirror`	Filtro COP: espelhar/caleidoscopar uma camada através de um ou mais planos (Mirror). mode 0 = planos personalizados (angle0/offset0/flip0), 1 = número-e-deslocamento (num_planes + angle/offset); flip reflexão.	`input` (+9 opcionais)
`cop_average`	Combinador COP: combinar muitas camadas de entrada com uma operação (Average). operation (add/average/multiply/min/max/over), `inputs` = caminhos de nós COP conectados 0..n, signature = tipo de camada de saída.	`inputs` (+3 opcionais)
`cop_worley_noise`	Gerador COP: ruído celular/Worley (Voronoi) (Worley Noise) — complementa cop_fractal_noise. element_size (tamanho da célula), jitter, lattice (grid/hex), metric, offset [x,y], tiled + tile_size [x,y]; pós bias/gain/contrast (auto-habilitado), complement.	12 opcionais
`cop_julia`	Gerador COP: fractal do conjunto de Julia (Julia). real/imag = a constante de Julia; escape_radius + max_iter controlam o teste de escape; scale [x,y].	7 opcionais
`cop_chladni`	Gerador COP: padrão nodal de onda estacionária de Chladni / cimática (Chladni). output (lines/abs/sdf), threshold+width (modo de linha nodal), amp/amp_ratio, freq/freq_ratio, tile_size [x,y].	9 opcionais
`cop_bubble_noise`	Gerador COP: ruído fractal de bolhas/celular (Bubble Noise). amp/center, element_size, phase [4], offset [x,y], tile_size [x,y], max_octaves, lacunarity, roughness, distort, stretch [x,y], fold; post bias (ativado automaticamente).	14 opcionais
`cop_crystal_noise`	Gerador COP: ruído cristalino facetado derivado de Worley (Crystal Noise). amp/center/contrast, metric, jitter, element_size, secondary + metric2, flatten_faces, tiled + tile_size [x,y], use_3d.	14 opcionais
`cop_phasor_noise`	Gerador COP: campo procedural de ondas e ruído fasor/Gabor (Phasor Noise). type (phasorwave/phasornoise/gabornoise/intensityfield), wave_type (sine/rectangle/saw), amp/center, element, wave_bias, blend, offset [x,y], seed, kernels, rotation (uniform/varying), use_3d.	14 opcionais
`cop_height_to_ao`	Filtro COP (relevo de terreno): bake de oclusão ambiente a partir de uma camada de altura mono (Height to Ambient Occlusion). height_scale, view_radius (distância do raio), step_scale, ray_count, hemisphere.	`input` (+6 opcionais)
`cop_height_to_shadow`	Filtro COP (relevo de terreno): mapa de sombra projetada a partir de uma camada de altura mono + perfil de luz (Height to Shadow). light_type (disk/sphere/directional), coord_mode (spherical/cartesian), azimuth/altitude/distance (spherical) ou position [x,y,z] (cartesian), radius, height_scale, view_radius, step_scale.	`input` (+11 opcionais)
`cop_curvature`	Filtro COP (relevo de terreno): curvatura de superfície a partir de uma camada de normal/altura (Curvature). method (index 0/1), curvature_type (gaussian/mean/principal_max/principal_min), output_type (index 0/1/2), normal_type (signed/offset), prescale/postscale, kernel, read_outside, normalize + clamp min/max.	`input` (+13 opcionais)
`cop_slope_dir`	Filtro COP (relevo de terreno): campo de direção de inclinação (aspecto) a partir de uma camada de altura mono (Slope Direction). angle (pós-rotação), scale (ajuste de escala de altura), read_outside, kernel.	`input` (+5 opcionais)
`cop_resample`	Filtro COP: redimensionar/reamostrar uma camada (Resample). size_control (res/aspect/pixel), base_size (parm/input), resolution [w,h], aspect [x,y] + aspect_preset, pixel_size, scale, fixed_side, filter (reconstrução), modo de estiramento, reframe.	`input` (+12 opcionais)
`cop_mono`	Filtro COP: combinar canais em uma única camada mono/luminância (Mono). op (lum/ntsclum/hdtvlum/average/max/min/magnitude/hue/saturation/value/red/green/blue/comp4/custom); fornecer `weight` [4] define op=custom + pesos por canal; normalize_weight.	`input` (+4 opcionais)
`cop_hextile`	Filtro COP: tiling de textura hexagonal sem emendas (Hex Tile).	11 opcionais
`cop_convert_normal`	Filtro COP: converter uma camada de mapa de normais entre codificações (Convert Normal). conversion (tosigned -1..1 / tooffset 0..1), normalize, offset [x,y,z], scale [x,y,z].	`input` (+5 opcionais)
`cop_combine_normals`	Combinador COP: sobrepor/misturar dois mapas de normais em espaço tangente (Combine Normals).	`input`, `fg` (+4 opcionais)
`cop_edge_detect_normal`	Filtro COP: bordas de tinta/contorno a partir de descontinuidades angulares de uma camada de normais (Edge Detect Normal). tolerance, thickness_scale, weight_spread, blur, min_probe_radius.	`input` (+6 opcionais)
`cop_edge_detect_depth`	Filtro COP: bordas de vinco/oclusão a partir de degraus de profundidade Z (Edge Detect Depth). tolerance, thickness_scale, weight_spread, blur, min_probe_radius.	`input` (+6 opcionais)
`cop_edge_detect_contour`	Filtro COP: bordas de silhueta/contorno a partir de descontinuidades de valor (Edge Detect Contour). tolerance, thickness_scale, weight_spread, blur, min_probe_radius.	`input` (+6 opcionais)
`cop_swirl`	Filtro COP: deformação espiral + abaulamento de lente (Swirl).	`input` (+14 opcionais)
`cop_pixelate`	Filtro COP: mosaico / quantização em blocos de uma camada (Pixelate). mode (index 0/1), units (image/pixels), block_size ou num_blocks [x,y], offset [x,y], mask; preblur + preblur_size.	`input` (+9 opcionais)
`cop_defocus`	Filtro COP: desfoque de câmera fisicamente parametrizado + bokeh (Defocus).	`input`, `depth` (+12 opcionais)
`cop_flip`	Filtro COP: espelhar uma camada (Flip). horizontal (xflip), vertical (yflip), diagonal (flop), mask.	`input` (+5 opcionais)
`cop_polar_to_uv`	Gerador COP: converter coordenadas polares (ângulo, comprimento) em uma camada UV (Polar to UV). angle_unit (rad/deg/tau), angle, length.	4 opcionais
`cop_random_mono`	Gerador COP: campo mono aleatório (Random Mono). range_method (minmax/ramp/specific), min/max, per_pixel, seed, time.	7 opcionais
`cop_random_rgb`	Gerador COP: campo de cor aleatório (Random RGB). range_method (minmax/ramp/specific), color_model (rgb/hsv), base_color [r,g,b] (ativa cor base), faixas aleatórias por canal rand_r/g/b ou rand_hue/sat/val (cada [min,max]), per_pixel, seed.	12 opcionais
`cop_triplanar`	Filtro COP: projeção triplanar em espaço mundial de uma textura (Triplanar).	`texture`, `position`, `normal` (+15 opcionais)
`cop_triplanar_uv`	Filtro COP: coordenadas UV triplanares a partir de um passe de posição mundial + normal (Triplanar UV).	`position`, `normal` (+2 opcionais)
`cop_triplanar_hextile`	Filtro COP: projeção triplanar com randomização hex-tile por célula (Triplanar Hex Tile).	`input` (+11 opcionais)
`cop_uv_map`	Gerador COP: gerar uma camada UV (UV Map). uv_space (texture/image/pixel), u_border/v_border (clamp/mirror/wrap/extend), u_shift/u_cycle, v_shift/v_cycle.	8 opcionais
`cop_pos_map`	Gerador COP: gerar uma camada de posição mundial (Position Map). source (pos/origin/view), borda por eixo x/y/z (clamp/mirror/wrap/extend), deslocamento x/y/z + cycle, signature (mono/vec3/...).	12 opcionais
`cop_corner_pin`	Filtro COP: distorção de canto em perspectiva (Corner Pin).	`input` (+6 opcionais)
`cop_lens_distort`	Filtro COP: distorção/desdistorção de lente radial + tangencial (Lens Distort). k1..k6 = coeficientes radiais, p1/p2 = tangenciais, center [x,y], scale [x,y], aspect, mask.	`input` (+13 opcionais)
`cop_uv_to_polar`	Filtro COP: converter uma camada UV em coordenadas polares (ângulo, comprimento) (UV to Polar) -- inverso de cop_polar_to_uv. angle_unit (rad/deg/tau).	`input` (+2 opcionais)
`cop_fractal_noise_3d`	Gerador COP: ruído fractal em espaço mundial (amostrado em 3D) (Fractal Noise 3D). noise_type (simplex/perlin/worleyA/worleyB/white/alligator), metric, amp/center/contrast, element_size, octaves, lacunarity, roughness, jitter, offset [x,y,z]; post bias/gain (ativado automaticamente), complement.	16 opcionais
`cop_worley_noise_3d`	Gerador COP: ruído celular/Worley em espaço mundial (Worley Noise 3D). element_size/element_scale, jitter/jitter_scale, metric, offset [x,y,z]; post bias/gain (ativado automaticamente), complement.	11 opcionais
`cop_crystal_noise_3d`	Gerador COP: ruído Worley cristalino facetado em espaço mundial (Crystal Noise 3D). metric, amp/center/contrast, jitter, element_size, secondary + metric2, flatten_faces, offset [x,y,z], signature.	12 opcionais
`cop_cloud_noise_3d`	Gerador COP: ruído de nuvens volumosas em espaço mundial (Cloud Noise 3D). amp/center, element_size, offset [x,y,z], max_octaves, lacunarity, roughness, distort, stretch [x,y,z], droop (ativa automaticamente), fold, signature; post bias (ativado automaticamente).	14 opcionais
`cop_xform_2d`	Filtro COP: transformação de imagem 2D (Transform 2D). translate [x,y], rotate, scale_xy [x,y] + escala uniforme, shear, pivot [x,y]; xform_order, border, filter, invert.	`input` (+11 opcionais)
`cop_vector_xform`	Filtro COP: transformar os VALORES de vetor 3 em uma camada (Vector Transform) -- para camadas de normal/posição/velocidade. translate/rotate/scale_xyz/shear/pivot (cada [x,y,z]), escala uniforme, xform_order, rot_order, invert.	`input` (+10 opcionais)
`cop_vector_xform_2d`	Filtro COP: transformar os VALORES de vetor 2 em uma camada (Vector Transform 2D) -- para camadas UV/flow. translate [x,y], rotate, scale_xy [x,y] + escala uniforme, shear, pivot [x,y], xform_order, invert.	`input` (+9 opcionais)
`cop_space_transform`	Filtro COP: converter valores de camada entre espaços de coordenadas (Space Transform). vector_type (position/vector), src_space + dst_space (buffer/pixel/texture/image/world).	`input` (+4 opcionais)
`cop_bend`	Filtro COP: dobrar/distorcer uma camada (Bend).	`input` (+15 opcionais)
`cop_id_to_mask`	Filtro COP: construir uma máscara 0/1 a partir de IDs selecionados (ID to Mask).	`input` (+10 opcionais)
`cop_mono_to_sdf`	Filtro COP: converter uma camada mono em um campo de distância assinada em torno de um limiar iso (Mono to SDF). invert, iso, iterations, tile_size.	`input` (+5 opcionais)
`cop_denoise_tvd`	Filtro COP: remoção de ruído por difusão de variação total (Denoise TVD) -- matemática pura, NÃO é um modelo de IA. iterations, speed, mask.	`input` (+4 opcionais)
`cop_fill_connected`	Filtro COP: preencher por inundação uma região conectada a partir de uma semente dentro de uma tolerância (Fill Connected). seed_location [x,y], source_location [x,y], tolerance, source (value/sample/first/last), color [r,g,b,a], id.	`input` (+7 opcionais)
`cop_ill_pixel`	Filtro COP: detectar/corrigir/sinalizar pixels ilegais (Illegal Pixel). method (fixblend/fixzero/highlight/isolate), detect (d_nan/d_inf/both/custom), rule (less/lessequal/greater/greaterequal/equal), compare_value, highlight_color [r,g,b,a].	`input` (+6 opcionais)
`cop_bound_rect`	Filtro COP: máscara de retângulo delimitador em torno de pixels que passam em um limiar (Bound Rect). side (less/greater), threshold, fg/bg, units (image/texture/pixel).	`input` (+6 opcionais)
`cop_hyperbolic_tile`	Gerador COP: tiling de polígonos regulares hiperbólico (disco de Poincaré) (Hyperbolic Tiling). iterations, polygon (sides), mapping (conformal/elliptic grid/squircle/equalarea), flattening, size, tile_fitting, rectanglize/stretch_to_fit/disk_mask.	10 opcionais
`cop_convert_depth`	Filtro COP: converter uma camada entre codificações de profundidade / distância / altura (Convert Depth). source + dest (depth/dist/height), zero_depth.	`input` (+4 opcionais)
`cop_zcomp`	Compositor COP: composição de profundidade Z de duas camadas, a superfície mais próxima vence (Z Composite).	`input`, `fg` (+5 opcionais)
`cop_uv_map_by_id`	Filtro COP: mapa UV por ilha (ou center/min/max/size) a partir de uma camada de ID (UV Map by ID).	`input` (+11 opcionais)
`cop_project_on_layer`	Filtro COP: reprojetar uma camada de origem no espaço de uma camada de destino (Project on Layer).	`input`, `source` (+4 opcionais)
`cop_contact_sheet`	Combinador COP: organizar em grade várias camadas de entrada em uma montagem / folha de contato (Contact Sheet).	`inputs` (+8 opcionais)
`cop_copy_xform`	Filtro COP: carimbar N cópias transformadas de uma forma (Copy Transform).	`input` (+14 opcionais)
`cop_lattice_deform`	Filtro COP: distorcer uma camada através de uma grade de treliça 4x4 (Lattice Deform).	`input` (+6 opcionais)
`cop_surface_dither`	Filtro COP: padrão de meio-tom/dither estável em superfície -> máscara ou SDF (Surface Dither).	`input` (+10 opcionais)
`cop_sample`	Filtro COP: reamostrar uma textura através de um mapa UV (Sample).	`input`, `texture` (+4 opcionais)
`cop_prefix_sum`	Filtro COP: varredura direcional cumulativa na imagem (Prefix Sum). sweep_dir (px/mx/py/ny/xy/index), op (add/min/max/count), scale (none/pixel/texture/image).	`input` (+4 opcional)
`cop_statistics`	Filtro COP: calcula estatísticas por camada (min/max/avg/...) como atributos de camada (Statistics), legíveis por nós a jusante.	`input` (+1 opcional)
`cop_layer_properties`	Filtro COP: define metadados de precisão / borda / type-info de uma camada (Layer Properties). precision (b8/b16/b32), border (constant/clamp/mirror/wrap), type_info (color/position/normal/id/mask/sdf/height/...) — cada um ativa automaticamente seu setter.	`input` (+4 opcional)
`cop_rgb_to_rgba`	Filtro COP: combina uma camada RGB com uma camada alfa → RGBA (RGB to RGBA).	`input` (+3 opcional)
`cop_rgba_to_rgb`	Filtro COP: remove o canal alfa → RGB (RGBA to RGB). unpremult (unpremultiply first).	`input` (+2 opcional)
`cop_id_to_mono`	Filtro COP: converte uma camada de ID em uma camada mono float (ID to Mono). conversion (cast/safe/bitwise).	`input` (+2 opcional)
`cop_mono_to_id`	Filtro COP: converte uma camada mono em uma camada de ID (Mono to ID). conversion (cast/safe/bitwise).	`input` (+2 opcional)
`cop_id_to_rgb`	Filtro COP: atribui uma cor aleatória por ID (ID to RGB). seed.	`input` (+2 opcional)
`cop_rgb_to_uv`	Filtro COP: reinterpreta uma camada RGB como uma camada UV (vetor 2) (RGB to UV).	`input` (+1 opcional)
`cop_uv_to_rgb`	Filtro COP: reinterpreta uma camada UV como RGB (UV to RGB); a camada `mono` opcional → a entrada 1 fornece o canal azul.	`input` (+2 opcional)
`cop_rgba_to_uv`	Filtro COP: reinterpreta uma camada RGBA como uma camada UV (vetor 2) (RGBA to UV).	`input` (+1 opcional)
`cop_uv_to_rgba`	Filtro COP: combina duas camadas de vetor 2 em RGBA (UV to RGBA).	`input` (+2 opcional)
`cop_channel_split`	Filtro COP: divide uma camada multicanal em saídas de canal único (Channel Split) — o inverso de cop_channel_join.	`input` (+1 opcional)
`cop_layer_attrib_create`	Filtro COP: adiciona um atributo de metadados de camada (Layer Attribute Create). attr_name, attr_type (string/float/int), value (digitado de acordo).	`input` (+4 opcional)
`cop_layer_attrib_delete`	Filtro COP: exclui atributos de metadados de camada por glob de nome (Layer Attribute Delete). delete (glob a remover), keep (glob a preservar).	`input` (+3 opcional)
`cop_dot`	Filtro COP: produto escalar por pixel de duas camadas vetoriais → mono (Dot).	`input`, `b` (+1 opcional)
`cop_cross`	Filtro COP: produto vetorial por pixel de duas camadas vec3 (Cross).	`input`, `b` (+1 opcional)
`cop_pos_sample`	Filtro COP: amostra uma textura em coordenadas lidas de uma camada de posição (Position Sample).	`input`, `texture` (+1 opcional)
`cop_statistics_by_id`	Filtro COP: estatísticas por ID calculadas como atributos de camada (Statistics by ID).	`input`, `source` (+1 opcional)
`cop_match_udim`	Filtro COP: realoca uma imagem em um tile UDIM escolhido (Match UDIM). udim (número do tile, ativa set_udim), invert, method (eye/data).	`input` (+4 opcional)
`cop_autostereogram`	Filtro COP: constrói um autostereograma Magic-Eye a partir de uma imagem de padrão + profundidade (Autostereogram).	`input`, `depth` (+5 opcional)
`cop_uv_xform`	Filtro COP: translada/rotaciona/escala uma camada UV (UV Transform). translate [x,y], rotate, scale_xy [x,y] + escala uniforme, pivot [x,y], seed.	`input` (+7 opcional)
`cop_layer`	Gerador COP: uma camada tipada em branco em resolução/precisão escolhida (Layer). signature (f1/f2/f3/f4/i), value (init mono), res [w,h], precision (b8/b16/b32), border (constant/clamp/mirror/wrap), type_info.	7 opcional
`cop_heat_distort`	Filtro COP: distorção de calor a partir de ruído interno (Heat Distort). global_scale, scale, element_size, detail_scale, roughness, cutoff, angle; alternâncias distort/detail_distort/streak_blur, mask.	`input` (+12 opcional)
`cop_heat_distort_by_layer`	Filtro COP: distorção de calor guiada por uma camada `noise` (Heat Distort by Layer).	`input`, `noise` (+9 opcional)
`cop_heightfield_visualize`	Filtro COP: escala/desloca uma camada heightfield recebida para visualização (Heightfield Visualize). height_scale, height_offset.	`input` (+3 opcional)
`cop_sop_import`	Gerador COP: conecta um SOP da cena ao copnet (SOP Import).	`sop` (+1 opcional)
`cop_rasterize_geo`	COP: rasteriza atributos de geometria em uma camada de imagem (Rasterize Geometry).	`geometry` (+6 opcional)
`cop_rasterize_setup`	COP: configura a câmera/espaço de rasterização que precede Rasterize Geometry (Rasterize Setup).	`geometry` (+7 opcional)
`cop_rasterize_curves`	COP: rasteriza geometria de curvas como traços em uma camada (Rasterize Curves).	`curves` (+10 opcional)
`cop_layer_to_geo`	COP: converte uma camada COP de volta em geometria SOP (Layer to Geometry) — uma primitiva volume/VDB.	`input` (+3 opcional)
`cop_layer_to_points`	COP: emite pontos SOP de uma camada COP (Layer to Points).	`input` (+6 opcional)
`cop_layer_from_curves`	COP: traços coloridos/perfilados de geometria de curvas em uma camada (Layer from Curves).	`curves` (+7 opcional)
`cop_mask_from_curves`	COP: máscara ou SDF de geometria de curvas (Mask from Curves).	`curves` (+7 opcional)
`cop_geo_to_layer`	COP: lê uma primitiva/VDB nomeada da geometria em uma camada tipada (Geometry to Layer).	`geometry` (+3 opcional)
`cop_vdb_posmap`	COP: mapa de posição de voxel VDB (VDB Pos Map).	`input` (+3 opcional)
`cop_layer_from_vdb`	COP: converte uma camada FloatVDB em uma camada COP amostrada (Layer from VDB).	`input` (+2 opcional)
`cop_vdb_from_layer`	COP: converte uma camada COP em um VDB, dimensionado para um VDB de referência (VDB from Layer).	`input`, `reference_vdb` (+2 opcional)
`cop_rasterize_volume`	COP: ray-march de uma camada VDB de densidade em uma imagem (Rasterize Volume).	`input` (+8 opcional)
`cop_integrate_volume`	COP: integra por raios uma camada de volume para mono (Integrate Volume) — depth / thickness.	`input` (+6 opcional)
`cop_pyro_configure`	COP pyro: define a grade de voxels da simulação (Pyro Configure).	8 opcional
`cop_pyro_source_from_layer`	COP pyro: emite em um campo a partir de uma camada de origem (Pyro Source from Layer).	`input`, `density` (+12 opcional)
`cop_pyro_source_from_points`	COP pyro: emite em um campo a partir de uma origem de pontos (Pyro Source from Points).	`input`, `points` (+8 opcional)
`cop_pyro_advect`	COP pyro: advecta um campo por uma velocidade VectorVDB (Pyro Advect).	`input`, `velocity` (+12 opcional)
`cop_pyro_buoyancy`	COP pyro: adiciona força de flutuabilidade impulsionada por temperatura à velocidade (Pyro Buoyancy).	`input`, `temperature` (+13 opcional)
`cop_pyro_dissipate`	COP pyro: dissipa um campo ao longo do tempo (Pyro Dissipate).	`input` (+17 opcional)
`cop_pyro_disturbance`	COP pyro: adiciona detalhe de perturbação à velocidade (Pyro Disturbance).	`input` (+12 opcional)
`cop_pyro_turbulence`	COP pyro: adiciona detalhe de turbulência / ruído-curl à velocidade (Pyro Turbulence).	`input` (+15 opcional)
`cop_pyro_uniform_force`	COP pyro: aplica força direcional uniforme / arrasto à velocidade (Pyro Uniform Force).	`input` (+13 opcional)
`cop_pyro_activate`	COP pyro: expande / ativa a região de voxels ativos da simulação (Pyro Activate).	`input` (+12 opcional)
`cop_pyro_advect_by_map`	COP pyro: advecta um campo por um mapa de advecção direto/reverso pré-computado (Pyro Advect by Map).	`input`, `fwd_map` (+5 opcional)
`cop_pyro_build_advection_map`	COP pyro: constrói um mapa de advecção direto/reverso a partir de um campo de velocidade (Pyro Build Advection Map).	`input` (+7 opcional)
`cop_pyro_axis_force`	COP pyro: força de vórtice / eixo / órbita em torno de um eixo (Pyro Axis Force).	`input` (+17 opcional)
`cop_pyro_light_ambient`	COP pyro: contribuição de luz ambiente / de ambiente em um campo de densidade (Pyro Light Ambient).	`input` (+14 opcional)
`cop_pyro_light_from_points`	COP pyro: espalhamento de luz pontual / direcional em um campo de densidade (Pyro Light from Points).	`input` (+14 opcional)
`cop_pyro_light_scatter`	COP pyro: luz de múltiplo espalhamento através de densidade + emissão (Pyro Light Scatter).	`input` (+8 opcional)
`cop_pyro_project_electrostatic`	COP pyro: torna um campo de velocidade não-divergente via projeção eletrostática (Pyro Project Non Divergent Electrostatic).	`input`, `reference` (+12 opcional)
`cop_pyro_packed_mipmap`	COP pyro: constrói um mipmap de densidade compactado (Pyro Packed Mipmap) — o acelerador que alimenta a entrada `mipmap` dos microsolvers de luz (cop_pyro_light_ambient / cop_pyro_light_from_points).	`input` (+3 opcional)
`cop_pyro_block_begin`	COP pyro: início do loop do bloco de realimentação pyro (Pyro Block Begin) — inicializa o estado de campo por iteração.	`input`, `velocity`, `temperature` (+11 opcional)
`cop_pyro_block_end`	COP pyro: fim do loop do bloco de realimentação pyro (Pyro Block End) — fecha o loop e contém os controles do loop.	`input`, `velocity`, `temperature`, `block_begin` (+14 opcional)
`cop_pyro_solver`	MACRO COP pyro (uma chamada): carimba um LOOP de solve de realimentação pyro nativo do COP mínimo — conecta automaticamente cop_pyro_block_begin (início do loop, inicializa densidade/v/temperatura por iteração) → um CORPO de pyro-advect mínimo (advecta a densidade do loop pela velocidade do loop) → cop_pyro_block_end (fecha o loop, contém os controles do loop), e define a ligação de caminho de bloco begin<->end.	`input`, `velocity`, `temperature` (+6 opcional)
`cop_vdb_leafpoints`	COP: emite pontos nos centros de leaf/voxel VDB (VDB Leaf Points).	`input` (+2 opcional)
`cop_layer_to_vdb_leafpoints`	COP: pontos de amostra de leaf VDB a partir de uma camada (Layer to VDB Leaf Points).	`input`, `thickness_layer` (+3 opcional)
`cop_vdb_activate_from_points`	COP: ativa regiões de voxel VDB a partir de posições de pontos (VDB Activate from Points).	`input`, `points` (+5 opcional)
`cop_vdb_reshape`	COP: conforma um VDB ao quadro de transform/topologia de um VDB de referência (VDB Reshape).	`input`, `reference` (+1 opcional)
`cop_stamp_point`	COP: carimba uma camada em posições de pontos (Stamp Point).	`points`, `stamps` (+17 opcional)
`cop_curve_scatter`	COP: espalha carimbos ao longo de curvas (Curve Scatter).	`curves`, `stamps` (+18 opcional)
`cop_shape_scatter`	COP: espalha carimbos por uma grade de imagem (Shape Scatter) — sem necessidade de geometria.	`stamps` (+18 opcional)
`cop_rasterize_layer`	COP: re-rasteriza / reprojeta uma camada existente (Rasterize Layer).	`input` (+5 opcional)
`cop_vdb_visualize`	COP: sombreia um VDB de densidade em uma imagem (VDB Visualize).	`input` (+10 opcional)
`cop_vdb_visualize_slice`	COP: visualização VDB de plano de corte (VDB Visualize Slice).	`input` (+9 opcional)
`cop_vdb_visualize_tree`	COP: visualização de árvore/topologia VDB (VDB Visualize Tree).	`input` (+8 opcional)
`cop_vdb_visualize_velocity`	COP: visualização de campo de velocidade VDB (VDB Visualize Velocity).	`input` (+9 opcional)
`cop_raytrace`	COP: ray-trace de geometria para mapas de AO / curvatura / espessura / cavidade / borda (Raytrace).	`geometry`, `origins`, `directions` (+16 opcional)
`cop_file`	COP generator: ler uma imagem do disco (File).	`filename` (+1 opcional)
`cop_rop_image`	COP output driver: escrever o fluxo COP de entrada em uma imagem no disco (ROP Image Output).	`input`, `output` (+3 opcionais)
`cop_font`	COP: renderizar texto como uma imagem (Font).	4 opcionais
`cop_onnx`	COP: executar inferência de modelo ONNX em uma imagem (ONNX Inference).	`input` (+2 opcionais)
`cop_slapcomp_import`	COP: puxar o buffer de renderização slap-comp em memória (Slap Comp Import).	4 opcionais
`cop_cache`	COP: um cache em memória por quadro da camada de entrada (Cache).	`input` (+3 opcionais)
`cop_fetch`	COP generator: buscar a saída de outro nó COP por caminho (Fetch).	2 opcionais
`cop_camera_import`	COP generator: importar os parâmetros de uma câmera da cena (Camera Import).	2 opcionais
`cop_ocio_transform`	COP: aplicar uma transformação de espaço de cor OpenColorIO (OCIO Transform).	`input` (+5 opcionais)
`cop_live_video`	COP generator: capturar quadros de um dispositivo de vídeo/webcam ao vivo (Live Video).	3 opcionais
`cop_denoise_ai`	COP: remover ruído por IA da camada de entrada (Denoise AI).	`input` (+2 opcionais)
`cop_cryptomatte`	COP filter: extrair um matte de cobertura único de uma camada cryptomatte (Cryptomatte).	`input` (+3 opcionais)
`cop_cryptomatte_decode`	COP filter: decodificar uma camada cryptomatte empacotada em pares de id/cobertura/rank (Cryptomatte Decode).	`input` (+1 opcional)
`cop_cryptomatte_encode`	COP filter: codificar pares de id/cobertura/rank em uma camada cryptomatte empacotada (Cryptomatte Encode).	`input`, `cov_a`, `id_b`, `cov_b` (+1 opcional)
`cop_grunge_aurora`	COP generator: padrão de intemperismo aurora/véu listrado (Grunge Aurora).	21 opcionais
`cop_grunge_birchbark`	COP generator: padrão de material de casca de bétula (Grunge Birch Bark).	24 opcionais
`cop_grunge_layered_noise`	COP generator: ruído composto em 4 camadas (Grunge Layered Noise) -- ruído base + células base + ruído secundário + células secundárias.	29 opcionais
`cop_grunge_pinebark`	COP generator: padrão de material de casca de pinheiro (Grunge Pine Bark).	21 opcionais
`cop_grunge_rust`	COP generator: padrão de ferrugem/corrosão (Grunge Rust).	22 opcionais
`cop_cable_merge`	COP: combinar dois cabos Copernicus (Cable Merge) -- `input` = input_cable (entrada 0), `reference` = o segundo cabo (entrada 1). a operação (union/intersection/difference/copy/fullunion/rename) controla como os dois conjuntos de fios se combinam.	`input` (+3 opcionais)
`cop_cable_split`	COP: particionar os fios de um cabo Copernicus em dois cabos (Cable Split).	`input` (+16 opcionais)
`cop_cable_pack`	COP: montar fios nomeados em um cabo Copernicus (Cable Pack).	`input` (+2 opcionais)
`cop_cable_unpack`	COP: extrair fios nomeados de um cabo Copernicus (Cable Unpack).	`input` (+2 opcionais)
`cop_cable_filter`	COP: remover fios vazios de um cabo Copernicus (Cable Filter).	`input` (+1 opcional)
`cop_cable_sort`	COP: ordenar alfabeticamente os fios de um cabo por nome (Cable Sort).	`input` (+2 opcionais)
`cop_cable_switch`	COP: selecionar um de dois cabos (Cable Switch).	`input` (+3 opcionais)
`cop_cable_rename`	COP: renomear os fios de um cabo por substituição de padrão (Cable Rename).	`input` (+5 opcionais)

Ferramenta	O que faz	Parâmetros-chave
`sbs_archive`	SideFX Labs SBS Archive — um GERADOR Cop2 que lê um arquivo Substance `.sbsar` e gera sua textura renderizada no cop2net compartilhado /obj/cops2.	3 opcionais
`blackbody_texture`	SideFX Labs Blackbody (labs::blackbody_cop) — um gerador Cop2 que mapeia temperatura (Kelvin) para a cor de corpo negro emitida na imagem, de temperature_low a temperature_high, com controles de tonemap / gamma / adaptation / burn.	12 opcionais
`attribute_to_texture`	SideFX Labs Attribute Import (labs::attribute_import) — um gerador Cop2 que rasteriza um ATRIBUTO de ponto/vértice de geometria em uma textura sobre o layout UV da geometria.	6 opcionais
`grid_texture`	SideFX Labs Grid Texture (labs::grid_texture) — um gerador Cop2 que produz uma textura de referência de xadrez/grid UV com texto, bordas e cores opcionais por tile.	12 opcionais
`normal_color`	SideFX Labs Normal Color (labs::normal_color) — um gerador Cop2 que emite um campo de cor de mapa normal de espaço tangente plano (a normal 'up' padrão, RGB 0.5/0.5/1) na resolução escolhida; a camada base sobre a qual você compõe normais de detalhe.	2 opcionais
`normal_map`	SideFX Labs Normal Map (labs::normal_map) — um FILTRO Cop2 que converte uma imagem de altura/escala de cinza de entrada (entrada 0) em um mapa normal de espaço tangente.	`input` (+5 opcionais)
`normal_combine`	SideFX Labs Normal Combine (labs::normal_combine) — um FILTRO Cop2 que sobrepõe um mapa normal de detalhe (entrada 1) sobre um mapa normal base (entrada 0) com mistura de normais reorientadas corretamente.	`input`, `input2` (+1 opcional)
`normal_invert`	SideFX Labs Normal Invert (labs::normal_invert) — um FILTRO Cop2 que inverte eixos selecionados de um mapa normal de espaço tangente (entrada 0).	`input` (+4 opcionais)
`normal_levels`	SideFX Labs Normal Levels (labs::normal_levels) — um FILTRO Cop2 que aplica um remapeamento de níveis/gamma a um mapa normal (entrada 0).	`input` (+4 opcionais)
`normal_rotate`	SideFX Labs Normal Rotate (labs::normal_rotate) — um FILTRO Cop2 que rotaciona os vetores normais de espaço tangente de um mapa normal de entrada (entrada 0) em `angle` graus em torno da normal da superfície (mantém o mapa consistente quando a textura é rotacionada nos UVs).	`input` (+2 opcionais)
`normal_normalize`	SideFX Labs Normal Normalize (labs::normal_normalize) — um FILTRO Cop2 que renormaliza cada pixel de um mapa normal de entrada (entrada 0) de volta ao comprimento unitário (corrige normais não unitárias após mistura ou filtragem).	`input` (+1 opcional)
`vector_normalize`	SideFX Labs Vector Normalize (labs::vector_normalize) — um FILTRO Cop2 que redimensiona uma imagem vetorial de entrada (entrada 0) para um intervalo normalizado: `enable` ativa; `min`/`max` definem o intervalo alvo no qual as magnitudes dos vetores são ajustadas.	`input` (+4 opcionais)
`demosaic`	SideFX Labs Demosaic (labs::demosaic) — um FILTRO Cop2 que descompacta um atlas de sprites / folha de flipbook de linhas x colunas (entrada 0) em um quadro individual: `frame` seleciona o tile, `start_frame` desloca a numeração.	`input` (+5 opcionais)

Solaris / LOP / USD

Ferramenta	O que faz	Parâmetros-chave
`usd_layer`	Montagem de estágio USD / Solaris multi-ramo e composição de camadas (LOP). op=merge combina vários ramos LOP em um único estágio (`inputs` entrada com fio input0..N; mergestyle define o estilo de composição/achatamento de camadas, padrão flattenloplayers = Simple Merge). op=sublayer compõe arquivos externos .usd/.usda/.usdc como subcamadas (`files`, confinado a leitura; `input` = um LOP para camada sobre). op=graft encaixa uma subárvore de origem sob um prim de destino (`input`=Input Stage, `source`=o LOP para enxertar em input1, `primpath`=prim pai de destino, `src_prims`/`dst_prims`=caminhos de prim de origem e destino).	10 opcionais
`usd_configure`	Criar metadados de prim / asset USD (LOP configureprimitive) ou selecionar uma variante -- metadados puros, sem shader/VEX. op=configure define, nos prims que correspondem a `primpattern`: kind (assembly\|group\|component\|subcomponent, a hierarquia de asset), purpose (default\|proxy\|render\|guide), drawmode (default\|origin\|bounds\|cards -- proxy LOD nativo USD para que assets pesados sejam desenhados como bounds/cards no estágio de montagem e geometria completa na renderização), instanceable (bool), visibility (inherit\|invisible\|visible -- mostrar/ocultar um prim) e specifier (def\|over\|class). op=variant seleciona um conjunto/nome de variante (troca de LOD ou look).	12 opcionais
`sop_import`	Trazer a geometria de uma rede SOP para o estágio USD -- a ponte SOP->Solaris.	`soppath` (+6 opcionais)
`usd_import`	Compor um arquivo USD no estágio como referência / payload / subcamada.	`path` (+4 opcionais)
`usd_light`	Adicionar/modelar uma luz USD/Karma no estágio (light::2.0 ou domelight::3.0).	27 opcionais
`usd_camera`	Adicionar/modelar um prim de câmera no estágio USD (camera LOP).	20 opcionais
`karma_render_settings`	SOMENTE WIRE: construir o grafo de renderização Karma no LOP (prim render-settings + usdrender ROP).	14 opcionais
`render_geo_settings`	Criar configurações de renderização Karma POR-PRIM em um estágio USD (Render Geometry Settings LOP) — o cavalo de batalha da linha de entrega: visibilidade de raio primário (defina `visibility` para um glob de categoria Karma — exclua camera para um prim FANTASMA / somente reflexão), modo holdout/MATTE, desfoque de movimento + velocidade, interpretação de volume uniforme e qualidade de dicing.	`input` (+9 opcionais)
`karma_fog_box`	Adicionar um VOLUME DE NEBLINA atmosférico a um estágio USD (Karma Fog Box LOP) — neblina uniforme ou modulada por ruído dentro de um limite de caixa/esfera/etc., para bruma de horizonte / raios de deus / profundidade.	17 opcionais
`physical_sky`	Construir um céu + sol Karma baseado em física no estágio (karmaphysicalsky) -- o primivo de estudo solar de terreno/globo.	20 opcionais
`light_link`	Restringir qual geometria uma luz (des)ilumina via um LOP lightlinker -- apenas strings de padrão de prim, sem expressões.	`light`, `geo` (+4 opcionais)
`assign_usd_material`	SOMENTE WIRE: criar um material MaterialX Standard Surface e VINCULÁ-lo a prim_pattern no estágio USD — o caminho tipado para um quadro Karma TEXTURIZADO (materiallibrary + mtlxstandard_surface + assignmaterial; sem VEX, sem código).	`prim_pattern` (+24 opcionais)
`material_graph_create`	Criar um grafo de material MaterialX processual vazio — um materiallibrary LOP /stage que você preenche com shader_node_add / shader_connect / shader_set_param e vincula com material_graph_assign.	2 opcionais
`shader_node_add`	Adicionar UM nó MaterialX a um grafo de material (biblioteca de material_graph_create). node_type = um tipo mtlx* na lista branca: mtlxstandard_surface (terminal de shader PBR), mtlximage/mtlxtriplanarprojection (textura), mtlxnoise3d/mtlxfractal3d/mtlxworleynoise3d (ruído), mtlxramplr/mtlxramp4 (rampa), mtlxgeompropvalue (LÊ um atributo de geometria/camada de terreno), mtlxmix/mtlxremap/mtlxmultiply/mtlxclamp (matemática), mtlxnormalmap/mtlxdisplacement (normal/deslocamento). signature define o tipo de dados do nó.	`library`, `node_type` (+2 opcionais)
`shader_connect`	Conectar a saída de um nó MaterialX à entrada de outro (construir uma aresta do grafo). dst_input é o NOME da entrada (ex.: base_color, specular_roughness, normal, texcoord, in1) ou um índice numérico; src_output assume o padrão 'out' (a saída única de todo nó mtlx).	`dst`, `dst_input`, `src` (+1 opcional)
`shader_set_param`	Definir um literal TIPADO em um nó MaterialX — lidando automaticamente com a armadilha do sufixo de assinatura. param = o NOME base do parm (ex.: amplitude, valuel, valuer, geomprop, file, octaves, inlow, outhigh); value = um número, uma lista [r,g,b]/[x,y,z] ou uma string.	`node`, `param`, `value`
`material_graph_assign`	Vincular um grafo de material construído à geometria no estágio USD (materiallibrary + assignmaterial). shader = o nó TERMINAL (mtlxstandard_surface, ou um collect/mtlxsurfacematerial unindo surface+displacement); prim_pattern = o caminho/padrão de prim de geometria a vincular (obrigatório; defina is_pattern para um curinga).	`library`, `shader`, `prim_pattern` (+2 opcionais)
`material_ramp_on_attribute`	Receita HERO de uma chamada: direcionar um canal de shader de COR a partir de uma RAMPA em um ATRIBUTO DE GEOMETRIA — o idioma altura do terreno->cor.	10 opcionais
`material_noise_channel`	Receita de uma chamada: direcionar um canal de shader ESCALAR a partir de ruído processual.	12 opcionais
`usd_prim_cube`	Criar um prim USD Cube no estágio (cube LOP): tamanho + transformação.	12 opcionais
`usd_prim_cone`	Criar um prim USD Cone no estágio (cone LOP): eixo, altura, raio, transformação.	12 opcionais
`usd_prim_cylinder`	Criar um prim USD Cylinder no estágio (cylinder::2.0 LOP): eixo, altura, raios.	12 opcionais
`usd_prim_sphere`	Criar um prim USD Sphere no estágio (sphere LOP): raio + transformação.	12 opcionais
`usd_prim_capsule`	Criar um prim USD Capsule no estágio (capsule::2.0 LOP): eixo, altura, raios.	12 opcionais
`usd_prim_mesh`	Criar um prim USD Mesh vazio + metadados de subdivisão (mesh LOP).	12 opcionais
`usd_prim_points`	Criar um prim USD Points no estágio (points LOP): transformação.	12 opcionais
`usd_prim_basiscurves`	Criar um prim USD BasisCurves no estágio (basiscurves LOP): tipo, base, wrap.	12 opcionais
`usd_prim_hermitecurves`	Criar um prim USD HermiteCurves no estágio (hermitecurves LOP): transformação.	12 opcionais
`usd_prim_primitive`	Criar um prim USD genérico único de qualquer tipo de schema (primitive LOP).	7 opcionais
`usd_instancer`	Construir um PointInstancer USD / instâncias baseadas em referência no estágio (instancer LOP).	17 opcionais
`usd_component_geometry`	Criar um contêiner componentgeometry conduzido pela sua subnet SOP interna (sem parâmetros de arquivo).	10 opcionais
`usd_component_geometry_variants`	Empacotar vários estágios de entrada em um conjunto de variantes em um componente (componentgeometryvariants LOP).	8 opcionais
`usd_component_material`	Vincular materiais a um componente e opcionalmente construir um conjunto de variantes de material (componentmaterial LOP).	`input` (+8 opcionais)
`usd_layout`	Dispersar/posicionar instâncias de um prim de protótipo no estágio (layout LOP).	14 opcionais
`usd_scene_import`	Importar objetos de cena /obj (geo/luzes/câmeras) para o estágio (sceneimport::2.0 LOP).	11 opcionais
`usd_graft_stages`	Enxertar a subárvore de outro estágio sob um prim de destino (graftstages LOP).	9 opcionais
`usd_graft_branches`	Enxertar ramos de um estágio de origem em prims de destino, mantendo posição/material (graftbranches LOP).	12 opcionais
`usd_restructure_scenegraph`	Reparentear/renomear prims e remover arcos de composição (restructurescenegraph LOP).	`input` (+13 opcionais)
`usd_split_scene`	Dividir o estágio em um ramo selecionado e o restante (splitscene LOP).	`input` (+4 opcionais)
`usd_isolate_scene`	Isolar parte do estágio para iteração mais rápida (isolatescene LOP).	`input` (+7 opcionais)
`usd_scope`	Criar um prim Scope (agrupamento), opcionalmente reparenteando prims correspondentes sob ele (scope LOP).	10 opcionais
`usd_collection`	Criar uma coleção USD (conjunto nomeado de prims) no estágio (collection::2.0 LOP; parâmetro de ícone excluído).	11 opcionais
`usd_prune`	Desativar ou ocultar prims no estágio (prune LOP).	7 opcionais
`usd_split_primitive`	Dividir prims compostos em prims editáveis separadamente (splitprimitive LOP).	`input` (+8 opcionais)
`usd_xform`	Criar uma transformação (xformOp) em prims correspondentes (xform LOP).	`input` (+14 opcionais)
`usd_create_xform`	Criar um novo prim Xform com uma transformação (createxform LOP).	14 opcionais
`usd_point_xform`	Transformar prims por atributos de ponto de um SOP (pointxform LOP).	`input` (+5 opcionais)
`usd_transform_uv`	Transformar coordenadas UV/textura em prims correspondentes (transformuv LOP; parâmetro de arquivo de mapa excluído).	`input` (+13 opcionais)
`usd_resample_transforms`	Reamostrar amostras de tempo de transformação animada em um intervalo fixo (resampletransforms LOP).	`input` (+4 opcionais)
`usd_duplicate`	Duplicar prims correspondentes N vezes com uma transformação cumulativa por cópia (duplicate LOP).	`input` (+15 opcionais)
`usd_retime_instances`	Deslocamentos de tempo por instância / re-timing de um PointInstancer (retimeinstances LOP).	`input` (+11 opcionais)
`usd_extract_instances`	Extrair instâncias PointInstancer em prims reais (extractinstances LOP).	`input` (+12 opcionais)
`usd_merge_point_instancers`	Mesclar vários PointInstancers em um (mergepointinstancers LOP).	`input` (+3 opcionais)
`usd_split_point_instancers`	Dividir um PointInstancer em subconjuntos por protótipo/atributo (splitpointinstancers LOP).	`input` (+7 opcionais)
`usd_modify_point_instances`	Editar instâncias individuais de um PointInstancer — transformação por instância (modifypointinstances LOP).	`input` (+8 opcionais)
`usd_coordsys`	Vincular um prim de sistema de coordenadas nomeado (coordsys) para espaços de textura/projeção (coordsys LOP).	`input` (+13 opcionais)
`usd_edit_material`	Abrir um material USD para edição / basear um novo material nele (editmaterial LOP).	6 opcionais
`usd_edit_material_properties`	Criar/editar propriedades em um prim de material (editmaterialproperties LOP).	12 opcionais
`usd_material_variation`	Variar os parâmetros de shader de um material vinculado entre prims (materialvariation LOP).	`input` (+8 opcionais)
`usd_unassign_material`	Remover vínculos de material de prims correspondentes (unassignmaterial LOP).	7 opcionais
`usd_vary_material_assignment`	Variar aleatoriamente/espacialmente qual material está vinculado entre prims (varymaterialassignment LOP).	`input` (+16 opcionais)
`usd_light_distant`	Criar um UsdLux DistantLight (sol) no estágio (distantlight::2.0 LOP).	15 opcionais
`usd_light_portal`	Criar um UsdLux PortalLight (portal de dome-light) no estágio (portallight LOP).	10 opcionais
`usd_light_geometry`	Transformar geometria correspondente em uma light de área emissiva (geometrylight LOP).	15 opcionais
`usd_light_mixer`	Agrupar e transformar luzes via coleções de luz para look-dev (lightmixer LOP).	17 opcionais
`usd_shadow_catcher`	Transformar prims correspondentes em superfícies captadoras de sombra para composição (shadowcatcher LOP).	6 opcionais
`usd_light_filter_library`	Criar uma biblioteca de prims de light-filter e atribuí-los a luzes (lightfilterlibrary LOP).	10 opcionais
`usd_add_variant`	Empacotar estágios de entrada em um conjunto de variantes em um prim (addvariant LOP).	15 opcionais
`usd_explore_variants`	Dispor cada variante de um conjunto de variantes lado a lado (explorevariants::2.0 LOP).	`input` (+16 opcionais)
`usd_create_lod`	Construir variantes de nível de detalhe polyreduced de um prim (createlod LOP).	`input` (+14 opcionais)
`usd_auto_select_lod`	Selecionar automaticamente uma variante LOD por distância da câmera (autoselectlod LOP).	`input` (+7 opcionais)
`usd_draw_mode`	Define o modo de desenho de exibição USD (bounds/cards/origin proxy) nos prims correspondentes (drawmode LOP).	14 opcional
`usd_configure_property`	Configura metadados nas propriedades USD correspondentes (configureproperty LOP).	9 opcional
`usd_configure_stage`	Configura regras de população/carga/mute no nível do stage (configurestage LOP).	11 opcional
`usd_edit_properties`	Cria/edita prims e suas propriedades em lote (editproperties LOP).	12 opcional
`usd_store_parameter_values`	Armazena valores de parâmetros nomeados como dados do stage para reutilização (storeparametervalues LOP).	5 opcional
`usd_set_extents`	Define/recalcula a dica de extent (bbox) nos prims correspondentes (setextents LOP).	`input` (+8 opcional)
`usd_edit_xform`	Edita a transformação dos prims correspondentes (edit LOP).	16 opcional
`usd_layer_break`	Insere uma quebra de camada para que edições a jusante vão para uma camada nova (layerbreak LOP).	2 opcional
`usd_set_variant`	Seleciona qual variante de um conjunto de variantes está ativa nos prims correspondentes (setvariant LOP).	`input` (+5 opcional)
`usd_copy_property`	Copia uma propriedade/atributo dos prims de origem para os prims de destino (copyproperty LOP).	`input` (+7 opcional)
`usd_shot_split`	Divide edições do stage em camadas por take para entrega editorial (shotsplit LOP).	`input` (+8 opcional)
`usd_shot_switch`	Alterna entre stages de entrada candidatos por índice para montagem de takes (shotswitch LOP).	4 opcional
`shot_load`	Carrega camadas de take no /stage a partir do pipeline de takes (shotload LOP) — o ponto de entrada editorial que popula um stage a partir de takes configurados.	5 opcional
`shot_output`	SOMENTE WIRE: cria um ROP LOP de Saída de Take (shotoutput) que salva o stage no disco para um take — configurado, mas NUNCA executado (você dispara a escrita). a saída é confinada a WRITE; os parâmetros SCRIPT de pré/pós-render nunca são expostos.	`input`, `output` (+5 opcional)
`shot_layer_edit`	Roteia edições do stage para uma camada de take específica (shotlayeredit LOP) — o direcionador de camadas editorial.	`input` (+6 opcional)
`usd_value_clip`	Cria um prim de value-clip USD que transmite animação a partir de um conjunto de arquivos de clip (valueclip LOP). clip_files e manifest_file são confinados a realpath no diretório de trabalho.	9 opcional
`usd_geometry_sequence`	Importa uma SEQUÊNCIA de arquivos de geometria animada para o stage (geometrysequence LOP) — a ponte de leitura em streaming para um cache por quadro .bgeo/.vdb. file é confinado a READ (coloque um token $F para uma sequência).	`file` (+7 opcional)
`usd_geo_clip_sequence`	Carrega/escreve uma sequência de value-clip de geometria USD (geoclipsequence LOP) — armazena em cache uma subárvore do stage animada em arquivos de clip por quadro e a transmite de volta. load_clip_file (READ) e save_clip_file (WRITE) são confinados a realpath.	13 opcional
`usd_blend_constraint`	Cria uma restrição USD Blend — mescla a transformação de um prim entre os prims de origem e destino (blendconstraint LOP).	`input` (+9 opcional)
`usd_followpath_constraint`	Cria uma restrição USD Follow-Path — desliza um prim ao longo de uma curva (followpathconstraint LOP).	`input` (+14 opcional)
`usd_lookat_constraint`	Cria uma restrição USD Look-At — aponta um prim para um alvo (lookatconstraint LOP).	`input` (+11 opcional)
`usd_parent_constraint`	Cria uma restrição USD Parent — torna a transformação de um prim filha de um alvo (parentconstraint LOP).	`input` (+14 opcional)
`usd_points_constraint`	Cria uma restrição USD Points — restringe um prim a pontos ponderados de um alvo (pointsconstraint LOP).	`input` (+13 opcional)
`usd_surface_constraint`	Cria uma restrição USD Surface — fixa um prim a uma localização UV em uma superfície alvo (surfaceconstraint LOP).	`input` (+14 opcional)

Visual, luzes e câmera

Ferramenta	O que faz	Parâmetros-chave
`build_globe`	Constrói um globo elipsoide WGS84 com um drape UV analítico de lon/lat (a 'pele'), de modo que uma textura equirretangular e tiles fixados em ECEF se registram por construção.	`name` (+12 opcionais)
`add_light`	Adiciona uma luz abrangendo toda a paleta de Tipos hlight mais dome.	21 opcionais
`add_camera`	Cria uma câmera para CORRESPONDER A UMA FOTO DE REFERÊNCIA / recriar uma imagem / resolver uma cena por câmera — define as intrínsecas para que um render se alinhe com uma imagem alvo. distância focal (mm) + abertura (mm) = campo de visão / compressão de perspectiva (focal mais curta ou abertura mais larga = FOV mais amplo); resx/resy = gate de resolução; aspecto.	17 opcionais
`camera_aim`	Aponta uma câmera existente para um alvo — somente dados (sem expressão/restrição de look-at).	`camera` (+6 opcionais)
`camera_path`	Anima uma câmera OBJ ao longo de uma curva SOP — somente dados (keyframes literais calculados, SEM restrição Follow-Path / expressão $F).	`curve` (+6 opcionais)
`setup_karma`	SOMENTE WIRE: constrói um grafo de render Karma no contexto OBJ (o ROP /out `karma` conectado a uma câmera + resolução + imagem de saída) e o devolve NÃO RENDERIZADO — o humano o dispara (isso remove a superfície de DoS de recursos / congelamento de cena pesada). a imagem é gravada no diretório de trabalho (PNG/EXR/JPG por extensão).	9 opcionais
`setup_prorender`	SOMENTE WIRE: constrói um ROP de render USD Solaris (/stage) configurado para AMD Radeon ProRender (o delegate Hydra `HdRprPlugin`) e o devolve NÃO RENDERIZADO — o humano o dispara (mesma postura do setup_karma / karma_render_settings; remove a superfície de DoS de recursos / congelamento de cook de GPU).	5 opcionais
`substance_material`	SideFX Labs Substance Material — atribui um material Substance à geometria de entrada (entrada 0).	`input` (+9 opcionais)
`quickmaterial`	SideFX Labs Quick Material — atribui UM material (Principled / MatCap / Labs PBR) à geometria de entrada (`input`), opcionalmente a uma primitiva `group`, dirigido por mapas de textura (`*_texture`, confinado a LEITURA) e alavancas escalares (rugosidade / metálico / ior).	`input` (+14 opcionais)
`set_view_camera`	Controla o viewport do Scene Viewer: olhar através de uma câmera (vincular o viewport a ela) e/ou alternar para uma vista ortográfica/perspectiva padrão (topo/base/frente/trás/esquerda/direita/persp), e opcionalmente enquadrar toda a geometria para caber na vista.	4 opcionais
`flightcam`	Câmera de voo com keyframes dirigida por um poses .json, com a nuvem de origem carregada como contexto.	`poses` (+7 opcionais)
`assign_material`	Atribui um material / shader PBR (Principled Shader principledshader::2.0) ao SOP de entrada via um SOP Material para que renderize com uma aparência de superfície — apenas parâmetros literais digitados + mapas de textura (sem autoria de VOP/grafo de shader).	`input` (+26 opcionais)
`bake_texture`	SOMENTE WIRE: constrói o grafo de bake de textura (Bake Texture 3.0) com uma saída confinada; não executa.	`output` (+3 opcionais)
`three_point_light`	Cria um rig OBJ de Three Point Light (three_point_light) — um nó que agrupa luzes key / fill / rim / bounce apontadas para um alvo compartilhado.	18 opcionais
`indirect_light`	Cria uma Light OBJ Indireta (bounce de iluminação global) (indirectlight). o dimmer escala a contribuição indireta.	6 opcionais
`ambient_light`	Cria uma Light OBJ Ambiente (ambient) — um preenchimento plano e uniforme adicionado a toda a cena.	8 opcionais
`environment_fog`	Cria um OBJ de Névoa de Ambiente (fog) — um contêiner de volume atmosférico que preenche a cena. t/r/s/escala dimensionam e posicionam a caixa de névoa.	5 opcionais
`reference_image`	Cria um OBJ de Imagem de Referência (refimage) — um plano de imagem plano para referência de modelagem / correspondência. image_file é realpath confinado a LEITURA no diretório de trabalho.	9 opcionais
`stereo_camera`	Cria um OBJ de Câmera Estéreo (stereocam) — um contêiner que agrupa uma câmera esquerda + direita.	7 opcionais
`stereo_camera_rig`	Cria um OBJ de Rig de Câmera Estéreo (stereocamrig) — um rig estéreo totalmente paramétrico com controles de interaxial / paralaxe zero e intrínsecas de câmera.	14 opcionais
`vr_camera`	Cria um OBJ de Câmera VR (vrcam) — uma câmera panorâmica estéreo para renders VR (esfera/cilindro = panoramas equirretangulares / cilíndricos).	14 opcionais

Cena, navegação e viewport

Ferramenta	O que faz	Parâmetros-chave
`scene_info`	Relata a cena atual do Houdini: arquivo hip, frame, versão e conteúdo de /obj.	—
`read_network`	Lê a ESTRUTURA de uma rede como texto — o mapa durável e barato em tokens para reconstruir sua visão de um grafo de nós grande (especialmente após uma compactação de contexto) SEM gastar orçamento com uma captura de tela.	5 opcionais
`set_frame`	Define o frame atual da timeline / playhead — salta para um ponto no tempo para que cooks, snapshots, exportações ou leituras de simulação subsequentes sejam avaliados naquele frame.	`frame`
`set_display`	Define o flag de display e/ou render em um nó SOP ou OBJ — controle limpo sobre o que é exibido/renderizado.	`node` (+2 opcionais)
`delete_node`	Exclui um nó (SOP ou OBJ) da cena.	`node` (+1 opcional)
`clear_scene`	Começa do zero na rede /obj sem um File->New destrutivo. mode='hide' (PADRÃO, não destrutivo + reversível) desliga o flag de display em todos os objetos /obj para que o viewport limpe mas os nós permaneçam; mode='delete' REMOVE os objetos /obj (destrutivo — como excluir cada um).	2 opcionais
`save_scene`	Salva / grava toda a cena do Houdini (todos os nós e redes) em um arquivo de projeto .hip / .hipnc / .hiplc no disco, restrito ao diretório de trabalho — a operação 'salvar meu trabalho' / snapshot da sessão.	`path`
`select_node`	Seleciona um nó (limpando qualquer seleção anterior) e o torna o nó atual.	`node` (+1 opcional)
`frame_selected`	Enquadra o Scene Viewer em um nó — o equivalente ao Shift+H 'home selected', para enquadramento preciso em cenas de escala mista onde frame-all é inútil.	1 opcional
`layout_nodes`	Organiza automaticamente os filhos de uma rede para que nós recém-adicionados não se empilhem — o equivalente ao Shift+L.	`parent`
`find_error_nodes`	Diagnóstico somente leitura: varre uma subárvore em busca de nós em estado de erro (e opcionalmente aviso) e relata seus caminhos, tipos e mensagens para que um agente de IA possa se autocorrigir. root (padrão /obj) define o escopo da varredura (root mais todos os descendentes); um cook protegido é tentado por nó para que um nó quebrado (ex.: um File SOP apontando para um caminho inexistente) apareça como um erro capturado, não como uma exceção levantada.	2 opcionais
`batch`	Executa até 64 operações de ferramenta em UMA chamada para reduzir a latência por chamada (ex.: construir uma cadeia de nós em uma única ida e volta).	`ops` (+1 opcional)
`capabilities`	Comece aqui — primeiros passos, como usar este servidor, uma visão geral do que ele pode fazer, orientação e primeiros passos para um novo agente.	—
`node_reference`	Consulta a referência autoritativa de nós do Houdini 21.0.671 sondada ao vivo — tipos de nó verificados e seus nomes reais de parâmetros, a fonte da verdade para quais cadeias de nós são possíveis.	3 opcionais
`vex_reference`	Consulta a referência autoritativa offline de VEX do Houdini 21.0.671: 1073 funções embutidas (assinaturas verbatim, resumos, grupos de ajuda) além de um guia curado de fluxos de trabalho/padrões de wrangle.	4 opcionais
`recipe_reference`	Receitas de fluxo de trabalho canônicas e mapeadas por ferramenta — como REALMENTE fazer X com as ferramentas deste servidor, e o ROUTER que escolhe qual receita se encaixa no que você está vendo.	4 opcionais
`viewport_display`	Alterna overlays de exibição/análise do Scene Viewer (marcadores de ponto, normais de ponto/prim/vertex, números de ponto/prim, posições de ponto, trilhas de ponto) para que uma captura de tela snapshot/capture_ui sirva para análise de geometria.	9 opcionais
`read_geo_stats`	Lê estatísticas estruturadas de geometria de um nó — contagens de ponto/primitiva/vertex, bounding box (min/max/tamanho/centro) e a lista completa de atributos de ponto/prim/vertex/detail com seus tipos — via intrinsics rápidos (seguro em nuvens de pontos de vários GB; sem loop Python por ponto).	`node` (+1 opcional)
`isolate`	Recorta uma nuvem de pontos para uma região de interesse: mantém apenas os pontos que caem dentro de um objeto de caixa de recorte orientada (usa a transformação de mundo do próprio box OBJ, então uma caixa rotacionada recorta um volume orientado) e exclui o resto — reduz uma varredura a um edifício/sala/área. box = um box OBJ atuando como os limites do recorte. out opcionalmente grava a nuvem recortada em um .bgeo/.ply confinado.	`input`, `box` (+1 opcional)
`object_merge`	Referencia / importa / puxa um ou muitos fluxos de geometria SOP ou OBJ para uma rede POR CAMINHO, SEM copiar a geometria — a primitiva de montagem de cenas grandes, venues e multi-objetos (reúne muitos objetos / combina / agrega / instancia geometria de outro lugar da cena, sobrevive a cenas enormes porque nada é duplicado).	`sources` (+7 opcionais)
`subnet_organize`	Organiza / arruma / limpa o grafo de nós (somente dados, sem cook, sem mudança de geometria): op=collapse agrupa um conjunto de nós irmãos em uma subnet (agrupa nós juntos); op=create cria um contêiner de subnet vazio; op=tag rotula um nó com uma cor do network editor, um comentário/nota e/ou uma chave/valor de user-data para que um grafo montado seja navegável e legível.	9 opcionais
`matchsize`	Ajusta / redimensiona / reescala / reposiciona / alinha uma entrada de geometria para corresponder a uma bounding box de referência ou a um tamanho alvo explícito — o nó tipado 'colocar este asset na cena no tamanho e posição corretos' / 'normalizar / ajustar aos limites' (matchsize SOP).	`input` (+9 opcionais)
`scene_assemble`	Macro de montagem/composição de cena multi-peça em uma única chamada (a primitiva venue-portfolio): constrói uma cena montada e navegável inteira a partir de muitas geometrias de origem em um único /obj geo novo.	`name`, `pieces` (+2 opcionais)
`list_node_types`	Descobre / enumera / busca a paleta de tipos de nó disponíveis do Houdini — quais tipos de operador (SOP/OBJ/LOP/DOP/COP/ROP/VOP/...) existem por nome, com contagens por categoria.	3 opcionais
`reload_node`	Força um nó a reler seu arquivo de origem do disco e atualizar / recozinhar — use depois que o .bgeo/.obj de um File SOP (ou qualquer arquivo em cache) foi reescrito externamente para que o Houdini capte o novo conteúdo.	`node`
`mem`	Relata o working set do processo + RAM do sistema + memória do Houdini + VRAM da GPU (total/usado/disponível da placa inteira — o sinal de teto de congelamento) para automonitoramento e dimensionamento de operações governado por memória: estou ficando sem memória, quanto de VRAM / memória de GPU ainda resta, qual é meu orçamento de memória, quanto mais posso construir antes de congelar.	—
`viewport_snap`	Define / configura o SNAPPING do Scene Viewer — snap-to-grid, snap a pontos / prims / geometria / templates / outros objetos / guias / drawables.	6 opcionais
`view_message`	Mostra / pisca / exibe uma mensagem voltada ao operador (notificação, toast na tela, prompt na linha de status) no Scene Viewer — a UX watched-crew para informar ao humano o que o agente está fazendo. type=flash é um overlay transitório (duração em s); type=prompt define o prompt persistente da linha de status em um nível de severidade.	`message` (+3 opcionais)
`home_view`	Home / redefine / recentraliza / frame-all o viewport atual para a DIREÇÃO de vista padrão de um alvo (all \| selected \| grid \| non_templated) — distinto de frame_selected, que reenquadra mas MANTÉM a direção de vista atual.	1 opcional
`save_view_to_camera`	Grava / salva a vista interativa atual do viewport (transform + configurações de lente) DENTRO de um nó de câmera OBJ — 'salvar vista na câmera' / criar-uma-câmera-desta-vista.	`camera` (+1 opcional)
`construction_plane`	Mostra / oculta / redimensiona a GRADE do plano de construção do Scene Viewer — visibilidade, tamanho da célula, contagem de células, células-por-linha-de-régua.	4 opcionais
`ui_reference`	Descoberta / ajuda da superfície de controle somente leitura (irmão de node_reference/vex_reference): DESCUBRA as ferramentas da superfície de controle + tokens de enum confirmados e — quando uma GUI está ativa — LEIA o estado atual da UI dirigível (modo de snapping, visibilidade do plano de construção, nome do estado do viewer, nomes de desktops).	1 opcional
`switch_desktop`	Alterna / ativa um DESKTOP (workspace / layout de painéis salvo — Build, Animate, Solaris, …) por nome.	`desktop`
`pane_focus_node`	Salta / navega / aponta um painel baseado em caminho (parm \| network \| scene) PARA um nó (quick-nav) — torna-o o nó atual do painel; para network você também pode mergulhar na própria rede do nó.	`node` (+2 opcionais)
`pane_pin`	Fixa / desafixa (ou define o grupo de link de) um painel baseado em caminho para que ele PARE de seguir a seleção — congela o painel parm/network/scene no nó atual.	3 opcionais
`pane_tab`	Abre / cria / fecha / alterna / clona / reescreve o tipo de ABAS de painel por tipo (somente dados) — adicione uma aba Network Editor / Parameters / Spreadsheet / Details, feche uma ou torne uma atual. op=query lista tokens paneTabType válidos + as abas atuais (execute PRIMEIRO para descobrir ids/tipos de painel); create/set_type/current/clone/close agem no painel alvo.	3 opcionais
`pane_layout`	Divide / maximiza / restaura / organiza o layout de PAINÉIS do desktop atual (UI de sessão reversível) — divida um painel horizontal ou verticalmente, maximize-o ou restaure.	`op` (+1 opcional)
`network_navigate`	Navega / salta / mergulha o Network Editor pelo grafo de nós — mergulhe em uma rede (path), selecione + torne um nó atual (current_node) e/ou enquadre a seleção (frame).	3 opcionais
`hotkey_reference`	Leitor somente leitura do mapa de hotkeys padrão / atalhos de teclado de hou.hotkeys (irmão de vex_reference/node_reference) — consulte / encontre atalhos de teclado: contexto → comando → teclas atribuídas + rótulo humano, com um filtro de busca opcional ou modo de categoria.	5 opcionais
`set_node_flags`	Define / alterna FLAGS DE NÓ em um nó — display, render, template, bypass, lock, soft-lock, highlight, debug, visible, xray, display-comment, descriptive-name — via setGenericFlag.	`node` (+13 opcionais)
`node_organize`	Organiza / arruma / posiciona / rotula / codifica por cor UM nó na rede — define sua cor, FORMA do nó, comentário (texto somente exibição), nome (renomear) e POSIÇÃO na rede.	`node` (+6 opcionais)
`viewport_appearance`	Define as configurações de exibição / inspeção / sombreamento do GeometryViewport para que a geometria fique VISÍVEL para o loop de aceitação visual / captura de tela — modo de sombreamento/exibição (wireframe · shaded · flat · matcap · hidden-line · bounding-box), mostrar marcadores de ponto/prim/vertex · normais · números, remoção de backface, texturas, oclusão ambiente, esquema de cores, iluminação.	19 opcionais
`viewport_layout`	Define o LAYOUT de viewports do Scene Viewer — como o painel se divide em viewports (variantes single \| quad \| double \| triple).	`layout` (+1 opcional)
`enter_state`	Entra / ativa um dos cinco estados de ferramenta FIXOS embutidos do Scene Viewer por nome (somente dados por construção) — view (olhar ao redor) \| translate \| rotate \| scale (estados de alça de transformação) \| current_node (o próprio estado de ferramenta do nó atual).	`state`
`viewport_optimize`	Acelera um Scene Viewer lento / com lag / pesado aplicando alavancas de desempenho somente de exibição — reduza a qualidade de volumes, limite a exibição de polígonos da cena, ative culling packed baseado em distância, reduza o nível de detalhe e o antialiasing.	1 opcional
`rivet`	Cria um Rivet OBJ (rivet) — uma transformação travada a um ponto/primitiva em uma superfície deformável (o clássico 'prender um prop a uma malha animada').	10 opcionais
`sticky`	Cria um Sticky OBJ (sticky) — uma transformação fixada a uma coordenada UV em uma superfície, para que deslize com a superfície conforme ela deforma.	11 opcionais
`blend_sticky`	Cria um Blend Sticky OBJ (blendsticky) — um Sticky cuja posição é um BLEND ponderado de vários objetos sticky de origem (parenteie os stickies de origem a ele).	8 opcionais

Parâmetros

Ferramenta	O que faz	Parâmetros-chave
`set_parm`	Define / escreve / controla um parâmetro de nó com um valor LITERAL (somente literal, nunca uma expressão) — o equivalente seguro, somente de dados, a um setter genérico de parâmetro.	`node`, `parm`, `value` (+1 opcional)
`get_parm`	Lê / obtém / inspeciona o valor de um parâmetro de nó (somente leitura, somente dados): retorna o valor avaliado, o valor bruto / não expandido, o tipo do parâmetro, se ele atualmente contém uma expressão ou keyframes (com a string da expressão) e se é um parâmetro de código negado (para que uma expressão injetada fique visível).	`node`, `parm` (+1 opcional)
`set_keyframe`	Define / adiciona um keyframe para animar um parâmetro numérico em um frame com um valor numérico LITERAL + uma interpolação opcional da lista permitida (constant / linear / bezier / ease / …) — animação por valor literal para parâmetros float / int / toggle / menu.	`node`, `parm`, `frame`, `value` (+2 opcionais)
`delete_keyframes`	Remove / limpa / exclui keyframes de um parâmetro para que ele retorne a um valor literal estático (desanimar).	`node`, `parm` (+3 opcionais)
`list_keyframes`	Lista somente leitura dos keyframes / animação de um parâmetro — o frame de cada keyframe, valor literal e string de interpolação (ex.: 'bezier()'), para que um agente possa inspecionar a animação.	`node`, `parm` (+1 opcional)

Entregar e exportar

Ferramenta	O que faz	Parâmetros-chave
`export_geometry`	Coze um SOP e o grava em um ÚNICO arquivo de geometria (o ROP /out `geometry`; executa a gravação).	`input`, `output` (+1 opcional)
`batch_export`	Divide a geometria `input` em PARTIÇÕES e grava UM arquivo confinado por partição — o pedido recorrente nº 1 de TDs ("divida isso por grupo/nome/atributo e exporte cada parte"). split_by=name (padrão) grava um arquivo por valor distinto do atributo de primitiva `name`; split_by=group grava um arquivo por grupo de primitiva/ponto; split_by=attribute grava um arquivo por valor distinto do atributo de ponto/primitiva nomeado em `attribute`.	`input` (+7 opcionais)
`export_pointcloud`	Exporta uma nuvem de pontos / geometria para PLY dentro do diretório de trabalho — a saída para nuvens importadas via import_pointcloud/las_import.	`input`, `output` (+2 opcionais)
`export_alembic`	Exporta um SOP para um Alembic .abc (o ROP /out `alembic`; executa a gravação) — o intercâmbio padrão para geometria animada/deformada para Maya/Nuke/Blender/UE. frames=[início,fim] grava um cache ANIMADO no único .abc; omita para um frame estático. formato ogawa (moderno, mais rápido, menor — recomendado) \| hdf5 (legado) \| padrão.	`input`, `output` (+3 opcionais)
`capture_ui`	Captura de tela / vê / lê a interface AO VIVO do Houdini, ISOLADA em um único painel sob solicitação.	5 opcionais
`snapshot`	Vê/captura o resultado 3D — um único PNG OpenGL do viewport/câmera retornado INLINE no resultado da ferramenta (os olhos do agente para verificação imagem->3D).	6 opcionais
`niagara`	SideFX Labs Niagara — SOP exportador SOMENTE-FIO que empacota as partículas/pontos de entrada (`input`, entrada 0) para o sistema Niagara da Unreal.	`input` (+8 opcionais)
`pcg_export`	SideFX Labs PCG Export — SOP exportador SOMENTE-FIO que empacota os pontos de instância de entrada (`input`, entrada 0) para o framework PCG da Unreal.	`input` (+7 opcionais)
`unreal_groom_export`	SideFX Labs Unreal Groom Export — empacota um groom do Houdini para o sistema de groom da Unreal e o grava como Alembic.	13 opcionais
`unreal_spline`	SideFX Labs Unreal Spline — empacota a curva de entrada (`input`, entrada 0) como uma spline da Unreal; a saída SOP cozida passa a curva adiante (opcionalmente marcada). orient_along_curve grava orientação por ponto; prim_tags grava tags por primitiva.	`input` (+4 opcionais)
`vector_field`	SideFX Labs Vector Field — reamostra um campo de velocidade de entrada (`input`, entrada 0 — volumes de velocidade ou pontos com um atributo de velocidade) em uma grade uniforme e prepara uma exportação de campo vetorial .fga para Unreal/Unity; a saída SOP cozida visualiza o campo amostrado. input_type escolhe volumes(0) ou pontos(1); velocity_volumes/velocity_attr nomeiam a fonte; div define o divisor de resolução da grade.	`input` (+9 opcionais)
`niagara_rop`	SideFX Labs Niagara ROP — a forma /out Driver do exportador Niagara: referencia um SOP por caminho (`soppath`) e o grava para o sistema Niagara da Unreal.	6 opcionais
`rbd_to_fbx`	SideFX Labs RBD to FBX — um Driver /out que exporta uma simulação RBD empacotada (referenciada por `node_to_export`) como um FBX de corpo rígido para um motor de jogo.	9 opcionais
`vertex_animation_textures`	SideFX Labs Vertex Animation Textures — o exportador VAT principal: assa um SOP animado (referenciado por `soppath`) em texturas de posição/rotação/cor + uma malha base para shaders VAT da Unreal/Unity.	11 opcionais
`xyz_pointcloud_exporter`	SideFX Labs XYZ Pointcloud Exporter — um Driver /out que grava os pontos de um SOP (referenciados por `objpath1`) em uma nuvem de pontos XYZ/CSV em texto simples.	3 opcionais
`texture_sheets`	SideFX Labs Texture Sheets — renderizador de folhas de textura / flipbook SOMENTE-FIO (Mantra ROP).	18 opcionais
`goz_export`	SideFX Labs GoZ Export — exportador SOMENTE-FIO que envia geometria para o ZBrush via ponte GoZ.	`input` (+2 opcionais)
`filecache`	SideFX Labs File Cache — cache de geometria SOMENTE-FIO.	`input` (+6 opcionais)
`static_fracture_export`	SideFX Labs Static Fracture Export — exportador SOMENTE-FIO paraos pedaços de um objeto fraturado (`input`).	`input` (+5 opcionais)
`simple_baker`	SideFX Labs Simple Baker — baker de mapas SOMENTE-FIO.	`input` (+19 opcionais)
`unreal_pivotpainter`	SideFX Labs Unreal Pivot Painter — exportador SOMENTE-FIO que assa texturas de pivô / hierarquia para animação de vento UE4/5.	`input` (+10 opcionais)
`zibravdb_filecache`	SideFX Labs ZibraVDB File Cache — cache VDB comprimido SOMENTE-FIO.	`input` (+3 opcionais)
`rop_zibravdb_compress`	SideFX Labs ROP ZibraVDB Compress — ROP VDB comprimido SOMENTE-FIO.	`input` (+3 opcionais)
`games_baker`	SideFX Labs Games Baker — um Driver /out que assa mapas de textura (basecolor / normal / AO / roughness / metallic / curvature / thickness / position / …) de uma malha fonte de alta resolução em uma malha alvo de baixa resolução via bake nativo COP/Karma do Houdini.	40 opcionais
`csv_exporter`	SideFX Labs CSV Exporter — um Driver /out que grava os atributos de ponto/primitiva de um SOP (referenciados por export_node) em um arquivo CSV de texto simples.	12 opcionais
`json_exporter`	SideFX Labs JSON Exporter — um Driver /out que grava os atributos de um SOP (referenciados por export_node) em um arquivo JSON.	5 opcionais
`export_usd`	Grava um estágio USD de uma rede LOP em um caminho de saída confinado (o ROP /out `usd`; executa a gravação).	`output` (+3 opcionais)
`export_fbx`	Grava um FBX (.fbx) do OBJ que contém `input` em um caminho de saída confinado (o ROP /out `filmboxfbx`; executa a gravação) — o intercâmbio padrão rigado/animado para Maya/Max/UE/Unity.	`input`, `output` (+2 opcionais)
`export_gltf`	Grava um glTF/GLB do SOP `input` em um caminho de saída confinado (o ROP /out `gltf`; executa a gravação) — o intercâmbio web/tempo real (three.js, model-viewer, UE/Unity, AR quicklook). exporttype auto (da extensão — padrão) \| gltf (.gltf + buffers externos) \| glb (binário de arquivo único). frames=[início,fim] grava um glTF ANIMADO; omita para um frame estático.	`input`, `output` (+3 opcionais)
`export_cache`	Grava um cache de geometria versionado — uma sequência .bgeo.sc por frame — em um intervalo de frames (o ROP /out `geometry`; executa a gravação).	`input`, `output` (+2 opcionais)
`flipbook`	Renderiza uma sequência rápida de pré-visualização OpenGL (o ROP /out `opengl`; executa a gravação) — um flipbook de qualidade de viewport para revisar movimento, NÃO um render final (use setup_karma/karma_render_settings para isso).	`output` (+5 opcionais)
`export_package`	SOMENTE-FIO: exportação / entrega / empacotamento de gravação de USD em estágios: constrói + configura completamente um ROP `usd` (Driver) que grava um estágio LOP montado em um arquivo .usd/.usda/.usdc/.usdz confinado, mas NÃO o executa — como setup_karma / bake_texture, um flatten de estágio inteiro pode ser uma gravação pesada, então o chamador/humano o dispara (retorna rendered=false).	`loppath`, `output` (+3 opcionais)
`define_hda`	Empacota um subnet SOP existente em um Houdini Digital Asset reutilizável e confinado a caminho — a operação 'tornar esta rede uma ferramenta reutilizável'.	`node`, `output`, `type_name` (+6 opcionais)
`usd_export_sop`	Grava a geometria do SOP `input` em um arquivo USD (o `usdexport` de contexto SOP — a ponte de gravação de SOPs nativos até um estágio USD; executa a gravação). A saída é CONFINADA a WRITE (caminho real) no diretório de trabalho; a extensão escolhe o formato (.usd/.usda/.usdc/.usdz).	`input`, `output` (+8 opcionais)
`usd_stitch`	SOMENTE-FIO: constrói um ROP USD Stitch (/out usdstitch) que mescla várias camadas USD de entrada em uma camada de saída — configurado mas NUNCA executado (você dispara a gravação).	`input_files`, `output` (+1 opcional)
`usd_stitch_clips`	SOMENTE-FIO: constrói um ROP USD Stitch Clips (/out usdstitchclips) que monta clips USD por frame em uma topologia de value-clip + template — configurado mas NUNCA executado.	`input_files`, `output_template` (+5 opcionais)
`usd_zip`	SOMENTE-FIO: constrói um ROP USD Zip (/out usdzip) que empacota camadas USD de entrada em um arquivo .usdz — configurado mas NUNCA executado.	`input_files`, `output` (+2 opcionais)

Renderizar e saída (SOMENTE-FIO)

Ferramenta	O que faz	Parâmetros principais
`render_mantra`	ROP de renderização de imagem Mantra CPU (ifd, out/) — SOMENTE-CABEAMENTO: constrói + conecta o render Mantra em /out; VOCÊ dispara.	11 opcionais
`render_karma_rop`	ROP de renderização de imagem Karma no contexto Driver (karma, out/) — SOMENTE-CABEAMENTO: constrói + conecta o render Karma em /out; VOCÊ dispara.	11 opcionais
`render_usd`	ROP de renderização USD/Husk no contexto Driver (usdrender, out/) — SOMENTE-CABEAMENTO: constrói + conecta o render Husk em /out; VOCÊ dispara.	10 opcionais
`render_comp`	ROP de gravação de imagem de composite/rede COP (comp, out/) — SOMENTE-CABEAMENTO: constrói + conecta a gravação do composite em /out; VOCÊ dispara.	8 opcionais
`render_image`	ROP de renderização de imagem COP (image, out/) — SOMENTE-CABEAMENTO: constrói + conecta a gravação de imagem COP em /out; VOCÊ dispara.	8 opcionais
`export_ifd_archive`	ROP de exportação de arquivo-cena IFD Mantra (ifdarchive, out/) — SOMENTE-CABEAMENTO: constrói + conecta a exportação do archive em /out; VOCÊ dispara.	7 opcionais
`render_settings_usd`	Prim USD RenderSettings (LOP Solaris rendersettings) — SOMENTE-CABEAMENTO: constrói + conecta a configuração de render de nível superior (resolução, amostras, câmera) que um renderizador downstream lê; você dispara o render.	7 opcionais
`render_product`	Prim USD RenderProduct (LOP Solaris renderproduct) — SOMENTE-CABEAMENTO: nomeia a IMAGEM DE SAÍDA (caminho, tipo, enquadramento) que um renderizador gravará; você dispara o render.	7 opcionais
`render_var`	Definição USD RenderVar / AOV (LOP Solaris rendervar[::2.0]) — SOMENTE-CABEAMENTO: declara um AOV / variável de saída de render (fonte + tipo de dado) para um renderizador produzir.	6 opcionais
`render_vars_additional`	RenderVars adicionais (LOP Solaris additionalrendervars) — SOMENTE-CABEAMENTO: anexa uma linha extra de AOV / RenderVar ao conjunto de saídas de render do stage.	7 opcionais
`karma_render_properties`	Propriedades de Render Karma (LOP Solaris karmarenderproperties) — SOMENTE-CABEAMENTO: constrói + conecta uma configuração combinada de render-settings + product do Karma no stage; você dispara o render.	9 opcionais
`karma_render_products`	Pacote de Render Products Karma (LOP Solaris karmarenderproducts[::2.0]) — SOMENTE-CABEAMENTO: constrói + conecta um conjunto de produtos de saída Karma (beauty + AOVs) no stage; você dispara o render.	7 opcionais
`karma_render_vars`	RenderVars padrão Karma (LOP Solaris karmastandardrendervars[::2.0]) — SOMENTE-CABEAMENTO: constrói + conecta o conjunto padrão de AOVs Karma (beauty, divisões diffuse/glossy/volume, etc.) no stage; você dispara o render.	4 opcionais
`karma_cryptomatte`	Configuração de AOV Karma Cryptomatte (LOP Solaris karmacryptomatte) — SOMENTE-CABEAMENTO: constrói + conecta saídas de matte de ID cryptomatte no stage; você dispara o render.	5 opcionais
`husk_image_metadata`	Metadados de Imagem Husk (LOP Solaris huskimagemetadata) — SOMENTE-CABEAMENTO: constrói + conecta metadados (atributos de quais prims incorporar) na imagem de saída renderizada; você dispara o render.	3 opcionais
`rop_geometryraw`	Saída de Geometria ROP — RAW (`rop_geometryraw`, contexto SOP) — SOMENTE-CABEAMENTO: constrói + conecta um ROP de exportação de geometria bruta dentro da rede SOP após `input`; você dispara a gravação.	`input` (+4 opcionais)
`dopio`	E/S DOP (`dopio`, contexto SOP) — SOMENTE-CABEAMENTO: constrói um nó de cache de disco de campo/geometria DOP (sem entrada SOP — ele referencia uma rede DOP por caminho e grava um arquivo); você dispara o cache.	6 opcionais
`heightfield_output`	Saída Heightfield (`heightfield_output`, contexto SOP) — SOMENTE-CABEAMENTO: constrói + conecta um ROP de exportação de heightmap de heightfield/terreno após `input`; você dispara a gravação.	`input` (+8 opcionais)
`export_channel`	ROP de exportação de canais/movimento CHOP (channel, out/Driver) — SOMENTE-CABEAMENTO: constrói + conecta um exportador de canais/movimento CHOP; você dispara. choppath é um caminho CHOP da cena (dados); output -> chopoutput (restrito).	7 opcionais
`export_mdd`	ROP de exportação de point-cache MDD (mdd, out/Driver) — SOMENTE-CABEAMENTO: constrói + conecta um exportador de point-cache MDD; você dispara. soppath é um caminho SOP da cena (dados); output -> file (restrito).	8 opcionais
`render_dsm_merge`	ROP de merge Deep-Shadow-Map (dsmmerge, out/Driver) — SOMENTE-CABEAMENTO: constrói + conecta um merge DSM; você dispara. output -> dsm_output (restrito a gravação); dsm_source1/2 são entradas restritas a leitura.	8 opcionais
`export_brickmap`	Gerador de brick-map ROP (brickmap, out/Driver) — SOMENTE-CABEAMENTO: constrói + conecta um gerador point-cloud/i3d -> brick-map; você dispara. sop é um caminho SOP da cena (dados); output/geofile/ptcfile/i3dfile são restritos.	9 opcionais
`bake_animation_rop`	ROP Bake Animation (bake_animation, out/Driver) — SOMENTE-CABEAMENTO: constrói + conecta um bake de animação de objetos em keyframes/canais CHOP; você dispara. source e write_to_chop_channel são dados da cena (verbatim).	7 opcionais
`export_geometry_raw`	ROP de stream de geometria bruta (geometryraw, out/Driver) — SOMENTE-CABEAMENTO: constrói + conecta um despejo de stream de geometria bruta; você dispara. soppath é um caminho SOP da cena (dados); output -> sopoutput (restrito).	7 opcionais
`export_ml_example_raw`	ROP ML Example Raw (ml_exampleraw, out/Driver) — SOMENTE-CABEAMENTO: constrói + conecta um exportador bruto de exemplos de treinamento ML; você dispara. soppath é um caminho SOP da cena (dados); output -> sopoutput (restrito).	9 opcionais
`export_ml_example_output`	ROP ML Example Output (ml_exampleoutput, contexto SOP) — SOMENTE-CABEAMENTO: constrói + conecta um gravador de dataset de exemplos ML após um SOP (entrada 0); você dispara. output -> sopoutput (restrito).	`input` (+4 opcionais)
`export_ml_example_raw_sop`	ROP ML Example Raw (rop_ml_exampleraw, contexto SOP) — SOMENTE-CABEAMENTO: constrói + conecta o exportador bruto de exemplos ML em nível de SOP após um SOP (entrada 0); você dispara. soppath são dados da cena; output -> sopoutput (restrito).	`input` (+9 opcionais)
`render_ml_cv_synthetics`	Labs ML-CV Synthetics Karma ROP v1.0 (labs::ml_cv_synthetics_karma_rop::1.0, lop/Solaris) — SOMENTE-CABEAMENTO: constrói + conecta um renderizador de dados sintéticos Karma (beauty + conjunto grande de AOVs) em /stage; você dispara o render. camera/primpath/primpattern são dados de scene-graph USD; saídas de imagem restritas; res/samples/frames limitados; botões de render nunca pressionados.	16 opcionais
`render_ml_cv_synthetics_v11`	Labs ML-CV Synthetics Karma ROP v1.1 (labs::ml_cv_synthetics_karma_rop::1.1, lop/Solaris) — SOMENTE-CABEAMENTO: mesma postura do render_ml_cv_synthetics para o asset ::1.1 (2 entradas; importsecondaryinputvars). camera/primpath/primpattern são dados USD; saídas de imagem restritas; res/samples/frames limitados; botões de render nunca pressionados.	16 opcionais
`bake_karma_texture`	Karma Texture Baker (karmatexturebaker, lop/Solaris) — SOMENTE-CABEAMENTO: constrói + conecta o bake de textura UV/textura Karma em /stage e o configura; você dispara o bake.	26 opcionais
`bake_impostor_texture`	Labs Impostor Texture (labs::impostor_texture, out/Driver) — SOMENTE-CABEAMENTO: constrói + conecta o baker de atlas de impostor octaédrico em /out; você dispara o bake. source_geo/camera_rig são caminhos de nós da cena; output_sequence/anim_output_sequence/sopoutput restritos; res de sprite + amostras de raio limitados; execute/renderdialog nunca pressionados.	24 opcionais
`bake_motion_vectors`	Labs Motion Vectors (labs::motion_vectors, out/Driver) — SOMENTE-CABEAMENTO: constrói + conecta o baker de atlas de vetores de movimento em /out; você dispara o bake. export_node/camera são caminhos de nós da cena; vm_picture restrito; res do atlas + faixa de frames limitados; execute/render_map/render_sequence/renderdialog nunca pressionados.	10 opcionais
`bake_flipbook_textures`	Labs Flipbook Textures (labs::flipbook_textures::1.0, out/Driver) — SOMENTE-CABEAMENTO: constrói + conecta o baker de folha de texturas flipbook em /out; você dispara o bake.	23 opcionais
`bake_haircard_texture`	Hair Card Texture (haircardtex, out/Driver) — SOMENTE-CABEAMENTO: constrói + conecta o baker de textura de hair-card em /out; você dispara o bake. hairobjects é um bundle de objetos, camera um caminho de nó da cena; vm_picture restrito; tokens de nome por mapa sanitizados; res/samples limitados; execute/renderdialog nunca pressionados.	23 opcionais
`export_geo_to_i3d`	Geometry to i3d (geo2i3d, out/Driver) — SOMENTE-CABEAMENTO: constrói + conecta a exportação de textura de volume geometry->i3d em /out; você dispara. filename (saída) e image (entrada, leitura) restritos; res/faixa de frames limitados; execute/renderdialog nunca pressionados.	19 opcionais
`export_image_to_i3d`	Gerador de Textura 3D (image3d, out/Driver) — SOMENTE-CABEAMENTO: constrói + conecta o gerador de textura 3D i3d em /out; você dispara. soppath/shoppath são caminhos de nós da cena; saída de imagem restrita; token de compressão sanitizado; res/samples/faixa de frames limitados; execute/renderpreview/renderdialog nunca pressionados.	27 opcionais

Referências

Quatro superfícies de descobrimento dão suporte ao catálogo de ferramentas. capabilities é o índice inicial — ele imprime apontadores para todos os outros (incluindo a URL do servidor de ajuda ao vivo), então na dúvida chame-o primeiro.

Catálogo de ferramentas — a lista enumerada de toda operação tipada (reference/catalog.json, a contagem autoritativa), apresentada nas tabelas acima; detalhes por parâmetro vêm da ferramenta MCP node_reference e reference/NODE_REFERENCE.md. Esta é a fronteira de segurança: se não está no catálogo, o servidor não pode fazê-lo.
Referência de nós — a ferramenta MCP node_reference responde "quais parâmetros o nó X aceita?" a partir de verdade de campo sondada ao vivo; o arquivo legível por humanos é reference/NODE_REFERENCE.md (SOP / OBJ / LOP / Driver / COP), anotado com qual ferramenta expõe cada nó.
Referência VEX — a ferramenta MCP vex_reference consulta funções VEX seguras validadas; o guia curado é reference/VEX_REFERENCE.md.
Servidor de ajuda Houdini offline — a documentação completa de nós/VEX/HOM da SideFX, servida localmente e iniciada junto à ponte. Não tem ferramenta MCP; a saída de capabilities imprime sua URL.

Dados geoespaciais do mundo real

Este é o diferencial. acquire_terrain é a única operação de rede — dê a ela um lat/lon (+ raio) ou uma caixa delimitadora explícita, e ela auto-seleciona uma fonte, busca, reprojeta e prepara tiles prontos para Houdini no seu diretório de trabalho. A cobertura é global (veja DOWNLOADER_SCOPE.md para a matriz completa):

EUA — USGS 3DEP (1 m lidar / 10 m / 30 m) + vários portais de lidar estaduais.
Global 30 m — Copernicus GLO-30, SRTM ou JAXA ALOS AW3D30 (todos anônimos, sem chave), então qualquer ponto na Terra retorna terreno.
Nacional de alta resolução — Países Baixos 0,5 m, Reino Unido 1 m, França 1 m / 0,5 m, Espanha 5 m, Austrália 5 m (auto-selecionado quando uma solicitação "grande"/de alta resolução cai inteiramente dentro de um país coberto).
Opt-in com chave — a API global da OpenTopography, usando a própria chave gratuita do usuário (HMCP_OPENTOPO_KEY), nunca embutida.

Dois modos de posicionamento:

flat — heightfields métricas locais para um único local, importadas na elevação verdadeira com import_heightfield.
globe — tiles ECEF fixados em um globo WGS84 (build_globe + import_ecef_tile) para que um scan fique em um quadro terrestre correto e tiles adjacentes se registrem por construção.

Como uma origem de projeto é mantida entre chamadas, tiles sucessivos compartilham um quadro e se alinham automaticamente. A busca é restrita a um pequeno conjunto de hosts DEM confiáveis; nenhuma URL arbitrária cruza a fronteira.

Convenção de coordenadas

1 Houdini unit = 1 meter
Working CRS    = a local UTM zone chosen per project (metric, minimal distortion)
X = east-west,  Y = elevation (up),  Z = north-south, NEGATED (north = -Z)

A negação de Z é a clássica armadilha do espelho — custou uma sessão completa de depuração. Uma origem é mantida por projeto, então tiles sucessivos compartilham um quadro e se alinham automaticamente. Um <tile>.npy preparado precisa do seu sidecar <tile>.npy.json (cols, rows, res_m, houdini_center_x/z, nodata) ao lado dele.

Pegadinhas — Houdini 21.0.671

LIDAR/DEM do mundo real no Houdini quebra de maneiras não óbvias. Estas são confirmadas na 21.0.671 e são o valor original, arduamente conquistado, deste projeto:

GeoTIFF não é legível pelo COP2 / heightfield_file do Houdini. Todo I/O de GeoTIFF ocorre no Python do sistema (rasterio) → .npy; apenas arrays cruzam para o Houdini.
convertheightfield produz 0 prims a partir de volumes createVolume de estilo antigo — mas converte limpo a partir de um volume SOP heightfield adequado (verificado: 249k polys de um heightfield padrão).
heightfield_mosaic / heightfield_wrangle não existem no H21 — use heightfield_patch / volumewrangle em vez disso.
O "congelamento de 12 GB" é a tesselação GL do viewport, não RAM. Um heightfield pesado tesseliza centenas de milhões de voxels na GPU. Correção: construir com display desligado, transmitir tiles empacotados com um proxy de caixa e reduzir a qualidade do volume (viewport_optimize). RAM de dados não é um problema.
Nunca faça flipbook ou renderize em OpenGL uma cena com heightfield pesado — pode travar o Houdini. Use capture_ui (uma captura de tela em nível de SO) em vez disso.
Um volume SOP heightfield precisa de um atributo de primitiva name='height', e arrays LIDAR são primeiro-linha-norte, então as linhas são invertidas antes de setAllVoxels.
O viewport GL não mostra o bump do Principled Shader (apenas render Karma); relevo real precisa de deslocamento de geometria.

Opcional: Renderização GPU AMD (ProRender)

O caminho GPU Karma XPU do Houdini é exclusivo NVIDIA/OptiX. Se você tem uma placa AMD Radeon (RDNA2 / gfx1030+) e quer renderização por GPU, este repositório inclui uma compilação a partir do código-fonte do delegate hdRpr do AMD Radeon ProRender portado para Houdini 21 / USD 25 — a AMD não fornece plugin H21 pré-compilado. Ele instala como um renderizador Hydra nativo ("RPR") no Solaris e é totalmente opcional e independente do MCP central.

Status: funcionando (recompilado com o toolset MSVC v143; "RPR" é um renderizador Hydra selecionável e os VOPs de material RPR / configurações de render LOP / Biblioteca de Materiais carregam). Uma lacuna de conveniência conhecida: o diálogo Render Devices do menu RPR ainda precisa de um port de binding Python para USD-25 — não é necessário para renderizar. Veja AMDProRender/README.md para o release pré-compilado, passos de compilação a partir do código-fonte e o patch de port.

Configuração

A maioria da configuração acontece na GUI e é gravada em um arquivo de configuração compartilhado que ambas as metades leem ao vivo. A única variável de ambiente que o cliente MCP precisa é a flag headless.

Configuração	Onde	Descrição
`HMCP_GW_HEADLESS`	env (config do cliente)	`1` = executar o binário como gateway MCP stdio headless; não definido = abrir a janela da GUI.
`HMCP_MIN_ACTION_INTERVAL_MS`	env (config do cliente)	Throttle de ação (padrão `0` = desligado). Quando definido, o gateway impõe esse intervalo mínimo de relógio de parede, em milissegundos, entre chamadas de ferramenta destrutivas sucessivas (`delete_node`, `save_scene`, `delete_keyframes`) — ele as paceia com um sono curto, nunca rejeita. Um governador de segurança para que um loop descontrolado ou injeção de prompt não possa disparar rapidamente chamadas que destroem a cena. Ferramentas não destrutivas (construções, leituras) nunca são atrasadas.
Diretório de trabalho	GUI → Diretório de trabalho	Sua raiz do projeto. Cada leitura/escrita de arquivo é confinada por `realpath` sob ela. Alterar + Aplicar tem efeito ao vivo, sem reiniciar.
Porta do executor	GUI → Configurações	Porta de loopback compartilhada pelo gateway e o executor dentro do Houdini.
Token de sessão	GUI → Configurações	O segredo compartilhado entre o gateway e o executor. Gerado para você.
Auto-arm Houdini	GUI → Configurações	Arma o executor automaticamente quando a GUI do Houdini inicia.

Segurança

O modelo de segurança é a própria fronteira, não uma sandbox:

Somente dados por construção. Nenhum código arbitrário, nenhum driver de nó genérico, nenhum VEX ou Python bruto jamais chega ao Houdini. O catálogo é a superfície de ataque, e o catálogo é operações em formato de dados. Um teste de regressão afirma que as primitivas RCE (exec / node_op / wrangle) nunca podem aparecer no catálogo.
Diretório de trabalho confinado por realpath. Cada operação de arquivo resolve e re-verifica contra uma raiz, com escapes de symlink/junction fechados. Leituras devem existir sob a raiz; escritas podem criar uma nova folha, mas nunca escapar.
Armamento com falha fechada. O executor se recusa a armar a menos que uma regra de firewall bloqueie conexões de entrada para sua porta de loopback (veja Passo 4).
Renders são apenas wire. setup_karma e bake_texture constroem grafos, mas nunca executam — você os dispara no Houdini.
batch não concede privilégio. A meta-ferramenta batch executa até 64 operações em uma chamada para reduzir latência, mas cada operação é despachada pelo exato mesmo caminho que uma chamada direta — validada por esquema, numéricos limitados, caminhos de arquivo confinados por realpath, e auditados em ordem. Um lote só pode invocar ferramentas reais do catálogo (sem código arbitrário, sem nomes fora do catálogo) e não pode aninhar (uma operação chamada batch é rejeitada). É um envelope de latência, não uma forma de contornar a fronteira.
Throttle de ação opcional. HMCP_MIN_ACTION_INTERVAL_MS (padrão desligado) paceia ferramentas destrutivas (delete_node, save_scene, delete_keyframes) com um sono curto para que um descontrole/injeção não possa disparar rapidamente destruição de cena. Ele desacelera, nunca bloqueia; ferramentas comuns não são afetadas (veja Configuração).
O Python embutido do Houdini não é sandboxed, então a garantia é o que a IA pode pedir, validado no gateway — não isolamento de processo. Trate a IA como entrada semi-confiável.
Postura pretendida: loopback, usuário único confiável, máquina confiável. Esta é uma ferramenta local. O transporte deve permanecer no host local.

Uma auditoria em nível de código confirma que a fronteira somente-dados se mantém como construída. Para o modelo de ameaça completo, o status atual de endurecimento e os itens residuais conhecidos, veja SECURITY.md — leia antes de executar isso em qualquer lugar que não seja uma única máquina confiável.

Solução de problemas

Veja docs/TROUBLESHOOTING.md para soluções detalhadas e docs/GUIDE.md para operação do dia a dia.

Lista de verificação rápida:

O pílula de status da GUI mostra Armado com sua versão do Houdini.
O Houdini foi iniciado depois que o pacote foi instalado e o auto-arm foi habilitado.
A etapa de endurecimento do firewall (Passo 4) foi executada — o executor é fail-closed sem ela.
A configuração do cliente MCP aponta para o houdini-bridge-mcp.exe compilado com HMCP_GW_HEADLESS definido para 1.
Caminhos na configuração do cliente usam barras invertidas duplas (C:\\...).
O cliente foi totalmente reiniciado após editar sua configuração.
Caminhos de arquivo que você passa para ferramentas vivem dentro do diretório de trabalho configurado.

Licença

Licença dupla. Grátis para uso não comercial — pessoal, educacional, pesquisa e avaliação — sob a Licença Não Comercial PolyForm 1.0.0. Uso comercial, empresarial e de produção requer licença paga; veja COMMERCIAL-LICENSE.md para obter uma.

A ferramenta não inclui nenhum dado de elevação — ela baixa em seu nome em tempo de execução. As fontes globais são de domínio público / abertas (USGS 3DEP, Copernicus, SRTM, JAXA AW3D30); as fontes nacionais de alta resolução exigem atribuição sob suas próprias licenças abertas (Países Baixos AHN & Espanha IGN — CC-BY 4.0; Reino Unido EA — OGL; França IGN — Etalab OL 2.0; Austrália GA — CC-BY 4.0). Veja DOWNLOADER_SCOPE.md para a licença/atribuição por fonte. Avisos de dependências de terceiros são gerados em THIRD-PARTY-LICENSES.md para releases (veja CONTRIBUTING.md).

Suporte

Se isso economizou seu tempo e você está usando de forma não comercial, uma gorjeta é sempre apreciada — ko-fi.com/eviscerations. É voluntária e não concede licença; uso comercial é coberto por COMMERCIAL-LICENSE.md.

Desenvolvimento e testes

Os testes rodam em três níveis em dois ambientes (Níveis 1–2 no CI, Nível 3 local), divididos pelo que uma máquina sem licença do Houdini pode provar honestamente — veja docs/TESTING.md para o método completo:

CI em nuvem (a cada push, sem licença do Houdini): o cargo test em Rust protege as invariantes de segurança do gateway — o catálogo nunca expõe uma ferramenta de código arbitrário, nomes de ferramentas são únicos, e confine_path rejeita escapes de ../, symlink e junction. O job Python roda o corpus de red-team do validador de VEX seguro, a fronteira de travessia confined_path + escape de symlink, uma verificação de paridade catálogo↔executor em cada ferramenta (cada ferramenta mapeia para exatamente um endpoint somente-dados, nenhum com formato RCE), e um smoke de construção que chama o handler de cada ferramenta contra um Houdini mock para pegar regressões de código. Esses verificam que a superfície de ferramentas é estruturalmente sólida e que o código de cada handler roda — eles não cozinham geometria.
Local (antes de um push, hython licenciado): a suíte comportamental em tests/executor/ cozinha geometria real e trava testes de regressão. Execute hython tests/executor/run_tests.py.

O método completo está documentado para contribuidores em docs/TESTING.md.

Contribuindo

Pull requests são bem-vindos — veja CONTRIBUTING.md. Se você testar em hardware ou configuração do Houdini não listados aqui, por favor abra uma issue com seus resultados.