houdini-bridge-mcp

Controla SideFX Houdini desde un chat de IA: una superficie de control centrada en la seguridad y basada únicamente en datos, donde la IA crea wrangles validados, nunca código arbitrario.

GitHubPrueba este MCPPatrocinado

Documentación

houdini-bridge-mcp

Maneja SideFX Houdini desde un chat de IA: una superficie de control solo-datos y seguridad-primero donde la IA crea wrangles validados, nunca código arbitrario.

Un servidor MCP (Model Context Protocol) nativo de Windows que permite a un cliente de chat de IA manejar SideFX Houdini a lo largo de una amplia franja de su superficie creativa, mediante un catálogo fijo de herramientas tipadas y validadas sin vía de código arbitrario. La IA construye e inspecciona redes de nodos y puede crear un wrangle validado y acotado; tú lanzas los cooks y renders pesados. También funciona como una forma segura de aprender Houdini: cada paso es una operación guiada, explicable y en sandbox, no una caja negra. El catálogo es amplio: geometría y limpieza · instancing · simulación (FLIP/Pyro/RBD/Vellum) · rigging y animación de personajes (KineFX, Crowd, Muscle) · composición de imágenes COP · look y materiales · ML/ONNX · SideFX-Labs (árboles/biomas/construcción de mundos) · render y exportación — además de un carril único de geodatos del mundo real (DEM / USGS 3DEP / LIDAR) que reproyecta y sitúa la elevación a escala real. Un único binario se ejecuta junto a Houdini y a tu cliente de IA; eso es toda la instalación.

Estado: v0.1.0 publicada — endurecida en seguridad, completa en funciones. El ejecutor dentro de Houdini (la superficie de herramientas tipadas), el descargador de terreno (cobertura global + nacional) y el binario controlador en Rust + el paquete de Houdini están todos incluidos — descarga la puerta de enlace desde la página de Releases. Objetivo: Houdini 21.0.671 (Apprentice funciona; Houdini 22 existe pero aún no se adopta aquí). Prioridad Windows; otras plataformas más adelante.

Inicio rápido

¿Nuevo aquí / no eres programador? Empieza aquí. Muchos usuarios de Houdini ya viven en código y en una terminal: pero no necesitas hacerlo. Para ponerte en marcha: consigue un programa, haz clic en un par de botones en su ventana, inicia Houdini y pega un pequeño bloque de configuración en tu cliente de IA. Eso es todo el trabajo. Los tres pasos siguientes son el mapa; los pasos numerados 1–7 más abajo desarrollan cada uno en detalle, y solo tocas una línea de comandos si eliges compilar el programa desde el código fuente en lugar de descargarlo.

Lo que necesitarás a mano: Houdini 21.0.671 (la edición gratuita Apprentice es suficiente), un PC con Windows y un cliente de IA que hable MCP (Claude Desktop, Cursor, etc.). Una carpeta en tu disco se convierte en el proyecto al que se le permite acceder a la IA — elígela en el Paso 3.

Tres pasos para una configuración funcional (detalle completo en los Pasos 1–7 más abajo):

Consigue la puerta de enlace (el único programa que conecta tu IA con Houdini) — ya sea descargando el houdini-bridge-mcp.exe precompilado desde Releases (sin programación), o compilándolo desde el código fuente (cd gateway && cargo build --release, necesita el toolchain de Rust). Es un único archivo sin dependencias de ejecución.
Instala y arma — ejecuta la puerta de enlace, que abre una pequeña ventana de GUI. En ella: haz clic en Install Houdini package (conecta Houdini para que se auto-conecte), configura tu directorio de trabajo y haz clic en Apply (la única carpeta que la IA puede leer y escribir), y activa Auto-arm. Luego inicia Houdini — la píldora de estado debería indicar Armed. Antes de permitir que cualquier cosa que no sea esta misma máquina acceda a él, ejecuta el script de firewall (Paso 4).
Conecta tu cliente de IA — indícale a tu cliente de IA (Claude Desktop, Cursor, ...) dónde está la puerta de enlace pegando un pequeño bloque JSON en su configuración (listo para copiar y pegar en el Paso 6), reinicia el cliente por completo y luego ejecuta la verificación del Paso 7 para confirmar que la IA puede ver tu escena de Houdini.

Por qué es diferente

Otros servidores MCP de Houdini/Blender exponen ejecución arbitraria de Python al modelo — potente, pero es ejecución remota de código por diseño (en todo el campo analizado, cada puente comparable incluye una herramienta de tipo execute_code, y un puente de Blender ampliamente usado tiene un problema documentado de ejecución remota de código). Este es lo contrario:

Solo datos por construcción. La IA solo puede llamar a un registro fijo de 1.467 operaciones tipadas y validadas. Deliberadamente no existe herramienta de código arbitrario, no hay configurador genérico de parámetros de nodos y no hay vía directa a VEX/Python crudo — simplemente no existen en el catálogo, por lo que no se puede sortear el límite hablando con él. El conjunto de cosas que el servidor puede hacer es la lista enumerada de herramientas.
Creación validada: el diferenciador, no una vía de escape. La única herramienta que lleva código, set_attrib_expr (opt-in, desactivada por defecto), toma un fragmento de atributo VEX y lo valida contra una lista blanca antes de que Houdini lo vea: sin acceso a archivos/host/red, solo funciones de la lista blanca y demostrablemente total — siempre termina. El flujo de control se compone de condicionales, bucles contados acotados estáticamente (for — un techo de iteración literal o limitado por min()) y un bucle de arreglo finito y de solo-hojas (foreach, cuyo número de iteraciones VEX fija al entrar, y que no puede anidarse dentro ni contener otro bucle); while/do/gather siguen prohibidos, por lo que no existe ninguna construcción de bucle infinito. Tres capacidades se superponen detrás de sus propios consentimientos independientes desactivados por defecto: bucles acotados (allow_attrib_loops), ediciones de topología por eliminación (removepoint/removeprim, allow_attrib_geoedit) y construcción/crecimiento (addpoint/addprim/addvertex/removevertex, allow_attrib_geogrow) — todo anclado a la geometría de trabajo de la entrada 0, y cada consentimiento es independiente (activar uno nunca otorga otro). La mayor parte del trabajo de wrangle está cubierto por operadores tipados de todos modos (cálculo de campos, matemática por vóxel, CSG/advance mediante vdb_*); vex_reference también sirve como referencia de funciones sin conexión para pegar a mano.

Esta es la línea que ningún otro MCP de Houdini mantiene: la IA puede crear un wrangle real y capaz sin jamás entregarte un shell remoto. Cada puente de terceros incluye execute_code sin validar/VEX crudo — RCE por diseño. El propio MCP oficial que SideFX está preparando valida el código generado para verificar su corrección a posteriori, y solo para rigging. Este valida un subconjunto acotado de la entrada, antes de que se ejecute, en todo el conjunto de herramientas — un modelo más estricto, no una puerta más pequeña.
Aprende Houdini con una IA — con seguridad, no solo manejarlo. Cada acción es una operación tipada, en sandbox, explicable, y la IA te entrega el wrangle validado exacto que propone — así que funciona como un tutor guiado: pídele que construya algo, observa cómo conecta la red, lee el porqué. Nada de lo que hace puede ejecutar código arbitrario en tu máquina ni tocar trabajo fuera de la carpeta del proyecto, lo que lo hace tan seguro para la primera escena de un principiante como para un pipeline bloqueado. Las mismas vías que lo mantienen seguro lo convierten en un lugar de bajo riesgo para aprender cómo funciona realmente Houdini.
Un único directorio de trabajo. Cada lectura y escritura de archivo está confinada por realpath a una sola carpeta de proyecto que tú eliges. Nada fuera de ella es accesible, ni siquiera a través de un symlink o junction.
Los renders son solo de cableado. La IA construye grafos de render (Karma, texture bake); tú los lanzas. Nunca desencadena un render por su cuenta.
Construido para geodatos del mundo real. Es el único de su tipo orientado a DEM / 3DEP / LIDAR: reproyecta y sitúa la elevación a escala real, reconstruye nubes de puntos en mallas limpias (ajuste de plano y remesh, no masas orgánicas) y puede fijar teselas en un marco terrestre correcto.
Amplio, no solo terreno. El pipeline geoespacial es la especialidad, pero la misma superficie tipada y solo-datos abarca la mayor parte de Houdini: modelado y limpieza, los principales solvers, rigging y animación de personajes (esqueletos/captura/deformación KineFX, Crowd, Muscle), composición de imágenes COP, ML/ONNX y el conjunto de herramientas de árboles/biomas/mundos SideFX-Labs — todo bajo el mismo límite sin RCE.

Aprende Houdini con una IA

Houdini es famosamente profundo, y el momento de la red en blanco es donde la mayoría de la gente se da por vencida. Este puente es una forma guiada y de bajo riesgo de sentarse y aprenderlo de verdad — describes lo que quieres, la IA lo construye en tu sesión en vivo, y observas cómo la red toma forma.

No es un juguete. La superficie de herramientas alcanza una porción amplia y capaz del Houdini real — modelado y limpieza, configuración de simulación de geometría (FLIP / Pyro / RBD / Vellum), rig y animación de personajes (KineFX, Crowd, Muscle), composición de imágenes COP, look y materiales, y el conjunto de herramientas de árboles/biomas/mundos de SideFX-Labs. Puedes aprender un flujo de trabajo genuino, no una imitación de sandbox. (Consulta los números honestos de cobertura más abajo para saber exactamente qué está dentro y fuera del alcance).
Los endpoints tipados son el andamiaje de aprendizaje. Cada capacidad es una operación fija, tipada y validada, por lo que la IA solo puede alcanzar operaciones reales de Houdini — no puede vagar fuera de lo que el software realmente hace ni inventar un paso que no existe. La propia lista de herramientas refleja cómo está organizado Houdini (las familias SOP/COP/DOP/KineFX, el conjunto de herramientas de Labs), de modo que la superficie que limita a la IA también te enseña cómo está estructurada la aplicación.
Lo observas, no lo ejecutas a ciegas. Cada operación se transmite en vivo al registro de auditoría de la GUI de la puerta de enlace, así que ves a la IA trabajar paso a paso en una sesión de Houdini en ejecución — la red se construye frente a ti, nodo por nodo, en lugar de ejecutarse en un lote sin cabeza que nunca observas. Ese modo en vivo y observado es la ventaja de aprendizaje. (La operación sin cabeza sigue siendo compatible para usuarios avanzados que la quieran).
Los errores se convierten en momentos de enseñanza, no en desastres. La IA puede equivocarse — puede elegir el nodo incorrecto o calcular mal un parámetro. El punto no es que nunca falle; es que la superficie tipada, en sandbox e inspeccionable hace que cualquier error sea visible, fácil de deshacer e inofensivo. Nada de lo que hace ejecuta código arbitrario ni toca archivos fuera de tu carpeta de proyecto, así que un mal paso es algo que detectas y corriges mientras aprendes por qué, no algo que pueda dañar tu máquina o tu trabajo.
- Por eso no se construyó sobre un puente execute_code existente. El diseño asume que el modelo puede equivocarse, ser manipulado (inyección de indicaciones) o funcionar mal — y que darle a un agente código arbitrario más un objetivo es el modo de fallo de alta severidad documentado (agentes que escapan de su sandbox, actúan de forma autónoma y no detectada, y alcanzan credenciales/red/archivos). Así que, en lugar de iterar desde un MCP de Blender/Houdini que le entrega al modelo un shell, este elimina la vía de código por completo y reconstruye solo-datos: el catálogo tipado fijo es el límite. La limitación es la propiedad de seguridad. Consulta SECURITY.md para conocer el razonamiento completo.

Cobertura honesta: qué está dentro del alcance y qué no. Por recuento bruto, el catálogo alcanza una minoría deliberada de los tipos de nodos no obsoletos de Houdini — expuestos como las 1.467 herramientas tipadas del catálogo (un tipo de nodo suele alcanzarse mediante varias herramientas, y familias enteras — VOP / SHOP / COP-internas / PDG — se excluyen por diseño, no por omisión). Pero ese número bruto subestima la cobertura creativa, porque está fuertemente ponderado hacia los flujos de trabajo que la mayoría de la gente usa realmente y deja fuera algunos dominios completos a propósito:

Bien cubierto (el núcleo creativo): composición COP ~84 %, modelado/geometría SOP ~49 %, SideFX-Labs ~65 %, rig/animación KineFX ~53 %.
Deliberadamente fuera del alcance (decisiones de alcance, no errores): USD / Solaris (LOP) ~10 %, PDG / TOP 0 % (el dominio de lotes / grafo de dependencias), los contextos heredados Cop2 y Shop, y los internos de VOP (1,3 % — por diseño: un VOP es un bloque de construcción interno de grafo, no una superficie de datos que el puente exponga).

En resumen: aproximadamente una cuarta parte de la superficie de nodos de Houdini por recuento bruto, pero ponderada hacia los flujos de trabajo creativos que la mayoría de la gente usa realmente, con algunos dominios completos (USD/Solaris, PDG) excluidos intencionalmente. Un recién llegado sabe de antemano qué puede aprender aquí y qué no.

Qué puedes hacer con él

Una vez instalado y armado, puedes decir cosas como estas directamente en tu cliente de chat de IA (las rutas son relativas al único directorio de trabajo que configures):

"Construye el terreno alrededor de 46.5°N, 114.0°O a una resolución de 10 m y coloca una cámara sobre él."
"Obtén la elevación para este cuadro delimitador e impórtala a escala real."
"Carga scans/site.ply, limpia el moteado y conviértelo en malla."
"Erosiona este heightfield, luego enmascara los barrancos y las laderas sombreadas."
"Dispersa rocas por el terreno con instancias empaquetadas para que el viewport siga liviano."
"Dame una luz solar para media tarde y encuadra la cresta."
"Configura un render Karma apuntando a esa cámara; yo presionaré el botón."
"Exporta la malla del terreno como USD a mi carpeta de proyecto."
"Construye un esqueleto KineFX para esta malla, captúralo y prueba la deformación del bind."
"Configura una multitud de agentes caminando por un camino a través del terreno."
"Lanza una simulación FLIP en esa cuenca y guárdala solo como wire."
"¿Qué hay en la escena ahora mismo y cuánta memoria está usando Houdini?"

Cómo 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

El binario es tanto una pequeña interfaz gráfica (front-of-house: localiza Houdini, define el directorio de trabajo, genera un token de sesión y muestra un registro de auditoría en vivo de cada llamada) como la puerta de enlace MCP sin interfaz gráfica con la que tu cliente de IA se comunica a través de stdio.
La pasarela es la puerta de entrada tipada: cada tools/call se valida contra el catálogo — claves desconocidas rechazadas, numéricos limitados al rango, enum comprobados, rutas confinadas — antes de reenviar cualquier cosa.
El ejecutor es un paquete de Python solo con datos que se arma automáticamente dentro de tu sesión de Houdini y realiza la operación solicitada sobre nodos reales.

La pasarela y el ejecutor comparten un único token, puerto y directorio de trabajo, con una única fuente de verdad en un pequeño archivo de configuración que escribe la GUI — así que no hay fragmentos manuales de shell ni conflictos de puertos.

Requisitos

Houdini 21.0.671 — Apprentice funciona (la edición gratuita; no se necesita comprar licencia para probar esto).
Una cadena de herramientas Rust (estable) — solo si compilas la pasarela tú mismo; sáltalo si descargas el .exe precompilado desde Releases. rustup.rs.
Python — solo para el descargador opcional de terreno (rasterio para el paso de preparación de datos DEM); cualquier CPython reciente funciona. No es necesario para la primera ejecución.
Windows — primero Windows; otras plataformas más adelante.

Paso 1 — Obtén la pasarela

¿Prefieres no codificar? Descarga el houdini-bridge-mcp.exe precompilado desde Releases y salta directamente al Paso 2: es el mismo binario único que produce la compilación. ¿Quieres compilar desde el código fuente en su lugar (o aún no hay binario precompilado para tu configuración)? Ejecuta:

cd gateway
cargo build --release

De cualquier manera terminarás con un archivo: la pasarela es tanto la GUI como el servidor MCP sin interfaz gráfica. El modo en el que se ejecuta se selecciona al iniciar mediante una variable de entorno, HMCP_GW_HEADLESS — sin asignar abre la ventana de la GUI; 1 ejecuta el servidor stdio sin interfaz gráfica. (Normalmente no lo configurarás a mano: hacer doble clic en el archivo abre la GUI, y el bloque de configuración del Paso 6 establece la bandera sin interfaz gráfica para tu cliente de IA).

Paso 2 — Instala el paquete de Houdini con auto-armado

Esto coloca un pequeño paquete de Houdini que arma el ejecutor automáticamente cuando la GUI de Houdini se inicia, por lo que el puente se activa listo, sin un paso de "iniciar el servidor".

A través de la GUI (recomendado): lanza el binario y luego ve a Configuración → Instalar paquete de Houdini.

O manualmente, copia los dos archivos estáticos del paquete a tu directorio de preferencias de usuario de Houdini (por defecto en %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

Los archivos del paquete son distribuibles: no contienen rutas absolutas, nombres de usuario ni valores de máquina; todo lo dinámico se lee en tiempo de ejecución desde el archivo de configuración compartido.

Paso 3 — Configura mediante la GUI

Lanza el binario con HMCP_GW_HEADLESS sin asignar para que aparezca la ventana, luego:

Configuración — confirma el puerto del ejecutor y el token de sesión (los valores predeterminados están bien; el token es el secreto compartido entre las dos mitades).
Directorio de trabajo — escribe tu raíz del proyecto. Todos los subdirectorios dentro de ella son accesibles; nada fuera de ella lo es. Haz clic en Aplicar.
Vuelve a Configuración y activa Auto-armado de Houdini.

Aplicar + Auto-armado escriben el archivo de configuración compartido (arm.json, bajo tu perfil de usuario) que la GUI, el ejecutor y la pasarela sin interfaz gráfica leen en vivo. Cambiar el directorio de trabajo más tarde es simplemente Aplicar: no se necesita reiniciar.

Dónde vive arm.json / habilitar VEX seguro. arm.json es la raíz de confianza — directorio de trabajo, token de sesión, puerto y banderas de características — en:

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

La única vía opcional de código, set_attrib_expr, está desactivada por defecto. Para activarla, abre Configuración → VEX seguro (avanzado) y activa Habilitar VEX seguro (allow_attrib_expr) — esto tiene efecto inmediato (el ejecutor vuelve a leer la bandera por llamada; sin reinicio). Ese panel también tiene botones Abrir arm.json y Abrir carpeta de configuración si prefieres editar a mano; para habilitarlo manualmente, establece "allow_attrib_expr": true en el archivo. Este es un interruptor solo para operadores — un agente conductor nunca puede acceder a arm.json (se mantiene fuera de límites incluso cuando el directorio de trabajo está mal configurado a un ancestro), por lo que la IA no puede habilitar su propia vía de código. Desactívalo de la misma manera cuando termines.

Paso 4 — Refuerza el firewall

El ejecutor se arma con cierre por fallo — se niega a armarse a menos que una regla de firewall bloquee conexiones entrantes a su puerto de loopback. Ejecuta el script incluido una vez, desde un 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

Usa loopback (el valor predeterminado) para una sola máquina confiable; usa lan solo en una red de estudio confiable.

Paso 5 — Arma el ejecutor

Lanza Houdini. El paquete instalado arma automáticamente el ejecutor desde la configuración compartida — la consola imprime:

[houdini-bridge-mcp] executor armed

La pastilla de estado de la GUI muestra Armado con la versión de Houdini conectada — para la mayoría de las personas esa pastilla es toda la confirmación que necesitan. No se requiere ningún fragmento de shell de Python. Si quieres verificar desde una terminal (opcional, para curiosos — usa tu puerto y token configurado):

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

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

Paso 6 — Regístrate con tu cliente MCP

Apunta tu cliente (por ejemplo, Claude Desktop — edita el archivo en %APPDATA%\Claude\claude_desktop_config.json; pega esa ruta en la barra de direcciones del Explorador de archivos para encontrarlo) al binario de la pasarela en modo sin interfaz gráfica (sin ventana — la IA lo controla directamente). La pasarela lee el directorio de trabajo, el puerto y el token del archivo de configuración compartido, por lo que el bloque de entorno solo necesita la bandera sin interfaz gráfica. Establece command a la ruta completa del .exe del Paso 1:

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

Usa doble barra invertida en todas las rutas de Windows.

Cierra y reabre el cliente por completo. En un nuevo chat aparecen las herramientas de houdini-bridge-mcp.

Paso 7 — Verifica tu configuración

Confirma que la pastilla de estado de la GUI muestre Armado con tu versión de Houdini.
En un nuevo chat del cliente, pide un informe de escena:

"Ejecuta scene_info."

Una respuesta exitosa (archivo hip, fotograma, versión de Houdini, contenido de /obj) confirma el enlace cliente → pasarela → ejecutor de extremo a extremo.
Luego convierte un tile DEM preparado en un heightfield real:

"import_heightfield de terrain.npy, nómbralo terrain y muéstralo."

Si ambos devuelven resultados, estás conectado. Consulta docs/SETUP.md para el tutorial completo de la primera ejecución y docs/GUIDE.md para la operación diaria.

Herramientas disponibles

Alrededor de 1,467 operaciones tipadas, agrupadas en las familias a continuación (las tablas generadas muestran el catálogo actual exacto). Cada herramienta es un manejador validado — no existe una ruta de código libre. Referencia completa de parámetros: consulta docs/GUIDE.md, o pregunta a la herramienta node_reference en vivo durante la sesión.

Adquirir e importar

Herramienta	Qué hace	Parámetros clave
`acquire_terrain`	Obtén la elevación del mundo real para un lugar y prepárala en teselas listas para Houdini en el directorio de trabajo.	11 opcionales
`create_geo`	Crea una geometría /obj vacía, opcionalmente sembrada con un SOP de primitiva inicial.	`name` (+1 opcional)
`import_pointcloud`	Carga / importa una NUBE DE PUNTOS .ply o .bgeo (LIDAR, fotogrametría, puntos de escaneo) en una nueva geometría /obj mediante un SOP de archivo. up_axis z_up rota los datos de levantamiento con eje Z hacia el eje Y de Houdini; downsample conserva cada N-ésimo punto para aligerar nubes pesadas; recenter lo mueve al origen.	`path`, `name` (+3 opcionales)
`import_heightfield`	Importa un DEM preparado (.npy + .json sidecar) como un volumen de altura de Houdini, colocado en la elevación real sobre un origen de proyecto compartido (con Z negada).	`npy`, `name` (+1 opcional)
`import_ecef_tile`	Fija una tesela DEM preparada (un .npy prep_ecef de posiciones (H,W,3)) sobre el globo como una malla de cuadriláteros curvada en su posición y elevación reales.	`npy`, `name` (+1 opcional)
`list_working_dir`	Lista los archivos + carpetas en el DIRECTORIO DE TRABAJO confinado para que puedas DESCUBRIR qué activos están presentes antes de importar: la respuesta a '¿puedes ver mi archivo?'.	5 opcionales
`import_geo`	Carga / importa un archivo de geometría de MALLA — .obj, .bgeo/.bgeo.sc, .fbx, .stl, .ply, .geo y otros formatos de File-SOP — en una nueva geometría /obj. include_prim_types carga como geometría empaquetada (memoria plana para activos pesados).	`path`, `name` (+1 opcional)
`import_alembic`	Carga / importa un archivo Alembic (.abc) — mallas animadas/en caché, cámaras y transformaciones — en una nueva geometría /obj mediante un SOP de Alembic. groupnames elige cómo las rutas del archivo se convierten en grupos de primitivas; polysoup carga polígonos como primitivas de sopa de polígonos ligeras en memoria.	`path`, `name` (+2 opcionales)
`trace_raster`	Trazar / vectorizar un ráster de imagen (.png/.jpg/.tif) en CURVAS de contorno 2D mediante el SOP de Trazado — convierte un logotipo, silueta, máscara o mapa en curvas poligonales para extruir/barrer.	`file`, `name` (+2 opcionales)
`osm_filter`	Filtro OSM de SideFX Labs — conserva solo las clases de características deseadas de la geometría de OpenStreetMap importada (entrada 0 = una salida de osm_import).	`input` (+12 opcionales)
`osm_buildings`	Edificios OSM de SideFX Labs — extruye masas de edificios 3D a partir de los polígonos de huella cerrados de OpenStreetMap en la entrada 0 (una salida de osm_import / osm_filter que lleva el atributo de primitiva `building`).	`input` (+8 opcionales)
`obj_importer`	Importador OBJ de SideFX Labs — una geometría /obj nueva que importa un archivo Wavefront .obj (`file`, confinado a lectura) con un .mtl personalizado opcional (`custom_mtl`, confinado a lectura).	`name`, `file` (+1 opcional)
`fbx_archive_import`	Importación de archivo FBX de SideFX Labs — una geometría /obj nueva que importa un archivo FBX (`file`, confinado a lectura) como geometría de Houdini fusionada, opcionalmente con materiales / animación / huesos.	`name`, `file` (+10 opcionales)
`multi_file`	Archivo múltiple de SideFX Labs — una geometría /obj nueva que importa hasta ocho archivos de geometría a la vez (`file1`..`file8`, cada uno confinado a lectura) y los fusiona, opcionalmente estampando un atributo `name` de cada nombre de archivo.	`name`, `file1` (+9 opcionales)
`regions_from_image`	Regiones desde imagen de SideFX Labs — una geometría /obj nueva que lee una imagen (`image`, confinada a lectura) y genera geometría de regiones cuantizadas por color (`num_colors` regiones; `smoothing` suaviza los límites).	`name` (+9 opcionales)
`trace_psd_file`	Trazar archivo PSD de SideFX Labs — una geometría /obj nueva que lee una imagen en capas (`file`, confinada a lectura; un .psd de Photoshop) y traza sus capas en contornos poligonales 2D.	`name`, `file`
`las_import`	Ingesta nativa de LIDAR LAS/LAZ/E57 (el formato real de entrega topográfica/aérea) en una nueva geometría /obj.	`name`, `file` (+13 opcionales)
`osm_import`	Importa carreteras/edificios/huellas de OpenStreetMap (geometría de contexto de recinto) en una nueva geometría /obj.	`name`, `file` (+4 opcionales)
`usd_import_sop`	Importa un archivo USD en geometría SOP dentro de una geometría /obj nueva (el `usdimport` de contexto SOP — el puente de lectura desde un escenario USD hasta los SOP nativos de Houdini).	`file` (+12 opcionales)

Terreno y campos de altura

Herramienta	Qué hace	Parámetros clave
`heightfield_crop`	Recortar / redimensionar / redefinir la ventana de un volumen de altura a una caja de tamaño en metros. sizex/sizey son el ancho y largo de la ventana; center [x,y,z] posiciona la ventana (deslizarla sobre un campo más grande con cropmode=replace); cropmode es intersect (recortar a la superposición, predeterminado), replace (usar la nueva caja, extender más allá de la original mediante la política de borde) o union (bbox de ambos); voxelpad agrega píxeles de relleno.	`input` (+6 opcionales)
`heightfield_patch`	Transferir/mezclar características de un volumen de altura de parche (entrada1) sobre una base (entrada0) con un límite suave — mosaico de teselas DEM adyacentes o sellado de una región enmascarada. scale escala uniformemente el parche (cuadrícula + magnitud de características) antes de la transferencia; heightscale escala solo las alturas de características transferidas; tx/tz trasladan y ry rotan alrededor de Y el parche antes de la transferencia; centerpatch pivota esos controles sobre la región enmascarada.	`input`, `patch` (+7 opcionales)
`convert_heightfield`	Convertir un volumen de altura en geometría renderizable/exportable. conversion elige la salida (poly \| polysoup denso no editable \| vdb volumen 3D); surftype es la conectividad de polígonos (triángulos/cuadriláteros son los diseños de terreno útiles); lod es Densidad = relación de resolución de salida (0.5 = media res, 2 = 4x supermuestreo); bake_colors hornea el material del campo de altura sobre la malla como Cd de punto para que el entregable lleve el gradiente; extrude_base + depth agregan una base extruida sólida (hermética para impresión/CFD).	`input` (+8 opcionales)
`heightfield_morph`	Morfología en escala de grises en la capa de altura de un /obj heightfield nombrado, construida en el servidor como una cadena de volume-wrangles mín/máx separables (sin un SOP nativo único). op: dilate (crecer picos) \| erode (crecer valles) \| close (rellenar canales hasta el envolvente circundante, mantener picos) \| open (eliminar picos delgados). radius_m establece el radio del kernel en metros (convertido a vóxeles mediante voxelsize).	`name` (+5 opcionales)
`heightfield_fill`	Relajación laplaciana enmascarada, construida en el servidor como una cadena de volume-wrangles de Jacobi (sin un SOP nativo único): rellenar vóxeles enmascarados (mask==1) promediando vecinos mientras se mantienen vóxeles no enmascarados (mask==0) como límite de Dirichlet — reconstruye una superficie suave a través de un canal/hueco. iterations = pasos de Jacobi (más = relleno más suave/lejano); seed_layer opcionalmente presiembra los vóxeles enmascarados.	`name` (+5 opcionales)
`heightfield_tilesplit`	Dividir un campo de altura en una cuadrícula de tiles_x por tiles_y (LOD nativo / streaming / exportación por tesela para motores de juego).	`input` (+7 opcionales)
`heightfield_clip`	Recortar valores de altura a una banda mín/máx (recorte de valores atípicos / aplanado de mesas). minheight/maxheight son el suelo/techo del recorte (cada uno activa automáticamente su conmutador); soft_clip suaviza la transición al valor recortado en lugar de un límite duro (predeterminado activado) y clip_strength establece su nitidez.	`input` (+5 opcionales)
`heightfield_cutout`	Recortar una región no rectangular del campo de altura delimitada por geometría (entrada1), escribiendo la capa de visualización `Alpha` (recorte en Alpha=0.5).	`input` (+5 opcionales)
`heightfield_erode`	Erosión hidráulica + térmica a una escala de características elegida (HeightField Erode 3.0).	`input` (+27 opcionales)
`heightfield_visualize`	Aplicar un gradiente de color a un campo de altura para que su elevación (y una tinción de máscara opcional) sea visible en el viewport — se inserta en el espacio de vóxeles nativo. layer es la capa de altura mostrada como superficie 3D (parámetro de nodo `heightvolume`); color_layer tiñe una capa de máscara sobre ella; preset elige un esquema difuso integrado (infrarrojo/rosa/mono/blackbody/bipartito); min_elevation/max_elevation fijan el rango altura->rampa, o deja compute_range activado (predeterminado) para presionar automáticamente los botones Compute Range del SOP y que la rampa se asigne a la elevación real.	`input` (+8 opcionales)
`heightfield_maskbyfeature`	Enmascarar terreno por una o más características (pendiente / altura / dirección de orientación / curvatura) — aislar picos, valles, línea de nieve, suelo plantable.	`input` (+17 opcionales)
`heightfield_maskbyocclusion`	Máscara de oclusión ambiental (cavidades / grietas / suelo resguardado) en la capa de máscara — la oclusión es cuánto de una esfera alrededor de cada vóxel está bloqueada por terreno cercano (raycasting). minexposure/maxexposure reasignan la banda de oclusión a la máscara (por debajo de min->0, por encima de max->1); dohemisphere muestrea solo el hemisferio superior (cielo); viewdistance es la longitud del rayo (0=infinito, más largo=más preciso/lento).	`input` (+9 opcionales)
`heightfield_maskbyshadow`	Enmascarar las áreas sombreadas desde una dirección de sol dada (impulsa derretimiento de nieve, musgo, vestuario sol/sombra). lightdir es el acimut del sol en grados (0=luz a lo largo de +X, +90=a lo largo de -Z); lightangle es la elevación del sol en grados (más bajo=sombras más largas); opacity es el valor de máscara en sombra; falloff suaviza los bordes de sombra (0=duro).	`input` (+9 opcionales)
`heightfield_maskbyobject`	Enmascarar una región del campo de altura desde otra geometría (entrada1, fusionada por objetos) en la capa de máscara — el contorno 2D de la geometría de superficie, o la intersección de un volumen de niebla/SDF (para proyección de altura 3D usar heightfield_project en su lugar). method: ray (proyectar una superficie hacia abajo) \| volume (niebla) \| sdf; maskdir (método ray): proyectar desde ambos lados \| arriba \| abajo; maxdist es la distancia máxima del rayo antes de un fallo; value es el valor de máscara donde la geometría impacta; blurradius suaviza la máscara.	`input` (+11 opcionales)
`heightfield_flatten`	Aplanar una región enmascarada de un campo de altura (borrar características, o nivelar una huella de edificio). method: value = establecer el área enmascarada a `elevation` (establecer elevación fuerza este modo); average = nivelar al promedio del área enmascarada; slope = interpolar suavemente el límite (predeterminado; ignora elevación). mask_layer controla el aplanado (0=intacto, 1=completamente plano); blurradius suaviza el borde de la máscara.	`input` (+5 opcionales)
`heightfield_maskbyconcavity`	Enmascarar regiones cóncavas (lechos de río / valles / barrancos) en una capa de máscara — la concavidad se mide por visibilidad del cielo (rayos lanzados desde cada vóxel). concavity/maxconcavity establecen la banda enmascarada (agregar vóxeles cuya concavidad sea >= concavity y <= maxconcavity); invert enmascara fuera de esa banda; combine fusiona con una máscara existente; viewdistance es la longitud del rayo (más largo=más preciso/lento).	`input` (+7 opcionales)
`heightfield_deform`	Deformar geometría por un campo de altura CAMBIANTE: los puntos suben/bajan (y opcionalmente rotan a la nueva pendiente) por la diferencia entre el terreno en reposo y el actual — por ejemplo, flotar props empaquetados en una superficie de agua, o aplicar una inclinación de rebote isostático.	`input` (+3 opcionales)
`heightfield_layer`	Utilidad por capa en una capa de campo de altura nombrada. op=clear establece cada vóxel de la capa a `value`. op=prop establece la política de extensión de borde de la capa `border` (constante \| repetición \| streak \| sdf) — importa al teselar/fusionar campos. op=isolate copia la capa en `mask` (y opcionalmente `height` mediante overwrite_height/overwrite_mask) para que el viewport con tinte rojo predeterminado la muestre.	`input` (+7 opcionales)
`terrain_analysis`	Labs Terrain Analysis: escribir atributos de punto de pendiente / curvatura para dispersión, pathfinding y sombreado.	`input` (+7 opcionales)
`add_tile_packed`	Cargar una tesela .bgeo(.sc) horneada como primitiva de disco empaquetada (carga diferida, costo de visualización casi nulo) en un nuevo /obj geo — la forma segura de memoria para transmitir muchas teselas de terreno.	`name`, `path` (+3 opcionales)
`set_tile_lod`	Alternar el LOD del viewport de una tesela empaquetada (proxy de caja <-> geometría completa) para un intercambio hero — apunta al File SOP `packed_tile` creado por add_tile_packed bajo el /obj geo nombrado.	`name` (+1 opcional)
`heightfield_noise`	Agregar ruido procedural a una capa de campo de altura (superficie de ruido completa: combinar, amp/scale/offset, base+fractal, octavas, gain/bias, recorte, deformación de lattice/gradiente).	`input` (+32 opcionales)
`heightfield_blur`	Desenfocar / desenfoque de caja / expandir / encoger / afinar una capa de campo de altura.	`input` (+10 opcionales)
`heightfield_flowfield`	Lluvia sobre un campo de altura y deslizamiento del agua cuesta abajo para calcular capas de flujo / dirección de flujo (impulsa máscaras de erosión, deposición, valles topográficos rápidos).	`input` (+15 opcionales)
`heightfield_project`	Raycasting de geometría de entrada (objeto, fusionado por objetos en entrada1) sobre una capa de campo de altura como altura 3D — sellar geometría real en el terreno (para un contorno 2D plano usar heightfield_maskbyobject).	`input` (+16 opcionales)
`heightfield_scatter`	Dispersar puntos etiquetados a través de un campo de altura usando su capa de máscara (colocación de activos / instancias, heightfield_scatter 2.0).	`input` (+45 opcionales)
`heightfield_terrace`	Cortar terrazas / mesas escalonadas en un campo de altura (heightfield_terrace 2.0) con ruido de ondulación y máscaras de pendiente de mesa/acantilado.	`input` (+22 opcionales)
`heightfield_remap`	Reasignar el rango de valores de una CAPA de campo de altura (heightfield_remap) — reescalar altura/máscara/cualquier capa escalar de [input_min,input_max] a [output_min,output_max]: normalizar un DEM a 0..1, aumentar contraste de máscara, invertir una capa (intercambiar min/max de salida), comprimir elevación.	`input` (+9 opcionales)
`heightfield_resample`	Remuestrear un campo de altura a una nueva resolución (heightfield_resample) — reducir resolución de un DEM enorme para iteración rápida, o aumentar antes de erosión/exportación. resolution_scale multiplica la res actual (0.5=mitad, 2=doble), o exact_resolution + division_mode para un objetivo preciso.	`input` (+7 opcionales)
`hf_combine_masks`	SideFX Labs Combine Masks — fusiona y post-procesa capas de MÁSCARA de campo de altura en el campo de altura entrante (`input`, entrada 0).	`input` (+11 opcionales)
`hf_insert_mask`	SideFX Labs Insert Mask — copia una capa de MÁSCARA/altura nombrada desde un segundo campo de altura (`mask`, entrada 1) al campo de altura base (`input`, entrada 0).	`input`, `mask` (+4 opcionales)
`terrain_segment`	SideFX Labs Terrain Segment — divide el campo de altura entrante (`input`, entrada 0) en una cuadrícula de tiles_x x tiles_y de teselas de terreno mallado (su SOP cocinado ES la geometría segmentada). doextrude+depth dan faldones sólidos; flat hornea a una malla plana; iterations impulsa el remallado de densidad adaptativa.	`input` (+12 opcionales)
`terrain_texture`	SideFX Labs Terrain Texture — horneador de mapas de terreno SOLO-CABLE: hornea mapas normal / altura / oclusión / cavidad / curvatura del terreno entrante (`input`, entrada 0) a `outputdir`.	`input` (+15 opcionales)
`terrain_layer_export`	SideFX Labs Terrain Layer Export — SOP exportador SOLO-CABLE que escribe el campo de altura entrante (`input`, entrada 0) como heightmap de paisaje Unreal/Unity + imágenes de capas de pintura a `output`.	`input` (+12 opcionales)
`terrain_layer_import`	SideFX Labs Terrain Layer Import — nodo FUENTE (0 entradas) que lee una imagen de heightmap de paisaje Unreal/Unity (`sHeightmap`) en un /obj heightfield nuevo. voxelsize establece la resolución HF resultante; bFlop invierte el orden de filas.	`name` (+3 opcionales)
`biome_define`	SideFX Labs Biome Define — define el perfil climático de UN bioma (nombre + temperatura/precipitación promedio + indicador de suelo) como un flujo de puntos de configuración.	9 opcionales
`biome_plant_define`	SideFX Labs Biome Plant Define — define UNA especie de planta y sus tolerancias climáticas (temperatura y precipitación mínima/preferida/máxima), hábito (Árbol/Arbusto), límites/radio de tronco, escala y densidad máxima — el registro que biome_scatter lee para colocar vegetación.	27 opcionales
`biome_definitions_file`	SideFX Labs Biome Definitions File — serializa una biblioteca de biomas a / desde JSON.	6 opcionales
`biome_plant_definitions_file`	SideFX Labs Biome Plant Definitions File — serializa la biblioteca de especies de plantas a / desde JSON (espejo de biome_definitions_file para plant_define).	6 opcionales
`biome_profile`	SideFX Labs Biome Profile — almacena/escribe el perfil de bioma combinado (el biomeprofile.json que consumen los nodos biome_initialize / region_assign / curve) con temperatura y precipitación promedio por bioma.	`name` (+4 optional)
`biome_initialize`	SideFX Labs Biome Initialize — el punto de entrada del pipeline: toma un terreno y una fuente de región de bioma y genera el Terrain preparado (salida 0) + Biome Regions (salida 1).	28 optional
`biome_region_assign`	SideFX Labs Biome Region Assign — asigna las regiones de bioma de la fuente de región entrante (`input`, entrada 0) contra la biblioteca de biomas, emitiendo Biome Regions (salida 0) + Guide Geometry (salida 1).	`input` (+25 optional)
`biome_attributes_evolve`	SideFX Labs Biome Attributes Evolve — evoluciona las capas de atributos climáticos (temperatura / precipitación / suelo) a través del terreno entrante (`input`, entrada 0) según reglas físicas: la temperatura disminuye con la elevación (`lapserate`), la precipitación se elimina en el lado de sotavento de las montañas (sombra de lluvia: removebydir + dirección rain_x/rain_z + anglespread), y el suelo se elimina en acantilados (removebyslope + pendiente min/max) y por ruido procedural (removebynoise + noise basis/fractal/amp/elementsize).	`input` (+34 optional)
`biome_attributes_to_terrain`	SideFX Labs Biome Attributes To Terrain — hornea los atributos climáticos del bioma en el terreno entrante (`input`, entrada 0) como capas de heightfield nombradas (temperatura / precipitación / suelo / color de bioma) listas para sombreado o exportación posteriores.	`input` (+12 optional)
`biome_curve_setup`	SideFX Labs Biome Curve Setup — etiqueta una CURVE de región creada (`input`, entrada 0 — un límite dibujado a mano) con el bioma al que pertenece (`biomename_curve`) y un orden de clasificación (`biomehierarchy`), produciendo el flujo de curvas fusionado que biome_region_assign lee en modo curvas.	5 optional
`biome_curve_label`	SideFX Labs Biome Curve Label — etiqueta una CURVE de región (`input`, entrada 0) directamente con valores climáticos explícitos (temperatura / precipitación / suelo / color de bioma / orden de clasificación) en lugar de extraerlos de un perfil — la contraparte manual de biome_curve_setup.	11 optional
`region_assignment_subutil`	SideFX Labs Region Assignment (subutilidad) — un helper interno de plomería utilizado dentro del pipeline de regiones de bioma: itera `lpcount` veces sobre la geometría entrante (`input`, entrada 0), leyendo un parámetro HDA nombrado (`hda_parm`) por iteración y escribiendo su valor en un atributo de punto/prim (`attrib_name`), indexado por `index_parm`.	`input` (+5 optional)
`convert_regions_to_curves_subutil`	SideFX Labs Convert Regions To Curves (subutilidad) — convierte los POLYGONS de región en la geometría entrante (`input`, entrada 0) en primitivas CURVE de límite, una curva cerrada por región.	`input` (+2 optional)

Modelo y geometría

Herramienta	Lo que hace	Parámetros clave
`remesh`	Remesh de triangulación uniforme (Remesh 2.0) — reconstruye una superficie triangulada/escaneada en triángulos bien formados y de tamaño uniforme para suavizado, simulación o deformación limpia. targetsize es la longitud de arista objetivo en unidades del mundo (menor = malla más densa, mayor recuento de polígonos); sizing=uniform da un solo tamaño en todos lados, sizing=adaptive concentra triángulos más pequeños en la curvatura (density = multiplicador de densidad objetivo adaptativo). gradation sesga la mezcla uniform<->adaptive (0 uniforme .. 1 completamente adaptativo a curvatura). iterations = pasos de suavizado/optimización; smoothing = fuerza de relajación de puntos por pasada. min_edge/max_edge restringen la longitud de arista producida.	`input` (+13 opcionales)
`polyreduce`	Decimar (PolyReduce 2.0) — colapsar una malla a una fracción de su recuento de polígonos para LOD / entrega en tiempo real manteniendo la silueta y las características. target elige a qué apunta la reducción: poly_percent / pt_percent (porcentaje, el predeterminado, mediante percentage) o poly_count / pt_count (un recuento final absoluto — el caballo de batalla del LOD). qualitytolerance intercambia calidad por velocidad.	`input` (+11 opcionales)
`boolean`	Booleano (mesh CSG) de A contra B (boolean::2.0) — cortar/combinar sólidos.	`input` (+7 opcionales)
`sweep`	Barrer una sección transversal a lo largo de una curva guía para hacer una SUPERFICIE — la pieza clave de curva→geometría: tuberías, cables, cuerdas, rieles, cintas de carretera/río, molduras arquitectónicas. shape=tube\|square\|ribbon usa un perfil incorporado (tube: radius; square/ribbon: width; cols fija la densidad); shape=input barre tu propia sección transversal SOP (entrada 1).	`input` (+15 opcionales)
`polyextrude`	Extruir caras poligonales hacia afuera a lo largo de sus normales (polyextrude::2.0) — el caballo de batalla para edificios desde huellas, greebles, engrosamiento. distance = profundidad de empuje; inset encoge la tapa extruida hacia adentro; divisions añade bucles de pared lateral; twist rota la tapa (en grados).	`input` (+19 opcionales)
`polybevel`	Biselar/redondear aristas o puntos (polybevel::3.0) — la operación de suavizado de superficies duras (chaflanes, empalmes, costuras de soldadura). offset = tamaño del empalme; divisions = segmentos redondeados (1 = chaflán plano, más = más suave); shape elige el perfil (round \| chamfer \| crease \| solid).	`input` (+8 opcionales)
`deform`	Deformador de nodo único, elegido por op: bend (curva la geometría a lo largo de un eje, `amount` = ángulo°), twist (`amount` = fuerza de torsión°), mountain (desplaza a lo largo de normales por ruido fractal, `amount` = altura, `frequency` = tamaño del elemento de ruido), attribnoise (ruido en un atributo, `amount` = amplitud, `frequency` = tamaño del elemento), lattice (deformación por jaula, fija divsx/divsy/divsz), peak (empuja puntos a lo largo de normales, `amount` = distancia).	`input` (+7 opcionales)
`drape`	Proyectar/colgar los puntos de entrada sobre una superficie de colisión — asentar props dispersos, curvas o una rejilla sobre el terreno.	`input` (+5 opcionales)
`transform`	Mover / rotar / escalar GEOMETRÍA 3D en la escena (SOP Transform) — posicionar un objeto o un grupo de puntos/prims en el espacio 3D. translate, rotate (grados), escala uniforme + por eje, pivot, restricción de grupo, orden transform/rotate.	`input` (+15 opcionales)
`select_group`	Selección acotada y luego borrado inverso; bbox mantiene la geometría interior, de lo contrario pattern selecciona un grupo con nombre.	`input` (+4 opcionales)
`merge`	Fusionar varios SOPs en un solo flujo.	`inputs` (+1 opcional)
`switch`	Generar UNA de varias entradas, seleccionada por un índice entero — ensamblaje de variantes/LOD y alternancias A/B.	`inputs` (+2 opcionales)
`null`	Paso directo sin operación / punto de referencia con nombre — la convención LANDMARK: colocar un null después de cada resultado significativo y nombrarlo OUT_ (un identificador de resultado estable; los downstream object_merge/refs apuntan al NOMBRE, por lo que insertar nodos arriba nunca los rompe), IN_ (una entrada de geo externa) o CONTROL (parámetros de control / entrada libre).	`input` (+1 opcional)
`sort`	Reordenar deterministamente puntos y/o prims — ids estables para determinismo de copy-stamp / instancing.	`input` (+7 opcionales)
`polysplit_loop`	Insertar bucle(s) de arista paramétrico(s) (modo Edge-Loop de polysplit::2.0) — añadir bucles de soporte/control manteniendo quads.	`input`, `seed_edge` (+3 opcionales)
`poly_split`	Cortar una ruta de arista de forma LIBRE a través de caras (modo Shortest-Distance de polysplit::2.0) — enrutar un nuevo tramo de arista 'hacia arriba y sobre' n-gons / costuras booleanas para recuperar quads, la primitiva de retopología mecánica.	`input`, `path` (+6 opcionales)
`copy_transform`	Copiar-y-Transformar (copyxform): N copias de la entrada, cada una con una transformación incremental ACUMULATIVA (la copia i obtiene i× el translate/rotate/scale).	`input` (+14 opcionales)
`helix`	Crear un /obj geo nuevo con una curva de hélice / bobina (SOP spiral) — el generador de resortes / bobinas / roscas (resorte de vástago, rosca de perno, hebra de ADN, guía espiral). turns=revoluciones, height=elevación axial (0=espiral plana), start/end_radius afinan la bobina.	`name` (+8 opcionales)
`polywire`	Convertir una curva / alambre en geometría de tubo sólido (polywire) — resortes, cables, tuberías, cuerdas, renderizados de alambre, neuronas, ramas. divisions=lados de la sección transversal (mín 3), segments=subdivisiones a lo largo del tramo, joint_correct evita el pandeo donde se encuentran los alambres.	`input` (+9 opcionales)
`convex_decompose`	Descomposición convexa aproximada (convexdecomposition) — romper una malla cóncava en un conjunto de piezas de casco convexo, la forma estándar de hacer PROXIES DE COLISIÓN RBD/física baratos (un casco convexo es mucho más barato de colisionar que una malla cóncava, y la mayoría de los solvers quieren colisionadores convexos). max_concavity (0..1) intercambia ajuste vs cantidad: menor = más ajustado + MÁS cascos, mayor = menos/más sueltos. output=hulls (piezas convexas, predeterminado) \| segments (superficie original particionada + etiquetada). per_piece descompone cada isla `piece_attrib` (p. ej., `name`) de forma independiente — la norma después de una fractura.	`input` (+10 opcionales)
`set_color`	Asignar un color constante.	`input` (+3 opcionales)
`uv`	UV mediante modo: project (uvproject), unwrap (uvunwrap auto), layout (uvlayout::3.0 empaquetado de atlas), transform (uvtransform) o flatten (uvflatten::3.0 impulsado por costuras).	`input` (+17 opcionales)
`uv_transfer`	Transferir un conjunto de UV desde un mesh FUENTE a la geometría de entrada — restaurar UVs que un cambio de topología (remesh/quad_remesh/polyreduce) destruyó.	`input`, `source` (+5 opcionales)
`create_primitive`	Crear un /obj geo nuevo con un SOP primitivo (box/grid/sphere/tube/line/circle/platonic/torus) — el bloque de inicio para modelado de superficies duras + orgánico.	`name` (+10 opcionales)
`skin`	Loft/skin una superficie a través de curvas de perfil ordenadas — la entrada es un SOP que contiene varios prims de perfil (fusiona curvas paralelas primero); skin cruza entre ellas en orden de prim. output_polygons=false produce un mesh de splines; v_wrap=wv cierra el loft en un bucle.	`input` (+10 opcionales)
`revolve`	Tornear una curva de perfil alrededor de un eje → una superficie de revolución (jarrón, tubo, botella, rueda, pantalla de lámpara). axis+origin definen el eje de giro (por defecto Y a través del origen); divisions = lados; revolve_type=openarc\|closedarc + angle=[start,end] hacen un arco parcial; caps cierra los extremos.	`input` (+11 opcionales)
`mirror`	Reflejar geometría a través de un plano y (por defecto) soldar la costura. axis=x\|y\|z es un atajo para la normal del plano (o da dirx/diry/dirz + originx/originy/originz); dist desplaza el plano. keep_original=false reemplaza con solo el espejo; weld fusiona la costura; operation=clip corta en el plano en lugar de reflejar.	`input` (+15 opcionales)
`dissolve`	Disolver un grupo de aristas (o puntos), FUSIONANDO las caras adyacentes — simplificación de topología (a diferencia de blast, que elimina y deja un agujero).	`input`, `group` (+6 opcionales)
`bridge`	Puentear dos bucles de aristas en un tubo/faldón de conexión (polybridge).	`input`, `src_group`, `dst_group` (+12 opcionales)
`pointdeform`	Deformar la entrada por el movimiento de una jaula: rest_cage (entrada1) → deformed_cage (entrada2).	`input`, `rest_cage`, `deformed_cage` (+7 opcionales)
`crease`	Escribir creaseweight en un grupo de aristas para que un subdivide posterior mantenga esas aristas NÍTIDAS — la clave para un modelado creíble de superficies de subdivisión en superficies duras. group = grupo de aristas, weight = valor de crease (0..10), op = addto\|set\|delete.	`input` (+5 opcionales)
`divide`	Dividir/triangular polígonos. triangulate (convexo, predeterminado activado) con max_sides; smooth (subdivisiones estilo Catmull) con divisions; brick=true + brick_size=[x,y,z] tesela el mesh; compute_dual construye el mesh dual; remove_shared_edges fusiona.	`input` (+10 opcionales)
`polyexpand2d`	Desplazar curvas 2D en contornos/cintas de ancho variable — carreteras desde curvas OSM, líneas de panel, insets. input = un SOP de curva 2D. offset = semi-ancho; output=curves\|surfaces; inside/outside elige qué lado(s) emitir; width_attrib nombra un atributo por punto para ancho variable.	`input` (+10 opcionales)
`lsystem`	Crear un /obj geo nuevo con un sistema-L (curvas ramificadas procedimentales o tubos barridos — árboles, coral, rayos, crecimiento). premise = el axioma; rules = una lista de cadenas de producción 'A=...' (una gramática de tortuga INERTE, NO código); generations/angle/step/thickness son escalares tipados; output=skel\|tube.	`name` (+10 opcionales)
`create_curve`	Crear un /obj geo nuevo que contiene una curva construida a partir de puntos proporcionados por el llamador.	`name`, `points` (+3 opcionales)
`tree_trunk_generator`	Generador de tronco de árbol SideFX Labs — la RAÍZ de la cadena de árbol modular.	`name` (+24 opcionales)
`tree_controller`	Controlador de árbol SideFX Labs — un nodo FUENTE (0 entradas, 1 salida) que contiene ajustes a nivel de árbol (gravedad / curvatura / tropismo de luz, booleano de costuras, LOD).	`name` (+18 opcionales)
`tree_branch_generator`	Generador de ramas de árbol SideFX Labs — EL caballo de batalla: hace crecer un nivel de ramas laterales desde un padre.	`input` (+30 opcionales)
`tree_simple_leaf`	Hoja simple de árbol SideFX Labs — construye un /obj geo nuevo que contiene UNA tarjeta de plantilla de hoja (o aguja); conecta su salida a la entrada `leaf` del tree_leaf_generator para dispersarla sobre el árbol. bend=0 da una aguja plana.	`name` (+11 opcionales)
`tree_leaf_generator`	Generador de hojas de árbol SideFX Labs — el término de la cadena: dispersa la plantilla de hoja sobre las ramas.	`input` (+21 opcionales)
`quick_basic_tree`	Árbol básico rápido SideFX Labs — árbol de conveniencia de una llamada crecido desde `input` (una superficie base / conjunto de puntos), complementando la cadena modular.	`input` (+15 opcionales)
`maps_baker`	Baker de mapas SideFX Labs — horneado de textura de atlas LOD SOLO POR CABLES.	`input` (+28 opcionales)
`capsule`	Cápsula SideFX Labs — un /obj geo nuevo que contiene un primitivo de cápsula (un cuerpo cilíndrico con dos tapas hemisféricas). radius/height lo dimensionan, sides fija la resolución radial, bodysegments/capsegments la resolución longitudinal, direction el eje largo.	`name` (+6 opcionales)
`cylinder_generator`	Generador de cilindro SideFX Labs — un /obj geo nuevo que contiene un cilindro/cono/tubo procedimental con más control que el tube nativo. uniformradius une la parte superior + base a radius; deshabilítalo para afinar con topradius/baseradius. sides/divisions fijan la resolución; opencylinder + arcstart/arcend cortan un arco abierto; endcaps + fillmode tapan los extremos.	`name` (+14 opcionales)
`disc_generator`	SideFX Labs Disc Generator — una /obj geo nueva que contiene un disco / anillo / corona plana. innerradius>0 crea un anillo/arandela; outerradius es el borde exterior. sides/divisions establecen la resolución; arcstart/arcend cortan una cuña; orientation elige el plano; innerheight/outerheight lo convierten en un cono/embudo poco profundo.	`name` (+10 opcionales)
`hexagon_grid`	SideFX Labs Hexagon Grid — una /obj geo nueva que contiene una cuadrícula de hexágonos. type=polygon construye caras hexagonales (malla); type=points genera solo los centros de los hexágonos. gridshape define la forma base (hexagon/triangle/rectangle/parallelogram), gridsize su extensión, cellradius el tamaño de cada hexágono, cellorientation la orientación punta vs plana, orientation el plano. connectivity=connected fusiona los bordes compartidos.	`name` (+7 opcionales)
`quad_sphere_generator`	SideFX Labs Quad Sphere Generator — una /obj geo nueva que contiene una esfera solo de quads (cubo subdividido) con topología limpia y uniforme (a diferencia de la esfera nativa con polos). subdivisions es EXPONENCIAL en el recuento de polígonos (6*4^n quads) y está limitado a <=7.	`name` (+3 opcionales)
`simple_shapes`	SideFX Labs Simple Shapes — una /obj geo nueva que contiene una de una familia de formas de perfil 2D seleccionada por `shape` (triangle/diamond/rectangle/trapezoid/polygon/star/double_star/square_star). base/height dimensionan la familia rectangular; radius/sides/points/innerradius controlan las familias de polígonos y estrellas. closed cierra el perfil en una cara; adduvs añade UVs.	`name` (+11 opcionales)
`superformula_shapes`	SideFX Labs Superformula Shapes — una /obj geo nueva que contiene una forma 2D de la familia superfórmula, seleccionada por `shapeselect` (square/circle/triangle/polygon/diamond/star/squircle/rounded_polygon/clover/flower/sunburst/eye/teardrop/heart/custom). width/height la dimensionan; circpointnum establece la resolución de círculo/curva; polysides/starspokes+starpinchbloat/flowerspokes controlan las familias de polígonos/estrellas/flores. fillshape rellena el perfil en una superficie (de lo contrario, una curva de contorno); roundcorners bisela las esquinas.	`name` (+10 opcionales)
`quadrangulate`	SideFX Labs Quadrangulate (labs::quadrangulate::2.0) — convierte una malla triangulada en quads fusionando pares de triángulos (preserva la topología; NO es una reconstrucción completa como quad_remesh).	`input` (+8 opcionales)
`voxelmesh`	SideFX Labs VoxelMesh (labs::voxelmesh::2.0) — reconstruye `input` (entrada 0) en una malla hermética rasterizándola a un VDB con `resolution` vóxeles a lo largo del eje más largo, y luego mallando la superficie (un remallado basado en volumen, distinto del remallado de superficie nativo).	`input` (+11 opcionales)
`connect_polygon_neighbours`	SideFX Labs Connect Polygon Neighbours (labs::connect_polygon_neighbours::1.0) — emite un punto en cada centroide de polígono de `input` (entrada 0) y (modo predeterminado) aristas de polilínea que conectan vecinos adyacentes por cara — el grafo dual/adyacencia de la malla.	`input` (+6 opcionales)
`edge_group_to_polylines`	SideFX Labs Edge Group to Polylines (labs::edge_group_to_polylines::1.0) — extrae las aristas nombradas por `edgegroup` de `input` (entrada 0) como primitivas de polilínea individuales.	`input` (+2 opcionales)
`edgegroup_to_curve`	SideFX Labs Edge Group to Curve (labs::edgegroup_to_curve::1.1) — como edge_group_to_polylines pero une las aristas nombradas por `group` en curvas conectadas y ordenadas (encadena extremos compartidos).	`input` (+8 opcionales)
`symmetrize`	SideFX Labs Symmetrize (labs::symmetrize) — refleja `input` (entrada 0) a través del plano definido por `origin` + `direction` (normal) y suelda las mitades en una malla simétrica.	`input` (+9 opcionales)
`thicken`	SideFX Labs Thicken (labs::thicken::1.1) — da grosor a una superficie / capa abierta extruyéndola a lo largo de sus normales por `depth` y puenteando las paredes (solidificar).	`input` (+10 opcionales)
`boolean_curve`	SideFX Labs Boolean Curve — booleano 2D/curva de dos entradas de curva.	`input` (+5 opcionales)
`curve_branches`	SideFX Labs Curve Branches — dispersa curvas de ramas hijas a lo largo de la(s) curva(s) de entrada (entrada 0).	`input` (+14 opcionales)
`curve_resample_by_density`	SideFX Labs Curve Resample by Density — remuestrea la curva de entrada (entrada 0) con una densidad de puntos no uniforme.	`input` (+5 opcionales)
`curve_sweep`	SideFX Labs Curve Sweep — barre una sección transversal a lo largo de la curva base (entrada 0) para construir un tubo/cinta.	`input` (+6 opcionales)
`merge_splines`	SideFX Labs Merge Splines — fusiona/combina curvas spline superpuestas en una red conectada.	`input` (+5 opcionales)
`polywire_uv`	SideFX Labs PolyWire UV — construye tubos polywire con UV alrededor de una red de aristas o curva (entrada 0).	`input` (+11 opcionales)
`progressive_resample`	SideFX Labs Progressive Resample — remuestrea uniformemente la curva de entrada (entrada 0) con una longitud de segmento progresiva controlada por un atributo `pscale` por punto.	`input` (+5 opcionales)
`spiral`	SideFX Labs Spiral — un nodo FUENTE (0 entradas): construye una /obj geo nueva que contiene una curva espiral / hélice.	`name` (+7 opcionales)
`sweep_geometry`	SideFX Labs Sweep Geometry — instancia/barre una MALLA de sección transversal a lo largo de una curva base.	`input`, `curve` (+11 opcionales)
`view_vertex_order`	SideFX Labs View Vertex Order — anota la geometría de entrada (entrada 0) con una visualización del orden de vértices: color por elemento más flechas de orden opcionales, pasando la geometría de origen.	`input` (+5 opcionales)
`box_clip`	SideFX Labs Box Clip — recorta `input` (entrada 0) contra una caja alineada a los ejes, conservando la geometría que sobrevive a los planos laterales habilitados (cada conmutador neg/pos activa uno de los seis planos de recorte; los seis están activados por defecto). size/center (vec3 vía _x/_y/_z) y scale dimensionan y colocan la caja de recorte — hazla MÁS GRANDE que la geometría para conservarlo todo, más pequeña para recortar. fillholes tapa el corte.	`input` (+16 opcionales)
`boxcutter`	SideFX Labs BoxCutter — un cortador de caja booleano para `input` (entrada 0): resta, fragmenta o une una caja transformable contra la malla. boolean_op elige la operación; bevel_divisions/bevel_distance redondean la caja de corte; translate/rotate/scale (vec3 vía _x/_y/_z) la colocan y dimensionan; copies (+ copy_translate/copy_rotate vec3) repiten el corte en matriz.	`input` (+20 opcionales)
`boxcutter_subutil`	SideFX Labs BoxCutter Sub-Utility — el cortador de caja booleano de forma única subyacente a boxcutter, utilizable de forma independiente en `input` (entrada 0). operation elige subtract/shatter/union; translate/rotate/scale (vec3 vía _x/_y/_z) colocan la caja; distance extruye el corte, divisions biselan sus esquinas; copies (+ copy_translate/copy_rotate vec3) lo repiten en matriz. active lo activa/desactiva; pasa la malla cuando está inactivo.	`input` (+21 opcionales)
`mesh_slice`	SideFX Labs Mesh Slice — corta `input` (entrada 0) con una cuadrícula de planos de corte alineados a los ejes (divisions_x/_y/_z planos por eje) y (con fill_holes) tapa los cortes, produciendo piezas separables. isolate_index + index conservan solo una pieza.	`input` (+7 opcionales)
`polyslice`	SideFX Labs PolySlice — corta `input` (entrada 0) con num_slices planos paralelos, posicionados/orientados por center (vec3), size (vec3), scale y rotate (vec3). mode genera polígonos cortados o secciones transversales de polilínea. connectivity decide cómo se agrupan las piezas cortadas; divide_convex triangula las caras no convexas resultantes.	`input` (+25 opcionales)
`split_prim_by_normal`	SideFX Labs Split Prim by Normal — selecciona las primitivas de `input` (entrada 0) cuya normal apunta a lo largo de `axis` en el `direction` elegido, dentro de spread_angle grados; invert invierte la selección.	`input` (+5 opcionales)
`polyscalpel`	SideFX Labs PolyScalpel — corta la malla de origen `input` (entrada 0) dondequiera que la geometría requerida `cutter` (entrada 1) la cruce. cutting_geo_type DEBE coincidir con el tipo del cortador (points / polylines / polygon_surfaces); input_geo_type coincide con el origen. surface_output elige puntos en aristas vs superficies cortadas; slicing_method elige la ruta exacta de PolySplit o la más rápida de Boolean-Shatter. source_group/cutting_group son NOMBRES de grupos de geometría que limitan cada lado.	`input`, `cutter` (+14 opcionales)
`calculate_occlusion`	SideFX Labs Calculate Occlusion — análisis de oclusión ambiental / cavidad: lanza rayos contra la superficie (y un `occluder` opcional en la entrada 1) y escribe un valor de oclusión en el atributo de punto `occattr` (más una visualización `Cd` cuando `colorout` está activado).	`input` (+14 opcionales)
`calculate_slope`	SideFX Labs Calculate Slope — calcula la pendiente de la superficie (ángulo de la normal de cada punto respecto al eje vertical) en el atributo de punto `sSlopeAttribute` (más una visualización `Cd` cuando `bSlopeCd` está activado).	`input` (+8 opcionales)
`calculate_thickness`	SideFX Labs Calculate Thickness — mide el grosor local de la malla lanzando `numrays` rayos hacia adentro por punto y escribe la distancia en el atributo de punto `attrname` (predeterminado `thickness`; más una visualización `Cd` cuando `outputcolor` está activado).	`input` (+10 opcionales)
`distance_from_border`	SideFX Labs Distance From Border — para cada punto calcula la distancia al borde/arista de frontera abierta más cercano y la escribe en el atributo de punto `distattr` (más una visualización `Cd` cuando `bDistanceAsColor` está activado).	`input` (+11 opcionales)
`edge_color`	SideFX Labs Edge Color — escribe una visualización `Cd` que resalta aristas convexas vs cóncavas (una visualización de desgaste/curvatura utilizada para impulsar máscaras de daño en bordes).	`input` (+8 opcionales)
`fast_gaussian_curvature`	SideFX Labs Fast Gaussian Curvature — calcula la curvatura gaussiana discreta (defecto angular) en el atributo de punto `attribname_curv` (predeterminado `curvature`) más un ángulo en `attribname_angle`.	`input` (+11 opcionales)
`measure_curvature`	SideFX Labs Measure Curvature — mide la curvatura de la superficie en los atributos de punto `convexityattr` (predeterminado `convexity`) y `concavityattr` (predeterminado `concavity`), más una visualización `Cd` cuando `viscolor` está activado.	`input` (+13 opcionales)
`physical_ambient_occlusion`	SideFX Labs Physical Ambient Occlusion — un horneado de AO basado en física en el atributo de punto `outputattrib` (predeterminado `ao_mask`; más una visualización `Cd`).	`input` (+18 opcionales)
`spectral_feature_extract`	SideFX Labs Spectral Feature Extract — análisis de características espectrales (difusión/PDE): extrae características multiescala de un atributo de punto de entrada y escribe los atributos de punto `outattrib_f` (predeterminado `extracted_float`) y `outattrib_v` (predeterminado `extracted_vec`).	`input` (+19 opcionales)
`validate_geometry_type`	SideFX Labs Validate Geometry Type — un GUARDIÁN de pipeline: pasa la geometría de entrada sin cambios mientras verifica una regla sobre ella, generando un mensaje/advertencia/error si la regla falla.	`input` (+5 opcionales)
`autouv`	SideFX Labs Auto UV — UV automático con un clic: auto-costuras la malla, aplana cada isla (SCP/ABF) y luego las empaqueta en un atlas.	`input` (+25 opcionales)
`uv_unwrap_cylinder`	SideFX Labs UV Unwrap Cylinder — desenvuelto UV cilíndrico para tuberías / tubos / extremidades.	`input` (+7 opcionales)
`inside_face_uvs`	SideFX Labs Inside Face UVs — aplana UVs en las caras interiores ("inside") de una malla fracturada para que el interior de la fractura pueda texturizarse.	`input` (+9 opcionales)
`automatic_trim_texture`	SideFX Labs Automatic Trim Texture — ajusta de forma no interactiva las islas UV de la malla sobre un atlas de hojas de recorte (trim-sheet).	`input`, `trim` (+10 opcionales)
`calculate_uv_distortion`	SideFX Labs Calculate UV Distortion — mide cuánto estira/comprime el diseño UV cada elemento frente a su forma 3D y lo escribe en `distortionattribute` (por defecto uv_distortion).	`input` (+5 opcionales)
`merge_small_islands`	SideFX Labs Merge Small Islands — fusiona las islas UV cuya área relativa esté por debajo de `cutoff` en una isla adyacente y las vuelve a aplanar, reduciendo el número de islas para un empaquetado más limpio.	`input` (+7 opcionales)
`remove_uv_distortion`	SideFX Labs Remove UV Distortion — relaja iterativamente el estiramiento UV empujando hacia dentro los vértices distorsionados ("picos") y tirando hacia fuera los aplastados ("agujeros").	`input` (+13 opcionales)
`texel_density`	SideFX Labs Texel Density — mide y (opcionalmente) iguala los texeles por unidad en una malla con UVs para un `texturesize` dado.	`input` (+9 opcionales)
`uv_remove_overlap`	SideFX Labs UV Remove Overlap — detecta islas UV superpuestas en el tile 0-1 (rasterizado en `resolution`) y, cuando `repairoverlaps` está activado, las separa; opcionalmente agrupa los prims problemáticos.	`input` (+6 opcionales)
`uv_unitize`	SideFX Labs UV Unitize — reasigna cada primitiva (o cada isla UV) para que sus UVs llenen el cuadrado unitario 0-1 — preparación estándar para flujos de trabajo de trim-sheet / texturas repetibles.	`input` (+8 opcionales)
`building_from_patterns`	SideFX Labs Building From Patterns — dispone MÓDULOS de edificio sobre un blockout usando una gramática de patrones de planta/módulo.	`input` (+17 opcionales)
`building_generator`	SideFX Labs Building Generator — corta un blockout 3D en plantas y lo reviste con módulos.	`input` (+20 opcionales)
`building_module`	SideFX Labs Building Module (labs::building_generator_utility) — etiqueta una malla de entrada como MÓDULO de edificio reutilizable (nombre, peso, prioridad, bounding box) para que lo consuman building_generator / building_from_patterns.	`input` (+9 opcionales)
`pathfinding_global`	SideFX Labs Pathfinding Global — calcula RUTAS de menor coste entre puntos de asentamiento sobre un terreno.	`input`, `terrain` (+12 opcionales)
`road_generator`	SideFX Labs Road Generator — construye mallas de superficie de carretera con intersecciones a partir de CURVAS de carretera de entrada (líneas centrales).	`input` (+19 opcionales)
`settlement_connections`	SideFX Labs Settlement Connections — conecta PUNTOS de asentamiento en un grafo de red de carreteras, filtrando las conexiones por ángulo / distancia / cantidad.	`input` (+13 opcionales)
`cable_generator`	SideFX Labs Cable Generator — construye mallas de cables / alambres colgantes.	`input` (+26 opcionales)
`lot_subdivision`	SideFX Labs Lot Subdivision — subdivide recursivamente un bloque poligonal 2D en LOTS de construcción.	`input` (+11 opcionales)
`scifi_panels`	SideFX Labs Sci-Fi Panels — añade greebles a una malla con paneles: subdivide la superficie en lotes y luego extruye paneles con bordes realzados, muescas / biseles.	`input` (+22 opcionales)
`simple_rope_wrap`	SideFX Labs Simple Rope Wrap — barre geometría de cuerda/cable sobre superficies poligonales y la envuelve alrededor de un objeto geométrico.	`input`, `geometry` (+20 opcionales)
`mesh_tiler`	SideFX Labs Mesh Tiler — envuelve geometría PACKED que cruza el límite de un tile unitario para que se repita sin costuras (las piezas que salen por un borde re-entran por el borde opuesto).	`input` (+9 opcionales)
`dirtskirt`	SideFX Labs Dirt Skirt — construye un borde de tierra/escombros dispersos donde un objeto (`input`, entrada 0) se encuentra con una superficie de suelo (`ground`, entrada 1) — el pequeño montón de escombros en la base de una roca/pared. obj* controla la banda de ruido que sube por el objeto; gnd* la banda que se extiende por el suelo; finalcount limita la cantidad de escombros dispersos; iterations hace crecer la banda; threshold la recorta.	`input`, `ground` (+17 opcionales)
`snow_buildup`	SideFX Labs Snow Buildup — acumula una capa de nieve en las partes orientadas hacia arriba de la superficie de entrada (`input`, entrada 0). angle es la pendiente máxima de cara que retiene nieve; baseheight/snowheight definen la profundidad; typenoise selecciona el aspecto de la superficie (ventisqueros / derretido / paleado); smoothiterations la suaviza. snow_only genera solo el grupo de nieve.	`input` (+20 opcionales)
`tree_branch_placer`	SideFX Labs Tree Branch Placer — hace crecer/coloca ramas a partir de un tronco padre.	`input` (+25 opcionales)
`tree_hierarchy`	SideFX Labs Tree Hierarchy — etiqueta las ramas de un árbol con una jerarquía de ramas/generaciones con nombre (p. ej. gen_0/_branch_1) para selección, viento o exportación posteriores.	`input` (+6 opcionales)
`cluster_refine`	SideFX Labs Cluster Refine — refina una malla en islas soldadas agrupando regiones conectadas y relajando los límites de los clústeres para que las costuras se lean limpiamente.	`input` (+8 opcionales)
`edge_damage`	SideFX Labs Edge Damage — astilla/erosiona bordes duros para añadir desgaste procedimental mediante un paso VDB; todo el desplazamiento es procedimental a lo largo de las normales, NO desde una imagen de disco.	`input` (+14 opcionales)
`edge_smooth`	SideFX Labs Edge Smooth — relaja/suaviza los bordes de la malla (opcionalmente solo bordes no compartidos/límite), limpiando las facetas en geometría biselada o booleanada.	`input` (+7 opcionales)
`mesh_sharpen`	SideFX Labs Mesh Sharpen — afila las características de la superficie empujando puntos a lo largo de un campo de curvatura, con un paso de suavizado opcional; acentúa geometría escaneada/orgánica suave.	`input` (+12 opcionales)
`soften_normals`	SideFX Labs Soften Normals — recalcula las normales de vértice con un ángulo de cúspide para que los bordes por debajo del ángulo se lean suaves y los bordes más marcados permanezcan duros; también puede endurecer las normales a través de costuras UV.	`input` (+3 opcionales)
`extract_borders`	SideFX Labs Extract Borders — extrae los bordes de límite abiertos de una malla (y opcionalmente los bordes de las islas UV) como polilíneas o curvas.	`input` (+4 opcionales)
`extract_silhouette`	SideFX Labs Extract Silhouette — traza la silueta exterior de una malla a lo largo de un eje de vista y la emite como curva (tarjetas recortadas / formas de trim).	`input` (+6 opcionales)
`straight_skeleton_2d`	SideFX Labs Straight Skeleton 2D — calcula el esqueleto recto 2D (columna topológica similar al eje medial) de un polígono/curva planar, útil para cubiertas/insetting y análisis de formas.	`input` (+7 opcionales)
`straight_skeleton_3d`	SideFX Labs Straight Skeleton 3D — extrae una red de esqueleto recto 3D / curva medial de una malla cerrada mediante una resolución voxelizada.	`input` (+5 opcionales)
`dissolve_flat_edges`	SideFX Labs Dissolve Flat Edges — elimina aristas entre caras (casi) coplanares para simplificar una malla sin cambiar su silueta, y opcionalmente elimina puntos en línea (colineales).	`input` (+8 opcionales)
`remove_inside_faces`	SideFX Labs Remove Inside Faces — elimina caras interiores/ocultas nunca visibles desde fuera (p. ej. geometría booleanada superpuesta de kit-bashing), reduciendo el recuento de polígonos.	`input` (+6 opcionales)
`path_deform`	SideFX Labs Path Deform — dobla `input` (entrada 0, la malla) a lo largo del `curve` requerido (entrada 1, la ruta); el `banking_curve` opcional (entrada 2) define la dirección hacia arriba/inclinación.	`input`, `curve` (+12 opcionales)
`polydeform`	SideFX Labs PolyDeform — deforma la malla de alto detalle `input` (entrada 0, source_mesh) para que siga la `target` esculpida/editada (entrada 1, target_mesh), transfiriendo la deformación de baja resolución a la malla de resolución completa.	`input`, `target` (+10 opcionales)
`sine_wave`	SideFX Labs Sine Wave — desplaza `input` (entrada 0) con dos ondas sinusoidales sumadas a lo largo de `axis` (X\|Y\|Z).	`input` (+14 opcionales)
`decal_projector`	SideFX Labs Decal Projector — proyecta un decal (color base + mapa de altura) sobre la superficie `input` (entrada 0, la malla de Proyección).	`input` (+21 opcionales)
`detail_mesh`	SideFX Labs Detail Mesh — repite la malla de sello/detalle `tile` (entrada 1) sobre el diseño UV de la superficie `input` (entrada 0, el lienzo), envolviendo los tiles sobre ella (p. ej. ladrillos/tejas sobre una pared).	`input`, `tile` (+10 opcionales)
`triplanar_displace`	SideFX Labs Triplanar Displace — desplaza `input` (entrada 0) muestreando una `texture` de desplazamiento proyectada de forma triplanar sobre la malla (no se necesitan UVs).	`input` (+22 opcionales)
`align_and_distribute`	SideFX Labs Align and Distribute — divide `input` (entrada 0) en piezas (por conectividad `split_by` o una `attribute_name` de pieza), opcionalmente `sort_by` (área/recuento de polígonos/aleatorio con `seed`), y luego las dispone con `spacing` en un `layout` (lineal\|cuadrícula).	`input` (+14 opcionales)
`delight`	SideFX Labs Delight — elimina la iluminación/AO horneados de los colores de vértice (Cd) de `input` (entrada 0), aplanando una malla escaneada/fotografiada hacia un albedo uniforme.	`input` (+11 opcionales)
`straighten`	SideFX Labs Straighten — reorienta `input` (entrada 0) hacia un marco canónico alineado a los ejes usando un `up_group` seleccionado (y opcionalmente un `forward_group` cuando `align_forward` está activado) del `grouptype` dado (primitiva\|punto\|arista) como referencia hacia arriba/adelante; `invert_up` invierte el eje hacia arriba.	`input` (+8 opcionales)
`axis_align`	SideFX Labs Axis Align — reposiciona `input` (entrada 0) respecto al origen por eje: cada uno de `x`/`y`/`z` elige dejar ese eje sin cambios o ajustar su Centro, Mín o Máx del bounding box a 0.	`input` (+5 opcionales)
`turntable`	SideFX Labs Turntable — rota `input` (entrada 0) alrededor de `axis` (X\|Y\|Z) como función del fotograma actual, completando `num_turns` rotaciones completas a lo largo del rango de fotogramas (una animación de vista previa tipo plato giratorio).	`input` (+4 opcionales)
`chaotic_shapes`	SideFX Labs Chaotic Shapes — una geo /obj nueva que contiene una nube de puntos trazada desde un sistema caótico (atractor extraño).	`name` (+8 opcionales)
`mandelbulb_generator`	SideFX Labs Mandelbulb Generator — una geo /obj nueva que contiene un fractal Mandelbulb 3D.	`name` (+10 opcionales)
`wang_tiles_sample`	SideFX Labs Wang Tiles Sample — una geo /obj nueva que contiene un muestreo estocástico de tiles de Wang (un conjunto de semillas de teselado aperiódico que el Wang Tiles Decoder expande más tarde).	`name` (+3 opcionales)
`wfc_initialize`	SideFX Labs WFC Initialize — una geo /obj nueva que contiene una cuadrícula vacía de colapso de función de onda (`rows` x `cols`, cada una limitada a <=1024) que las herramientas de muestra/pintura WFC luego resuelven.	`name` (+4 opcionales)
`wang_tiles_decoder`	SideFX Labs Wang Tiles Decoder — decodifica una cuadrícula de puntos de tiles de Wang (`input`, entrada 0; p. ej. una salida de wang_tiles_sample) en una teselación aperiódica de `rows` x `cols`.	`input` (+6 opcionales)
`connectivity_and_segmentation`	SideFX Labs Connectivity and Segmentation — particiona los polígonos de entrada (`input`, entrada 0) en segmentos y escribe un id de segmento en `segmentattrib`.	`input` (+15 opcionales)
`multi_bounding_box`	SideFX Labs Multi Bounding Box — construye bounding boxes sobre la malla de entrada (`input`, entrada 0).	`input` (+5 opcionales)
`wavefunction_collapse_2d`	SideFX Labs 2D Wave Function Collapse — sintetiza una teselación 2D más grande que se asemeja localmente a una pequeña muestra de color/tile.	`input`, `sample` (+9 opcionales)
`unreal_worldcomposition_prepare`	SideFX Labs Unreal World Composition Prepare — etiqueta un terreno/malla entrante (`input`, entrada 0) para Unreal World Composition; la salida SOP cocinada ES la geometría etiquetada. tilenum establece el número de teselas; levelpath/materialpath son rutas CONTENT de Unreal escritas como atributos de cadena (no rutas del sistema de archivos).	`input` (+12 opcionales)
`ml_cv_directory_import`	SideFX Labs ML CV Directory Import — un nodo SOURCE (0 entradas) que importa geometría de activos desde un directorio que coincide con un patrón de nombre de archivo; el punto de entrada para la preparación de datos sintéticos de visión por computadora.	`name` (+4 opcionales)
`ml_cv_keypoint_metadata`	SideFX Labs ML CV Keypoint Metadata — asigna metadatos de verdad fundamental de puntos clave (radio de puntos clave, posiciones 3D, conectividad de esqueleto) a la geo de entrada para datos de entrenamiento de estimación de pose.	`input` (+7 opcionales)
`ml_cv_label_metadata`	SideFX Labs ML CV Label Metadata — etiqueta geometría (o un grupo) con un ID/nombre de categoría más un ID de instancia opcional para entrenamiento de segmentación/detección.	`input` (+10 opcionales)
`ml_cv_promote_synth_attribute`	SideFX Labs ML CV Promote Synth Attribute — promueve un atributo de datos sintéticos de una clase de geometría a otra (p. ej. primitive -> point) con un método de agregación elegido, para que las etiquetas lleguen a los elementos correctos.	`input` (+6 opcionales)
`ml_cv_rop_annotation_output`	SideFX Labs ML CV Annotation Output — escritor SOLO-CABLE que exporta anotaciones JSON estilo COCO (IDs de categoría/instancia, datos de delimitación) para el fotograma sintético de entrada.	`input` (+10 opcionales)
`ml_cv_texture_mask`	SideFX Labs ML CV Texture Mask — asigna un ID de instancia de textura y un ID/nombre de categoría a la geometría de entrada para que una región de textura renderizada se convierta en una máscara etiquetada en el conjunto de datos sintético.	`input` (+4 opcionales)
`ml_cv_vector_data`	SideFX Labs ML CV Vector Data — calcula datos vectoriales por punto (p. ej. un vector de movimiento/dirección en espacio de pantalla desde un punto de origen) para el fotograma sintético.	`input` (+5 opcionales)
`ml_cv_visualize_keypoints`	SideFX Labs ML CV Visualize Keypoints — construye geometría guía de puntos clave / conectividad de esqueleto a partir de la geo de metadatos de puntos clave para inspeccionar etiquetas de datos sintéticos.	`input` (+6 opcionales)
`export_uv_wireframe`	SideFX Labs Export UV Wireframe — SOLO-CABLE: renderiza el diseño UV de la malla de entrada (wireframe + relleno de islas) a un archivo de imagen.	`input` (+10 opcionales)
`udim_tile_number`	SideFX Labs UDIM Tile Number — calcula el número de tesela UDIM para cada elemento a partir de sus UV y lo escribe en un atributo (`udim_tile` por defecto).	`input` (+5 opcionales)
`visualize_uvs`	SideFX Labs Visualize UVs — construye geometría de inspección para las UV de una malla: aplica una vista previa de mapa de textura de tablero de ajedrez y puede dibujar las islas UV + costuras.	`input` (+9 opcionales)
`testgeometry_luiz`	SideFX Labs Test Geometry (Luiz) — un nodo SOURCE (0 entradas) que construye una malla de prueba/mostrador lista (el activo 'Luiz') para prototipado.	`name` (+1 opcional)
`testgeometry_paul`	SideFX Labs Test Geometry (Paul) — un nodo SOURCE (0 entradas) que construye una malla de prueba/mostrador lista (el activo 'Paul') para prototipado.	`name` (+1 opcional)
`houdini_icon`	SideFX Labs Houdini Icon — un nodo SOURCE (0 entradas) que construye el logotipo de Houdini como geometría de malla, opcionalmente extruido.	`name` (+2 opcionales)
`simple_retime`	SideFX Labs Simple Retime — re-temporiza una entrada animada mediante un multiplicador de velocidad global (el Ramp de re-temporización por fotograma permanece en su valor predeterminado de HDA).	`input` (+2 opcionales)
`resample`	Remuestrea curvas/polilíneas en segmentos uniformes (SOP resample).	`input` (+14 opcionales)
`trail`	Estela de movimiento / conectividad a lo largo del tiempo (SOP trail): rastrea puntos a través de fotogramas, conéctalos como malla/polígonos, o calcula velocidad a partir del movimiento.	`input` (+14 opcionales)
`timeshift`	Re-temporiza la geometría aguas arriba — evalúa el SOP de entrada como si la barra de reproducción estuviera en un fotograma/tiempo diferente (SOP timeshift). method=byframe lee `frame` (con ajuste integer_frames); method=bytime lee `time` en segundos. clamp mantiene la muestra en el primer/último fotograma fuera de un rango.	`input` (+6 opcionales)
`polyframe`	Construye un marco de orientación por elemento — atributos tangente (tangentu), normal (N), bitangente (tangentv) — en una curva o superficie (SOP polyframe).	`input` (+13 opcionales)
`fuse`	Suelda / ajusta puntos coincidentes (Fuse 2.0) — el caballo de batalla de limpieza de costuras después de heightfield_tilesplit, boolean o fusiones de teselas de escaneo. distance es la tolerancia de ajuste 3D (unidades del mundo): los puntos dentro de ella se consolidan en uno, cerrando grietas entre teselas. snap_type selecciona distancesnap (proximidad, el predeterminado), gridsnap (ajustar a una cuadrícula) o specified (ajustar mediante un atributo objetivo). delete_degenerate elimina los prims de área/longitud cero que colapsan cuando los puntos se fusionan; delete_unused elimina los puntos ahora huérfanos; consolidate fusiona los puntos ajustados en puntos únicos (activado por defecto).	`input` (+6 opcionales)
`normals`	Recalcula (o invierte) normales mediante el SOP Normal. mode = a qué clase se escribe el atributo N: point (sombreado suave, predeterminado), vertex (por esquina de cara, bordes duros/suaves), prim (plano por cara) o detail. cusp_angle (grados) divide el sombreado suave vs facetado en bordes más afilados que el ángulo. reverse invierte la dirección de la normal (corrige superficies de escaneo/boolean invertidas); normalize fuerza longitud unitaria; weighting elige cómo se promedian las normales de caras adyacentes (0 por área .. 2).	`input` (+6 opcionales)
`facet_smooth_subdiv`	Tres operadores de superficie multiplexados por op. facet (SOP Facet): re-facetear / consolidar — cusp_angle afila bordes, unique_points divide puntos compartidos (aspecto facetado duro), make_planar aplana cada cara. smooth (SOP Smooth): relaja posiciones de puntos sin añadir polígonos — strength es la cantidad de suavizado (0..50), method uniform\|scaledominant\|curvaturedominant, filter_quality aumenta el número de pasadas (1..5). subdivide (SOP Subdivide): AÑADE polígonos — iterations niveles de subdivisión (cada nivel ~4x el recuento de polígonos, así que 3 ya es 64x; el nodo limita suavemente a 3), algorithm elige el esquema (osdcc = OpenSubdiv Catmull-Clark, el estándar de superficies suaves), close_holes sella límites abiertos.	`input` (+11 opcionales)
`lod_create`	Preparación de LOD / primitivas empaquetadas mediante op. lod (Labs LOD Create): construye una cadena de nivel de detalle — levels establece el número de LOD (genera esa cantidad de ranuras de reducción, todas comenzando al 100%; refina los porcentajes por ranura en el nodo después). pack (SOP Pack): colapsa la entrada en primitivas empaquetadas (unidades de instanciación planas y ligeras en memoria) — packbyname empaqueta un prim por valor de atributo name, transfer_attributes/transfer_groups llevan patrones a los prims empaquetados, pivot establece el pivote de empaquetado (origin\|centroid). proxy (SOP Pack): el mismo empaquetado pero preparado como un proxy de viewport económico mediante el viewport-LOD empaquetado (token lod, caja predeterminada) — el análogo de geometría general del set_tile_lod de terreno.	`input` (+8 opcionales)
`assemble`	Empaqueta piezas nombradas en primitivas PackedFragment (SOP Assemble) — el empaquetado listo para render/sim de una malla fracturada/nombrada. pack está activado por defecto (pack_geo es el conmutador que realmente emite prims empaquetados).	`input` (+14 opcionales)
`transform_pieces`	Aplica transformaciones por pieza de vuelta a las piezas empaquetadas (Transform Pieces) — EL viaje de ida y vuelta resultado-de-sim -> geometría-empaquetada.	`input` (+13 opcionales)
`for_each`	Construye un ANDAMIO de bucle For-Each / iteración-sobre-piezas (block_begin + cuerpo de paso + block_end, completamente cableado y con referencias cruzadas) para iterar sobre geometría por pieza, por punto, o un número fijo N de veces (bucle count).	`input` (+14 opcionales)
`for_each_begin`	Crea un block_begin de For-Each — el INICIO / entrada del bucle componible.	`input` (+4 opcionales)
`for_each_end`	Crea un block_end de For-Each — el CIERRE / recopilación del bucle componible. input = la salida del cuerpo de tu bucle (nodos a iterar), begin = el block_begin emparejado, pieces = la geometría cuyas piezas/puntos se van a iterar.	`input` (+14 opcionales)
`compile_block`	Envuelve un objetivo en un Compile Block (compile_begin + compile_end, con referencias cruzadas) — el optimizador multihilo / de reducción de sobrecarga de cook alrededor de un bucle For-Each pesado (establece el multithread de for_each_end dentro).	`input` (+6 opcionales)
`feather_template`	Feather Template from Shape — la ENTRADA del carril de plumas.	`name` (+10 opcionales)
`feather_template_assign`	Feather Template Assign — asigna plantillas de plumas a puntos de piel para sembrar un groom.	`input` (+7 opcionales)
`feather_template_interpolate`	Feather Template Interpolate — crece un groom completo interpolando plumas a través de una piel desde plumas guía dispersas + plantillas.	`input` (+13 opcionales)
`feather_clump`	Feather Clump — divide y agrupa barbas para el aspecto característico de pluma separada y apelmazada.	`input` (+12 opcionales)
`feather_noise`	Feather Noise — añade ruptura natural a las plumas.	`input` (+10 opcionales)
`feather_width`	Feather Width — establece anchos de raquis y barbas que controlan el grosor de pluma renderizado.	`input` (+6 opcionales)
`feather_resample`	Feather Resample — cambia la resolución de puntos de raquis y barbas de plumas.	`input` (+13 opcionales)
`feather_deintersect`	Feather Deintersect — separa plumas superpuestas para que un groom denso se lea limpiamente.	`input` (+12 opcionales)
`feather_normalize`	Feather Normalize — normaliza atributos de plumas a una forma de reposo canónica.	`input` (+5 opcionales)
`feather_barb_transform`	Feather Barb Transform — convierte posiciones de barbas entre el espacio local de la pluma y el espacio del objeto.	`input` (+3 opcionales)
`feather_deform`	Feather Deform — captura plumas a una piel y las deforma junto con una piel animada.	`input` (+12 opcionales)
`feather_attrib_interpolate`	Feather Attrib Interpolate — interpola atributos de barbas en plumas desde plumas de origen.	`input` (+9 opcionales)
`feather_surface`	Feather Surface — construye una malla de superficie poligonal renderizable a partir de plumas condensadas.	`input` (+10 opcionales)
`feather_surface_blend`	Feather Surface Blend — mezcla una superficie de pluma hacia una superficie objetivo (p. ej. plegar un ala).	`input` (+13 opcionales)
`feather_convert`	Feather Convert — convierte plumas condensadas en geometría explícita de curva o superficie.	`input` (+9 opcionales)
`feather_uncondense`	Feather Uncondense — expande una pluma condensada (un prim por pluma) en geometría de curva completa por barba.	`input` (+7 opcionales)
`feather_primitive`	Feather Primitive — edita la representación de primitiva de pluma condensada (resolución + nomenclatura).	`input` (+8 opcionales)
`feather_barb_tangents`	Feather Barb Tangents — calcula atributos de tangente por barba en plumas (necesario para algunas operaciones de estilo/sombreado de barbas).	`input` (+1 opcional)
`feather_min_dist`	Feather Minimum Distance — calcula un atributo de distancia mínima entre plumas (entrada 0) y plumas objetivo (entrada 3).	`input` (+3 opcionales)
`feather_ray`	Feather Ray — proyecta/lanza rayos de plumas sobre piel o geometría objetivo, muestreando opcionalmente primnum/primuv en el impacto.	`input` (+10 opcionales)
`feather_visualize`	Feather Visualize — genera geometría de visualización de viewport para plumas (barbas como curvas o una superficie).	`input` (+3 opcionales)
`hair_generate`	Hair Generate (hairgen::2.0) — el GENERADOR de cabello/guías programable y entrada de carril: dispersa raíces sobre una piel y crece curvas, opcionalmente interpoladas desde un conjunto de guías.	`input` (+17 opcional)
`fur_setup`	Fur (fur) — el generador de Fur heredado todo-en-uno: genera + agrupa + separa cabellos desde una piel y guías en un solo nodo.	`input` (+15 opcional)
`hair_growth_field`	Hair Growth Field (hairgrowthfield) — construye un campo de crecimiento de cabello / dispersa raíces de guías desde un cuero cabelludo.	`input` (+14 opcional)
`guide_initialize`	Guide Initialize (guideinit) — orienta guías recién creadas (forma de viento, elevación, mezcla a lo largo de la piel).	`input` (+11 opcional)
`guide_reguide`	Reguide (reguide) — redistribuye / remuestrea el conjunto de guías (cambia la densidad de guías y el número de segmentos).	`input` (+11 opcional)
`guide_fill`	Guide Fill (guidefill) — rellena huecos en un conjunto de guías disperso usando una malla de interpolación de guías.	`input` (+7 opcional)
`guide_grow_to_surface`	Guide Grow to Surface (guidegrowtosurface) — hace crecer las raíces de guías hacia una superficie objetivo (advecta puntos de origen sobre una malla).	`input` (+10 opcional)
`guide_process`	Guide Process (guideprocess) — la pila de operaciones de ESTILIZADO principal de guías: elige una sola operación con op1 (fijar dirección/elevación/longitud, desplazar, ondular, enderezar, suavizar, encrespar, doblar, atributo de simulación).	`input` (+15 opcional)
`hair_clump`	Hair Clump (hairclump::2.0) — agrupa cabellos/guías en mechones (el aspecto de cabello característico).	`input` (+15 opcional)
`guide_clump_center`	Guide Clump Center (guideclumpcenter) — calcula guías/atributos de centro de mechón que alimentan a hair_clump.	`input` (+5 opcional)
`guide_partition`	Guide Partition (guidepartition) — crea líneas de separación que dividen el groom en regiones de partición.	`input` (+10 opcional)
`guide_groom`	Guide Groom (guidegroom::2.0) — el nodo de datos del cepillador de groom.	`input` (+13 opcional)
`hair_comb`	Comb (comb) — peina la dirección del fur/cabello.	`input` (+9 opcional)
`guide_mask`	Guide Mask (guidemask) — crea máscaras (atributo/grupo) en guías/piel que leen todas las demás operaciones de groom.	`input` (+14 opcional)
`guide_group`	Guide Group (guidegroup) — crea grupos de guías / líneas de separación por convención de nombres.	`input` (+5 opcional)
`guide_find_strays`	Guide Find Strays (guidefindstrays) — detecta guías dispersas/atípicas y las etiqueta en un grupo/atributo.	`input` (+10 opcional)
`guide_skin_attrib_lookup`	Guide Skin Attribute Lookup (guideskinattriblookup) — copia atributos de la piel sobre las guías mediante el enraizamiento almacenado skinprim/skinprimuv.	`input` (+9 opcional)
`guide_tangent_space`	Guide Tangent Space (guidetangentspace) — calcula los marcos tangente/normal/bitangente/orientación por guía que necesitan las operaciones de dirección.	`input` (+12 opcional)
`guide_interpolation_mesh`	Guide Interpolation Mesh (guideinterpolationmesh) — construye la malla de interpolación (piel remallada + pesos de guías) que hair_generate usa para interpolar guías.	`input` (+14 opcional)
`guide_volume`	Guide Volume (guidevolume) — construye la representación de volumen de guías/piel (secciones transversales / capa / remallado / tetraedros, VDB opcional) que consumen muchas operaciones de groom.	`input` (+12 opcional)
`guide_surface`	Guide Surface (guidesurface) — mueve/construye una superficie desde guías a lo largo de una malla de interpolación de guías.	`input` (+9 opcional)
`guide_deform`	Guide Deform (guidedeform) — captura guías a una piel y las deforma con una piel animada.	`input` (+16 opcional)
`guide_transfer`	Guide Transfer (guidetransfer) — transfiere un groom desde una piel de origen a una piel de destino.	`input` (+11 opcional)
`groom_blend`	Groom Blend (groomblend) — mezcla dos grooms completos (guías A vs guías B) por peso/máscara.	`input` (+14 opcional)
`guide_collide_vdb`	Guide Collide With VDB (guidecollidevdb) — empuja las guías fuera de un VDB de colisión.	`input` (+11 opcional)
`guide_advect`	Guide Advect (guideadvect) — advecta guías a través de un VDB de velocidad o rellena colisiones.	`input` (+13 opcional)
`hair_card_generate`	Hair Card Generate (haircardgen) — genera CARDS de cabello texturizadas (salida para juegos / tiempo real) desde curvas de cabello.	`input` (+16 opcional)
`hair_volume_rasterize`	Volume Rasterize Hair (volumerasterizehair) — rasteriza curvas de cabello en un VDB de densidad/color/tangente (preparación para render / simulación).	`input` (+10 opcional)
`fiber_groom`	Fiber Groom (fibergroom) — grooming de FIBRAS musculares (carril de músculos KineFX, no cabello).	`input` (+8 opcional)
`volume_create`	Volume (volume) — GENERADOR: crea una primitiva de volumen escalar/vectorial nueva en un nuevo /obj geo (una fuente de autoría de niebla/densidad). type float/int; rank + components dimensionan el volumen; volume_name nombra la rejilla; initialalpha el relleno; zmin/zmax + use_cam_window/camera definen un volumen de frustum de cámara (camera es una referencia NodePath de escena, no un archivo).	`name` (+9 opcional)
`vdb_create`	VDB (vdb) — GENERADOR: crea una rejilla VDB tipada vacía nueva (level-set / niebla / vector) en un nuevo /obj geo — la fuente de autoría VDB. grid_class elige la interpretación; grid_type el tipo de vóxel; grid_precision single/double; grid_name nombra la rejilla.	`name` (+4 opcional)
`volume_from_attrib`	Volume from Attribute (volumefromattrib) — rasteriza un atributo de punto/vértice en un volumen.	`input` (+14 opcional)
`points_from_volume`	Points from Volume (pointsfromvolume) — dispersa puntos dentro de un volumen de niebla/SDF.	`input` (+13 opcional)
`paint_fog_volume`	Volume Paint Fog (paintfogvolume) — deposita densidad proceduralmente en un volumen de niebla.	`input` (+15 opcional)
`volume_rasterize_curve`	Volume Rasterize Curve (volumerasterizecurve) — rasteriza curvas en un volumen de niebla (densidad distribuida a lo largo de las curvas).	`input` (+14 opcional)
`volume_convert`	Convert Volume (convertvolume) — convierte un VDB/volumen en una superficie poligonal mediante marching cubes.	`input` (+7 opcional)
`volume_surface`	Volume Surface (volumesurface) — construye una superficie poligonal desde una jerarquía de volumen de niebla/SDF con longitud de borde adaptativa.	`input` (+15 opcional)
`extrude_volume`	Extrude Volume (extrudevolume) — extruye polígonos en un volumen sólido a lo largo de la normal base.	`input` (+11 opcional)
`convert_vdb_points`	Convert VDB Points (convertvdbpoints) — convierte entre nubes de puntos y rejillas VDB Points.	`input` (+15 opcional)
`volume_merge`	Volume Merge (volumemerge) — fusiona/compone volúmenes con una pila completa pre/post add-mul.	`input` (+16 opcional)
`vdb_merge`	VDB Merge (vdbmerge) — fusiona múltiples rejillas VDB del mismo nombre en una sola.	`input` (+6 opcional)
`volume_vector_join`	Volume Vector Join (volumevectorjoin) — une tres (o cuatro) volúmenes escalares en un volumen vectorial.	`input` (+8 opcional)
`volume_vector_split`	Volume Vector Split (volumevectorsplit) — divide un volumen vectorial en tres volúmenes escalares.	`input` (+3 opcional)
`volume_feather`	Volume Feather (volumefeather) — suaviza (empluma) los valores de un volumen cerca de su borde.	`input` (+12 opcional)
`volume_ramp`	Volume Ramp (volumeramp) — reasigna los valores de un volumen a través de un rango origen->destino.	`input` (+8 opcional)
`volume_noise_fog`	Volume Noise Fog (volumenoisefog) — añade ruido en capas a un volumen de niebla para detallar la densidad.	`input` (+14 opcional)
`volume_noise_sdf`	Volume Noise SDF (volumenoisesdf) — añade ruido en capas a un volumen SDF para detallar la superficie.	`input` (+14 opcional)
`volume_adjust_fog`	Volume Adjust Fog (volumeadjustfog) — ajusta el aspecto de un volumen de niebla (combinación init / remap).	`input` (+13 opcional)
`volume_resample`	Volume Resample (volumeresample) — remuestrea un volumen a una nueva resolución de vóxeles.	`input` (+10 opcional)
`volume_resize`	Volume Resize (volumeresize) — redimensiona / re-limita las extensiones de la rejilla de un volumen.	`input` (+10 opcional)
`volume_reduce`	Volume Reduce (volumereduce) — reduce un volumen a un valor agregado (max/min/promedio/mediana/suma/rms...).	`input` (+8 opcional)
`volume_bound`	Volume Bound (volumebound) — reconstruye la región activa/delimitadora de un volumen mediante umbralización.	`input` (+4 opcional)
`volume_sdf`	Volume SDF (volumesdf) — calcula un campo de distancia con signo desde un volumen de niebla/máscara.	`input` (+9 opcional)
`vdb_activate_sdf`	VDB Activate SDF (vdbactivatesdf) — activa / expande la banda estrecha de un VDB SDF.	`input` (+15 opcional)
`vdb_topology_to_sdf`	VDB Topology to SDF (vdbtopologytosdf) — construye un SDF desde la topología de vóxeles activos de un VDB.	`input` (+10 opcional)
`vdb_occlusion_mask`	VDB Occlusion Mask (vdbocclusionmask) — construye un VDB de máscara de oclusión orientado a la cámara detrás de los VDB de entrada.	`input` (+8 opcional)
`volume_analysis`	Volume Analysis (volumeanalysis) — calcula una cantidad diferencial de un volumen.	`input` (+4 opcional)
`volume_velocity_from_curves`	Volume Velocity from Curves (volumevelocityfromcurves) — construye un volumen de velocidad que fluye a lo largo de curvas.	`input` (+17 opcional)
`volume_velocity_from_surface`	Volume Velocity from Surface (volumevelocityfromsurface) — construye un volumen de velocidad (+ colisión) desde el movimiento de una superficie.	`input` (+9 opcional)
`lattice_from_volume`	Lattice from Volume (latticefromvolume) — construye un lattice / rejilla de puntos que coincide con la disposición de vóxeles de un volumen.	`input` (+7 opcional)
`volume_deform`	Volume Deform (volumedeform) — deforma un volumen mediante un point-deform / lattice en movimiento.	`input` (+10 opcional)
`volume_rasterize_lattice`	Volume Rasterize Lattice (volumerasterizelattice) — rasteriza un lattice en movimiento de vuelta en un volumen.	`input` (+15 opcional)
`volume_break`	Volume Break (volumebreak) — divide / rompe geometría en piezas mediante un cortador de volumen SDF.	`input` (+12 opcional)
`volume_splice`	Volume Splice (volumesplice) — empalma / cose piezas de volumen en mosaico de vuelta en una rejilla.	`input` (+3 opcional)
`volume_stamp`	Volume Stamp (volumestamp) — estampa un volumen de origen en un volumen de destino en puntos.	`input` (+10 opcional)
`volume_patch`	Volume Patch (volumepatch) — parchea una región de un volumen con otro volumen (mezcla de Poisson).	`input` (+9 opcional)
`volume_convolve`	Volume Convolve (volumeconvolve3) — aplica un kernel de convolución 3x3x3 a un volumen.	`input` (+4 opcional)
`volume_fft`	Volume FFT (volumefft) — FFT directa / inversa de un volumen (dominio de frecuencia).	`input` (+7 opcional)
`volume_normalize`	Volume Normalize Weights (volumenormalize) — normaliza un conjunto de pesos / valores de volumen.	`input` (+9 opcional)
`volume_compress`	Volume Compress (volumecompress) — comprime el almacenamiento de un volumen (poda de tiles / constantes).	`input` (+15 opcional)
`volume_arrival_time`	Volume Arrival Time (volumearrivaltime) — calcula el tiempo de llegada de propagación de frente a través de un volumen de velocidad.	`input` (+8 opcional)
`volume_optical_flow`	Volume Optical Flow (volumeopticalflow) — estima el movimiento (flujo óptico) entre dos volúmenes.	`input` (+11 opcional)
`volume_trail`	Volume Trail (volumetrail) — advecta / arrastra puntos a través de un volumen de velocidad a lo largo del tiempo.	`input` (+16 opcional)
`volume_ambient_occlusion`	Volume Ambient Occlusion (volumeambientocclusion) — calcula oclusión ambiental en un volumen.	`input` (+7 opcional)
`volume_bake`	Bake Volume (bakevolume) — hornear iluminación / dispersión en un volumen (preparación de render).	`input` (+11 opcional)
`volume_noise_vector`	Volume Noise Vector (volumenoisevector) — agregar ruido en capas a un volumen vectorial (detallado de velocidad).	`input` (+9 opcional)
`paint_color_volume`	Volume Paint Color (paintcolorvolume) — depositar color (Cd) en un volumen de forma procedural.	`input` (+15 opcional)
`paint_sdf_volume`	Volume Paint SDF (paintsdfvolume) — esculpir / agregar de forma procedural en un volumen SDF.	`input` (+8 opcional)
`vdb_convex_clip_sdf`	VDB Convex Clip SDF (vdbconvexclipsdf) — recorte convexo de un SDF VDB mediante un segundo SDF convexo.	`input` (+7 opcional)
`vdb_diagnostics`	VDB Diagnostics (vdbdiagnostics) — validar / diagnosticar una rejilla VDB (control de calidad solo de datos).	`input` (+15 opcional)
`vdb_lod`	VDB LOD (vdblod) — construir una pirámide de nivel de detalle (mip) para un VDB.	`input` (+6 opcional)
`vdb_points_delete`	VDB Points Delete (vdbpointsdelete) — eliminar puntos de una rejilla VDB Points.	`input` (+5 opcional)
`vdb_points_group`	VDB Points Group (vdbpointsgroup) — agrupar puntos dentro de una rejilla VDB Points.	`input` (+15 opcional)
`vdb_rasterize_frustum`	VDB Rasterize Frustum (vdbrasterizefrustum) — rasterizar partículas en un VDB alineado al frustum de cámara.	`input` (+17 opcional)
`vdb_visualize_tree`	VDB Visualize Tree (vdbvisualizetree) — construir geometría de visualización de la estructura interna del árbol de un VDB.	`input` (+15 opcional)
`poly_patch`	Construir una superficie de parche poligonal suave sobre un casco/jaula de curvas o una malla (polypatch) — ordenar una jaula de curvas tosca en una superficie limpia lista para subdivisión. basis = base de suavizado (cardinal \| bspline); connectivity = cómo se conectan las filas/columnas del casco en el parche; divisions [u,v] = resolución de salida; close_u/close_v la envuelven; output_polygons emite polígonos en lugar de una primitiva de malla.	`input` (+8 opcional)
`poly_loft`	Envolver una superficie poligonal a través de una secuencia de curvas de sección transversal (polyloft).	`input` (+11 opcional)
`poly_spline`	Ajustar una spline suave a través de los puntos de una polilínea y re-emitirla como una curva poligonal remuestreada (polyspline) — convertir un polígono de control tosco en una curva suave. spline_type = base de interpolación; closure = si cerrar; division_method = cómo se distribuye la densidad de muestreo; segment_length / divisions / sample_divisions = la resolución de salida; tension = la tensión de los CV.	`input` (+9 opcional)
`circle_spline`	Ajustar splines de arco circular / elipse / hélice a través de un polígono de control (circlespline) — curvatura perfectamente redonda que una spline de forma libre no puede dar. spline_type (hybrid \| circle \| ellipse \| helix); helix_type = el estilo de enrollado; reparm_strength = re-parametriza para espaciado uniforme; segment_divisions = la resolución de salida; output_tangent + tangent_attrib escriben un atributo de tangente.	`input` (+8 opcional)
`poly_cap`	Rellenar límites abiertos de polígonos (aristas no compartidas) con polígonos de tapa (polycap) — sellar un extremo de tubo/extrusión o un anillo de agujero.	`input` (+7 opcional)
`cap`	Añadir tapas de extremo/polo a superficies NURBS/malla y curvas abiertas, por límite U/V (cap) — cerrar los extremos de tubos, esferas y superficies revolucionadas. first_u_cap / last_u_cap / first_v_cap / last_v_cap cada uno elige un estilo (none \| facet \| share \| round \| tangent); divisions_u / divisions_v = la resolución de las tapas redondeadas; scale_u / scale_v abultan las tapas.	`input` (+10 opcional)
`fillet`	Construir una superficie de transición suave entre primitivas adyacentes / dos curvas (fillet) — redondear uniones duras entre superficies.	`input` (+11 opcional)
`stitch`	Mezclar/coser dos HULLS de superficie adyacentes a lo largo de límites compartidos (stitch).	`input` (+12 opcional)
`join`	Conectar una secuencia de primitivas separadas (curvas o superficies) de extremo a extremo en una sola primitiva continua (join) — convertir muchas piezas pequeñas en una primitiva larga.	`input` (+10 opcional)
`poly_hinge`	Doblar/rotar polígonos alrededor de un borde de bisagra o eje, subdividiendo el pliegue en segmentos (polyhinge) — abrir paneles, pétalos, pliegues emergentes. group + group_type (primitive \| edge) eligen qué se dobla; pivot_mode = cómo se define la línea de bisagra; hinge_edge = el borde para bisagra; hinge_angle = el ángulo de doblado; divisions = los segmentos del pliegue; enable_inset + inset añaden un bisel; output_front/back/side activan las capas de resultado.	`input` (+15 opcional)
`poly_stitch`	Soldar los límites de dos capas poligonales, rellenando el espacio con polígonos de unión (polystitch) — reparar costuras / unir mitades modeladas por separado. stitch_group / corners restringen qué bordes/puntos se cosen; tolerance = distancia máxima de cosido; consolidate fusiona puntos coincidentes; find_corners + corner_angle detectan automáticamente puntos de esquina.	`input` (+7 opcional)
`poly_soup`	Colapsar muchos polígonos en una sola primitiva ligera 'polysoup' (polysoup) — reducir memoria y sobrecarga de nodos para mallas estáticas densas, ideal antes de instanciar / objetivos de dispersión pesados. group restringe la fuente; min_polys = umbral de tamaño; convex triangula a polígonos convexos; use_max_sides + max_sides limitan los lados del polígono; merge_vertices suelda vértices idénticos; ignore_attribs / ignore_groups eliminan datos por primitiva.	`input` (+9 opcional)
`poly_cut`	Cortar/dividir polígonos a lo largo de puntos, aristas o un cruce de atributo, opcionalmente eliminando la región cortada (polycut). group restringe los polígonos afectados; type (points \| edges) = la primitiva de corte; cut_points / cut_edges nombran las ubicaciones de corte; strategy (remove \| cut) = si eliminar o solo dividir; cut_attrib + cut_value + cut_threshold cortan donde un atributo cruza un valor (isocorte); keep_closed vuelve a cerrar el resultado.	`input` (+10 opcional)
`poly_path`	Reconectar aristas sueltas / polilíneas abiertas en rutas continuas limpias (polypath) — ordenar extracciones de aristas y curvas de límite para sweep/remuestreo posteriores. connect_ends une extremos cercanos (dentro de max_end_dist); connect_only_to_ends restringe uniones a otros extremos (sin intersecciones en T de media curva); close_loops cierra anillos aislados.	`input` (+5 opcional)
`convert_line`	Convertir aristas de geometría en curvas polilínea (convertline) — extraer un wireframe / curvas de borde de una malla para polywire, remuestreo o sweep. group restringe la fuente; connect_path encadena aristas en rutas continuas; keep_order preserva el orden del grupo; close_loops cierra anillos aislados; remove_unused elimina puntos huérfanos; compute_length + length_name escriben un atributo de longitud en reposo por primitiva.	`input` (+8 opcional)
`circle_from_edges`	Ajustar un anillo de puntos/aristas sobre un círculo de mejor ajuste (circlefromedges) — hacer un agujero de perno, extremo de tubería o arco de rueda perfectamente redondo. group + group_type eligen el anillo; only_boundary usa solo el límite del grupo; explicit_radius + radius fuerzan un radio (si no, mejor ajuste); scale agranda/encoge el círculo ajustado; output_edge_group nombra las aristas de resultado.	`input` (+8 opcional)
`orient_along_curve`	Calcular marcos de orientación por punto (tangente/up + rotaciones) a lo largo de curvas (orientalongcurve) — el rig para sweeping, copia-a-curva o torsión de cinta.	`input` (+17 opcional)
`delta_mush`	Suavizar una malla deformada preservando el detalle de superficie (deltamush) — la corrección estándar para skinning grumoso / deformaciones temblorosas.	`input` (+10 opcional)
`surface_relax`	Redistribuir puntos uniformemente sobre una superficie para relajar topología amontonada/estirada (surfacerelax) — mejorar la distribución de puntos sin cambiar mucho la forma.	`input` (+4 opcional)
`laplacian`	Calcular el operador de Laplace discreto (cotangente / valor medio / Wachspress / pesos de Tutte) de una malla y almacenarlo como matriz dispersa en atributos (laplacian) — columna vertebral de difusión de mallas, suavizado y resoluciones de procesamiento geométrico. mode elige el esquema de pesos; separate_mass separa la matriz de masas; diffusion + diffusion_coeff construyen una matriz de difusión en su lugar; epsilon regulariza.	`input` (+6 opcional)
`soft_transform`	Mover/rotar/escalar una región de puntos con una caída radial suave (softxform) — una edición proporcional / agarre magnético.	`input` (+9 opcional)
`soft_peak`	Empujar puntos a lo largo de sus normales con una caída radial suave (softpeak) — un pincel suave de inflar/abollar.	`input` (+7 opcional)
`elastic_transform`	Deformar una malla como un sólido elástico mediante un mango de agarre / torsión / escala / pellizco que se propaga a través del material (elastictransform) — se siente como estirar goma suave.	`input` (+12 opcional)
`magnet`	Deformar `input` puntos mediante una forma 'imán' en movimiento cuyo campo estilo metaball cae con la distancia (magnet) — aplastar/estirar, abolladuras, bultos musculares impulsados por una forma proxy.	`input` (+11 opcional)
`bulge`	Empujar `input` puntos hacia afuera/adentro a lo largo de sus normales donde una forma 'imán' se superpone (bulge) — una hinchazón localizada rápida impulsada por una forma proxy.	`input` (+7 opcional)
`creep`	Proyectar `input` geometría sobre el espacio UV de una superficie y arrastrarla a través de ella (creep) — pegar decals/rastros/texto a una malla, o animar geo deslizándose sobre ella.	`input` (+10 opcional)
`vector_deform`	Deformar `input` mediante la diferencia entre dos nubes de puntos coincidentes (un conjunto de reposo y uno deformado), interpolando ese campo de movimiento en la malla (vectordeform) — deformación de jaula/rejilla desde puntos de control arbitrarios.	`input` (+9 opcional)
`shrinkwrap`	Envolver un casco convexo apretado alrededor de los `input` puntos (shrinkwrap) — proxies de colisión rápidas, capas límite, siluetas simplificadas. type (xyz = casco 3D completo \| xy = casco plano 2D); shrink_amount inseta el casco hacia adentro; plane_origin / plane_normal definen el plano de proyección para el modo 2D; preserve_attribs lleva atributos de origen; remove_inline_points limpia puntos colineales del casco.	`input` (+8 opcional)
`detangle`	Separar geometría con auto-intersecciones / interpenetración para que deje de superponerse (detangle) — limpieza para mallas de tela, cabello o multitudes que se han enredado.	`input` (+8 opcional)
`tetrahedralize`	Rellenar una superficie de entrada CERRADA con una malla tetraédrica (tet) (tetrahedralize) — el punto de entrada para preparación FEM / cuerpo blando / elementos finitos.	`input` (+17 opcional)
`tet_conform`	Construir una malla tet que se ajusta al límite cuya superficie coincide con los polígonos de entrada (tetconform) — mallado volumétrico de mayor calidad que un relleno simple cuando la superficie debe respetarse.	`input` (+17 opcional)
`tet_embed`	Incrustar la superficie de entrada dentro de una rejilla tet de fondo más gruesa (tetembed) — preparación rápida FEM/cuerpo blando cuando se quiere una jaula tet simulable ALREDEDOR de geometría detallada en lugar de una malla que se ajuste a la superficie.	`input` (+17 opcional)
`tet_layer`	Construir una sola capa tet de un grosor dado desde una superficie (tetlayer) — capas volumétricas rápidas para piel/corteza FEM o una banda tet inicial.	`input` (+7 opcional)
`tet_partition`	Dividir una malla tet en piezas nombradas usando polígonos de límite de región (tetpartition) — tallar un sólido en regiones FEM / fragmentos de fractura.	`input` (+5 opcional)
`tet_surface`	Extraer los polígonos de superficie exterior de una malla tet (tetrasurface) — obtener una piel renderizable / colisionable de vuelta de una malla tet volumétrica.	`input` (+4 opcional)
`tet_strata`	Construye capas (estratificadas) de conchas tet entre una superficie exterior y un límite interior (tetstrata) — materiales FEM multicapa (piel/grasa/músculo, sólidos laminados).	`input` (+9 opcionales)
`tet_fracture`	Fractura la geometría en trozos basados en tet mediante una división Voronoi / patrón (tetfracture) — sólidos pre-fracturados para destrucción FEM/RBD.	`input` (+7 opcionales)
`solid_embed`	Incrusta la geometría de entrada en un enrejado tet sólido dimensionado por una escala de elemento único (solidembed) — el constructor de jaulas FEM de una sola perilla.	`input` (+2 opcionales)
`topo_transfer`	Envuelve una malla TEMPLATE limpia sobre una malla TARGET, transfiriendo la topología de la plantilla a la forma del objetivo (topotransfer) — el caballo de batalla de retopología/personajes para emparejar una malla base riggeada a un escaneo/esculpido.	`input` (+18 opcionales)
`topo_slide`	Desliza los puntos de una malla objetivo a través de su superficie guiado por CURVAS de referencia/objetivo coincidentes, o ejecuta una transferencia de topo guiada por curvas (toposlidebycurverefs) — ajusta el flujo de retopología a lo largo de costuras/características de forma procedural.	`input` (+15 opcionales)
`usd_configure_sop`	Configura cómo se escribirá la geometría SOP en USD — establece opciones de importación a nivel de escenario como metadatos USD en la geometría (el `usdconfigure` en contexto SOP; un operador puro, SIN escritura de archivo).	9 opcionales
`usd_configure_geometry`	Autoriza metadatos de geometría USD por primitiva en geometría SOP (el `usdconfiguregeometry` en contexto SOP; un operador puro, SIN escritura de archivo).	9 opcionales
`usd_configure_prims_from_points`	Autoriza atributos de primitivas USD desde PUNTOS — convierte puntos en prims USD configurados (esferas, luces, xforms…) con metadatos por primitiva (el `usdconfigureprimsfrompoints` en contexto SOP; un operador puro, SIN escritura de archivo).	12 opcionales
`unpack_usd`	Desempaqueta primitivas USD empaquetadas en geometría nativa de Houdini (unpackusd) — convierte los prims empaquetados ligeros de usd_import_sop (unpack=false) en polígonos/puntos editables.	`input` (+14 opcionales)

Grupos y atributos

| attribute_normalize_float | SideFX Labs Attribute Normalize Float — remapear un atributo float a [out_min, out_max] (predeterminado 0..1) usando su rango de valores entrantes. | input (+10 opcionales) | | attribute_normalize_vector | SideFX Labs Attribute Normalize Vector — normalizar un atributo de vector. | input (+11 opcionales) | | attribute_value_replace | SideFX Labs Attribute Value Replace — renombrar un atributo y/o sembrar valores de inicialización/retroceso predeterminados en los atributos nombrados en attribute_list (predeterminado name). | input (+8 opcionales) | | color_adjustment | SideFX Labs Color Adjustment — ajuste de brillo / contraste / saturación / gamma en un atributo de color (predeterminado Cd, o un atributo personalizado). | input (+13 opcionales) | | color_blend | SideFX Labs Color Blend — mezclar dos atributos de color con un estilo de Photoshop blend_mode. | input, input2 (+9 opcionales) | | color_gradient | SideFX Labs Color Gradient — pintar un gradiente de color a lo largo de un axis (X/Y/Z, o personalizado rotado por rotation_angle) en Cd (o un atributo personalizado). | input (+7 opcionales) | | min_max_average | SideFX Labs Min Max Average — reducir un atributo a una sola estadística (method: max/min/mean/median/sum/rms/…) y escribirla de vuelta como un atributo de detalle (o, con detail_attribute desactivado, promovido por elemento) nombrado por prefix/suffix. | input (+8 opcionales) | | radial_sort | SideFX Labs Radial Sort — reordenar puntos y/o primitivas por su ángulo alrededor de un eje (*_dir) para que un abanico/anillo se indexe en un orden rotacional limpio. | input (+16 opcionales) | | sort_geometry | SideFX Labs Sort — reordenar puntos y/o primitivas por una clave elegida: eje (byx/byy/byz), aleatorio (*_seed), desplazamiento (*_offset), a lo largo de un vector (*_dir), localidad espacial, o por un atributo (*_attrib). | input (+17 opcionales) | | visualize_vector | SideFX Labs Visualize Vector — construir geometría de flechas a partir de un atributo de vector (vector_attribute, predeterminado P) para inspección. | input (+18 opcionales) | | fast_group_unshared | SideFX Labs Fast Group Unshared — agrupar los elementos NO COMPARTIDOS (borde abierto / borde) del mesh de entrada (entrada 0): bordes propiedad de una sola primitiva más los puntos/prims/vértices que los tocan. | input (+4 opcionales) | | group_by_attribute | SideFX Labs Group by Attribute — crear un grupo por cada valor distinto de un atributo en la entrada (entrada 0). | input (+5 opcionales) | | group_by_measure | SideFX Labs Group by Measure — agrupar primitivas por una medida de excentricidad geométrica (qué tan lejos se desvía la forma de una prim de un círculo/cuadrado). | input (+5 opcionales) | | group_curve_corners | SideFX Labs Group Curve Corners — etiquetar los puntos de esquina de las curvas de entrada (entrada 0) en un grupo inside (esquinas convexas) y un grupo outside (esquinas cóncavas). | input (+6 opcionales) | | group_grow | SideFX Labs Group Expand — expandir (o contraer) un grupo existente a través de la conectividad de la geometría de entrada. | input (+3 opcionales) | | group_invert | SideFX Labs Group Invert — invertir grupos nombrados en su lugar: cada grupo listado se reemplaza por su complemento (todos los elementos que NO están en él). | input (+4 opcionales) | | loops_from_selection | SideFX Labs Loops from Selection — hacer crecer bucles de borde completos (o bucles de quads) a partir de un grupo de bordes semilla. | input (+12 opcionales) | | random_selection | SideFX Labs Random Selection — seleccionar un subconjunto aleatorio de los elementos de entrada y convertirlo en un grupo. | input (+24 opcionales) | | extract_filename | SideFX Labs Extract Filename — lee la ruta de archivo de un File SOP upstream (input, o custom_file_sop cuando input_mode=custom) y escribe sus partes en atributos de cadena de detalle (ruta completa / ruta de archivo / nombre de archivo / directorio). | input (+7 opcionales) | | group_create | Crear un grupo de puntos/prims/bordes NOMBRADO y persistente (groupcreate) — el paso de configuración para cada operación dirigida (blast, bevel a group, dissolve, transform-a-group). | input, group_name (+10 opcionales) | | group_promote | Convertir un grupo entre clases de elementos (grouppromote) — por ejemplo, grupo de puntos -> grupo de prims, con opciones de límite/no compartido. | input (+8 opcionales) | | group_range | Agrupar elementos por rango de índice numérico y/o paso cada-N (grouprange) — seleccionar subconjuntos de piece-id, filas alternas, rebanadas deterministas. group_name = grupo a crear. class: points|prims|vertices. method: absolute (índice start..end) | relative (fraccional 0..1 del total) | length | partition (dividir en num_partitions bloques pares). start/end delimitan la ventana; select_amount ('of') + select_total ('every') + select_offset proporcionan un paso cada-N (of=1 every=3 => cada 3º). invert invierte la membresía; merge combina con un grupo existente del mismo nombre. | input (+13 opcionales) | | group_expand | Expandir o contraer un grupo por pasos conectados por bordes (groupexpand) — pasos negativos contraen. | input (+9 opcionales) | | group_transfer | Transferir la membresía de un grupo de una geometría a otra por proximidad (grouptransfer). | input (+11 opcionales) | | group_delete | Eliminar definiciones de grupo (geometría intacta) — groupdelete. | input (+3 opcionales) | | group_rename | Renombrar un grupo (grouprename). | input (+4 opcionales) | | group_geo | Selección geométrica profunda de grupos (groupcreate) — los modos que group_create no tiene: esfera/objeto/volumen/convexo de límites, cara trasera por cámara, ángulo de borde, bordes no compartidos/abiertos. | input (+27 opcionales) | | blast | Eliminar geometría por grupo — la primitiva fundamental de eliminación dirigida. group = el nombre/patrón del grupo (de las herramientas de grupo) o un rango de elementos crudo; group_type guía la interpretación (guess|points|prims|edges|breakpoints). delete_non_selected INVIERTE: mantener SOLO el grupo, eliminar todo lo demás (el patrón de aislar). fill_hole tapa los agujeros restantes; remove_group elimina la etiqueta de grupo después. | input, group (+5 opcionales) | | attribute_transfer | Transferir atributos de puntos/prims desde un mesh FUENTE a la entrada por proximidad (attribtransfer) — el caballo de batalla para LIDAR-color / atributos GIS: pintar Cd desde un escaneo a un remesh, llevar N/uv a través de un cambio de topología. | input, source (+4 opcionales) | | attribute_create | Crear un atributo tipado de punto/prim/vértice/detalle con un valor constante (attribcreate) — la forma tipada y no wrangle de agregar Cd/pscale/N/id/material-index o cualquier atributo personalizado. attrib_name = atributo a crear. type = tipo de almacenamiento (float|int|vector|...). class = clase de elemento. value = un número o [x,y,z] (los tipos de cadena toman una cadena via value como texto). size = tamaño de tupla 1..4. precision = bits de almacenamiento. type_info etiqueta semántica de transformación para que los nodos downstream transformen el atributo correctamente (normal para N, color para Cd, punto para posiciones). on_existing decide qué pasa si el nombre ya está presente. group restringe la creación. | input, attrib_name (+9 opcionales) | | attribute_promote | Mover/agregar un atributo entre clases de elementos (attribpromote) — convertir un atributo de punto en una media por prim, distribuir un valor de detalle a puntos, etc. attrib = nombre de origen. from_class/to_class = point|prim|vertex|detail. method = cómo colapsan los valores de origen en un elemento de destino (max|min|mean|mode|median|sum|first|last|array...). out_name renombra el resultado. piece_attrib agrega DENTRO de cada pieza nombrada de forma independiente. delete_original: NOTA el nodo ELIMINA el origen por defecto — pasa false para mantener ambos. | input, attrib (+7 opcionales) | | attribute_delete | Eliminar atributos por clase + patrones de nombre separados por espacios (attribdelete) — mantenimiento para quitar Cd/N/rest/atributos temporales antes de exportar o un solver. point/prim/vertex/detail son cada uno un patrón de nombres separados por espacios a eliminar (por ejemplo, "Cd N rest"). negate INVIERTE: mantener SOLO los patrones listados y eliminar todo lo demás. | input (+6 opcionales) | | attribute_cast | Convertir la precisión de almacenamiento de atributos (attribcast) — la optimización de memoria que reduce a la mitad 32->16 bits para nubes de puntos pesadas / tiles de terreno. class = clase de elemento. attribs = patrones de nombre separados por espacios (predeterminado * = todos). precision = almacenamiento objetivo: los floats amigables 16|32|64 mapean a fpreal16/32/64, o pasa un token de nodo explícito (uint8|int8|int16|int32|int64|fpreal16|fpreal32|fpreal64|preferred) para conversiones de enteros. | input (+4 opcionales) | | attribute_interpolate | Interpolar atributos desde una geometría fuente a puntos/vértices via UVW o pesos capturados (attribinterpolate). | input (+16 opcionales) | | attribute_from_volume | Muestrear un volumen/campo VDB en atributos de punto (attribfromvolume) con remapeo de entrada/salida. | input (+10 opcionales) | | attribute_blur | Suavizar/relajar atributos a través de la superficie (attribblur) — laplaciano/preservador de volumen, por conectividad o proximidad. | input (+15 opcionales) | | attribute_copy | Copiar atributos de una geometría a otra (attribcopy), opcionalmente emparejados por un atributo como piece. | input (+13 opcionales) | | attribute_randomize | Escribir valores aleatorios en un atributo (attribrandomize) — las 12 distribuciones incl. ramp / discreta (ponderada) / uniformdiscrete. min_limit/max_limit limitan solo las distribuciones no acotadas (normal/exponencial/lognormal/cauchy), no un sorteo uniforme ya acotado. | input (+26 opcionales) | | attribute_composite | Componer atributos a través de una secuencia fusionada/apilada (attribcomposite) — mean/max/min/over/under. | input (+9 opcionales) | | attribute_reorient | Reorientar atributos de vector/quaternion para seguir una deformación vs un reposo/referencia (attribreorient). | input (+6 opcionales) | | attribute_swap | Intercambiar / copiar / mover un atributo a otro nombre (attribswap). | input (+6 opcionales) | | assign_name | Asignar el atributo de identidad de pieza (Name SOP) — la preparación requerida para fragmentos importados/modelados antes de assemble/RBD. | input (+7 opcionales) | | enumerate | Escribir un atributo de índice/nombre por elemento o por pieza (Enumerate SOP). | input (+8 opcionales) | | connectivity | Etiquetar cada pieza conectada con un atributo de clase-id continuo (connectivity) — la entrada para blast-by-piece, despeckle-by-size, randomize por pieza y assemble. connect_type: point (puntos que comparten un borde) | prim (prims que comparten un punto). attrib_name = atributo de id de salida. attrib_type: int | string (string antepone prefix, p. ej. 'piece_3'). group restringe el etiquetado a un grupo de puntos/prims. by_uv divide la conectividad a través de costuras UV (necesita uv_attrib). | input (+8 opcionales) | | measure | Calcular una cantidad geométrica en un atributo (measure). measure_type: perimeter|area|volume|centroid|curvature|gradient|laplacian|boundaryintegral|surfaceintegral. attrib_name = salida. class: points|prims — qué clase recibe el resultado. curvature_type aplica solo cuando measure_type=curvature. src_attrib nombra el atributo sobre el que gradient/laplacian/*integral operan (por ejemplo, el gradiente de un campo 'height'). total_attrib escribe el total sumado (área/volumen de todo el mesh o por pieza) en un atributo de detalle. group restringe. | input (+8 opcionales) | | group_combine | Combina booleanamente dos grupos nombrados en un grupo resultante (groupcombine). result = nuevo nombre de grupo. group_a / group_b = nombres de grupos fuente existentes. operation: union (en cualquiera) | intersect (en ambos) | xor (en exactamente uno) | subtract (en A pero no en B). group_type = la clase de los tres grupos (guess auto-detecta). | input, result, group_a, group_b (+3 optional) | | attrib_adjust_float | Crear/Modificar un atributo flotante con un patrón de valor (attribadjustfloat). | input (+16 optional) | | attrib_adjust_integer | Crear/Modificar un atributo entero con un patrón de valor (attribadjustinteger). | input (+14 optional) | | attrib_adjust_vector | Crear/Modificar la dirección y/o longitud de un atributo vectorial (attribadjustvector). | input (+13 optional) | | attrib_adjust_color | Crear/Modificar un atributo de color (Cd) (attribadjustcolor). | input (+11 optional) | | attrib_adjust_array | Controles de identidad/orden para un atributo de arreglo (attribadjustarray). | input (+6 optional) | | attrib_adjust_dict | Controles de alto nivel para un atributo de diccionario (attribadjustdict). | input (+7 optional) | | attrib_combine | Combina atributos en un destino mediante una operación matemática (attribcombine). | input (+12 optional) | | attrib_fill | Rellena/propaga un atributo a través de una superficie resolviendo un campo (attribfill). | input (+13 optional) | | attrib_fade | Crea un peso de desvanecimiento por punto que aumenta/se mantiene/disminuye a lo largo de los fotogramas (attribfade), típicamente para desvanecer partículas/piezas al entrar y salir. | input (+10 optional) | | attrib_remap | Reasigna los valores de un atributo numérico de un rango de entrada a un rango de salida, opcionalmente mediante una rampa (attribremap). | input (+11 optional) | | attrib_sort | Reordena puntos/vértices/prims según el valor de un atributo (attribsort). | input (+7 optional) | | attrib_find | Para cada elemento, encuentra el/los elemento(s) en una geometría SEARCH con un valor de atributo coincidente (attribfind). | input (+10 optional) | | attrib_from_map | Muestrea una fuente en un atributo de punto a lo largo de las UVs (attribfrommap). | input (+10 optional) | | attrib_from_parm | Importa los VALORES DE PARÁMETRO de otro nodo a la geometría como atributos (attribfromparm). | input (+7 optional) | | attrib_from_pieces | Asigna un valor de atributo por pieza a través de piezas nombradas (attribfrompieces). | input (+11 optional) | | attrib_mirror | Copia/refleja un atributo de un lado de la geometría al otro (attribmirror). | input (+13 optional) | | attrib_paint | Configura un atributo pintable (attribpaint). | input (+8 optional) | | attrib_string_edit | Buscar/reemplazar en valores de atributos de cadena (attribstringedit). | input (+11 optional) |

Limpieza y mallado

Herramienta	Qué hace	Parámetros clave
`mesh_pointcloud`	Convierte una nube de puntos en una malla (nube → VDB → polígonos) con reducción, transferencia de color y exportación opcionales.	`name`, `input` (+6 opcionales)
`quad_remesh`	Remallado QUAD alineado al campo (SOP quadremesh nativo — sin licencia de Labs/terceros): convierte una malla triangulada / de escaneo en una malla limpia de solo quads para subdivisión o animación. resolution elige cómo se especifica la densidad: quad_count (un target_quads absoluto, el predeterminado), quad_area (target_area por quad), tolerance, o una escala relativa/absoluta. adaptivity (+curvature_weight) concentra quads en la curvatura para que las siluetas se mantengan nítidas con menos quads; feature_boundaries alinea el flujo de quads con bordes duros. decimation_level pre-decima la entrada para velocidad en escaneos densos.	`input` (+9 opcionales)
`gameres`	SideFX Labs GameRes — reduce una malla de alta resolución (`input`, entrada 0) a un LOD de resolución de juego mediante polyreduce / Instant Meshes / voxel-remesh; la salida del SOP cocinado ES la malla reducida. finalcount apunta al presupuesto de polígonos; use_instantmeshes cambia a quad-remesh; enable_voxelization+resolution hacen una reconstrucción de voxeles.	`input` (+19 opcionales)
`instant_meshes`	SideFX Labs Instant Meshes — remallado QUAD/tri alineado al campo de la malla de entrada mediante el núcleo compilado de Instant Meshes (no se lanza ningún ejecutable externo; cocinado solo de datos).	`input` (+6 opcionales)
`polydoctor`	Diagnostica y repara polígonos no múltiples / mal formados (PolyDoctor) — el saneador de mallas pre-booleano / pre-VDB / pre-sim.	`input` (+7 opcionales)
`polyfill`	Rellena agujeros de borde (pérdidas de LIDAR/escaneo, huecos booleanos) con polígonos de parche (PolyFill). fillmode elige la topología del parche: tris / trifan / quadfan / quads / gridquads (cuadrícula de quads, mejor para subdivisión posterior) o none (solo agrupa el agujero). smooth (+smooth_strength, hasta 50) relaja el nuevo parche para que se mezcle con la superficie circundante; tangent_strength controla cuán fuertemente el parche sigue las tangentes del borde (0..2, predeterminado 0.4). patch_group etiqueta los polígonos de parche creados para selección posterior.	`input` (+7 opcionales)
`mesh_repair`	Kit de reparación de SideFX Labs multiplexado por op. repair (Labs Repair): cierra agujeros + arregla geometría no múltiple — fillmode elige la topología del parche de agujero (tris..gridquads), iterations = pasadas de reparación. delete_small_parts: elimina cáscaras de basura desconectadas — mode perimeter\|area, threshold es el corte de tamaño relativo, extract_largest conserva solo la pieza más grande (ideal para aislar un objeto escaneado del ruido). clean_seams: disuelve bordes de costura de islas UV. fast_remesh (Labs Fast Remesh): retriangulación uniforme estilo GPU — target_polycount establece el tamaño de salida, iterations = pasadas de remallado.	`input` (+8 opcionales)
`clean`	Clean SOP — limpieza paramétrica de geometría sucia/de escaneo (el complemento basado en interruptores de polydoctor/mesh_repair).	`input` (+14 opcionales)
`point_normals`	Estima una normal de superficie por punto para una nube de puntos cruda (escaneo LIDAR/fotogrametría) ajustando un plano a la vecindad de cada punto (covarianza / PCA) — necesario antes del mallado (Poisson/VDB) o la segmentación pared-vs-piso, ya que los escaneos no tienen normales. radius_m = radio de búsqueda de vecindad (metros); maxpts limita los vecinos por punto (costo).	`input` (+3 opcionales)
`segment_planar`	Clasifica/segmenta puntos de nube de puntos como PARED vertical vs PISO/TECHO horizontal a partir de su normal v@N (ejecuta point_normals primero) — extracción de estructura de escaneos de edificios/interiores. kwall/coshoriz son los umbrales \|N.y\| (cerca de 0 = pared, cerca de 1 = horizontal).	`input` (+3 opcionales)
`despeckle`	Elimina el ruido de una nube de puntos borrando puntos aislados/errantes que tengan menos de min_nbrs vecinos dentro del radio — elimina ruido del escáner/moteado/voladores antes del mallado. radius = distancia de búsqueda de vecinos; min_nbrs = umbral de conservación.	`input` (+3 opcionales)
`level`	Alinea por gravedad / endereza una nube de puntos o escaneo inclinado para que el suelo quede plano y horizontal: ajuste RANSAC del plano de suelo dominante, refinamiento PCA de su normal, y rotación de toda la nube para que esa normal apunte a +Y (arriba), mediante un xform de nivel añadido después de la entrada. threshold = distancia de inliers de RANSAC.	`input` (+1 opcional)

Instancia y dispersión

Herramienta	Qué hace	Parámetros clave
`scatter_copy`	Dispersión e instancia en un solo paso: dispersa aleatoriamente `count` puntos sobre una superficie objetivo y copia/instancia una forma fuente en cada punto (follaje, rocas, trozos de hielo, escombros, greebles).	`name` (+6 opcionales)
`instance_attributes`	SideFX Labs Instance Attributes — escribe los atributos de punto que un instanciador lee (el atributo de ruta de asset `instanceattrib` + pscale/scale/orient por punto) en los puntos entrantes (`input`, entrada 0) para que una copia/instancia posterior pueda vestir una escena.	`input` (+20 opcionales)
`physics_painter`	SideFX Labs Physics Painter — dispersa objetos sobre la superficie entrante (`input`, entrada 0) y los asienta con una breve resolución de Bullet para que descansen naturalmente (rocas en una pendiente, accesorios en un estante).	`input` (+19 opcionales)
`copy_to_points`	Copia/instancia la geometría SOP fuente en cada punto del SOP objetivo (Copy to Points 2.0) — la operación de instancia central para follaje, rocas, escombros, greebles, multitudes.	`source`, `target` (+5 opcionales)
`scatter`	Dispersa/distribuye aleatoriamente `count` puntos sobre la superficie de la geometría de entrada (Scatter 2.0) — el conjunto de puntos sobre el que luego copias instancias (con copy_to_points) o usas como ubicaciones de muestra. count es el número total de puntos. density_attrib sesga dónde aterrizan los puntos mediante un atributo flotante por punto (máscara de heightfield / oclusión / pendiente). relax_iterations extiende los puntos a un espaciado casi uniforme de disco de Poisson (elimina la agrupación). seed reordena.	`input` (+6 opcionales)
`pack`	Colapsa la geometría de entrada en primitivas empaquetadas — una referencia ligera de memoria plana a la geometría que es mucho más barata de copiar/instanciar y transformar en masa (cada prim empaquetado se comporta como un punto que puedes mover/rotar/escalar). pack_by_name crea una prim empaquetada por valor único del atributo `name` (empaquetado por pieza para geometría fracturada/etiquetada). viewportlod controla cómo se dibujan las prims empaquetadas en el viewport (full/points/box/centroid/hidden) — baja a box/points para mantener interactivo un gran número de instancias.	`input` (+4 opcionales)
`unpack`	Expande las primitivas empaquetadas de vuelta a geometría editable cruda (el inverso de pack) — necesario antes de poder editar/deformar los puntos y polígonos subyacentes de las instancias empaquetadas.	`input` (+2 opcionales)
`instance`	Instance SOP: etiqueta los puntos de entrada para que cada uno se expanda en una copia instanciada de geometría en el momento de render/expansión — instancia de puntos diferida que se mantiene barata hasta que se renderiza. instance_attrib nombra el atributo de punto de cadena que contiene la ruta SOP/geometría a instanciar por punto (instancia heterogénea). pack emite las instancias expandidas como prims empaquetadas.	`input` (+3 opcionales)
`biome_scatter`	Dispersa vegetación / plantas sobre el terreno de entrada mediante el SOP Labs Biome Plant Scatter — decoración de ecosistema/follaje (hierba, arbustos, árboles) con control de densidad y espaciado. density multiplica el número de plantas; spacing establece el espacio mínimo entre plantas; seed reordena.	`input` (+4 opcionales)
`tag_radial`	Selecciona/etiqueta todos los puntos dentro de una esfera (centro + radio) escribiendo i@tag = 1 en ellos — una selección de región esférica para aislar o enmascarar parte de una nube de puntos. center = centro de la esfera [x,y,z].	`input` (+3 opcionales)
`point_replicate`	Replica/multiplica cada punto de entrada en `count` nuevos puntos con jitter distribuidos dentro de una forma alrededor de él (Point Replicate SOP) — convierte puntos dispersos en una nube más completa para emisión de spray/niebla/polvo o dispersión en una forma. count = réplicas por punto de entrada; shape (box/sphere/cylinder/cone/grid/circle/line) + size establecen el volumen de dispersión; noise añade jitter posicional extra; copy_attribs lleva los atributos del punto fuente (Cd, pscale, id...) a sus réplicas, y attribstocopy nombra cuáles.	`input` (+8 opcionales)

VDB y volúmenes

Herramienta	Qué hace	Parámetros clave
`vdb_transform_properties`	SideFX Labs VDB Transform Properties — vuelve a derivar los valores de un VDB vectorial bajo la propia transformación del volumen.	`input` (+4 opcional)
`volume_texture`	SideFX Labs Volume Texture — aplana el volumen/VDB entrante (`input`, entrada 0) en un atlas de flipbook en rebanadas para un shader de textura de volumen en tiempo real; la salida SOP cocinada es la geometría de vista previa de rebanadas. mode elige el empaquetado; customfield nombra el campo de volumen; slices/frameresolution establecen el diseño del atlas; equalizedensity/invertdensity ajustan la densidad.	`input` (+12 opcional)
`vdb_from_particles`	Puntos/partículas -> VDB. op=particles construye rejillas SDF/niebla/máscara/velocidad (vdbfromparticles); op=fluid convierte partículas FLIP en un VDB de densidad de fluido (vdbfromparticlefluid).	`input` (+26 opcional)
`vdb_from_polygons`	Polígonos -> VDB SDF y/o niebla (mallado de ida y vuelta / colisión / atmosféricos) con control de banda estrecha y transferencia opcional de atributos de puntos.	`input` (+16 opcional)
`vdb_convert`	Convertir VDB (el centro de ida y vuelta): polígonos/polysoup/vdb/volumen nativo, reclasificación SDF<->niebla, cambio de precisión/tipo, control de iso, transferencia de atributos y afilado de características.	`input` (+15 opcional)
`vdb_filter`	Filtro de campo de una sola entrada en un VDB / volumen nativo (suavizar, remodelar, renomalizar, desenfocar, extrapolar).	`input` (+29 opcional)
`volume_combine`	Combinar campos VOLUME nombrados transportados en UNA entrada mediante una operación (volumecombine) — dest = op(dest, source) emparejados por nombre: sumar dos campos de densidad, multiplicar una máscara en temperatura, máximo de dos simulaciones de humo.	`input` (+12 opcional)
`volume_rasterize_attributes`	Rasterizar ATRIBUTOS de puntos en VOLUMENES de niebla nombrados (volumerasterizeattributes) — convertir una nube de puntos que lleva densidad/temperatura/v/Cd en los CAMPOS de volumen correspondientes en UN solo nodo (una fuente de pyro/humo, o hornear una simulación de puntos en volúmenes renderizables).	`input` (+14 opcional)
`volume_rasterize`	Rasterizar puntos/partículas en un volumen de niebla de densidad/atributo (nube de densidad de puntos / fuente pyro). input=Base Volume (input0, define la resolución); los puntos/partículas de origen se conectan a input1.	`input` (+34 opcional)
`convert_volume`	Carril de volumen nativo: mode=isooffset (polígonos -> volumen/SDF/tetra nativo de Houdini mediante isooffset), tovdb/topoly (convertir totype), o convert (genérico).	`input` (+12 opcional)
`vdb_analysis`	Cálculo de campos en un VDB (SOP de Análisis VDB) sin VEX: gradiente/curvatura/laplaciano/punto más cercano/divergencia/rotacional/longitud/normalizar.	`input` (+7 opcional)
`vdb_topology`	Operaciones de conjunto de vóxeles activos (topología) mediante op: activate (vdbactivate), clip (vdbclip), resample (vdbresample), segment (vdbsegmentbyconnectivity).	`input` (+23 opcional)
`vdb_combine`	CSG de dos entradas / matemática de campos en VDBs (la respuesta tipada a un Volume VOP, sin VEX) mediante op: sdf (vdbcombine), fog (volumemix), vectormerge (vdbvectormerge), vectorsplit (vdbvectorsplit). input=A (input0), input_b=B (input1).	`input` (+17 opcional)
`vdb_advect`	Transportar un VDB mediante un VDB de velocidad (input1), sin VEX: op=points (vdbadvectpoints), sdf (vdbadvectsdf), morph (vdbmorphsdf hacia un SDF objetivo en input1).	`input` (+23 opcional)
`vdb_shatter`	VDB SDF -> piezas discretas / proxies de esfera, sin VEX: op=fracture (vdbfracture; geo de corte en input1; alimenta sim_rbd), spheres (vdbtospheres; paquete de proxy RBD).	`input` (+24 opcional)
`volume_visualize`	Inspeccionar/presentar un volumen de niebla en el viewport (sin render), sin VEX: op=shade (volumevisualization sombreado de densidad/emisión), slice (volumeslice sección transversal 2D).	`input` (+20 opcional)
`vdb_reshape`	Remodelar un VDB SDF desplazando su superficie (VDB Reshape SDF): dilate (crecer), erode (encoger), open (erosionar-luego-dilatar — elimina picos delgados), close (dilatar-luego-erosionar — rellena agujeros/grietas).	`input` (+6 opcional)

Solvers y simulación| Tool | Qué hace | Parámetros clave |

|---|---|---|---| | rbd_guide | Conecta un SOP de geometría guía en la entrada Guide Sim (índice 4) de un rbdbulletsolver EXISTENTE para una simulación RBD guiada / dirigida artísticamente (los parámetros guide_* del solver controlan la fusión). | solver, guide (+1 opcional) | | rbd_attach_constraints | Alimenta una red de restricciones creada (glue_cluster / rbd_constraints / set_constraint_field) en la entrada Constraint (índice 1) de un rbdbulletsolver EXISTENTE — adjunta restricciones a un solver sim_rbd en vivo. | solver, constraints (+2 opcionales) | | flowmap | SideFX Labs Flowmap — crea un atributo de vector de flujo por punto sobre una superficie con UV (input, entrada 0) para dirigir la distorsión de material del flow-map (ríos, lava). | input (+3 opcionales) | | flowmap_guide | SideFX Labs Flowmap Guide — orienta un flow-map de superficie hacia curvas guía dibujadas a mano. | input (+7 opcionales) | | flowmap_obstacle | SideFX Labs Flowmap Obstacle — desvía un flow-map de superficie alrededor de geometría de obstáculo. | input (+6 opcionales) | | flowmap_to_color | SideFX Labs Flowmap To Color — hornea un atributo de vector de flujo en un color RG(B) que el motor lee como flow-map. | input (+3 opcionales) | | flowmap_visualize | SideFX Labs Flowmap Visualize — previsualiza un flow-map animando una distorsión sobre input (entrada 0). | input (+7 opcionales) | | kelvin_wakes_deformer | SideFX Labs Kelvin Wakes Deformer — deforma una superficie de agua con el patrón de estela de Kelvin físicamente basado que sigue a un objeto en movimiento. | input (+15 opcionales) | | splatter | SideFX Labs Splatter — una FUENTE de salpicadura de fluido SPH autocontenida que construye una geo /obj nueva que emite fluido de partículas (salpicaduras de pintura/sangre). | name (+15 opcionales) | | procedural_smoke | SideFX Labs Procedural Smoke — construye una geo /obj nueva que contiene un volumen de DENSIDAD de humo totalmente procedural (sin simulación) controlado por ruido en capas. | name (+9 opcionales) | | volume_adjust_look | SideFX Labs Volume Adjust Look — dirige artísticamente el ASPECTO de un volumen de humo/pyro (multiplicadores de densidad / sombra / difusión / emisión, escala de grises opcional). | input (+12 opcionales) | | destruction_cleanup | SideFX Labs Destruction Cleanup — posprocesa la salida de simulación RBD/fractura: elimina caras interiores, cúspides de normales, regenera nombres de piezas, optimiza piezas en fragmentos. | input (+11 opcionales) | | rbd_edge_strip | SideFX Labs RBD Edge Strip — extrae tiras finas de borde a lo largo de las líneas de fractura de piezas RBD (para astillado / detallado de bordes). | input (+4 opcionales) | | loop_volume | SideFX Labs Loop Volume — hace un cross-fade de una secuencia de volumen (humo/pyro) en un bucle sin costuras. | input (+5 opcionales) | | make_loop | SideFX Labs Make Loop — convierte una secuencia animada en un bucle sin costuras (geometría, volumen o partículas). | input (+14 opcionales) | | lightning | SideFX Labs Lightning — genera geometría procedural de rayos/arcos a través de un modelo. | input (+16 opcionales) | | rbd_solver | Solver Bullet puro para piezas YA fracturadas + una red de restricciones arbitraria — el eslabón que permite que la vía de fractura granular (rbd_voronoi/vdb_shatter/rbd_constraints/set_constraint_field) sea realmente SIMULADA, SIN volver a fracturar (a diferencia de sim_rbd/rbd_destruction). pieces = SOP fracturado empaquetado (Geometry in0); constraints = SOP de red de restricciones opcional (in1); collider = malla/heightfield opcional (in3). | pieces (+50 opcionales) | | sim_rbd | Destrucción de cuerpo rígido (vía SOP Bullet): source -> rbdmaterialfracture::3.0 -> rbdbulletsolver. | name (+81 opcionales) | | rbd_constraint_properties | Autor de FÍSICA de restricciones RBD (el dial de rotura) en la red de pegamento de un solver mediante rbdconstraintproperties::2.0. | solver (+18 opcionales) | | rbd_material_fracture | Pre-fracturar geometría por TIPO DE MATERIAL (rbdmaterialfracture::3.0) SIN solver — presets de hormigón | vidrio | madera | personalizado. | input (+31 opcionales) | | rbd_voronoi | Fractura Voronoi pura (voronoifracture::2.0) para control dirigido artísticamente: source -> scatter cells -> fracture (sin presets de material). | name (+18 opcionales) | | rbd_interior | Detalle de caras interiores en geo fracturada (SOP rbdinteriordetail): desplaza las caras de grieta 'internas' con ruido para que el hormigón/roca rota se lea como interior real, no como cortes planos. | input (+18 opcionales) | | rbd_constraints | Construir la GEOMETRÍA DE RED de restricciones (grafo de enlaces) a partir de piezas fracturadas: method=rules (rbdconstraintsfromrules) o method=adjacency (connectadjacentpieces). | input (+13 opcionales) | | rbd_configure | Dinámica por pieza + activación en piezas fracturadas (SOP rbdconfigure): activo/animado, densidad/rebote/fricción, minactivationimpulse (disparador de impacto), overlap, presets tipo/pintype, visualizar. | input (+14 opcionales) | | rbd_collision | EL PUENTE DE TERRENO: conecta un collider de malla/heightfield en la entrada Collision Geometry (índice 3) de un rbdbulletsolver existente para que los escombros se asienten sobre terreno real capturado. | solver, collider (+10 opcionales) | | rbd_force | Fuerza DOP tipada (SIN VEX) para escombros RBD más allá de gravedad/drag: viento/uniforme/punto/vórtice/ventilador/drag/explosión (explosion|blast -> popaxisforce onda expansiva radial). | 12 opcionales | | rbd_cache | CONSTRUIR (nunca escribir) un SOP File Cache 2.0 después de una simulación RBD, con una ruta de escritura explícita confinada. | input, file (+7 opcionales) | | rbd_exploded | Depuración/inspección: separa las piezas fracturadas para ver la rotura (SOP rbdexplodedview). | input (+6 opcionales) | | rbd_destruction | LA MACRO DE DESTRUCCIÓN DE TERRENO: fractura un activo reconstruido y lo colapsa sobre terreno real capturado de extremo a extremo. building -> rbdmaterialfracture (+glue) -> [rbdconstraintproperties] -> rbdbulletsolver con el DEM conectado como colisión. | name (+20 opcionales) | | sim_flip | Líquido FLIP (contenedor profundo + solver): construye un flipcontainer + flipsolver alimentado por una primitiva fuente (una caja por defecto, o tu source_geo), conectado source->Sources(0)/container->Container(1). | name (+44 opcionales) | | flip_collision | Geometría -> volumen de colisión FLIP (SOP Collision Source 2.0). | input (+16 opcionales) | | flip_flood | MACRO de inundación de terreno: UNA llamada compone un SOP DEM/heightfield (input) -> convertheightfield -> collisionsource collider -> flipcontainer de tamaño automático (ajustado al bbox del DEM + padding + espacio superior) -> flipsolver, con el collider conectado automáticamente a la entrada Collisions del solver. | name, input (+22 opcionales) | | flip_source | Geometría -> partículas FLIP (SOP Flip Source): llenado inicial y/o emisión continua; alimenta la entrada Sources de un flipsolver. | input (+15 opcionales) | | flip_boundary | Fuente/sumidero de frontera abierta para un contenedor FLIP (SOP Flip Boundary): tipos de frontera none/velocity/pressure/hydro_pressure (hydro = línea de costa/inundación costera). | input (+11 opcionales) | | flip_tank | Piscina pre-llenada de partículas FLIP (SOP Particle Fluid Tank): una piscina/puerto/embalse que comienza ya lleno. | name (+11 opcionales) | | flip_force | Nodo de fuerza tipada (sin VEX) para una simulación FLIP/DOP: ftype -> uniformforce/vortexforce/windforce/drag/pointforce/fan/popaxisforce. | 13 opcionales | | sim_pop | Partículas POP (maestro): un sop dopnet (input0=emit geo) que envuelve popobject -> popsolver::2.0, fuente en la entrada Sources (solución usecontextgeo='first') y una popforce de gravedad por defecto encadenada en Pre-Solve. | name (+38 opcionales) | | pop_source | Añadir un emisor de partículas tipado (popsource::2.0) en un dopnet POP existente y conectarlo a la entrada Sources del popsolver. | dopnet (+23 opcionales) | | pop_force | Añadir UNA fuerza POP tipada en un dopnet POP y encadenarla en la entrada Pre-Solve del popsolver (las fuerzas se encadenan, apilándose limpiamente). | dopnet (+54 opcionales) | | pop_import | Extraer partículas POP simuladas de un dopnet de vuelta a SOP mediante dopimport::2.0 (el importador solo de datos; el menú de presets de dopio no se rellena headless). | dopnet (+7 opcionales) | | pop_collision | Colisionar partículas contra un collider SOP/terreno (popcollisiondetect) dentro de un dopnet POP, encadenado en Pre-Solve. | dopnet (+15 opcionales) | | pop_group | Agrupar o dividir un flujo de partículas por reglas TIPADAS (sin VEX), encadenado en Pre-Solve de un dopnet POP. op=group -> popgroup (etiquetar en groupname; región delimitada tipada + subconjunto aleatorio + combinación booleana). op=stream -> popstream (dividir un sub-flujo nombrado por las mismas reglas tipadas). | dopnet (+30 opcionales) | | pop_kill | Matar / limitar / restringir partículas por reglas TIPADAS (sin VEX), encadenado en Pre-Solve de un dopnet POP. op=kill -> popkill (región delimitada tipada + subconjunto aleatorio). op=limit -> poplimit (caja de dominio dura; clamp/bounce/wrap). op=softlimit -> popsoftlimit (región de empuje suave hacia atrás). op=speedlimit -> popspeedlimit (limitar velocidad/rotación). enablerule/randomcode nunca establecidos. | dopnet (+36 opcionales) | | pop_property | Dar forma a atributos por partícula con nodos POP de propiedades TIPADAS (sin VEX), encadenado en Pre-Solve de un dopnet POP. op=physical -> popproperty (pscale/mass/bounce/friction/drag/cling). op=color -> popcolor (constante/aleatorio/rampa/mezcla Cd + alpha). op=sprite -> popsprite (tarjetas de cámara). op=velocity -> popvelocity. op=lookat/torque -> orient. | dopnet (+39 opcionales) | | pop_instance | Instancing / transferencia de render para un dopnet POP (sin VEX). op=instance -> popinstance (escribir instancepath para que los puntos instancien un SOP en tiempo de render; se encadena en Pre-Solve). op=replicate -> popreplicate (generar hijos por padre para rocíos secundarios; se conecta a la entrada Sources). | dopnet (+26 opcionales) | | pop_cache | CONSTRUIR (nunca escribir) un SOP File Cache 2.0 después de un nodo pop_import para cachear partículas simuladas en disco. | 12 opcionales | | pop_flock | Boids / steering para un dopnet POP (sin VEX), encadenando UN nodo de comportamiento en Pre-Solve. behavior selecciona popflock/popinteract/popsteer{seek,avoid,wander,separate,cohesion,align,obstacle}/popproximity. popsteercustom (VEX) está excluido; todos los campos uselocal* (incl. el preset de ruido de wander) se dejan en su valor por defecto. | dopnet, behavior (+43 opcionales) | | pop_scatter_sim | MACRO de dispersión de partículas en terreno/escaneo (el análogo de flip_flood): UNA llamada compone toda la vía POP en una geo /obj nueva — emit geo -> dopnet(popobject+popsource) -> popsolver + un preset de fuerza tipada -> pop_collision opcional contra un collider de terreno/escaneo -> dopimport de vuelta a SOP -> transferencia de render copy_to_points opcional. | name (+14 opcionales) | | sim_pyro | Pyro (fuego/humo): MIGRADO a la vía SOP moderna pyrosource -> SOP pyrosolver (contenedor auto-dimensionado) + collider collisionsource::2.0 opcional. | name (+75 opcionales) | | pyro_source | Fuente de emisión Pyro (SOP pyrosource): rasteriza geo/puntos en campos fuente (density/temperature/fuel/burn/vel) que alimentan la entrada Sources de un pyrosolver. | input (+10 opcionales) | | pyro_collision | Geometría/terreno -> volumen de colisión pyro (SOP Collision Source 2.0): el puente de colisión de escena; alimenta la entrada Collision de un pyrosolver para que el humo se desvíe de un DEM, edificios o escombros RBD. | input (+10 opcionales) | | pyro_ground | Macro de suelo/incendio forestal: heightfield DEM -> collider + pyrosource sobre una región de emisión -> SOP pyrosolver (ajustado por tipo + viento) -> volumevisualization. | name, input (+22 opcionales) | | pyro_burst | Fuente de explosión/bola de fuego Pyro (SOP pyroburstsource): convierte los puntos de entrada en una carcasa de explosión/onda de choque/boca/anillo + brasas residuales que alimentan la entrada Sources de un pyrosolver. | input (+25 opcional) | | pyro_explosion | Macro de explosión: un único punto de estallido en el centro -> pyroburstsource (explosión + brasas) -> pyrosolver SOP (bola de fuego caliente) -> volumevisualization. | name (+30 opcional) | | pyro_visualize | Vista de viewport para un campo pyro/volumétrico (SOP volumevisualization): sombreado económico de viewport solamente, NO es un render. | input (+14 opcional) | | pyro_shade | Campos de sombreado listos para render de un volumen pyro (SOP pyrobakevolume): el nodo de preparación de render de Karma; hornea el aspecto de humo/fuego/scatter + asigna un material Pyro. | input (+25 opcional) | | pyro_post | Preparación de exportación/render para una sim pyro (SOP pyropostprocess::2.0): calcula el min/max de campos (Karma los necesita) + conversión opcional nativo->VDB para una secuencia .vdb. | input (+11 opcional) | | pyro_cache | CONSTRUIR (nunca escribir) un SOP File Cache 2.0 después de una sim pyro, con una ruta de escritura explícita y confinada + tipo de archivo bgeo/vdb. | input, file (+7 opcional) | | whitewater_source | Fuente de emisión de whitewater (SOP Whitewater Source 3.0): máscaras de emisión que deciden dónde nacen espuma/rociado/burbujas a partir de una sim líquida FLIP. | input (+21 opcional) | | sim_whitewater | Whitewater (espuma/rociado/burbuja): MIGRADO al carril SOP moderno whitewatersource::3.0 -> whitewatersolver (SOP) -> post opcional. | 39 opcional | | whitewater_post | Post-proceso de whitewater (SOP Whitewater Post Process): da forma a la espuma/rociado/burbuja resueltos para render — rampas de densidad/pscale, salida de partículas/niebla/malla, recorte del contenedor. | input (+17 opcional) | | fluid_surface | Convertir en malla las partículas FLIP como superficie de fluido (SOP Particle Fluid Surface 3.0). | input (+19 opcional) | | flip_volume_combine | Combinar los campos de una sim FLIP de BAJA resolución con detalle de ALTA resolución para UP-RESOLUCIÓN (flipvolumecombine) — el flujo de trabajo de up-res de H20: simular barato a baja res, mezclar detalle de alta frecuencia de superficie/velocidad solo donde importa. entrada=campos de baja res (in0); high_res=campos de alta res (in1); container=contenedor de referencia de alta res (in2); clip_bbox=caja de recorte (in3), todo puenteado automáticamente entre redes. | input (+14 opcional) | | flip_cache | CONSTRUIR (nunca escribir) un SOP File Cache 2.0 después de una sim, con una ruta de escritura explícita y confinada. | input, file (+6 opcional) | | sim_ripple | Ondas de superficie baratas mediante el SOP Ripple Solver sobre una rejilla (geometría de reposo en la entrada 0). | name (+8 opcional) | | sim_grains | PBD granular (arena/nieve/arena mojada/escombros): un dopnet SOP (entrada0=geo de emisión) que envuelve popobject -> popsolver::2.0 con un solucionador PBD popgrains ADJUNTO vía la entrada 'Solvers to be attached' del solucionador + una popforce de gravedad por defecto. | name (+35 opcional) | | set_constraint_field | Establecer / crear / nombrar / romper atributos de red de restricciones RBD (destrucción de cuerpo rígido) por grupo, como valores LITERALES tipados mediante un attribcreate::2.0 — la vía solo-datos, cero-VEX / cero-wrangle para controlar enlaces de pegamento/duro/blando en una fractura: constraint_name (el tipo de relación que mapea el solucionador — Glue/Hard/Soft o un nombre personalizado), next_constraint_name (en qué se convierte un enlace al romperse), strength (el umbral de ruptura), restlength (longitud de reposo para blando/resorte), broken (marca de pre-roto 0|1). | input (+8 opcional) | | glue_cluster | Dividir / agrupar piezas RBD fracturadas en CHUNKS para que una estructura se rompa en BLOQUES o losas en lugar de por casco (SOP gluecluster) — el control de dirección artística de destrucción más usado para edificios/muros que colapsan en secciones coherentes. | input (+14 opcional) | | rbd_constraints_from_curves | Construir / enrutar una red de restricciones RBD (destrucción de cuerpo rígido) A LO LARGO de curvas de usuario (SOP rbdconstraintsfromcurves) — enrutado de enlaces personalizado para barras de refuerzo, cables, cadenas, costuras o líneas de ruptura dibujadas a mano, y el tipo de conexión HINGE (mecánica) alcanzable desde SOP. | input, curves (+11 opcional) | | rbd_constraints_from_lines | Construir una red de restricciones RBD (destrucción de cuerpo rígido) desde SEGMENTOS DE LÍNEA explícitos (SOP rbdconstraintsfromlines) — la forma solo-datos de la herramienta interactiva de líneas dibujadas con el manejador: cada línea, dada como un par de puntos literal, enruta un enlace entre las piezas fracturadas que cruza. | input, lines (+13 opcional) | | rbd_group_constraints | Nombrar / agrupar / organizar una red de restricciones RBD (destrucción de cuerpo rígido) en un grupo de primitivas nombrado y seleccionable (SOP rbdgroupconstraints) para que un solucionador, set_constraint_field o rbd_constraint_properties puedan seleccionar esos enlaces. | input, constraints (+6 opcional) | | voronoi_adjacency | Construir el grafo de ADYACENCIA de piezas / topología de enlaces (qué piezas fracturadas tocan a cuáles) a partir de una fractura de Voronoi (SOP voronoiadjacency) — las polilíneas de adyacencia por las que se enrutan las redes de restricciones RBD (destrucción de cuerpo rígido). | input (+1 opcional) | | sim_viscosity | Andamiaje FLIP viscoso (agua fangosa / agua de deshielo / miel / lava): un flipcontainer + flipsolver con fuerza de viscosidad habilitada. | name (+11 opcional) | | ocean_surface | Superficie de OCÉANO / MAR grande y plano con espectro espectral — una rejilla desplazada por un espectro oceánico (Ocean Evaluate 2.0) en olas ondulantes. | name (+7 opcional) | | ocean_spectrum | Crear un ESPECTRO completo de olas oceánicas (Ocean Spectrum) + evaluarlo sobre una rejilla grande — los controles profundos de 'aspecto' que ocean_surface no puede alcanzar: modelo de espectro, profundidad del agua, swell, fetch, dirección/bias del viento, semilla determinista + bucle continuo. | name (+29 opcional) | | ocean_evaluate | Deformar geometría ARBITRARIA mediante un ESPECTRO oceánico (Ocean Evaluate a nivel SOP). | input, spectrum (+9 opcional) | | ocean_foam | Generar puntos de ESPUMA / whitewater / rociado desde la cúspide de una superficie oceánica (SOP Ocean Foam) — la capa de espuma marina sobre crestas rompientes. | input (+17 opcional) | | ocean_source | Acoplar un espectro oceánico a un tanque de fluido FLIP (Ocean Source 2.0) — el andamiaje que siembra una sim FLIP de agua salpicante / ola rompiente desde el océano espectral. particlesep = separación de partículas FLIP; waterlevel = nivel del mar en reposo. | name (+4 opcional) | | point_velocity | Crear el atributo de velocidad de punto v (SOP Point Velocity) — el caballo de batalla de velocidad semilla de FX. | input (+10 opcional) | | volume_velocity | Crear un VOLUMEN de velocidad (SOP Volume Velocity) — el campo de velocidad 'túnel de viento' no simulado que impulsa rociado de cresta / nieve / lluvia mediante pop_force(advect). entrada = el volumen/VDB en el que escribir; entrada opcional de puntos rasteriza v. | input (+9 opcional) | | debris_source | Emitir una fuente de ESCOMBROS secundarios (SOP Debris Source) desde la superficie de una pieza fracturada/estática — el mapa de emisión por fotograma (atributos de density/age/distance) que alimenta una sim secundaria de 'jugo' emit-RBD o POP. | input (+7 opcional) | | cloud | Primitiva de NUBE volumétrica (cumulus / nube de cielo / campo de densidad de volumen de niebla): geo de origen -> Cloud 2.0 (SDF/densidad/banda estrecha) -> Cloud Noise (desplazamiento ondulante/fino) -> opcional Cloud Adjust Density Profile (modelado de base/yunque). | name (+25 opcional) | | cloud_shape | Generar una nube MODERNA direccionable artísticamente con el set de herramientas Cloud Shape de H20+ (cloudshapegenerate) — el reemplazo del monolítico cloud obsoleto. | name (+18 opcional) | | cloud_billowy_noise | Desplazamiento de coliflor ondulante en un VDB de DENSIDAD de nube (cloudbillowynoise) — el modificador moderno de alto detalle para cumulus. | input (+16 opcional) | | cloud_wispy_noise | Desplazamiento fino / estriado advectado por velocidad en un VDB de DENSIDAD de nube (cloudwispynoise) — cirros, yunques estirados, estrías arrastradas por el viento. | input (+11 opcional) | | cloud_clip | Recortar / cortar un VDB de DENSIDAD de nube con un plano + ruido opcional (cloudclip) — bases planas de cumulus, yunques cizallados, cimas rebanadas. | input (+11 opcional) | | solver | Solucionador SOP genérico de retroalimentación / bucle de tiempo — la primitiva iterativa de propósito general (erosión acumulativa, crecimiento, autómatas celulares, cualquier retroalimentación por fotograma), distinto de la familia sim_* de DOP. | input (+6 opcional) | | sim_vellum | Maestro Vellum (XPBD) (SOP): origen -> Vellum Constraints -> Vellum Solver. | name (+65 opcional) | | vellum_collision | Conectar un colisionador externo/de terreno a la entrada Collision Geometry (índice 2) de un solucionador Vellum y ajustar la respuesta de colisión. | solver, collider (+14 opcional) | | vellum_attach | Fijar tela/geometría Vellum a un RIG (en movimiento) — el SOP dedicado Vellum Attach Constraints. | input, rig (+9 opcional) | | vellum_constraint | Superponer una restricción Vellum ADICIONAL sobre una cadena existente (soldaduras/pegamento/pines/fijación/costuras/estruts) mediante el añadido de la segunda entrada. | solver (+36 opcional) | | vellum_force | Fuerzas externas sobre una resolución Vellum. | 24 opcional | | vellum_drape | Estado de reposo / asentamiento de pre-rodaje. | solver (+29 opcional) | | vellum_source | Emisión continua / añadir parches de restricción a mitad de sim (con alcance DOP, avanzado — la única herramienta Vellum que baja a DOP). | 12 opcional | | vellum_post | Preparación de render para una sim Vellum (SOP vellumpostprocess): generación de tubos de cabello, suavizado (subdivide), desenredo, rigidez. | input (+15 opcional) | | vellum_cache | CONSTRUIR (nunca escribir) un SOP File Cache 2.0 después de una sim Vellum. | input, file (+8 opcional) | | sim_mpm | Red MPM (Método del Punto Material) (SOP): origen -> mpmsource -> mpmsolver. | name (+24 opcional) | | mpm_collider | Dar a una sim MPM algo con lo que COLISIONAR / INTERACTUAR — conectar un colisionador a la entrada MPM Colliders (índice 1) de un mpmsolver existente. | solver, collider (+11 opcional) | | mpm_container | Delimitar el DOMINIO de una sim MPM y fijar su resolución MAESTRA — conectar un mpmcontainer a la entrada MPM Container (índice 2) de un mpmsolver existente. | solver (+9 opcional) | | mpm_surface | Hacer RENDERIZABLE una sim MPM — generar malla / superficie de las partículas de la sim construyendo un mpmsurface después de ellas. | input (+14 opcional) | | mpm_postfracture | Disparo de destrucción MPM de sim-Y-LUEGO-fractura — fracturar geometría de alta res impulsada por dónde la sim MPM realmente estiró y rompió, para que las grietas sigan la deformación real (a diferencia de pre-fracturar). | geo, particles (+11 opcional) | | mpm_deformpieces | Reorientar una sim MPM sobre piezas NOMBRADAS pre-fracturadas — impulsar trozos de render rígidos o de alta res mediante una sim MPM (más barata) para que la geometría final se deforme/mueva con la resolución sin simular la alta res directamente. | pieces, particles (+8 opcional) | | mpm_debrissource | Emitir escombros SECUNDARIOS desde una sim MPM — generar trozos/partículas extra donde el material se estira fuertemente, se mueve rápido o está cerca de la superficie (la pasada de metralla / rociado / chispas encima de una sim de destrucción o impacto). | input (+10 opcional) | | glue_constraint | Relación de restricción de pegamento KineFX (glueconrel) — nodo de datos de relación de restricción DOP que pega objetos vinculados hasta que un impulso superior a strength rompe el enlace, luego propaga la ruptura. | 10 opcional | | hard_constraint | Relación de restricción dura KineFX (hardconrel) — relación DOP rígida que fija objetos vinculados a una longitud de reposo, con motores angulares opcionales y rigidez del solucionador (CFM/ERP). | 14 opcional | | no_constraint | KineFX No Constraint Relationship (noconrel) — relación DOP que hace que los objetos vinculados sean afectores mutuos SIN ninguna fuerza de restricción (solo colisión / marcador de posición). | 7 opcionales | | bullet_soft_constraint | KineFX Bullet Soft Constraint Relationship (bulletsoftconrel) — relación Bullet elástica con rigidez/amortiguación lineal + angular opcional y plasticidad opcional (deformación permanente más allá de un umbral). | 18 opcionales | | cone_twist_constraint | KineFX Cone Twist Constraint Relationship (conetwistconrel) — articulación Bullet de cono-torsión que limita la rotación de torsión/salida/arriba dentro de un cono, con un límite suave y motor opcionales. | 20 opcionales | | constraint_relationship | KineFX Constraint Relationship (conrelationship) — el nodo de datos de relación genérico que define cómo se relacionan dos objetos vinculados (tipo + parámetros de ruptura de dos estados / resorte). | 10 opcionales | | apply_constraint | KineFX Constraint (constraint) — aplica una relación de restricción nombrada entre los objetos de simulación affected y affector (el nodo DOP que vincula una relación a los objetos). | 11 opcionales | | constraint_network_relationship | KineFX Constraint Network Relationship (constraintnetworkrelationship) — aplica una relación a una red de restricciones, opcionalmente haciendo coincidir objetos afectados/afectores mediante un atributo de punto. | 12 opcionales | | motion_data | KineFX Motion (motion) — el nodo de datos DOP Motion que lleva la posición / pivote / rotación de un objeto y la velocidad lineal + angular (el movimiento de estado inicial / objetivo para un objeto RBD o agente). | 11 opcionales | | softbody_constraint | KineFX SBD Constraint (sbdconstraint) — una restricción de dinámica de cuerpo blando que fija (type 0) o une con resortes (type 1) los puntos restringidos de un objeto a un objeto/puntos/ubicación objetivo, con límites opcionales de fuerza y longitud. | 19 opcionales | | cloth_stitch_constraint | KineFX Cloth Stitch Constraint (clothstitchconstraint) — cose los puntos restringidos de un objeto de tela a un objeto/puntos objetivo con una rigidez y amortiguación dadas (type 0/1). | 11 opcionales | | fem_attach_constraint | KineFX FEM Attach Constraint (femattachconstraint) — une puntos de un objeto FEM restringido a un objeto objetivo en un desplazamiento de reposo, con filtrado opcional por umbral de distancia. | 13 opcionales | | fem_fuse_constraint | KineFX FEM Fuse Constraint (femfuseconstraint) — fusiona puntos coincidentes de dos objetos FEM (coincidentes por grupo de puntos ordenado o por un atributo identificador) en un límite compartido. | 12 opcionales | | fem_region_constraint | KineFX FEM Region Constraint (femregionconstraint) — restringe regiones tetraédricas superpuestas de dos objetos FEM juntas, opcionalmente haciendo coincidir partes mediante un atributo identificador. | 10 opcionales | | fem_slide_constraint | KineFX FEM Slide Constraint (femslideconstraint) — restringe puntos de un objeto FEM para que se deslicen a lo largo de la superficie de un objeto objetivo (modelo de conexión atraer/repeler), con filtrado opcional por umbral de distancia. | 14 opcionales | | fem_target_constraint | KineFX FEM Target Constraint (femtargetconstraint) — tira suavemente de los puntos restringidos de un objeto FEM hacia sus posiciones objetivo animadas con una rigidez y amortiguación dadas (type 0/1). | 9 opcionales | | ragdoll_solver | SOLO CABLE: construir un solucionador de ragdoll KineFX (kinefx::ragdollsolver) en la geometría del personaje/esqueleto (entrada 0). | input (+16 opcionales) | | muscle_solver | SOLO CABLE: construir un solucionador de músculos (musclesolver) en la geometría del músculo (entrada 0). | input (+16 opcionales) | | muscle_solver_fem | SOLO CABLE: construir un solucionador de músculos FEM (musclesolverfem) en la geometría del músculo (entrada 0). | input (+16 opcionales) | | muscle_solver_vellum | SOLO CABLE: construir un solucionador de músculos Vellum (musclesolvervellum) en la geometría del músculo (entrada 0). | input (+16 opcionales) | | tissue_solver | SOLO CABLE: construir un solucionador de tejido (carne FEM) (tissuesolver) en la geometría de tejido/piel (entrada 0). | input (+12 opcionales) | | tissue_solver_vellum | SOLO CABLE: construir un solucionador de tejido Vellum (tissuesolvervellum) en la geometría del tejido (entrada 0). | input (+15 opcionales) | | skin_solver_vellum | SOLO CABLE: construir un solucionador de piel Vellum (skinsolvervellum) en la geometría de la piel (entrada 0). | input (+16 opcionales) | | armature_deform | SOLO CABLE: construir un solucionador de deformación de armadura (armaturedeform) en la geometría del personaje (entrada 0) — deformación cuasiestática de músculo/piel. | input (+13 opcionales) | | fem_solver | SOLO CABLE: construir un clúster de resolución de cuerpo blando FEM (femsolidobject -> femsolver) dentro de un dopnet nuevo. | name (+33 opcionales) | | solid_object_solver | SOLO CABLE: construir un clúster FEM de sólido/tela (solidobject -> femsolver) dentro de un dopnet nuevo. | name (+29 opcionales) | | filament_solver | SOLO CABLE: construir un clúster de dinámica de filamento/hebra (filamentobject -> filamentsolver) dentro de un dopnet nuevo. | name (+19 opcionales) | | crowd_solver | SOLO CABLE: construir un clúster de resolución de agentes de multitud/criatura (crowdobject -> crowdsolver::3.0) dentro de un dopnet nuevo, leyendo agentes de la fuente conectada (o una ruta SOP de geometría inicial). | name (+39 opcionales) |

KineFX

Herramienta	Qué hace	Parámetros clave
`character_skeleton`	KineFX Skeleton — el contenedor de creación de esqueletos (kinefx::skeleton).	`skeleton` (+4 opcionales)
`configure_joints`	KineFX Configure Joints — escribe atributos de configuración del solver en un esqueleto (entrada 0) para Full Body IK / Ragdoll / Rig Pose.	`skeleton` (+15 opcionales)
`configure_joint_limits`	KineFX Configure Joint Limits — establece límites de articulación de rotación/traslación + visualización de guía de límites en un esqueleto (entrada 0).	`skeleton` (+14 opcionales)
`orient_joints`	KineFX Orient Joints — recalcula las orientaciones de las articulaciones (el atributo de punto `transform`) para un esqueleto (entrada 0), apuntando cada articulación hacia su hijo con un vector de referencia/up.	`skeleton` (+10 opcionales)
`parent_joints`	KineFX Parent Joints — reparenta articulaciones en una jerarquía de esqueleto (entrada 0).	`skeleton` (+2 opcionales)
`delete_joints`	KineFX Delete Joints — elimina (o conserva solo) las articulaciones nombradas por `group` de un esqueleto (entrada 0), opcionalmente en cascada a los hijos.	`skeleton` (+5 opcionales)
`group_joints`	KineFX Group Joints — crea/actualiza un grupo de puntos nombrado de articulaciones en un esqueleto (entrada 0) a partir de una expresión de selección, con una fusión booleana contra cualquier grupo existente.	`skeleton` (+7 opcionales)
`skeleton_blend`	KineFX Skeleton Blend — combina la pose de uno o más esqueletos en un esqueleto base.	`skeleton` (+14 opcionales)
`skeleton_mirror`	KineFX Skeleton Mirror — refleja las articulaciones de un esqueleto (entrada 0) a través de un plano o punto, renombrando las articulaciones reflejadas mediante tokens de buscar/reemplazar (p. ej. `_l` -> `_r`).	`skeleton` (+13 opcionales)
`rig_doctor`	KineFX Rig Doctor — valida y repara un esqueleto: inicializa nombres de articulaciones / transformaciones faltantes, sanea nombres y genera atributos de jerarquía (índice de padre, índices de hijos, orden de evaluación) a partir de un rig en la entrada 0.	`skeleton` (+16 opcionales)
`visualize_rig`	KineFX Visualize Rig — genera geometría de visualización del rig (gnomons de articulaciones / enlaces de huesos, estilizados por color/escala) a partir de un esqueleto en la entrada 0.	`skeleton` (+11 opcionales)
`rig_pose`	KineFX Rig Pose — el SOP interactivo de FK/IK para posar un esqueleto (entrada 0).	`skeleton` (+16 opcionales)
`compute_rig_pose`	KineFX Compute Rig Pose — evalúa una pose de rig a partir de un esqueleto (entrada 0) y hornea las transformaciones / atributos de parámetros resultantes en la geometría (el gemelo sin cabeza de rig_pose).	`skeleton` (+15 opcionales)
`rig_match_pose`	KineFX Rig Match Pose — posa `skeleton` (entrada 0, el rig objetivo) para que coincida con la pose de `source` (entrada 1, el rig fuente), alineando opcionalmente por caja delimitadora y un fotograma de referencia.	`skeleton`, `source` (+18 opcionales)
`rig_mirror_pose`	KineFX Rig Mirror Pose — refleja la POSE animada de un esqueleto (entrada 0) a través de un eje/plano de simetría, emparejando articulaciones izquierda/derecha mediante tokens de nombre (p. ej. `_l`<->`_r`) o distancia de edición.	`skeleton` (+21 opcionales)
`rig_stash_pose`	KineFX Rig Stash Pose — almacena la pose actual de un esqueleto (entrada 0) en un atributo de punto (`mode`=store) o restaura una pose previamente almacenada (`mode`=restore).	`skeleton` (+12 opcionales)
`rig_copy_transforms`	KineFX Rig Copy Transforms — copia las transformaciones de articulaciones desde `source` (entrada 1) hacia `skeleton` (entrada 0, el rig de destino), emparejando articulaciones mediante un atributo de mapeo o un atributo de coincidencia.	`skeleton`, `source` (+6 opcionales)
`ik_chains`	KineFX IK Chains — resuelve cadenas IK de dos huesos en un esqueleto (entrada 0) hacia posiciones objetivo proporcionadas como `targets` (entrada 1).	`skeleton`, `targets` (+2 opcionales)
`full_body_ik`	KineFX Full Body IK — resuelve una pose IK de todo el esqueleto en `skeleton` (entrada 0) para que las articulaciones efectoras configuradas alcancen sus objetivos; opcionalmente `targets` (entrada 1) suministra la geometría objetivo.	`skeleton` (+25 opcionales)
`fbik_configure_targets`	KineFX Full Body IK Configure Targets — escribe la configuración de objetivos FBIK (desplazamientos por articulación, referencia de pose de reposo, objetivo de centro de masa) en un esqueleto (entrada 0); la entrada opcional 1 suministra geometría objetivo.	`skeleton` (+13 opcionales)
`spline_ik`	KineFX Spline IK — impulsa una cadena de articulaciones de un esqueleto (entrada 0) a lo largo de una spline ajustada a través de las articulaciones, brindando control suave basado en curvas (espinas, colas, tentáculos).	`skeleton` (+17 opcionales)
`reverse_foot`	KineFX Reverse Foot — construye un sistema de roll de pie inverso en un esqueleto (entrada 0), agregando marcadores de pivote de talón/emblema/dedo para que un pie pueda rodar y pivotar.	`skeleton` (+8 opcionales)
`stabilize_joint`	KineFX Stabilize Joint — elimina el jitter / bloquea una articulación de un esqueleto animado (entrada 0) en su lugar durante un rango de fotogramas, con límites de cambio de posición/ángulo y desvanecimiento de entrada/salida.	`skeleton` (+21 opcionales)
`pose_difference`	KineFX Pose Difference — calcula la diferencia por articulación entre la pose en `skeleton` (entrada 0) y la pose `reference` (entrada 1), almacenándola en un atributo de salida (opcionalmente solo posición/rotación/escala, invertida, o aplicada como desplazamiento).	`skeleton`, `reference` (+12 opcionales)
`joint_capture_biharmonic`	KineFX Joint Capture Biharmonic (kinefx::jointcapturebiharmonic) — calcula pesos de skinning boneCapture suaves resolviendo funciones biharmónicas sobre un `geometry` tetraedralizado internamente (entrada 0) usando el `skeleton` (entrada 1) como rig de influencia.	`geometry`, `skeleton` (+22 opcionales)
`joint_capture_proximity`	KineFX Joint Capture Proximity (kinefx::jointcaptureproximity) — asigna pesos de skinning boneCapture a `geometry` (entrada 0) por proximidad a los huesos `skeleton` (entrada 1).	`geometry`, `skeleton` (+11 opcionales)
`point_capture_biharmonic`	KineFX Point Capture Biharmonic (kinefx::pointcapturebiharmonic) — captura biharmónica de nube de puntos de `geometry` (entrada 0) hacia `skeleton` (entrada 1).	`geometry`, `skeleton` (+3 opcionales)
`joint_capture_paint`	KineFX Joint Capture Paint (kinefx::jointcapturepaint) — inicializa / normaliza los pesos boneCapture en `geometry` (entrada 0) contra `skeleton` (entrada 1).	`geometry`, `skeleton` (+5 opcionales)
`capture_packed_geo`	KineFX Capture Packed Geo (kinefx::capturepackedgeo) — transfiere/empaqueta la captura en `geometry` (entrada 0) contra `skeleton` (entrada 1), empaquetando opcionalmente la entrada, emparejando por nombre y desempaquetando el resultado.	`geometry`, `skeleton` (+13 opcionales)
`capture_proximity`	Classic Capture Proximity (captureproximity) — captura por proximidad de `geometry` (entrada 0) a las regiones de captura en `skeleton` (entrada 1; un esqueleto KineFX cuya transformación por punto suministra las regiones).	`geometry`, `skeleton` (+18 opcionales)
`bone_capture`	Classic Capture (capture) — asigna pesos de captura a `geometry` (entrada 0) a partir de las regiones de captura en `skeleton` (entrada 1).	`geometry`, `skeleton` (+13 opcionales)
`bone_capture_lines`	Classic Bone Capture Lines (bonecapturelines) — genera geometría de líneas de región de captura clásica (que lleva boneCapture) a partir de `skeleton` (entrada 0), para alimentar solvers de captura clásica.	`skeleton` (+17 opcionales)
`capture_region`	Classic Capture Region (cregion) — una FUENTE de 0 entradas que emite una primitiva de región de captura (un tubo con una transformación) dentro de una geo /obj nueva.	`name` (+7 opcionales)
`capture_mirror`	Classic Capture Mirror (capturemirror) — refleja los pesos de captura en `geometry` ya capturado (entrada 0) a través de un plano, renombrando las regiones reflejadas mediante tokens de buscar/reemplazar.	`geometry` (+10 opcionales)
`capture_correct`	Classic Capture Correct (capturecorrect) — limpia los pesos de captura en `geometry` ya capturado (entrada 0): actualiza/elimina regiones obsoletas, recorta pesos negativos/positivos, limita influencias por punto y renormaliza.	`geometry` (+14 opcionales)
`capture_override`	Classic Capture Override (captureoverride) — sobreescribe los pesos de captura en `geometry` ya capturado (entrada 0) para los `cregions` nombrados, aplicando una operación a un peso establecido.	`geometry` (+8 opcionales)
`name_from_capture_weight`	Labs Name From Capture Weight (labs::name_from_capture_weight::1.0) — escribe un atributo de punto `name` en `geometry` ya capturado (entrada 0) a partir de la región de captura dominante de cada punto (su peso boneCapture más alto).	`geometry` (+3 opcionales)
`skinning_converter`	Labs Skinning Converter (labs::skinning_converter::3.0) — convierte un `geometry` de animación por vértices / deformable (entrada 0, dependiente del tiempo) en un esqueleto + pesos de skinning boneCapture (una resolución de la familia DemBones sobre frame_start..frame_end).	`geometry` (+18 opcionales)
`dembones_skinning_converter`	KineFX DemBones Skinning Converter (kinefx::dembones_skinningconverter) — SOLO CABLEADO: construye + conecta + configura el solve externo de DemBones que convierte una malla deformable almacenada en Alembic en un esqueleto + pesos de skinning, pero NUNCA lo ejecuta (espejo de maps_baker — un solve externo/pesado es disparado por el humano).	`geometry` (+17 opcionales)
`joint_deform`	KineFX Joint Deform (kinefx::jointdeform) — deforma la piel capturada mediante transformaciones de articulaciones.	`skin`, `rest_skeleton`, `deform_skeleton` (+8 opcionales)
`bone_deform`	KineFX Bone Deform (bonedeform) — deforma geometría ponderada por captura utilizando atributos de captura de hueso/articulación.	`skin` (+12 opcionales)
`deform_skeleton_skin`	KineFX Deform Skeleton/Skin (kinefx::deformskelskin) — posa un esqueleto (entrada 0) y deforma la piel vinculada (entrada opcional 1) juntos, luego emite el rig/piel transformados.	`skeleton` (+12 opcionales)
`pose_space_deform_combine`	KineFX Pose-Space Deform Combine (posespacedeformcombine) — fusiona múltiples salidas de Pose-Space Deform (entrada 0..N) en un único resultado correctivo.	`geometry` (+3 opcionales)
`pose_space_edit_configure`	KineFX Pose-Space Edit Configure (posespaceeditconfigure) — establece cómo calcula Pose-Space Edit las diferencias de forma (pre/post-deformación, orientación) en la geometría (entrada 0), opcionalmente re-deformando con captura de hueso.	`geometry` (+7 opcionales)
`character_blend_shapes_add`	KineFX Character Blend Shapes Add (kinefx::characterblendshapesadd) — empaqueta un nuevo objetivo de blend-shape (o intermedio) (entrada 1) sobre una malla base (entrada 0).	`base` (+10 opcionales)
`character_blend_shapes_core`	KineFX Character Blend Shapes Core (kinefx::characterblendshapescore) — el evaluador de mezcla ponderada de bajo nivel: entrada 0 = malla base, entrada 1 = objetivos de blendshape empaquetados + pesos.	`base`, `blend_targets` (+6 opcionales)
`character_blend_shapes_extract`	KineFX Character Blend Shapes Extract (kinefx::characterblendshapesextract) — extrae una única malla objetivo de blend-shape (o intermedia) nombrada de una entrada de blendshape empaquetada (entrada 0).	`blendshape_geo` (+5 opcionales)
`character_blend_shape_channels`	KineFX Character Blend Shape Channels (kinefx::characterblendshapechannels) — define/actualiza la tabla de canales de blend-shape (pesos) para una malla (entrada 0), opcionalmente sembrada desde una segunda entrada.	`mesh` (+3 opcionales)
`character_blend_shapes`	KineFX Character Blend Shapes (kinefx::characterblendshapes) — el nodo de blendshape todo-en-uno: entrada 0 = malla base, entrada 1 = mallas de blend-shape, entrada 2 = definiciones de canales; aplica las mezclas ponderadas.	`mesh`, `blend_shapes`, `channels` (+4 opcionales)
`blend_shapes`	Classic Blend Shapes (SOP blendshapes::2.0) — morph ponderado de una malla base (entrada 0) hacia una o más formas objetivo (entrada 1..N).	`base` (+14 opcionales)
`secondary_motion`	KineFX Secondary Motion (kinefx::secondarymotion) — añade solapamiento/vibración/seguimiento con resorte a un esqueleto animado (entrada 0).	`skeleton` (+21 opcionales)
`dynamic_warp`	KineFX Dynamic Warp (kinefx::dynamicwarp) — deforma temporalmente una animación de origen (entrada 1) para alinearla con una animación de referencia (entrada 0) mediante dynamic time warping sobre atributos emparejados.	`reference_motion`, `source_motion` (+12 opcionales)
`skeleton_deform`	KineFX/Classic Deform (SOP `deform`) — deforma geometría con pesos de captura (entrada 0) mediante un esqueleto referenciado a través de `skel_root_path` (una referencia de nodo en escena).	`skin` (+15 opcionales)
`motion_clip`	KineFX MotionClip — EMPAQUETA un esqueleto animado (entrada 0) muestreado a lo largo de un rango de fotogramas en un motionclip empaquetado de un solo fotograma (primitivas de canal).	`skeleton` (+17 opcionales)
`motion_clip_create`	KineFX MotionClip Create — crea un motionclip desde un SOP en vivo (modo single/fetchsop + source_sop), una biblioteca de clips o un clip .bgeo/FBX importado.	18 opcionales
`motion_clip_compute_create`	KineFX Compute MotionClip Create — empaqueta el esqueleto animado en `source_sop` (una ruta de nodo de Houdini) a lo largo de un rango de fotogramas en un motionclip mediante el motor de cómputo (0 entradas de geometría).	`parent` (+5 opcionales)
`motion_clip_compute_retime`	KineFX Compute MotionClip Retime — remuestrea temporalmente un motionclip (entrada 0) mediante el motor de cómputo: desplazamiento / tiempo absoluto / fotograma / velocidad, con recorte opcional y remuestreo de rango de salida/tasa de muestreo.	`motionclip` (+22 opcionales)
`motion_clip_retime`	KineFX MotionClip Retime — remuestrea temporalmente un motionclip (entrada 0): desplazamiento / tiempo absoluto / fotograma / velocidad, con recorte opcional, anulaciones por fotograma de tiempo/fotograma/velocidad, y remuestreo de rango de salida/tasa de muestreo.	`motionclip` (+27 opcionales)
`motion_clip_velocity`	KineFX MotionClip Compute Velocity — calcula velocidades por articulación en un motionclip (entrada 0); `rest_frame` opcional (entrada 1) proporciona la pose de reposo.	`motionclip` (+13 opcionales)
`motion_clip_cycle`	KineFX MotionClip Cycle — repite un motionclip (entrada 0) antes/después de sí mismo para construir un bucle, con continuidad de locomoción (desplazamiento/velocidad/espejo) y fusión de poses en la costura.	`motionclip` (+18 opcionales)
`motion_clip_evaluate`	KineFX MotionClip Evaluate — muestrea un motionclip (entrada 0) en un fotograma para devolverlo a una pose de esqueleto en vivo (fotograma actual o uno personalizado), con salida COM opcional y comportamiento final.	`motionclip` (+14 opcionales)
`motion_clip_extract`	KineFX MotionClip Extract — extrae poses de un motionclip (entrada 0) como esqueletos por fotograma o estelas de movimiento a lo largo de un rango de fotogramas.	`motionclip` (+16 opcionales)
`motion_clip_key_poses`	KineFX MotionClip Extract Key Poses — reduce un motionclip (entrada 0) a sus poses clave (por porcentaje o cantidad), ya sea extrayéndolas o etiquetándolas.	`motionclip` (+17 opcionales)
`motion_clip_locomotion`	KineFX MotionClip Extract Locomotion — separa la locomoción de la raíz de un motionclip (entrada 0) de su movimiento en el lugar (fuente de cómputo/primitiva/articulación), extrayendo opcionalmente la trayectoria del suelo o aplanando el clip en su lugar.	`motionclip` (+15 opcionales)
`motion_clip_merge`	KineFX MotionClip Merge — fusiona dos motionclips (entrada 0 + `merge_clip` opcional en la entrada 1) en una única secuencia de clip.	`input` (+5 opcionales)
`motion_clip_pose_delete`	KineFX MotionClip Pose Delete — elimina poses (y/o articulaciones) de un motionclip (entrada 0) por rango de fotogramas, patrón de fotogramas, rango de poses o grupo de poses.	`motionclip` (+13 opcionales)
`motion_clip_pose_insert`	KineFX MotionClip Pose Insert — inserta una pose de esqueleto única (`pose`, entrada 1) en un motionclip (entrada 0) en un fotograma.	`motionclip`, `pose` (+3 opcionales)
`motion_clip_sequence`	KineFX MotionClip Sequence — concatena dos motionclips de extremo a extremo: `first` (entrada 0) seguido de `second` (entrada 1), con continuidad de locomoción y una costura fusionada.	`first`, `second` (+18 opcionales)
`motion_clip_blend`	KineFX MotionClip Blend — superpone un motionclip `layer` (entrada 1) sobre un motionclip `base` (entrada 0) con envolventes de fundido de entrada/salida y un efecto de fusión por articulación.	`base`, `layer` (+19 opcionales)
`motion_clip_unpack`	KineFX MotionClip Unpack — desempaqueta un motionclip (entrada 0) de vuelta a un esqueleto animado en vivo (fotograma único / rango / fotograma actual) o estelas de movimiento, llevando un atributo de punto `time`.	`motionclip` (+20 opcionales)
`motion_clip_update`	KineFX MotionClip Update — actualiza un motionclip (entrada 0) con nuevas poses desde `poses` (entrada 1) — un STREAM de esqueleto desempaquetado que DEBE llevar un atributo de punto `time` (p. ej., una salida de motion_clip_unpack).	`motionclip`, `poses` (+9 opcionales)
`motion_clip_info`	KineFX MotionClip Create Clip Info — garantiza que un motionclip (entrada 0 opcional) lleve un atributo de detalle `clipinfo`, derivándolo del atributo de primitiva `time` del clip cuando falte.	3 opcionales
`motion_mixer_retime`	KineFX Motion Mixer Retime — remuestrea temporalmente una escena de motion-mixer / motionclip (entrada 0) por fotograma absoluto, tiempo, velocidad de reproducción o retención.	`input` (+9 opcionales)
`motion_mixer_smooth`	KineFX Motion Mixer Smooth — aplica un filtro Butterworth a los canales de una escena de motion-mixer / motionclip (entrada 0) seleccionados por `pattern`, sobre los componentes t/r/s.	`input` (+9 opcionales)
`motion_mixer_transform`	KineFX Motion Mixer Transform — aplica una transformación TRS (+cizallamiento/pivote) a los canales de una escena de motion-mixer / motionclip (entrada 0) seleccionados por `group`.	`input` (+10 opcionales)
`fbx_character_import`	KineFX FBX Character Import — importa un personaje FBX completo (esqueleto en la salida 0, piel en la salida 1, blendshapes en la salida 2), fusionando opcionalmente animación desde un segundo FBX, en un /obj geo nuevo.	`name`, `fbx_file` (+15 opcionales)
`fbx_anim_import`	KineFX FBX Animation Import — importa un esqueleto animado (un motion clip) desde un archivo FBX a un /obj geo nuevo.	`name`, `fbx_file` (+14 opcionales)
`fbx_skin_import`	KineFX FBX Skin Import — importa la malla con piel (que lleva pesos `boneCapture`) desde un personaje FBX a un /obj geo nuevo.	`name`, `fbx_file` (+8 opcionales)
`gltf_character_import`	KineFX glTF Character Import — importa un personaje glTF/glb completo (esqueleto en la salida 0, piel en la salida 1, blendshapes en la salida 2) a un /obj geo nuevo.	`name`, `gltf_file` (+7 opcionales)
`gltf_anim_import`	KineFX glTF Animation Import — importa un esqueleto animado (motion clip) desde un archivo glTF/glb a un /obj geo nuevo.	`name`, `gltf_file` (+5 opcionales)
`gltf_skin_import`	KineFX glTF Skin Import — importa la malla con piel (que lleva pesos `boneCapture`) desde un personaje glTF/glb a un /obj geo nuevo.	`name`, `gltf_file` (+2 opcionales)
`usd_character_import`	KineFX USD Character Import — importa un personaje USDSkel (esqueleto en la salida 0, piel en la salida 1, blendshapes en la salida 2) desde un archivo USD a un /obj geo nuevo (fuerza la fuente de archivo, no un LOP de /stage).	`name`, `usd_file` (+7 opcionales)
`usd_anim_import`	KineFX USD Animation Import — importa un esqueleto animado (motion clip) desde un archivo USDSkel a un /obj geo nuevo (fuerza la fuente de archivo).	`name`, `usd_file` (+7 opcionales)
`usd_skin_import`	KineFX USD Skin Import — importa la malla con piel (que lleva pesos `boneCapture`) desde un personaje USDSkel a un /obj geo nuevo (fuerza la fuente de archivo).	`name`, `usd_file` (+3 opcionales)
`mocap_import`	KineFX Mocap Import — importa datos brutos de captura de movimiento (Biovision BVH, Acclaim ASF+AMC o Motion-Analysis TRC) como un esqueleto animado a un /obj geo nuevo.	`name` (+20 opcionales)
`clip_import`	KineFX Clip Import — lee un motion clip CHOP .bclip/.clip desde el disco y (opcionalmente, cuando se proporciona una entrada 0 `skeleton`) lo aplica a ese esqueleto; de lo contrario, emite el clip a un /obj geo nuevo.	`name`, `file` (+5 opcionales)
`retarget_biped_fbx`	KineFX Retarget Biped FBX — importa un FBX bípedo y reorienta su animación sobre la plantilla bípeda de KineFX (esqueleto en la salida 0, animación en la salida 1, piel en la salida 2) en un /obj geo nuevo.	`name`, `fbx_file` (+9 opcionales)
`character_io`	KineFX Character IO — ensambla un personaje KineFX a partir de sus partes: entrada0 = `geometry` de reposo, entrada1 = esqueleto `capture_pose` (opcional), entrada2 = esqueleto/motionclip `animated_pose` (opcional).	`geometry` (+13 opcionales)
`fbx_anim_export`	KineFX FBX Animation Output — SOLO CABLE.	`geometry` (+17 opcionales)
`fbx_character_export`	KineFX FBX Character Output — SOLO CABLE.	`skin_geo`, `capture_pose` (+20 opcionales)
`gltf_character_export`	KineFX glTF Character Output — SOLO CABLE.	`skin_geo`, `capture_pose` (+13 opcionales)
`clip_export`	KineFX Clip Export — SOLO CABLE.	`geometry` (+8 opcionales)
`scene_character_export`	KineFX Scene Character Export — SOLO CABLE.	`geometry`, `skeleton` (+7 opcionales)
`retarget_fbx_export`	KineFX Retarget FBX Export — SOLO CABLE.	`geometry` (+18 opcionales)
`classic_bone`	KineFX/Classic Bone (OBJ `bone`) — crea un objeto Bone clásico: un hueso parametrizado por longitud con visualización de bonelink y cilindros ajustables de región de captura / captura-deformación (la primitiva de skinning anterior a KineFX).	14 opcionales
`dembones_skinning_export`	KineFX/Classic DemBones Skinning Converter ROP (/out `dembones_skinningconverter`) — SOLO CABLE: construye y configura la resolución externa DemBones que convierte un caché Alembic animado (+ FBX de pose de reposo opcional) en un FBX con esqueleto + pesos de piel, pero NUNCA lo ejecuta (refleja maps_baker — la resolución externa pesada la dispara el humano).	19 opcionales
`deform_bone_rig_biped_arm`	KineFX/Classic Deform Bone Rig — Biped Arm (OBJ `deform_bone_rig_biped_arm`) — instancia un rig clásico de deformación de huesos listo para usar para el brazo de un bípedo (huesos de clavícula/brazo superior/antebrazo/muñeca con regiones de captura).	9 opcionales
`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 clásico de deformación de huesos listo para usar para una mano de 4 dedos y 2 segmentos.	9 opcionales
`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 clásico de deformación de huesos listo para usar para una mano de 4 dedos y 3 segmentos.	9 opcionales
`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 clásico de deformación de huesos listo para usar para una mano completa de 5 dedos y 3 segmentos.	9 opcionales
`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 clásico de deformación de huesos listo para usar para la cabeza + cadena del cuello de un bípedo.	9 opcionales
`deform_bone_rig_biped_leg`	KineFX/Classic Deform Bone Rig — Biped Leg (OBJ `deform_bone_rig_biped_leg`) — rig clásico de deformación de huesos listo para usar para la pierna de un bípedo (huesos de muslo/espinilla/pie con regiones de captura).	9 opcionales
`deform_bone_rig_biped_spine_3pc`	KineFX/Classic Deform Bone Rig — Biped Spine, 3 Pieces (OBJ `deform_bone_rig_biped_spine_3pc`) — rig clásico de deformación de huesos de 3 segmentos listo para usar para la columna de un bípedo.	9 opcionales
`deform_bone_rig_biped_spine_5pc`	KineFX/Classic Deform Bone Rig — Columna bípeda, 5 piezas (OBJ `deform_bone_rig_biped_spine_5pc`) — rig de deformación de huesos clásico prefabricado de 5 segmentos para una columna bípeda.	9 opcionales
`deform_bone_rig_quadruped_back_leg`	KineFX/Classic Deform Bone Rig — Pata trasera de cuadrúpedo (OBJ `deform_bone_rig_quadruped_back_leg`) — rig de deformación de huesos clásico prefabricado para una pata trasera de cuadrúpedo.	9 opcionales
`deform_bone_rig_quadruped_front_leg`	KineFX/Classic Deform Bone Rig — Pata delantera de cuadrúpedo (OBJ `deform_bone_rig_quadruped_front_leg`) — rig de deformación de huesos clásico prefabricado para una pata delantera de cuadrúpedo.	9 opcionales
`deform_bone_rig_quadruped_head_and_neck`	KineFX/Classic Deform Bone Rig — Cabeza y cuello de cuadrúpedo (OBJ `deform_bone_rig_quadruped_head_and_neck`) — rig de deformación de huesos clásico prefabricado para una cadena de cabeza + cuello de cuadrúpedo.	9 opcionales
`deform_bone_rig_quadruped_ik_spine`	KineFX/Classic Deform Bone Rig — Columna IK de cuadrúpedo (OBJ `deform_bone_rig_quadruped_ik_spine`) — rig de deformación de huesos clásico prefabricado para una cadena de columna IK de cuadrúpedo.	9 opcionales
`deform_bone_rig_quadruped_tail`	KineFX Deform Bone Rig Cola de cuadrúpedo — un HDA de rig de deformación de huesos /obj para una cadena de cola de cuadrúpedo (A_source: 0 entradas, genera un rig de guía/gancho predeterminado).	11 opcionales
`deform_bone_rig_quadruped_toes_4f`	KineFX Deform Bone Rig Dedos de cuadrúpedo (4 dedos) — un HDA de rig de deformación de huesos /obj para una pata de cuadrúpedo de 4 dedos (A_source: 0 entradas).	11 opcionales
`deform_bone_rig_quadruped_toes_5f`	KineFX Deform Bone Rig Dedos de cuadrúpedo (5 dedos) — un HDA de rig de deformación de huesos /obj para una pata de cuadrúpedo de 5 dedos (A_source: 0 entradas).	11 opcionales
`deform_rig_biped_arm`	KineFX Deform Rig Brazo bípedo — un HDA de rig de deformación muscular /obj para un brazo bípedo (A_source: 0 entradas, genera un rig de músculo/guía predeterminado).	14 opcionales
`deform_rig_biped_hand_4f_2s`	KineFX Deform Rig Mano bípeda (4 dedos, 2 segmentos) — un HDA de rig de deformación muscular /obj para una mano bípeda (A_source: 0 entradas).	14 opcionales
`deform_rig_biped_hand_4f_3s`	KineFX Deform Rig Mano bípeda (4 dedos, 3 segmentos) — un HDA de rig de deformación muscular /obj para una mano bípeda (A_source: 0 entradas).	14 opcionales
`deform_rig_biped_hand_5f_3s`	KineFX Deform Rig Mano bípeda (5 dedos, 3 segmentos) — un HDA de rig de deformación muscular /obj para una mano bípeda (A_source: 0 entradas).	14 opcionales
`deform_rig_biped_head_and_neck`	KineFX Deform Rig Cabeza y cuello bípedos — un HDA de rig de deformación muscular /obj para cabeza+cuello bípedos (A_source: 0 entradas).	21 opcionales
`deform_rig_biped_leg`	KineFX Deform Rig Pierna bípeda — un HDA de rig de deformación muscular /obj para una pierna bípeda (A_source: 0 entradas).	14 opcionales
`deform_rig_biped_spine_3pc`	KineFX Deform Rig Columna bípeda (3 piezas) — un HDA de rig de deformación muscular /obj para una columna bípeda de 3 piezas (A_source: 0 entradas).	14 opcionales
`deform_rig_biped_spine_5pc`	KineFX Deform Rig Columna bípeda (5 piezas) — un HDA de rig de deformación muscular /obj para una columna bípeda de 5 piezas (A_source: 0 entradas).	14 opcionales
`deform_rig_quadruped_back_leg`	KineFX Deform Rig Pata trasera de cuadrúpedo — un HDA de rig de deformación muscular /obj para una pata trasera de cuadrúpedo (A_source: 0 entradas).	14 opcionales
`deform_rig_quadruped_front_leg`	KineFX Deform Rig Pata delantera de cuadrúpedo — un HDA de rig de deformación muscular /obj para una pata delantera de cuadrúpedo (A_source: 0 entradas).	14 opcionales
`deform_rig_quadruped_head_and_neck`	KineFX Deform Rig Cabeza y cuello de cuadrúpedo — un HDA de rig de deformación muscular /obj para cabeza+cuello de cuadrúpedo (A_source: 0 entradas).	21 opcionales
`deform_rig_quadruped_ik_spine`	KineFX Deform Rig Columna IK de cuadrúpedo — un HDA de rig de deformación muscular /obj para una columna IK de cuadrúpedo (A_source: 0 entradas).	14 opcionales
`deform_rig_quadruped_tail`	KineFX Deform Rig Cola de cuadrúpedo — un HDA de rig de deformación muscular /obj para una cola de cuadrúpedo (A_source: 0 entradas).	14 opcionales
`deform_rig_quadruped_toes_4f`	KineFX Deform Rig Dedos de cuadrúpedo (4 dedos) — un HDA de rig de deformación muscular /obj para una pata de cuadrúpedo de 4 dedos (A_source: 0 entradas).	14 opcionales
`deform_rig_quadruped_toes_5f`	KineFX Deform Rig Dedos de cuadrúpedo (5 dedos) — un HDA de rig de deformación muscular /obj para una pata de cuadrúpedo de 5 dedos (A_source: 0 entradas).	14 opcionales
`toon_character_deform_rig`	KineFX Toon Character Deform Rig (toon_character_deform_rig) — un PRESET OBJ de 0 entradas que instancia el personaje toon completo prefabricado heredado: un rig de huesos por partes del cuerpo (columna / brazos / piernas / cabeza+cuello / manos) que impulsa un sub-objeto capturado `skin`.	5 opcionales
`bone_link`	KineFX Bone Link (bonelink) — una FUENTE de 0 entradas que emite la geometría clásica de enlace de hueso (la forma de enlace cónica dibujada entre los extremos de un hueso, con visualizaciones opcionales de hueso empaquetado / aleta / proxy / captura) dentro de una geo /obj nueva.	13 opcionales
`bone_solidify`	KineFX Bone Solidify (bonesolidify) — tetraedraliza una piel de entrada `mesh` (entrada 0) en una malla tet sólida vinculada al rig, para deformación de hueso estilo FEM / cuerpo blando.	`mesh` (+19 opcionales)
`capture_attribute_unpack`	KineFX Capture Attribute Unpack (captureattribunpack) — expande un atributo de captura empaquetado (predeterminado `boneCapture`) en `geometry` (entrada 0) en atributos de componente separados `_index` + `_data` para que los pesos brutos puedan editarse con herramientas de atributos genéricas.	`geometry` (+8 opcionales)
`capture_attribute_pack`	KineFX Capture Attribute Pack (captureattribpack) — colapsa los atributos de componente de captura separados `_index` + `_data` en `geometry` (entrada 0) de nuevo en un único atributo de captura empaquetado (predeterminado `boneCapture`).	`geometry` (+8 opcionales)
`capture_layer_paint`	KineFX Capture Layer Paint (capturelayerpaint::2.0) — edita/normaliza los pesos de captura clásicos en `geometry` (entrada 0) para las regiones de captura activas; el pincel es una herramienta de viewport, por lo que este endpoint solo de datos expone únicamente los controles de selección de región / normalización / tipo de captura y pasa el rig re-normalizado.	`geometry` (+11 opcionales)
`post_anim_deform`	Labs Post Animation Deform (labs::post_anim_deform) — aplica el delta de deformación entre una malla en reposo (entrada 1) y su versión deformada (entrada 2) sobre una malla `deforming` coincidente (entrada 0), transfiriendo opcionalmente un atributo de orientación/transformación.	`deforming`, `rest`, `deformed` (+6 opcionales)
`neuron_mocap`	Labs Neuron Mocap (labs::neuron_mocap) — una FUENTE de 0 entradas (geo /obj nueva) que configura una transmisión de mocap en vivo Perception Neuron (nombre de personaje / IP / puerto / formato de datos / índice de actor) y emite el esqueleto recibido.	`name` (+5 opcionales)
`rokoko_mocap`	Labs Rokoko Mocap (labs::rokoko_mocap) — una FUENTE de 0 entradas (geo /obj nueva) que configura una transmisión de mocap en vivo Rokoko Smartsuit (IP / puerto / actor / nombre de traje) y un archivo de grabación opcional, y emite el esqueleto recibido.	`name` (+6 opcionales)
`dembones_skinning_external`	Labs DemBones Skinning Converter (labs::dembones_skinningconverter) — SOLO CABLEADO.	`geometry` (+20 opcionales)
`dembones_skinning_bake`	DemBones Skinning Converter, escritor SOP nativo (dembones_skinningconverter::1.0) — SOLO CABLEADO.	`geometry` (+21 opcionales)
`skin_properties`	KineFX Skin Properties (skinproperties) — crea atributos de propiedades SOLVER de músculo/piel por punto en la piel de entrada (entrada 0): rigidez de superficie y sólida / amortiguación / rigidez de flexión / densidad de masa / tasa de deslizamiento, opcionalmente enmascarados y combinados, con un material `preset`.	`geometry` (+15 opcionales)
`skin_solidify`	KineFX Skin Solidify (skinsolidify::2.0) — construye una capa tet SÓLIDA alrededor de una superficie de piel de entrada (entrada 0) para simulación de piel estilo FEM / tela: `skin_thickness` + `num_layers` establecen la profundidad de la capa, las palancas de tamaño de elemento (`min_size`/`max_size`/`rel_density`/`gradation`) impulsan la densidad tet, y una relajación de suavizado (`iterations`/`step_size`) limpia los pesos interiores.	`geometry` (+15 opcionales)
`skin_deform`	KineFX Skin Deform (skindeform) — acabado de piel consciente de músculos sobre una piel de entrada (entrada 0): un paso de desenfoque muscular que suaviza los pesos de la piel hacia el movimiento muscular subyacente, más una relajación opcional de deslizamiento de piel que permite que la piel se deslice sobre los músculos, resuelta contra un marco de referencia.	`geometry` (+12 opcionales)
`animation_rig_biped_arm`	KineFX Animation Rig Brazo bípedo — un HDA de rig de animación (control) /obj para un brazo bípedo (A_source: 0 entradas, genera un rig de control FK/IK predeterminado). control_scale/control_lod/control_color dimensionan y estilizan los controles; hook_object referencia un objeto padre en escena.	`name` (+14 opcionales)
`animation_rig_biped_hand_4f_2s`	KineFX Animation Rig Mano bípeda (4 dedos, 2 segmentos) — un HDA de rig de animación /obj para una mano bípeda (A_source: 0 entradas). control_scale/control_lod/control_color dimensionan y estilizan los controles; hook_object referencia un objeto padre en escena.	`name` (+14 opcionales)
`animation_rig_biped_hand_4f_3s`	KineFX Animation Rig Mano bípeda (4 dedos, 3 segmentos) — un HDA de rig de animación /obj para una mano bípeda (A_source: 0 entradas). control_scale/control_lod/control_color dimensionan y estilizan los controles; hook_object referencia un objeto padre en escena.	`name` (+14 opcionales)
`animation_rig_biped_hand_5f_3s`	KineFX Animation Rig Mano bípeda (5 dedos, 3 segmentos) — un HDA de rig de animación /obj para una mano bípeda (A_source: 0 entradas). control_scale/control_lod/control_color dimensionan y estilizan los controles; hook_object referencia un objeto padre en escena.	`name` (+14 opcionales)
`animation_rig_biped_head_and_neck`	KineFX Animation Rig Cabeza y cuello bípedos — un HDA de rig de animación /obj para cabeza+cuello bípedos (A_source: 0 entradas, genera controles de look-at de cabeza/cuello/mandíbula/ojos). control_scale/control_lod/control_color dimensionan y estilizan los controles; hook_object referencia un objeto padre en escena.	`name` (+14 opcionales)
`animation_rig_biped_leg`	KineFX Animation Rig Pierna bípeda — un HDA de rig de animación /obj para una pierna bípeda (A_source: 0 entradas, genera un rig de control FK/IK predeterminado). control_scale/control_lod/control_color dimensionan y estilizan los controles; hook_object referencia un objeto padre en escena.	`name` (+14 opcionales)
`animation_rig_biped_spine_3pc`	KineFX Animation Rig Columna bípeda (3 piezas) — un HDA de rig de animación /obj para una columna bípeda de 3 piezas (A_source: 0 entradas). control_scale/control_lod/control_color dimensionan y estilizan los controles; hook_object referencia un objeto padre en escena.	`name` (+14 opcionales)
`animation_rig_biped_spine_5pc`	KineFX Animation Rig Columna bípeda (5 piezas) — un HDA de rig de animación /obj para una columna bípeda de 5 piezas (A_source: 0 entradas). control_scale/control_lod/control_color dimensionan y estilizan los controles; hook_object referencia un objeto padre en escena.	`name` (+14 opcionales)
`animation_rig_character_placer`	KineFX Animation Rig Colocador de personaje — el HDA de rig de colocación raíz /obj que posiciona un personaje completo (A_source: 0 entradas). control_scale/control_lod/control_color dimensionan y estilizan los controles de colocación; hook_object referencia un objeto padre en escena.	`name` (+14 opcionales)
`animation_rig_quadruped_back_leg`	KineFX Animation Rig Pata trasera de cuadrúpedo — un HDA de rig de animación /obj para una pata trasera de cuadrúpedo (A_source: 0 entradas). control_scale/control_lod/control_color dimensionan y estilizan los controles; hook_object referencia un objeto padre en escena.	`name` (+14 opcionales)
`animation_rig_quadruped_front_leg`	KineFX Animation Rig Pata delantera de cuadrúpedo — un HDA de rig de animación /obj para una pata delantera de cuadrúpedo (A_source: 0 entradas). control_scale/control_lod/control_color dimensionan y estilizan los controles; hook_object referencia un objeto padre en escena.	`name` (+14 opcionales)
`animation_rig_quadruped_head_and_neck`	KineFX Animation Rig Cabeza y cuello de cuadrúpedo — un HDA de rig de animación /obj para cabeza+cuello de cuadrúpedo (A_source: 0 entradas). control_scale/control_lod/control_color dimensionan y estilizan los controles; hook_object referencia un objeto padre en escena.	`name` (+14 opcionales)
`animation_rig_quadruped_ik_spine`	KineFX Animation Rig Quadruped IK Spine — un HDA de rig de animación /obj para una columna vertebral IK de cuadrúpedo (A_source: 0 inputs). control_scale/control_lod/control_color dimensionan y estilizan los controles; hook_object hace referencia a un objeto padre en la escena.	`name` (+14 opcionales)
`animation_rig_quadruped_tail`	KineFX Animation Rig Quadruped Tail — un HDA de rig de animación /obj para una cola de cuadrúpedo (A_source: 0 inputs). control_scale/control_lod/control_color dimensionan y estilizan los controles; hook_object hace referencia a un objeto padre en la escena.	`name` (+14 opcionales)
`animation_rig_quadruped_toes_4f`	KineFX Animation Rig Quadruped Toes (4 Fingers) — un HDA de rig de animación /obj para un pie de cuadrúpedo de 4 dedos (A_source: 0 inputs). control_scale/control_lod/control_color dimensionan y estilizan los controles; hook_object hace referencia a un objeto padre en la escena.	`name` (+14 opcionales)
`animation_rig_quadruped_toes_5f`	KineFX Animation Rig Quadruped Toes (5 Fingers) — un HDA de rig de animación /obj para un pie de cuadrúpedo de 5 dedos (A_source: 0 inputs). control_scale/control_lod/control_color dimensionan y estilizan los controles; hook_object hace referencia a un objeto padre en la escena.	`name` (+14 opcionales)
`auto_rig_biped_arm`	KineFX Auto Rig Biped Arm — un HDA constructor de auto-rig /obj que ensambla un rig de control completo de brazo bípedo a partir de valores predeterminados (A_source: 0 inputs). control_scale/control_lod/control_color dimensionan y estilizan los controles; hook_object hace referencia a un objeto padre en la escena.	`name` (+14 opcionales)
`auto_rig_biped_hand_4f_2s`	KineFX Auto Rig Biped Hand (4 Fingers, 2 Segments) — un HDA constructor de auto-rig /obj que ensambla un rig de control completo de mano bípeda de 4 dedos a partir de valores predeterminados (A_source: 0 inputs). control_scale/control_lod/control_color dimensionan y estilizan los controles; hook_object hace referencia a un objeto padre en la escena.	`name` (+14 opcionales)
`auto_rig_biped_hand_4f_3s`	KineFX Auto Rig Biped Hand (4 Fingers, 3 Segments) — un HDA de auto-rig /obj que construye un rig de control de mano bípeda de 4 dedos predeterminado (A_source: 0 inputs).	17 opcionales
`auto_rig_biped_hand_5f_3s`	KineFX Auto Rig Biped Hand (5 Fingers, 3 Segments) — un HDA de auto-rig /obj que construye un rig de control de mano bípeda de 5 dedos predeterminado (A_source: 0 inputs).	17 opcionales
`auto_rig_biped_head_and_neck`	KineFX Auto Rig Biped Head and Neck — un HDA de auto-rig /obj que construye un rig de control de cabeza y cuello bípedo predeterminado (A_source: 0 inputs).	16 opcionales
`auto_rig_biped_leg`	KineFX Auto Rig Biped Leg — un HDA de auto-rig /obj que construye un rig de control de pierna bípeda predeterminado (A_source: 0 inputs).	19 opcionales
`auto_rig_biped_spine_3pc`	KineFX Auto Rig Biped Spine (3 Pieces) — un HDA de auto-rig /obj que construye un rig de control de columna vertebral bípeda de 3 piezas predeterminado (A_source: 0 inputs).	15 opcionales
`auto_rig_biped_spine_5pc`	KineFX Auto Rig Biped Spine (5 Pieces) — un HDA de auto-rig /obj que construye un rig de control de columna vertebral bípeda de 5 piezas predeterminado (A_source: 0 inputs).	15 opcionales
`auto_rig_quadruped_back_leg`	KineFX Auto Rig Quadruped Back Leg — un HDA de auto-rig /obj que construye un rig de control de pata trasera de cuadrúpedo predeterminado (A_source: 0 inputs).	19 opcionales
`auto_rig_quadruped_front_leg`	KineFX Auto Rig Quadruped Front Leg — un HDA de auto-rig /obj que construye un rig de control de pata delantera de cuadrúpedo predeterminado (A_source: 0 inputs).	19 opcionales
`auto_rig_quadruped_head_and_neck`	KineFX Auto Rig Quadruped Head and Neck — un HDA de auto-rig /obj que construye un rig de control de cabeza y cuello de cuadrúpedo predeterminado (A_source: 0 inputs).	18 opcionales
`auto_rig_quadruped_ik_spine`	KineFX Auto Rig Quadruped IK Spine — un HDA de auto-rig /obj que construye un rig de control de columna vertebral IK de cuadrúpedo predeterminado (A_source: 0 inputs).	16 opcionales
`auto_rig_quadruped_tail`	KineFX Auto Rig Quadruped Tail — un HDA de auto-rig /obj que construye un rig de control de cola de cuadrúpedo predeterminado (A_source: 0 inputs).	15 opcionales
`auto_rig_quadruped_toes_4f`	KineFX Auto Rig Quadruped Toes (4 Fingers) — un HDA de auto-rig /obj que construye un rig de control de pie de cuadrúpedo de 4 dedos predeterminado (A_source: 0 inputs).	18 opcionales
`auto_rig_quadruped_toes_5f`	KineFX Auto Rig Quadruped Toes (5 Fingers) — un HDA de auto-rig /obj que construye un rig de control de pie de cuadrúpedo de 5 dedos predeterminado (A_source: 0 inputs).	18 opcionales
`auto_rig_character_placer`	KineFX Auto Rig Character Placer — un HDA de auto-rig /obj que dispone las guías de ubicación a partir de las cuales se construye un rig (A_source: 0 inputs).	18 opcionales
`biped_auto_rig`	KineFX Biped Auto Rig — un HDA de una sola llamada /obj que construye un rig de control bípedo completo predeterminado (A_source: 0 inputs).	24 opcionales
`auto_rig_eye`	KineFX Auto Rig Eye — un HDA de auto-rig /obj que construye un rig de ojo individual (A_source: 0 inputs).	14 opcionales
`impostor_camera_rig`	KineFX Labs Impostor Camera Rig — un HDA de rig /obj que construye el rig de cámara multivista desde el cual se dispara un horneado de impostor (A_source: 0 inputs).	9 opcionales
`mocap_acclaim`	KineFX Mocap Acclaim — un HDA de importación de mocap /obj para captura de movimiento Acclaim ASF/AMC (A_source: 0 inputs; cocina vacío en verde hasta que se establece un esqueleto).	17 opcionales
`mocap_rig_biped_arm`	KineFX Mocap Rig Biped Arm — un HDA de rig de retargeting de mocap /obj que impulsa un rig de animación de brazo bípedo a partir de un esqueleto de mocap (A_source: 0 inputs).	18 opcionales
`mocap_rig_biped_head_and_neck`	KineFX Mocap Rig Biped Head and Neck — un HDA de rig de retargeting de mocap /obj que impulsa un rig de animación de cabeza y cuello bípedo a partir de un esqueleto de mocap (A_source: 0 inputs).	17 opcionales
`mocap_rig_biped_leg`	KineFX Mocap Rig Biped Leg — un HDA de rig de retargeting de mocap /obj que impulsa un rig de animación de pierna bípeda a partir de un esqueleto de mocap (A_source: 0 inputs).	23 opcionales
`mocap_rig_biped_spine_3pc`	KineFX Mocap Rig Biped Spine (3 Pieces) — un HDA de rig de retargeting de mocap /obj que impulsa un rig de animación de columna vertebral bípeda de 3 piezas a partir de un esqueleto de mocap (A_source: 0 inputs).	19 opcionales
`mocap_rig_biped_spine_5pc`	KineFX Mocap Rig Biped Spine (5 Pieces) — un HDA de rig de retargeting de mocap /obj que impulsa un rig de animación de columna vertebral bípeda de 5 piezas a partir de un esqueleto de mocap (A_source: 0 inputs).	23 opcionales
`mocap_biped_1`	KineFX MoCap Biped 1 — un personaje de prueba MoCap Biped preconstruido con clips de locomoción horneados (A_source: construido desnudo, 0 inputs conectados).	10 opcionales
`mocap_biped_2`	KineFX MoCap Biped 2 — un personaje de prueba MoCap Biped preconstruido con una gran biblioteca de clips horneados (A_source: construido desnudo, 0 inputs conectados).	10 opcionales
`mocap_biped_3`	KineFX MoCap Biped 3 — el personaje de prueba MoCap Biped preconstruido avanzado con una biblioteca de clips categorizada y motion-matching (A_source: construido desnudo, 0 inputs conectados).	14 opcionales
`quadruped_auto_rig_4f`	KineFX Quadruped Auto Rig (4 Toes) — un HDA de una sola llamada /obj que construye un rig de control de cuadrúpedo completo con 4 dedos predeterminado (A_source: 0 inputs).	28 opcionales
`quadruped_auto_rig_5f`	KineFX Quadruped Auto Rig (5 Toes) — un HDA de una sola llamada /obj que construye un rig de control de cuadrúpedo completo con 5 dedos predeterminado (A_source: 0 inputs).	28 opcionales
`toon_character`	KineFX Toon Character — un HDA /obj que construye un personaje de dibujos animados completo preriggeado (auto-rig + cara + mocap) a partir de valores predeterminados (A_source: 0 inputs).	18 opcionales
`constraint_begin`	KineFX Constraint Get World Space Begin (constraintbegin) — el INICIO de una red de restricciones CHOP: emite la transformación mundial de `object` como pistas t/r/s (9 pistas) que los CHOP de restricciones posteriores combinan.	6 opcionales
`constraint_object`	KineFX Constraint Object (constraintobject) — emite la transformación mundial de `target` como pistas t/r/s (9), expresada opcionalmente en relación con `reference`.	6 opcionales
`constraint_object_pretransform`	KineFX Constraint Object Pretransform (constraintobjectpretransform) — emite la pre-transformación (el desplazamiento de reposo/pivote del objeto) de `target` como pistas t/r/s (9).	5 opcionales
`constraint_object_offset`	KineFX Constraint Object Offset (constraintobjectoffset) — emite la transformación de desplazamiento de `target` en relación con `reference` como pistas t/r/s (9), enmascarada por `channel_mask`.	9 opcionales
`constraint_get_world_space`	KineFX Constraint Get World Space (constraintgetworldspace) — emite la transformación en ESPACIO MUNDIAL de `object` como pistas t/r/s (9).	5 opcionales
`constraint_get_parent_space`	KineFX Constraint Get Parent Space (constraintgetparentspace) — emite la transformación en ESPACIO DEL PADRE de `object` como pistas t/r/s (9); `parent_bone` selecciona la convención de hueso padre.	6 opcionales
`constraint_get_local_space`	KineFX Constraint Get Local Space (constraintgetlocalspace) — emite la transformación en ESPACIO LOCAL de `object` como pistas t/r/s (9); `mode` elige la convención de espacio local.	6 opcionales
`constraint_look_at`	KineFX Constraint Look At (constraintlookat) — emite una rotación que apunta `look_at_axis` hacia una posición de look-at mientras mantiene `look_up_axis_*` hacia un objetivo hacia arriba (9 pistas).	15 opcionales
`constraint_path`	KineFX Constraint Path (constraintpath) — emite una transformación que viaja a lo largo de la curva en `sop_path` en el parámetro `position`, orientada por la configuración de look-at/look-up (9 pistas).	21 opcionales
`constraint_points`	KineFX Constraint Points (constraintpoints) — emite una transformación adjunta al(los) punto(s) del SOP en `sop_path` (un `group`, o el más cercano dentro de `search_distance`/`search_max_points`), orientada por la configuración de look-at/look-up (9 pistas).	22 opcionales
`constraint_export`	KineFX Constraint Export (constraintexport) — termina una red de restricciones exportando la transformación combinada al objeto de restricción en `constraints_path`; `enable_constraints` activa/desactiva su estado en vivo.	4 opcionales
`constraint_blend`	KineFX Constraint Blend (constraintblend) — mezcla dos o más flujos de transformación de restricciones.	`input` (+5 opcionales)
`constraint_sequence`	KineFX Constraint Sequence (constraintsequence) — mezcla secuencialmente una cadena de flujos de restricciones mediante `blend`.	`input` (+5 opcionales)
`constraint_offset`	KineFX Constraint Offset (constraintoffset) — aplica la transformación de desplazamiento en `input1` (entrada 1) a la transformación base en `input` (entrada 0) mediante `blend`.	`input`, `input1` (+6 opcionales)
`constraint_parent`	KineFX Constraint Parent (constraintparent) — compone una transformación hija bajo una transformación padre (la primitiva de parenting CHOP).	`input` (+3 opcionales)
`constraint_parent_extended`	KineFX Constraint Parent Extended (constraintparentx) — parenting con un `write_mask` (máscara de bits int de canales escritos, predeterminado 511).	`input` (+4 opcionales)
`constraint_simple_blend`	KineFX Constraint Simple Blend (constraintsimpleblend) — una mezcla ligera de dos flujos de restricciones mediante `blend`.	`input` (+5 opcionales)
`constraint_offset_blend`	KineFX Constraint Offset Blend (constraintoffsetblend) — mezcla un desplazamiento en hasta cuatro flujos de restricciones mediante `blend`.	`input` (+7 opcionales)
`constraint_surface`	KineFX Constraint Surface (constraintsurface) — un CHOP que emite una transformación adherida a la SUPERFICIE del SOP en `sop_path`, ubicada por una coordenada UV (`uv` sobre `uv_attribute`), una posición (`p` sobre `position_attribute`), o el punto más cercano dentro de `search_distance`/`search_max_points`, y orientada por la configuración de look-at / look-up.	26 opcionales
`constraint_transform`	KineFX Constraint Transform (constrainttransform) — un CHOP que emite una transformación explícita construida a partir de `translate`/`rotate`/`scale` (con `transform_order`/`rotation_order`), un pivote (`pivot` / `pivot_rotate`), y `mode`/`pivot_mode`; `invert` invierte el resultado.	15 opcionales
`constraint_pose`	KineFX Pose (pose) — un CHOP de la pestaña Constraints que emite una pose estática almacenada como pistas de transformación t/r/s (desde `translate`/`rotate`/`scale` con `transform_order`/`rotation_order`).	8 opcionales
`jiggle`	KineFX Jiggle (jiggle) — un CHOP que añade movimiento de sacudida secundario al flujo de transformación en `input` (entrada 0, que DEBE llevar canales tx/ty/tz).	`input` (+7 opcionales)
`lag`	KineFX Lag (lag) — un CHOP que suaviza / retrasa el flujo de canales en `input` (entrada 0).	`input` (+8 opcionales)
`channel_spring`	KineFX Spring (spring, CHOP) — impulsa el flujo de canales en `input` (entrada 0) con un sistema masa-resorte: `spring_constant`, `mass`, `damping`, `method` (disp / force), inicial `position` / `speed`, y `use_channel_condition` para sembrar el estado inicial desde la entrada.	`input` (+8 opcionales)
`channel_pose_difference`	KineFX Pose Difference (posedifference, CHOP) — calcula la diferencia entre el flujo de poses en `input` (entrada 0) y una pose de referencia.	`input` (+3 opcionales)
`chop_wave`	CHOP Wave (wave) — genera un canal de forma de onda periódica (sine/triangle/ramp/square/pulse) en un rango de fotogramas.	16 opcionales
`chop_waveform`	CHOP Waveform (waveform) — genera un canal de forma de onda constante/seno/cuadrada (fuente de forma de onda basada en datos).	13 opcionales
`chop_noise`	CHOP Noise (noise) — genera un canal de ruido animado (sparse/perlin/harmonic/brownian/alligator).	14 opcionales
`chop_constant`	CHOP Constant (constant) — genera canales que mantienen valores constantes (hasta cuatro canales con nombre).	10 opcionales
`chop_spline`	CHOP Spline (spline) — genera un canal interpolado por spline (bezier/cubic) en un rango.	11 opcionales
`chop_pulse`	CHOP Pulse (pulse) — genera una secuencia de pulsos de valor en un rango.	13 opcionales
`chop_channel`	CHOP Channel (channel) — genera canales muestreados de canales de parámetros / fotogramas clave en un rango.	11 opcionales
`chop_oscillator`	CHOP Oscillator (oscillator) — oscilador de estilo de audio impulsado por un canal de entrada (REQUIERE un CHOP de entrada).	`input` (+15 opcionales)
`chop_math`	CHOP Math (math) — aritmética por canal y entre CHOPs, ganancia y remapeo.	`input` (+19 opcionales)
`chop_function`	CHOP Function (function) — aplica una función matemática (sqrt/trig/log/pow/...) a los canales de entrada.	`input` (+12 opcionales)
`chop_filter`	CHOP Filter (filter) — filtro temporal (gaussian/box/edge/sharpen/despike) en los canales de entrada.	`input` (+9 opcionales)
`chop_limit`	CHOP Limit (limit) — limita / recorre / cuantiza los valores de los canales de entrada.	`input` (+15 opcionales)
`chop_lag`	CHOP Lag (lag) — suaviza los canales de entrada con retraso/sobreimpulso (seguimiento tipo resorte).	`input` (+11 opcionales)
`chop_lookup`	CHOP Lookup (lookup) — usa la entrada 0 como índice para buscar valores en la entrada 1.	`input` (+9 opcionales)
`chop_cycle`	CHOP Cycle (cycle) — repite/refleja los canales de entrada antes y después con mezclas opcionales.	`input` (+13 opcionales)
`chop_blend`	CHOP Blend (blend) — mezcla por peso los canales a través de las entradas conectadas.	`input` (+10 opcionales)
`chop_merge`	CHOP Merge (merge) — combina los canales de todas las entradas conectadas en un flujo único.	`input` (+9 opcionales)
`chop_warp`	CHOP Warp (warp) — deforma temporalmente la entrada 0 mediante el canal de deformación de la entrada 1.	`input` (+7 opcionales)
`chop_resample`	CHOP Resample (resample) — remuestrea los canales de entrada a una nueva tasa / rango.	`input` (+14 opcionales)
`chop_shift`	CHOP Shift (shift) — desplaza / arrastra los canales de entrada en el tiempo.	`input` (+10 opcionales)
`chop_hold`	CHOP Hold (hold) — mantiene (sample-and-hold) los canales de entrada.	`input` (+5 opcionales)
`chop_spectrum`	CHOP Spectrum (spectrum) — convierte los canales de entrada hacia/desde el dominio de la frecuencia.	`input` (+11 opcionales)
`chop_multiply`	CHOP Multiply (multiply) — multiplica los canales de todas las entradas conectadas.	`input` (+7 opcionales)
`chop_invert`	CHOP Invert (invert) — invierte (recíproco) los valores de los canales de entrada.	`input` (+4 opcionales)
`chop_extend`	CHOP Extend (extend) — establece cómo se extienden los canales de entrada antes/después de su rango.	`input` (+7 opcionales)
`chop_stretch`	CHOP Stretch (stretch) — estira los canales de entrada en tiempo y valor.	`input` (+12 opcionales)
`chop_trim`	CHOP Trim (trim) — recorta los canales de entrada a un subrango.	`input` (+9 opcionales)
`chop_area`	CHOP Area (area) — integra los canales de entrada (área / integral acumulada).	`input` (+13 opcionales)
`chop_envelope`	CHOP Envelope (envelope) — extrae la envolvente de amplitud de los canales de entrada.	`input` (+11 opcionales)
`chop_interp`	CHOP Interpolate (interp) — interpola entre las entradas conectadas a lo largo del tiempo.	`input` (+11 opcionales)
`chop_delay`	CHOP Delay (delay) — añade ecos retardados y con ganancia de los canales de entrada.	`input` (+14 opcionales)
`chop_slope`	CHOP Slope (slope) — calcula la pendiente / aceleración (derivada) de los canales de entrada.	`input` (+6 opcionales)
`chop_fan`	CHOP Fan (fan) — distribuye un canal a muchos, o combina muchos canales en uno.	`input` (+8 opcionales)
`chop_count`	CHOP Count (count) — cuenta los cruces de umbral de los canales de entrada.	`input` (+14 opcionales)
`chop_null`	CHOP Null (null) — null de paso (un tap nombrado estable en el flujo de canales).	`input` (+4 opcionales)
`chop_vector`	CHOP Vector (vector) — operaciones vectoriales (magnitud/normalizar/producto punto/producto cruz/proyectar/...) en tripletas de canales.	`input` (+11 opcionales)
`chop_attribute`	CHOP Attribute (attribute) — gestiona atributos de transformación (orden de rotación / slerp) en los canales.	`input` (+6 opcionales)
`chop_copy`	CHOP Copy (copy) — sella la entrada 0 en cada muestra de disparo de la entrada 1.	`input` (+7 opcionales)
`chop_shuffle`	CHOP Shuffle (shuffle) — reordena / divide / secuencia los canales de entrada.	`input` (+6 opcionales)
`chop_reorder`	CHOP Reorder (reorder) — reordena canales por patrón numérico / de caracteres.	`input` (+10 opcionales)
`chop_rename`	CHOP Rename (rename) — renombra canales por patrón.	`input` (+7 opcionales)
`chop_delete`	CHOP Delete (delete) — elimina canales por nombre o número.	`input` (+12 opcionales)
`chop_switch`	CHOP Switch (switch) — deja pasar una de las entradas conectadas, seleccionada por índice.	`input` (+9 opcionales)
`chop_layer`	CHOP Layer (layer) — superpone las entradas conectadas con pesos por capa (la capa activa selecciona la base).	`input` (+8 opcionales)
`chop_composite`	CHOP Composite (comp) — compone (ascenso aditivo / pico / liberación) las entradas conectadas.	`input` (+18 opcionales)
`chop_trigger`	CHOP Trigger (trigger) — genera una envolvente estilo ADSR disparada por los canales de entrada.	`input` (+16 opcionales)
`chop_footplant`	CHOP Foot Plant (footplant) — detecta + bloquea contactos de pie en una animación de caminata para eliminar deslizamientos.	`input` (+11 opcionales)
`chop_iksolver`	CHOP IK Solver (iksolver) — resuelve una cadena de huesos para alcanzar un efector final.	`input` (+11 opcionales)
`chop_inversekin`	CHOP Inverse Kinematics (inversekin) — el clásico solucionador de IK de cadena de huesos impulsado por rutas de huesos OBJ.	11 opcionales
`chop_transform_chain`	CHOP Transform Chain (transformchain) — recompone una cadena de transformaciones en canales de salida.	`input` (+7 opcionales)
`chop_export_transforms`	CHOP Export Transforms (exporttransforms) — mapea canales de transformación a parámetros de nodos OBJ.	`input` (+6 opcionales)
`chop_extract_bone_transforms`	CHOP Extract Bone Transforms (extractbonetransforms) — lee las transformaciones de huesos de un esqueleto KineFX en canales.	10 opcionales
`chop_extract_pose_drivers`	CHOP Extract Pose Drivers (extractposedrivers) — extrae canales conductores (xforms de articulaciones / parámetros) que alimentan un deformador basado en poses.	9 opcionales
`chop_blendpose`	CHOP Blend Pose (blendpose) — interpolación en espacio de poses (RBF / hiperplano) que mezcla poses de ejemplo según valores de conductores.	`input` (+13 opcionales)
`chop_stashpose`	CHOP Stash Pose (stashpose) — guarda la pose actual como pose de referencia estática para flujos de trabajo basados en poses.	`input` (+5 opcionales)

Crowd

Herramienta	Qué hace	Parámetros clave
`agent_source`	Crowd Agent (SOP de agente) — crea/importa primitivas de agente. input=scene (un subred de huesos /obj), disk (directorio de caché del agente), fbx o usd.	16 opcionales
`agent_look_at`	Crowd Agent Look At (agentlookat::3.0) — orienta las articulaciones de cabeza/ojos del agente hacia un objetivo. input0 = agents, input1 = target points (target_type=points).	`agents` (+19 opcionales)
`agent_terrain_adaptation`	Crowd Agent Terrain Adaptation (agentterrainadaptation::3.0) — microsolver de multitud DOP: bloqueo de pies + ajuste de cadera de los agentes al terreno.	17 opcionales
`agent_terrain_projection`	Crowd Agent Terrain Projection (agentterrainprojection) — microsolver de multitud DOP que proyecta partículas/pies de agentes sobre una superficie de terreno.	14 opcionales
`agent_look_at_apply`	Crowd Agent Look At Apply (agentlookatapply::3.0) — microsolver de multitud DOP que aplica la orientación cabeza/ojos (look-at) a los agentes en cada paso de simulación.	14 opcionales
`agent_clip_layer`	Crowd Agent Clip Layer (agentcliplayer) — microsolver de multitud DOP que superpone/mezcla clips de animación sobre los agentes.	15 opcionales
`agent_arcing_clip_layer`	Crowd Agent Arcing Clip Layer (agentarcingcliplayer) — microsolver de multitud DOP que superpone un clip de arco/giro sobre los agentes.	6 opcionales
`crowd_fuzzy_logic`	Crowd Fuzzy Logic (crowdfuzzylogic) — nodo DOP que combina entradas de disparo mediante lógica difusa en un atributo de disparo.	7 opcionales
`crowd_object`	Crowd Object (crowdobject) — el objeto DOP que contiene la multitud de agentes en una simulación de multitud.	16 opcionales
`crowd_state`	Crowd State (crowdstate::3.0) — un estado de comportamiento con nombre (asignación de clip, marcha, modo ragdoll) en una máquina de estados de multitud.	13 opcionales
`agent_clip`	KineFX Agent Clip (agentclip::2.0) — hornea una fuente de movimiento sobre primitivas de agente como un clip con nombre. input0 = agents, input1 = MotionClip (source=sop/chop).	`agents` (+16 opcionales)
`crowd_trigger`	KineFX Crowd Trigger (crowdtrigger::2.0) — evalúa una condición por agente (proximidad/atributo/velocidad/distancia/...) y escribe un atributo de disparo.	19 opcionales
`crowd_trigger_logic`	KineFX Crowd Trigger Logic (crowdtriggerlogic::2.0) — combina hasta dos flujos de disparo con una operación booleana y escribe un atributo de disparo.	7 opcionales
`crowd_transition`	KineFX Crowd Transition (crowdtransition::3.0) — define una transición entre dos estados de multitud, activada por un disparo.	`input` (+17 opcionales)
`crowd_sop_import`	KineFX Crowd SOP Import (sopcrowdimport) — importa una multitud SOP (primitivas de agente) al escenario USD como personajes UsdSkel. sop_path = el SOP que contiene los agentes.	`sop_path` (+7 opcionales)
`crowd_render_procedural`	KineFX Crowd Render Procedural (houdinicrowdprocedural) — configura un procedural de carga diferida de multitud en tiempo de render (Karma) para que los agentes se expandan en el render, no horneados. input (opcional) = un escenario LOP con la multitud.	13 opcionales
`bake_skinning`	KineFX Bake Skinning (bakeskinning) — hornea el skinning UsdSkel de un escenario de entrada a posiciones de puntos deformadas (preparación de render de multitud tras crowd_sop_import). input (REQUERIDO) = el escenario LOP con personajes con skinning.	`input` (+1 opcional)
`agent_channels`	KineFX Agent Channels (canal CHOP de agente) — evalúa el clip o las transformaciones de pose de una primitiva de agente en pistas CHOP (conducir rigs/luces/objetos desde animación de multitud). sop_path = el SOP que contiene el agente.	`sop_path` (+13 opcionales)
`agent_camera`	KineFX Agent Cam (agentcam) — una cámara /obj controlada por la propia definición de cámara de un agente de multitud (renderizar a través de los ojos de un agente). agent_source = el SOP que contiene el agente.	9 opcionales
`agent_clip_properties`	Crowd Agent Clip Properties (agentclipproperties) — crea metadatos por clip (rango de fotogramas, unidades de muestreo, clip previsualizado) en el catálogo de clips de un agente. input0 = agents.	`agents` (+5 opcionales)
`agent_clip_transition_graph`	Crowd Agent Clip Transition Graph (agentcliptransitiongraph) — calcula mezclas de transición clip-a-clip para un agente. input0 = agents, input1 = existing transition graph, input2 = clip properties.	`agents` (+8 opcionales)
`agent_collision_layer`	Crowd Agent Collision Layer (agentcollisionlayer) — construye/marca una capa de colisión en los agentes para formas de colisión ragdoll/bullet. input0 = agents.	`agents` (+9 opcionales)
`agent_configure_joints`	Crowd Agent Configure Joints (agentconfigurejoints) — configura límites de ragdoll por articulación y visualización de guías en los agentes. input0 = agents.	`agents` (+4 opcionales)
`agent_constraint_network`	Crowd Agent Constraint Network (agentconstraintnetwork) — construye la red de restricciones ragdoll (ajuste de suavidad / ERP / CFM / bias) para los agentes. input0 = agents.	`agents` (+12 opcionales)
`agent_definition_cache`	Crowd Agent Definition Cache (agentdefinitioncache) — carga una definición de agente en caché (rig/capas/formas/clips/metadatos).	19 opcionales
`agent_edit`	Crowd Agent Edit (agentedit) — sobrescribe la capa actual/de colisión de un agente, su clip actual y el tiempo del clip. input0 = agents.	`agents` (+7 opcionales)
`agent_layer`	Crowd Agent Layer (agentlayer::2.0) — añade/asigna capas de forma a los agentes y establece las capas actual y de colisión. input0 = agents, input1 = shape geometry, input2 = capture pose.	`agents` (+17 opcionales)
`agent_metadata`	Crowd Agent Metadata (agentmetadata) — lee/combina/establece diccionarios de metadatos tipados en los agentes. input0 = agents.	`agents` (+10 opcionales)
`agent_prep`	Crowd Agent Prep (agentprep::3.0) — prepara agentes para la simulación de multitud (clip de reposo, configuración de extremidades, carga de clips). input0 = agents. cachedir + clippaths confinados al directorio de trabajo; los botones create-chopnet/reload/save nunca se presionan.	`agents` (+11 opcionales)
`agent_proxy`	Crowd Agent Proxy (agentproxy) — establece la visualización de proxy en el viewport (LOD / id / color) para puntos de agente, para previsualizaciones rápidas de multitudes. input0 = points carrying agent primitives.	`agents` (+6 opcionales)
`agent_relationship`	Crowd Agent Relationship (agentrelationship) — establece agentes hijos bajo un agente padre (opcionalmente en una articulación específica) con una restricción de posición/rotación/total. input0 = parent agents, input1 = child agents.	`agents` (+10 opcionales)
`agent_transform_group`	Crowd Agent Transform Group (agenttransformgroup) — define grupos de transformación (articulaciones) con nombre en los agentes para deformación/mezcla ponderada. input0 = agents.	`agents` (+10 opcionales)
`agent_unpack`	Crowd Agent Unpack (agentunpack) — desempaca primitivas de agente en su geometría subyacente (deformada \| reposo \| articulaciones \| esqueleto \| motionclips). input0 = agents.	`agents` (+15 opcionales)
`agent_vellum_unpack`	Crowd Agent Vellum Unpack (agentvellumunpack) — desempaca agentes en geometría de simulación (Vellum) + reposo para configuraciones de multitud con tela/cuerpos blandos. input0 = agents.	`agents` (+16 opcionales)
`crowd_assign_layers`	Crowd Assign Layers (crowdassignlayers) — asigna/aleatoriza las capas actual y de colisión en una multitud de agentes por grupo / patrón de capa / porcentaje. input0 = agents.	`agents` (+13 opcionales)
`crowd_motion_path`	Crowd Motion Path (crowdmotionpath) — genera curvas de ruta de movimiento editables para una multitud evaluando los clips asignados de cada agente (o una simulación en caché) en un rango de fotogramas. input0 = a crowd (points carrying agent prims).	`agents` (+15 opcionales)
`crowd_motion_path_apply_relationship`	Crowd Motion Path Apply Relationship (crowdmotionpathapplyrel) — aplica relaciones padre/hijo de agentes sobre rutas de movimiento. input0 = motion paths, input1 = agents.	`motion_paths` (+3 opcionales)
`crowd_motion_path_arcing_layer`	Crowd Motion Path Arcing Layer (crowdmotionpatharcinglayer) — superpone clips de giro (arcing) sobre una ruta de movimiento según la tasa de giro. input0 = motion paths, input1 = agents.	`motion_paths` (+11 opcionales)
`crowd_motion_path_avoid`	Crowd Motion Path Avoid (crowdmotionpathavoid) — dirige las rutas de movimiento para evitar colisiones, vecinos y obstáculos. input0 = motion paths, input1 = agents (opcional), input2 = obstacles (opcional).	`motion_paths` (+18 opcionales)
`crowd_motion_path_edit`	Crowd Motion Path Edit (crowdmotionpathedit) — edición de rutas de movimiento por peso de anclaje / ajuste de escala (controles de datos no interactivos). input0 = motion paths, input1 = agents.	`motion_paths` (+6 opcionales)
`crowd_motion_path_edit_core`	Crowd Motion Path Edit Core (crowdmotionpatheditcore) — el núcleo de datos de la edición de ruta de movimiento: aplica atributos de peso de anclaje / ajuste de escala a las rutas. input0 = motion paths.	`motion_paths` (+9 opcionales)
`crowd_motion_path_evaluate`	Crowd Motion Path Evaluate (crowdmotionpathevaluate) — muestrea las rutas de movimiento de una multitud en un fotograma dado, produciendo los puntos de multitud poseados. input0 = motion paths, input1 = agents.	`motion_paths` (+3 opcionales)
`crowd_motion_path_evaluate_core`	Crowd Motion Path Evaluate Core (crowdmotionpathevaluatecore) — el núcleo de datos de la evaluación de ruta de movimiento: posea agentes desde rutas de movimiento en un momento dado.	`agents` (+4 opcionales)
`crowd_motion_path_follow`	Crowd Motion Path Follow (crowdmotionpathfollow) — deforma rutas de movimiento para seguir curvas guía. input0 = motion paths, input1 = agents (opcional), input2 = curves to follow (opcional).	`motion_paths` (+14 opcionales)
`crowd_motion_path_layer`	Crowd Motion Path Layer (crowdmotionpathlayer) — superpone un clip de animación sobre una ruta de movimiento cuando se activa (mediante grupos de disparo). input0 = motion paths, input1 = agents.	`motion_paths` (+19 opcionales)
`crowd_motion_path_retime`	Crowd Motion Path Retime (crowdmotionpathretime) — re-temporiza / recorta el rango de fotogramas y la velocidad de reproducción de una ruta de movimiento. input0 = motion paths, input1 = agents (opcional).	`motion_paths` (+8 opcionales)
`crowd_motion_path_transition`	Crowd Motion Path Transition (crowdmotionpathtransition) — transiciona una ruta de movimiento desde su clip actual a un nuevo clip cuando se activa. input0 = motion paths, input1 = agents.	`motion_paths` (+19 opcionales)
`crowd_source`	Crowd Source (crowdsource::3.0) — genera el flujo de puntos de multitud (cuadrícula de formación o dispersión) que siembra una simulación de multitud; cada punto genera un agente con un estado inicial / clip / dirección.	27 opcionales
`crowd_motion_path_trigger`	Crowd Motion Path Trigger (crowdmotionpathtrigger) — evalúa una condición de disparo (tiempo / límites / distancia a objeto / raycast / distancia a vecino / clip) a lo largo de rutas de movimiento y escribe un disparo con nombre usado por las transiciones.	`motion_paths` (+29 opcionales)
`agent_animation_unpack`	Agent Animation Unpack (kinefx::agentanimationunpack) — desempaca la animación de un agente en un esqueleto KineFX `output`: pose / pose de clip de agente / pose de reposo / clip de movimiento / clips de movimiento empaquetados.	`agents` (+14 opcionales)
`agent_character_unpack`	Agent Character Unpack (kinefx::agentcharacterunpack) — desempaca un agente en su geometría componente: salida 0 = formas de piel, salida 1 = esqueleto, salida 2 = pose de captura.	`agents` (+15 opcionales)
`agent_from_rig`	Agent From Rig (kinefx::agentfromrig) — convierte un rig/esqueleto KineFX en una única primitiva de Agent (pose de reposo, sin clips).	`rig` (+10 opcionales)
`agent_pose_from_rig`	Agent Pose From Rig (kinefx::agentposefromrig) — conduce la pose de un agente desde una pose de rig/esqueleto KineFX (ambas entradas REQUERIDAS).	`agents`, `rig` (+7 opcionales)
`agent_transforms`	Crowd Agent Transforms (agenttransforms) — VOP proveedor de datos que lee las matrices de transformación de una primitiva de agente.	7 opcionales
`agent_transform_names`	Crowd Agent Transform Names (agenttransformnames) — VOP proveedor de datos que lee los nombres ordenados de transformaciones (articulaciones) del rig de un agente.	6 opcionales
`agent_transform_count`	Crowd Agent Transform Count (agenttransformcount) — VOP proveedor de datos que emite el número de transformaciones (articulaciones) en el rig de un agente.	6 opcionales
`agent_rig_find`	Crowd Agent Rig Find (agentrigfind) — VOP proveedor de datos que devuelve el índice de transformación de una articulación nombrada en el rig de un agente.	7 opcionales
`agent_rig_children`	Crowd Agent Rig Children (agentrigchildren) — VOP proveedor de datos que devuelve los índices de transformación hijos de una articulación en la jerarquía del rig de un agente.	7 opcionales
`agent_rig_parent`	Crowd Agent Rig Parent (agentrigparent) — VOP proveedor de datos que devuelve el índice de transformación padre de una articulación en la jerarquía del rig de un agente.	7 opcionales
`agent_clip_weights`	Crowd Agent Clip Weights (agentclipweights) — VOP proveedor de datos que lee los pesos de mezcla activos por clip de un agente.	6 opcionales
`agent_layers`	Crowd Agent Layers (agentlayers) — VOP proveedor de datos que lee la lista de nombres de capas en una definición de agente.	6 opcionales
`agent_layer_name`	Crowd Agent Layer Name (agentlayername) — VOP proveedor de datos que resuelve un nombre de capa para un agente (p. ej., capa actual / de colisión).	7 opcionales
`agent_layer_bindings`	Crowd Agent Layer Bindings (agentlayerbindings) — VOP proveedor de datos que lee los enlaces forma->transformación de una capa de agente nombrada.	8 opcionales
`agent_layer_shapes`	Crowd Agent Layer Shapes (agentlayershapes) — VOP proveedor de datos que lee los nombres de formas en una capa de agente nombrada, opcionalmente filtrados por tipo de forma.	8 opcionales
`agent_convert_transforms`	Crowd Agent Convert Transforms (agentconverttransforms) — VOP proveedor de datos que convierte el arreglo de transformaciones de un agente entre espacios (p. ej., local <-> mundo).	7 opcionales

Muscle

Herramienta	Qué hace	Parámetros clave
`franken_muscle`	Muscle Franken Muscle (frankenmuscle) — asigna múltiples sub-regiones `muscle_id` dentro de una única geometría de músculo, de modo que una misma malla sólida se comporta como varios músculos independientes.	`muscle` (+10 opcional)
`franken_muscle_paint`	Muscle Franken Muscle Paint (frankenmusclepaint) — la interfaz de pintura para las máscaras `muscle_id` sobre una geometría de músculo (entrada 0).	`muscle` (+20 opcional)
`muscle_id`	Muscle Muscle ID (muscleid) — asigna un atributo de nombre `muscle_id` por primitiva a cada grupo de superficie conectado, para que los SOP de músculo posteriores aborden los músculos individualmente.	`surface` (+8 opcional)
`muscle_solidify`	Muscle Muscle Solidify (musclesolidify) — tetraedraliza una SUPERFICIE de músculo en un músculo sólido (conserva `muscle_id` + `maxthickness`) listo para propiedades y simulación.	`surface` (+14 opcional)
`muscle_properties`	Muscle Muscle Properties (muscleproperties) — crea propiedades de material sólido por músculo (forma/volumen/amortiguación/masa/rigidez de fibra y tendón) y calcula el marco de dirección de fibra `materialW` en un músculo sólido.	`muscle` (+19 opcional)
`muscle_properties_otis`	Muscle Muscle Properties OTIS (musclepropertiesotis) — la variante con solucionador OTIS de Muscle Properties (propiedades de material sólido por músculo para la simulación de músculo y tejido OTIS).	`muscle` (+19 opcional)
`muscle_constraint_properties_fem`	Muscle Muscle Constraint Properties FEM (muscleconstraintpropertiesfem) — crea las propiedades de RESTRICCIÓN por músculo (extremidad / músculo a músculo / rigidez músculo a hueso, amortiguación, distancia) para el solucionador muscular FEM.	`muscle` (+13 opcional)
`muscle_constraint_properties_otis`	Muscle Muscle Constraint Properties OTIS (muscleconstraintpropertiesotis) — la variante con solucionador OTIS del nodo de creación de propiedades de RESTRICCIÓN de músculo (extremidad / pegamento / rigidez músculo a músculo + amortiguación + distancia).	`muscle` (+11 opcional)
`muscle_constraint_properties_vellum`	Muscle Muscle Constraint Properties Vellum (muscleconstraintpropertiesvellum) — la variante con solucionador Vellum del nodo de creación de propiedades de RESTRICCIÓN de músculo (extremidad / músculo a músculo / rigidez músculo a hueso, amortiguación, distancia, compresión, velocidad de deslizamiento).	`muscle` (+15 opcional)
`muscle_auto_tension_lines`	Muscle Auto Tension Lines (muscleautotensionlines) — genera automáticamente una curva de línea de tensión a lo largo del eje largo de cada región `muscle_id` (los impulsores que los deformadores de músculo flexionan).	`muscle` (+5 opcional)
`muscle_tension_lines`	Muscle Tension Lines (muscletensionlines) — el nodo de autoría de líneas de tensión: selecciona/edita las líneas de tensión usadas para flexionar músculos, con soporte de simetría.	`muscle` (+8 opcional)
`muscle_tension_lines_activate`	Muscle Tension Lines Activate (muscletensionlinesactivate) — activa/anima las líneas de tensión (activación mín/máx por grupo, activación de espejo en todo el cuerpo).	`tension_lines` (+11 opcional)
`muscle_deform`	Muscle Muscle Deform (muscledeform::2.0) — el deformador muscular cuasiestático moderno: resuelve el sólido muscular para seguir sus líneas de tensión con rigidez de fibra + tensión.	`muscle`, `tension_lines`, `tension_lines_anim` (+13 opcional)
`muscle_flex`	Muscle Muscle Flex (muscleflex::2.0) — flexiona un músculo a lo largo de sus líneas de tensión mediante una mezcla a escala de fibra (la protuberancia rápida no resuelta).	`muscle` (+15 opcional)
`muscle_preroll`	Muscle Muscle Preroll (musclepreroll) — pre-rolla la deformación muscular desde una pose de reposo sobre un rango de fotogramas de espera + preroll para que una simulación se asiente antes del inicio de la toma.	`muscle` (+7 opcional)
`muscle_merge`	Muscle Muscle Merge (musclemerge) — fusiona hasta seis flujos de músculos en un solo sistema muscular (mantiene `muscle_id` distinto).	`muscle` (+6 opcional)
`muscle_mirror`	Muscle Muscle Mirror (musclemirror) — refleja músculos de un lado del cuerpo al otro, renombrando `muscle_id` mediante intercambio de prefijos.	`muscle` (+7 opcional)
`muscle_deintersect`	Muscle Muscle Deintersect (muscledeintersect) — separa músculos superpuestos para que dejen de interpenetrarse, hasta un desplazamiento de grosor.	`muscle` (+4 opcional)
`muscle_adjust_volume`	Muscle Muscle Adjust Volume (muscleadjustvolume) — crece/encoge el volumen muscular a lo largo de normal y tangente, con resolución de colisión opcional contra la piel.	`muscle` (+15 opcional)
`muscle_slide_constraint`	Muscle Muscle Slide Constraint (muscleslideconstraint) — construye restricciones de deslizamiento que permiten que un músculo se deslice sobre sus vecinos/huesos mientras resiste el estiramiento.	`muscle` (+12 opcional)
`muscle_tpose`	Muscle Muscle T-Pose (muscletpose) — almacena/restaura la forma de reposo (T-pose) del músculo en un atributo con nombre para que los deformadores posteriores tengan una pose de referencia estable.	`muscle` (+5 opcional)
`otis_configure_muscle_tissue`	Muscle OTIS Configure Muscle and Tissue (otisconfiguremuscleandtissue) — ensambla la geometría de músculo y tejido y las restricciones en el payload que consume el solucionador OTIS (restricciones extremo-músculo / pegamento / tejido a hueso, calidad de tetraedros).	`muscle` (+19 opcional)
`tissue_solidify`	Muscle Tissue Solidify (tissuesolidify::2.0) — construye una capa de tejido tetraedralizado (grasa/fascia) de un grosor dado bajo una superficie de piel/músculo.	`surface` (+16 opcional)
`tissue_solidify_otis`	Muscle Tissue Solidify OTIS (tissuesolidifyotis) — la variante con solucionador OTIS: construye el volumen de tejido entre una piel EXTERIOR y una superficie interna envuelta por contracción.	`skin` (+14 opcional)
`tissue_properties`	Muscle Tissue Properties (tissueproperties) — crea propiedades de material de tejido (superficie + sólido + rigidez/amortiguación/masa de deslizamiento, escala de reposo) a partir de un preajuste o valores explícitos, opcionalmente enmascarado.	`tissue` (+18 opcional)
`tissue_properties_otis`	Muscle Tissue Properties OTIS (tissuepropertiesotis) — la variante con solucionador OTIS de Tissue Properties (rigidez/amortiguación/masa del sólido del núcleo y la capa, rigidez tejido a músculo / tejido a hueso).	`tissue` (+20 opcional)
`muscle_paint`	Muscle Muscle Paint (musclepaint) — la interfaz de pintura para atributos/máscaras de músculo sobre una geometría de músculo (entrada 0).	`muscle` (+18 opcional)

VEX (validated safe-VEX)

Herramienta	Qué hace	Parámetros clave
`set_attrib_expr`	Ejecuta un fragmento seguro de VEX sobre atributos de geometría mediante un wrangle que lleva un fragmento de atributo VEX seguro VALIDADO — el único canal de texto de código en el puente.	`outputs`, `code` (+8 opcional)

ML / ONNX inference

Herramienta	Qué hace	Parámetros clave
`onnx_inference`	Ejecuta un modelo de grafo tensorial ONNX confinado sobre atributos de puntos o un campo de volumen — super-resolución / denoise / segmentación aprendida de nubes y volúmenes.	`input`, `modelfile`, `input_name`, `input_type` (+8 opcional)
`ml_regression`	Entrenamiento en línea + inferencia de una regresión de atributos a partir de una entrada de Ejemplos Etiquetados — predicción aprendida de máscara/etiqueta/valor sobre nubes de puntos y heightfields.	`input`, `examples`, `method` (+6 opcional)
`pca`	Análisis de Componentes Principales sobre atributos de puntos/volúmenes — compresión de características, análisis de espacio de formas y el front-end de preprocesado para ml_regression.	`input` (+6 opcional)
`ml_volume_upres`	Super-resolución volumétrica aprendida — simular en grueso, upres de detalle (canal de contenido pyro/fluido). modelfile es un .onnx confinado; configurado pero NO cocinado aquí (se resuelve en un cook posterior con un archivo de hash-pin).	`input`, `modelfile` (+5 opcional)
`acquire_model`	Descarga un modelo ONNX para las herramientas ML desde la lista de hosts permitidos de HuggingFace hacia /models/, verificado contra un sha256 fijado.	`repo`, `file`, `sha256` (+2 opcional)
`ml_example`	Empareja un Componente de Entrada (entrada 0) con un Componente de Destino (entrada 1, obligatorio) en un EJEMPLO de entrenamiento supervisado (ml_example) — el átomo de un dataset de ML (características -> objetivos).	`input`, `target` (+5 opcional)
`ml_extract_example`	Extrae un único ejemplo de entrenamiento (por índice) de un flujo de Ejemplos (ml_extractexample) — inspecciona/vista previa de una muestra.	`input` (+3 opcional)
`ml_attrib_generate`	Sintetiza valores de atributo aleatorizados sobre un prototipo (ml_attribgenerate) — aumenta datos de un conjunto de entrenamiento con entradas aleatorias controladas.	`input` (+6 opcional)
`ml_pose_generate`	Muestrea poses de esqueleto aleatorizadas desde un Prototipo de Pose (ml_posegenerate) — el generador de datos de entrenamiento para deformadores de espacio de poses / ML.	`input` (+4 opcional)
`ml_pose_serialize`	Aplana una pose de esqueleto en un ATRIBUTO de punto serial (ml_poseserialize) — convierte una pose de rig en el vector de características de longitud fija que consume un modelo de ML.	`input` (+9 opcional)
`ml_example_partition`	Divide un flujo de Ejemplos en partes no mayores que max_part_size (ml_examplepartition) — agrupa un conjunto de entrenamiento grande en fragmentos manejables.	`input` (+2 opcional)
`ml_deform`	SOLO CABLEADO: construye el deformador de personaje aprendido (ml_deform) — aplica un modelo ENTRENADO para deformar una piel, impulsado por una pose de esqueleto.	`input`, `modelfile` (+7 opcional)

Copernicus / COP

Herramienta	Qué hace	Parámetros clave
`cop_constant`	Generador COP: una capa de imagen de valor constante (Constant).	4 opcionales
`cop_fractal_noise`	Generador COP: ruido fractal (Fractal Noise) — la fuente de textura procedural principal. noise_type, métrica de distancia, amplitud, tamaño de elemento, octavas, lacunaridad, rugosidad, contraste.	9 opcionales
`cop_ramp`	Generador COP: un gradiente lineal/radial (Ramp). ramp_type, número de ciclos, fase y el método de fuera de rango.	5 opcionales
`cop_remap`	Filtro COP: reasignar el rango de valores de una capa (Remap). op=remap mapea input_min/max -> output_min/max con un método de fuera de rango; op=threshold usa threshold+width+side.	`input` (+10 opcionales)
`cop_invert`	Filtro COP: invertir una capa (Invert). method: complement (1-x), negate (-x) o reciprocal (1/x).	`input` (+2 opcionales)
`cop_equalize`	Filtro COP: normalizar el contraste estirando/desplazando el rango de una capa (Equalize). mode, fit_method, tipo de luminancia, puntos negro/blanco, promedio objetivo.	`input` (+7 opcionales)
`cop_blend`	Filtro COP: componer dos capas (Blend).	`input`, `fg` (+3 opcionales)
`cop_bright`	Filtro COP: ajuste de brillo/niveles (Bright). brightness multiplica, shift suma.	`input` (+3 opcionales)
`cop_hsv`	Filtro COP: ajuste de tono/saturación/valor o conversión RGB<->HSV (HSV Adjust). op, hue_shift, sat_scale, sat_shift, val_scale, val_shift.	`input` (+7 opcionales)
`cop_glow`	Filtro COP: resplandor/brillo desde áreas brillantes (Glow). threshold, ganancia de brillo, tamaño de desenfoque, filter (box/gaussian), units (image/pixels).	`input` (+7 opcionales)
`cop_quantize`	Filtro COP: posterizar una capa en pasos discretos (Quantize). method (width/segments), cantidad de segmentos o ancho, redondeo.	`input` (+5 opcionales)
`cop_blur`	Filtro COP: desenfocar una capa (Blur). size (radio), filter (box/gaussian), units (image/pixels).	`input` (+5 opcionales)
`cop_sdf_shape`	Generador COP: una forma 2D de campo de distancia con signo (SDF Shape) — círculo, rectángulo, estrella, triángulo, squircle y docenas más. shape_class elige la familia; `shape` es el nombre de la forma; scale la dimensiona; translate + rotate la posicionan.	6 opcionales
`cop_sdf_blend`	Filtro COP: combinar dos capas SDF (SDF Blend).	`input`, `b` (+6 opcionales)
`cop_sdf_to_mono`	Filtro COP: rasterizar un SDF en una capa mono (SDF To Mono) — valor de relleno, valor de fondo, contorno opcional (width + inside/outside/center), antialiasing.	`input` (+7 opcionales)
`cop_sdf_to_rgb`	Filtro COP: rasterizar un SDF en una capa de color (SDF To RGB) — contorno opcional (width + inside/outside/center), antialiasing, desplazamiento iso.	`input` (+6 opcionales)
`cop_sdf_adjust`	Filtro COP: ajustar un SDF (SDF Adjust) — iso_offset dilata/erosiona el campo, onion crea una cáscara hueca, abs lo hace de un solo lado, invert intercambia interior/exterior.	`input` (+5 opcionales)
`cop_id_to_sdf`	Filtro COP: construir un SDF a partir de una capa de ID/etiqueta (ID To SDF) — distancia al límite de ID más cercano. invert invierte el signo, iterations controla la propagación, tile_size el tamaño de bloque.	`input` (+4 opcionales)
`cop_median`	Filtro COP: filtro de mediana (Median) — elimina ruido sal y pimienta / moteado mientras conserva los bordes. size = tres o cinco píxeles; mask mezcla el resultado.	`input` (+3 opcionales)
`cop_streak_blur`	Filtro COP: desenfoque direccional/de movimiento a lo largo de una línea (Streak Blur). dir_type (angle/coord), angle, length, units, mode (on/min/max combine).	`input` (+8 opcionales)
`cop_kuwahara`	Filtro COP: filtro de Kuwahara (Kuwahara Filter) — suavizado pictórico que preserva bordes. radius (tamaño de región, píxeles), tipo de luminancia, blend, separation.	`input` (+6 opcionales)
`cop_compare`	Filtro COP: comparar una capa con un valor o una segunda capa, genera una máscara 0/1 (Compare).	`input` (+7 opcionales)
`cop_edge_detect`	Filtro COP: detección de bordes (Edge Detect). preblur suaviza antes de la detección, normalize escala la salida, los umbrales low/high filtran bordes débiles/fuertes; method + mode son selectores enteros.	`input` (+7 opcionales)
`cop_sharpen`	Filtro COP: nitidez (Sharpen) — amplifica el detalle mediante una máscara de desenfoque. amplitude, gain, threshold, size, units (image/pixels).	`input` (+6 opcionales)
`cop_tile_pattern`	Generador COP: un patrón de ladrillos/azulejos (Tile Pattern) — stackbond, herringbone, basketweave, flemishbond y más diseños de mampostería. pattern elige el diseño; mode (seamless/tilecount/tilesize); tiled_size la escala.	4 opcionales
`cop_sequence_blend`	Filtro COP: mezclar a través de una secuencia temporal (Sequence Blend) — estela de movimiento / promedio de fotogramas. blend = cantidad de mezcla, invert invierte.	`input` (+3 opcionales)
`cop_wipe`	Filtro COP: transición/cortinilla entre dos capas (Wipe).	`input`, `b` (+6 opcionales)
`cop_chromatic_aberration`	Filtro COP: aberración cromática de lente (Chromatic Aberration) — escala/rotación por canal para franjas R/G/B. r_scale/g_scale/b_scale, overall_scale, r_angle/g_angle/b_angle, filter.	`input` (+9 opcionales)
`cop_convolve`	Filtro COP: kernel de convolución 3x3 (Convolve) — sharpen/emboss/edge/custom.	`input` (+7 opcionales)
`cop_distort`	Filtro COP: deformar una capa (Distort) — empuja píxeles a lo largo de un ángulo (uniform) o mediante una capa de vector de distorsión conectada como `distortion` (entrada 1). angle, scale, dir_type, filter, border.	`input` (+7 opcionales)
`cop_derivative`	Filtro COP: gradiente de imagen / pendiente (Derivative) — tasa de cambio de la capa, para normales / bordes / relieve. angle, scale, offset, difference_mode (central/forward/diagonal).	`input` (+5 opcionales)
`cop_segment_connectivity`	Filtro COP: etiquetar regiones conectadas con IDs únicos (Segment By Connectivity) — interfaz para id_to_sdf / operaciones por región. connectivity (below/above/at/levels vs threshold), threshold, offset, collapse.	`input` (+5 opcionales)
`cop_segment_value`	Filtro COP: cuantizar una capa en bandas de valor etiquetadas (Segment By Value) — method (width o segments), ancho o cantidad de segmentos, rango min/max.	`input` (+6 opcionales)
`cop_smooth_fill`	Filtro COP: rellenar/extender regiones suavemente (Smooth Fill) — difunde valores de origen en el fill_area (inpaint / extender límites).	`input`, `fill_area` (+4 opcionales)
`cop_fill`	Filtro COP: relleno por inundación de una capa (Fill) — reemplaza con un valor/muestra. source (value/sample/first/last), color (valor de relleno), id.	`input` (+4 opcionales)
`cop_feather`	Filtro COP: difuminar/suavizar bordes de máscara (Feather) — direction (diamond/square/oct/circle), decay_mode (unitdist/decay), decay, unit_distance; outside difumina hacia afuera.	`input` (+6 opcionales)
`cop_light`	Filtro COP: sombrear una capa con una capa de normales (Light).	`input`, `normals` (+4 opcionales)
`cop_bokeh`	Filtro COP: bokeh / desenfoque de profundidad de campo (Bokeh) — radius, gain (realce de brillos), resolution, kernel de filtro, normalize.	`input` (+6 opcionales)
`cop_dilate_erode`	Filtro COP: dilatación/erosión morfológica (Dilate Erode) — radio positivo agranda áreas brillantes, negativo las encoge; soft_edge difumina; fill cierra agujeros.	`input` (+5 opcionales)
`cop_channel_extract`	Filtro COP: extraer un solo canal en una capa mono (Channel Extract). channel = índice (0=R,1=G,2=B,3=A).	`input` (+2 opcionales)
`cop_channel_swap`	Filtro COP: barajar canales (Channel Swap) — establece cada canal de salida a cualquier canal de origen o cero/uno.	`input` (+5 opcionales)
`cop_mono_to_rgb`	Filtro COP: mapear una capa mono a RGB mediante un rango de valores (Mono To RGB). input_min/max -> output_min/max, method (clamp/repeat).	`input` (+6 opcionales)
`cop_mono_to_rgba`	Filtro COP: promover una capa a RGBA (Mono To RGBA) — alpha_mode extend (copiar valor) o value (alpha_value constante).	`input` (+3 opcionales)
`cop_premult`	Filtro COP: premultiplicar / despremultiplicar alfa (Premult). op = mult (premultiplicar) o divide (despremultiplicar).	`input` (+2 opcionales)
`cop_crop`	Filtro COP: recortar una capa (Crop). crop_min/crop_max = las esquinas [x,y] (unidades de imagen 0..1); mode (data/both/display), manejo de bordes.	`input` (+5 opcionales)
`cop_tonemap`	Filtro COP: mapeo tonal de HDR a rango de visualización (Tonemap). operator = índice 0..5 (curvas estilo Reinhard / Hable / ACES), exposure ajusta la pre-ganancia.	`input` (+3 opcionales)
`cop_contrast`	Filtro COP: ajuste de contraste (Contrast) — fuerza de contraste alrededor de un punto central.	`input` (+3 opcionales)
`cop_gamma`	Filtro COP: corrección gamma (Gamma) — valor gamma, invert opcional.	`input` (+3 opcionales)
`cop_transform`	Filtro COP: transformar una capa en 2D/3D (Transform). translate/rotate/scale_xyz/shear/pivot (cada uno [x,y,z]), escala uniforme, orden de transformación+rotación, invert, manejo de bordes y filtro de reconstrucción.	`input` (+12 opcionales)
`cop_color_correct`	Filtro COP: corrección de color por rango tonal (Color Correct).	`input` (+10 opcionales)
`cop_checkerboard`	Generador COP: patrón de prueba de tablero de ajedrez (Checkerboard). divisiones rows/cols, colores de casillas pares/impares [r,g,b], translate/tile_size/bias ([x,y]).	8 opcionales
`cop_clamp`	Filtro COP: limitar valores a un límite inferior/superior (Clamp).	`input` (+5 opcionales)
`cop_channel_join`	Combinador COP: fusionar capas mono separadas en una capa RGB/RGBA (Channel Join).	`inputs` (+3 opcionales)
`cop_chroma_key`	Filtro COP: keyer de pantalla verde/azul por rango HSV (Chroma Key) -> matte. hue_circle [4] (centro+ancho de hue/sat), lum_range [min,max], bordes suaves hue/sat/lum rolloff, interpolation (función de rolloff 0..4), preview + preview_color [r,g,b], premult (multiplica la entrada por el matte).	`input` (+10 opcionales)
`cop_histogram`	Filtro COP: renderizar un histograma de valores de la entrada como imagen (Histogram). mode (colorbar/separatebar/graph), buckets, rango min/max, outside (discard/clamp), scale; set_res + res [w,h] para anular la resolución de salida.	`input` (+9 opcionales)
`cop_vignette`	Filtro COP: oscurecer/aclarar hacia el borde del encuadre (Vignette). shape (round/rectangle/blend), brightness, circle_radius/circle_scale [x,y], cantidad de blend, rect_size [x,y]/rect_roundness, center [x,y], blur, mask.	`input` (+11 opcionales)
`cop_height_to_normal`	Filtro COP: derivar una capa de mapa de normales a partir de una capa mono de altura (Height to Normal) -- alimenta cop_light `normals` para sombreado de relieve. normal_type (signed/offset), scale (ganancia de altura), read_outside, kernel (distancia de derivada).	`input` (+5 opcionales)
`cop_mirror`	Filtro COP: espejo/caleidoscopio de una capa a través de uno o más planos (Mirror). mode 0 = planos personalizados (angle0/offset0/flip0), 1 = número-y-desplazamiento (num_planes + angle/offset); flip reflexión.	`input` (+9 opcionales)
`cop_average`	Combinador COP: combinar muchas capas de entrada con una operación (Average). operation (add/average/multiply/min/max/over), `inputs` = rutas de nodos COP conectadas 0..n, signature = tipo de capa de salida.	`inputs` (+3 opcionales)
`cop_worley_noise`	Generador COP: ruido celular/Worley (Voronoi) (Worley Noise) -- complementa cop_fractal_noise. element_size (tamaño de celda), jitter, lattice (grid/hex), metric, offset [x,y], tiled + tile_size [x,y]; post bias/gain/contrast (auto-habilitados), complement.	12 opcionales
`cop_julia`	Generador COP: fractal de conjunto de Julia (Julia). real/imag = la constante de Julia; escape_radius + max_iter controlan la prueba de escape; scale [x,y].	7 opcionales
`cop_chladni`	Generador COP: patrón nodal de ondas estacionarias tipo Chladni / cimático (Chladni). salida (líneas/abs/sdf), umbral+anchura (modo de línea nodal), amp/amp_ratio, freq/freq_ratio, tile_size [x,y].	9 opcionales
`cop_bubble_noise`	Generador COP: ruido fractal burbuja/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; sesgo posterior (auto-habilitado).	14 opcionales
`cop_crystal_noise`	Generador COP: ruido cristalino facetado derivado de Worley (Crystal Noise). amp/center/contrast, métrica, jitter, element_size, secundario + metric2, flatten_faces, enlosado + tile_size [x,y], use_3d.	14 opcionales
`cop_phasor_noise`	Generador COP: campo de ondas y ruido procedural fasor/Gabor (Phasor Noise). tipo (phasorwave/phasornoise/gabornoise/intensityfield), wave_type (sine/rectangle/saw), amp/center, element, wave_bias, blend, offset [x,y], seed, kernels, rotación (uniforme/variante), use_3d.	14 opcionales
`cop_height_to_ao`	Filtro COP (relieve de terreno): horneado de oclusión ambiental desde una capa de altura monocromática (Height to Ambient Occlusion). height_scale, view_radius (distancia de rayo), step_scale, ray_count, hemisferio.	`input` (+6 opcionales)
`cop_height_to_shadow`	Filtro COP (relieve de terreno): mapa de sombras proyectadas desde una capa de altura monocromática + perfil de luz (Height to Shadow). light_type (disco/esfera/direccional), coord_mode (esférico/cartesiano), azimuth/elevación/distancia (esférico) o posición [x,y,z] (cartesiano), radio, height_scale, view_radius, step_scale.	`input` (+11 opcionales)
`cop_curvature`	Filtro COP (relieve de terreno): curvatura de superficie desde una capa de normal/altura (Curvature). método (índice 0/1), curvature_type (gaussiana/media/principal_máx/principal_mín), output_type (índice 0/1/2), normal_type (con signo/desplazado), prescale/postscale, kernel, read_outside, normalizar + límite mín/máx.	`input` (+13 opcionales)
`cop_slope_dir`	Filtro COP (relieve de terreno): campo de dirección de pendiente (aspecto) desde una capa de altura monocromática (Slope Direction). ángulo (post-rotación), escala (ajuste de escala de altura), read_outside, kernel.	`input` (+5 opcionales)
`cop_resample`	Filtro COP: redimensionar/remuestrear una capa (Resample). size_control (res/aspect/pixel), base_size (parm/input), resolución [w,h], aspect [x,y] + aspect_preset, pixel_size, escala, fixed_side, filtro (reconstrucción), modo de estiramiento, reencuadre.	`input` (+12 opcionales)
`cop_mono`	Filtro COP: combinar canales en una única capa monocromática/luminancia (Mono). op (lum/ntsclum/hdtvlum/average/max/min/magnitude/hue/saturation/value/red/green/blue/comp4/custom); al proporcionar `weight` [4] se establece op=custom + pesos por canal; normalize_weight.	`input` (+4 opcionales)
`cop_hextile`	Filtro COP: mosaico de textura hexagonal sin costuras (Hex Tile).	11 opcionales
`cop_convert_normal`	Filtro COP: convertir una capa de mapa de normales entre codificaciones (Convert Normal). conversión (tosigned -1..1 / tooffset 0..1), normalizar, desplazamiento [x,y,z], escala [x,y,z].	`input` (+5 opcionales)
`cop_combine_normals`	Combinador COP: capa/mezclado de dos mapas de normales en espacio tangente (Combine Normals).	`input`, `fg` (+4 opcionales)
`cop_edge_detect_normal`	Filtro COP: bordes de tinta/contorno desde discontinuidades angulares de una capa de normales (Edge Detect Normal). tolerancia, thickness_scale, weight_spread, desenfoque, min_probe_radius.	`input` (+6 opcionales)
`cop_edge_detect_depth`	Filtro COP: bordes de pliegue/oclusión desde pasos de profundidad Z (Edge Detect Depth). tolerancia, thickness_scale, weight_spread, desenfoque, min_probe_radius.	`input` (+6 opcionales)
`cop_edge_detect_contour`	Filtro COP: bordes de silueta/contorno desde discontinuidades de valor (Edge Detect Contour). tolerancia, thickness_scale, weight_spread, desenfoque, min_probe_radius.	`input` (+6 opcionales)
`cop_swirl`	Filtro COP: deformación espiral + abultamiento de lente (Swirl).	`input` (+14 opcionales)
`cop_pixelate`	Filtro COP: mosaico / cuantización de bloques de una capa (Pixelate). modo (índice 0/1), unidades (imagen/píxeles), block_size o num_blocks [x,y], offset [x,y], máscara; preblur + preblur_size.	`input` (+9 opcionales)
`cop_defocus`	Filtro COP: desenfoque de cámara físicamente parametrizado + bokeh (Defocus).	`input`, `depth` (+12 opcionales)
`cop_flip`	Filtro COP: reflejar una capa (Flip). horizontal (xflip), vertical (yflip), diagonal (flop), máscara.	`input` (+5 opcionales)
`cop_polar_to_uv`	Generador COP: convertir coordenadas polares (ángulo, longitud) a una capa UV (Polar to UV). angle_unit (rad/deg/tau), ángulo, longitud.	4 opcionales
`cop_random_mono`	Generador COP: campo monocromático aleatorio (Random Mono). range_method (minmax/ramp/specific), mín/máx, per_pixel, seed, tiempo.	7 opcionales
`cop_random_rgb`	Generador COP: campo de color aleatorio (Random RGB). range_method (minmax/ramp/specific), color_model (rgb/hsv), base_color [r,g,b] (habilita color base), rangos aleatorios por canal rand_r/g/b o rand_hue/sat/val (cada [min,max]), per_pixel, seed.	12 opcionales
`cop_triplanar`	Filtro COP: proyección triplanar de una textura en espacio mundial (Triplanar).	`texture`, `position`, `normal` (+15 opcionales)
`cop_triplanar_uv`	Filtro COP: coordenadas UV triplanares desde un pase de posición mundial + normal (Triplanar UV).	`position`, `normal` (+2 opcionales)
`cop_triplanar_hextile`	Filtro COP: proyección triplanar con aleatorización de mosaico hexagonal por celda (Triplanar Hex Tile).	`input` (+11 opcionales)
`cop_uv_map`	Generador COP: generar una capa UV (UV Map). uv_space (textura/imagen/píxel), u_border/v_border (clamp/mirror/wrap/extend), u_shift/u_cycle, v_shift/v_cycle.	8 opcionales
`cop_pos_map`	Generador COP: generar una capa de posición mundial (Position Map). fuente (pos/origin/view), borde por eje x/y/z (clamp/mirror/wrap/extend), desplazamiento x/y/z + ciclo, firma (mono/vec3/...).	12 opcionales
`cop_corner_pin`	Filtro COP: deformación de esquinas de perspectiva (Corner Pin).	`input` (+6 opcionales)
`cop_lens_distort`	Filtro COP: distorsión/desdistorsión de lente radial + tangencial (Lens Distort). k1..k6 = coeficientes radiales, p1/p2 = tangenciales, centro [x,y], escala [x,y], aspect, máscara.	`input` (+13 opcionales)
`cop_uv_to_polar`	Filtro COP: convertir una capa UV a coordenadas polares (ángulo, longitud) (UV to Polar) -- inverso de cop_polar_to_uv. angle_unit (rad/deg/tau).	`input` (+2 opcionales)
`cop_fractal_noise_3d`	Generador COP: ruido fractal en espacio mundial (muestreo 3D) (Fractal Noise 3D). noise_type (simplex/perlin/worleyA/worleyB/white/alligator), métrica, amp/center/contrast, element_size, octaves, lacunarity, roughness, jitter, offset [x,y,z]; sesgo/ganancia posterior (auto-habilitado), complemento.	16 opcionales
`cop_worley_noise_3d`	Generador COP: ruido celular/Worley en espacio mundial (Worley Noise 3D). element_size/element_scale, jitter/jitter_scale, métrica, offset [x,y,z]; sesgo/ganancia posterior (auto-habilitado), complemento.	11 opcionales
`cop_crystal_noise_3d`	Generador COP: ruido cristalino facetado Worley en espacio mundial (Crystal Noise 3D). métrica, amp/center/contrast, jitter, element_size, secundario + metric2, flatten_faces, offset [x,y,z], firma.	12 opcionales
`cop_cloud_noise_3d`	Generador COP: ruido de nubes abullonado en espacio mundial (Cloud Noise 3D). amp/center, element_size, offset [x,y,z], max_octaves, lacunarity, roughness, distort, stretch [x,y,z], droop (auto-habilita), fold, firma; sesgo posterior (auto-habilitado).	14 opcionales
`cop_xform_2d`	Filtro COP: transformación de imagen 2D (Transform 2D). traslación [x,y], rotación, scale_xy [x,y] + escala uniforme, cizallamiento, pivote [x,y]; xform_order, borde, filtro, invertir.	`input` (+11 opcionales)
`cop_vector_xform`	Filtro COP: transformar los VALORES de vectores de 3 componentes en una capa (Vector Transform) -- para capas de normal/posición/velocidad. traslación/rotación/scale_xyz/cizallamiento/pivote (cada [x,y,z]), escala uniforme, xform_order, rot_order, invertir.	`input` (+10 opcionales)
`cop_vector_xform_2d`	Filtro COP: transformar los VALORES de vectores de 2 componentes en una capa (Vector Transform 2D) -- para capas UV/flujo. traslación [x,y], rotación, scale_xy [x,y] + escala uniforme, cizallamiento, pivote [x,y], xform_order, invertir.	`input` (+9 opcionales)
`cop_space_transform`	Filtro COP: convertir valores de capa entre espacios de coordenadas (Space Transform). vector_type (posición/vector), src_space + dst_space (buffer/pixel/textura/imagen/mundo).	`input` (+4 opcionales)
`cop_bend`	Filtro COP: doblar/deformar una capa (Bend).	`input` (+15 opcionales)
`cop_id_to_mask`	Filtro COP: construir una máscara 0/1 desde IDs seleccionados (ID to Mask).	`input` (+10 opcionales)
`cop_mono_to_sdf`	Filtro COP: convertir una capa monocromática a un campo de distancia con signo sobre un umbral iso (Mono to SDF). invertir, iso, iteraciones, tile_size.	`input` (+5 opcionales)
`cop_denoise_tvd`	Filtro COP: desenfoque de difusión de variación total (Denoise TVD) -- matemática pura, NO un modelo de IA. iteraciones, velocidad, máscara.	`input` (+4 opcionales)
`cop_fill_connected`	Filtro COP: relleno por inundación de una región conectada desde una semilla dentro de una tolerancia (Fill Connected). seed_location [x,y], source_location [x,y], tolerancia, fuente (valor/muestra/primera/última), color [r,g,b,a], id.	`input` (+7 opcionales)
`cop_ill_pixel`	Filtro COP: detectar/corregir/marcar píxeles ilegales (Illegal Pixel). método (fixblend/fixzero/highlight/isolate), detectar (d_nan/d_inf/ambos/personalizado), regla (less/lessequal/greater/greaterequal/equal), compare_value, highlight_color [r,g,b,a].	`input` (+6 opcionales)
`cop_bound_rect`	Filtro COP: máscara de rectángulo delimitador alrededor de píxeles que superan un umbral (Bound Rect). lado (menor/mayor), umbral, fg/bg, unidades (imagen/textura/píxel).	`input` (+6 opcionales)
`cop_hyperbolic_tile`	Generador COP: mosaico hiperbólico de polígono regular (disco de Poincaré) (Hyperbolic Tiling). iteraciones, polígono (lados), mapeo (conforme/rejilla elíptica/squircle/área igual), aplanamiento, tamaño, tile_fitting, rectanglize/stretch_to_fit/disk_mask.	10 opcionales
`cop_convert_depth`	Filtro COP: convertir una capa entre codificaciones de profundidad / distancia / altura (Convert Depth). fuente + destino (depth/dist/height), zero_depth.	`input` (+4 opcionales)
`cop_zcomp`	Compositor COP: componer dos capas por profundidad Z, gana la superficie más cercana (Z Composite).	`input`, `fg` (+5 opcionales)
`cop_uv_map_by_id`	Filtro COP: mapa UV por isla (o centro/mín/máx/tamaño) desde una capa de ID (UV Map by ID).	`input` (+11 opcionales)
`cop_project_on_layer`	Filtro COP: reproyectar una capa fuente en el espacio de una capa objetivo (Project on Layer).	`input`, `source` (+4 opcionales)
`cop_contact_sheet`	Combinador COP: enlosar muchas capas de entrada en un montaje / hoja de contactos (Contact Sheet).	`inputs` (+8 opcionales)
`cop_copy_xform`	Filtro COP: estampar N copias transformadas de una forma (Copy Transform).	`input` (+14 opcionales)
`cop_lattice_deform`	Filtro COP: deformar una capa mediante una rejilla 4x4 (Lattice Deform).	`input` (+6 opcionales)
`cop_surface_dither`	Filtro COP: patrón de tramado/medio tono estable en superficie -> máscara o SDF (Surface Dither).	`input` (+10 opcionales)
`cop_sample`	Filtro COP: remuestrear una textura a través de un mapa UV (Sample).	`input`, `texture` (+4 opcionales)
`cop_prefix_sum`	Filtro COP: escaneo direccional acumulativo a través de la imagen (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: calcular estadísticas por capa (min/max/avg/...) como atributos de capa (Statistics), legibles por nodos posteriores.	`input` (+1 opcional)
`cop_layer_properties`	Filtro COP: establecer metadatos de precisión / borde / tipo de información de una capa (Layer Properties). precision (b8/b16/b32), border (constant/clamp/mirror/wrap), type_info (color/position/normal/id/mask/sdf/height/...) — cada uno habilita automáticamente su setter.	`input` (+4 opcional)
`cop_rgb_to_rgba`	Filtro COP: unir una capa RGB con una capa alfa → RGBA (RGB to RGBA).	`input` (+3 opcional)
`cop_rgba_to_rgb`	Filtro COP: eliminar el canal alfa → RGB (RGBA to RGB). unpremult (despremultiplicar primero).	`input` (+2 opcional)
`cop_id_to_mono`	Filtro COP: convertir una capa de IDs en una capa mono flotante (ID to Mono). conversion (cast/safe/bitwise).	`input` (+2 opcional)
`cop_mono_to_id`	Filtro COP: convertir una capa mono en una capa de IDs (Mono to ID). conversion (cast/safe/bitwise).	`input` (+2 opcional)
`cop_id_to_rgb`	Filtro COP: asignar un color aleatorio por ID (ID to RGB). seed.	`input` (+2 opcional)
`cop_rgb_to_uv`	Filtro COP: reinterpretar una capa RGB como capa UV (vector de 2 componentes) (RGB to UV).	`input` (+1 opcional)
`cop_uv_to_rgb`	Filtro COP: reinterpretar una capa UV como RGB (UV to RGB); la capa opcional `mono` → la entrada 1 suministra el canal azul.	`input` (+2 opcional)
`cop_rgba_to_uv`	Filtro COP: reinterpretar una capa RGBA como capa UV (vector de 2 componentes) (RGBA to UV).	`input` (+1 opcional)
`cop_uv_to_rgba`	Filtro COP: unir dos capas de 2 vectores en RGBA (UV to RGBA).	`input` (+2 opcional)
`cop_channel_split`	Filtro COP: dividir una capa multicanal en salidas de un solo canal (Channel Split) — el inverso de cop_channel_join.	`input` (+1 opcional)
`cop_layer_attrib_create`	Filtro COP: añadir un atributo de metadatos de capa (Layer Attribute Create). attr_name, attr_type (string/float/int), value (tipado acorde).	`input` (+4 opcional)
`cop_layer_attrib_delete`	Filtro COP: eliminar atributos de metadatos de capa por glob de nombre (Layer Attribute Delete). delete (glob a eliminar), keep (glob a conservar).	`input` (+3 opcional)
`cop_dot`	Filtro COP: producto punto por píxel de dos capas vectoriales → mono (Dot).	`input`, `b` (+1 opcional)
`cop_cross`	Filtro COP: producto cruz por píxel de dos capas vec3 (Cross).	`input`, `b` (+1 opcional)
`cop_pos_sample`	Filtro COP: muestrear una textura en coordenadas leídas desde una capa de posición (Position Sample).	`input`, `texture` (+1 opcional)
`cop_statistics_by_id`	Filtro COP: estadísticas por ID calculadas como atributos de capa (Statistics by ID).	`input`, `source` (+1 opcional)
`cop_match_udim`	Filtro COP: reubicar una imagen en un mosaico UDIM elegido (Match UDIM). udim (número de mosaico, habilita set_udim), invert, method (eye/data).	`input` (+4 opcional)
`cop_autostereogram`	Filtro COP: construir un autoestereograma Magic-Eye a partir de una imagen de patrón + profundidad (Autostereogram).	`input`, `depth` (+5 opcional)
`cop_uv_xform`	Filtro COP: trasladar/rotar/escalar una capa UV (UV Transform). translate [x,y], rotate, scale_xy [x,y] + escala uniforme, pivot [x,y], seed.	`input` (+7 opcional)
`cop_layer`	Generador COP: una capa tipada en blanco a una resolución/precisión elegida (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: distorsión de neblina de calor a partir de ruido interno (Heat Distort). global_scale, scale, element_size, detail_scale, roughness, cutoff, angle; interruptores distort/detail_distort/streak_blur, mask.	`input` (+12 opcional)
`cop_heat_distort_by_layer`	Filtro COP: distorsión de neblina de calor impulsada por una capa `noise` (Heat Distort by Layer).	`input`, `noise` (+9 opcional)
`cop_heightfield_visualize`	Filtro COP: escalar/desplazar una capa de campo de altura entrante para visualización (Heightfield Visualize). height_scale, height_offset.	`input` (+3 opcional)
`cop_sop_import`	Generador COP: conectar un SOP de la escena al copnet (SOP Import).	`sop` (+1 opcional)
`cop_rasterize_geo`	COP: rasterizar atributos de geometría en una capa de imagen (Rasterize Geometry).	`geometry` (+6 opcional)
`cop_rasterize_setup`	COP: configurar la cámara / espacio de rasterización que precede a Rasterize Geometry (Rasterize Setup).	`geometry` (+7 opcional)
`cop_rasterize_curves`	COP: rasterizar geometría de curvas como trazos en una capa (Rasterize Curves).	`curves` (+10 opcional)
`cop_layer_to_geo`	COP: convertir una capa COP de vuelta en geometría SOP (Layer to Geometry) — un primitivo volume/VDB.	`input` (+3 opcional)
`cop_layer_to_points`	COP: emitir puntos SOP desde una capa COP (Layer to Points).	`input` (+6 opcional)
`cop_layer_from_curves`	COP: trazos coloreados/perfilados desde geometría de curvas hacia una capa (Layer from Curves).	`curves` (+7 opcional)
`cop_mask_from_curves`	COP: máscara o SDF desde geometría de curvas (Mask from Curves).	`curves` (+7 opcional)
`cop_geo_to_layer`	COP: leer un primitivo/VDB nombrado desde geometría hacia una capa tipada (Geometry to Layer).	`geometry` (+3 opcional)
`cop_vdb_posmap`	COP: mapa de posiciones de vóxeles VDB (VDB Pos Map).	`input` (+3 opcional)
`cop_layer_from_vdb`	COP: convertir una capa FloatVDB en una capa COP muestreada (Layer from VDB).	`input` (+2 opcional)
`cop_vdb_from_layer`	COP: convertir una capa COP en un VDB, dimensionado según un VDB de referencia (VDB from Layer).	`input`, `reference_vdb` (+2 opcional)
`cop_rasterize_volume`	COP: raymarch de una capa VDB de densidad en una imagen (Rasterize Volume).	`input` (+8 opcional)
`cop_integrate_volume`	COP: integración por rayos de una capa de volumen a mono (Integrate Volume) — depth / thickness.	`input` (+6 opcional)
`cop_pyro_configure`	Pirosimulación COP: definir la rejilla de vóxeles de la simulación (Pyro Configure).	8 opcional
`cop_pyro_source_from_layer`	Pirosimulación COP: emitir en un campo desde una capa fuente (Pyro Source from Layer).	`input`, `density` (+12 opcional)
`cop_pyro_source_from_points`	Pirosimulación COP: emitir en un campo desde una fuente de puntos (Pyro Source from Points).	`input`, `points` (+8 opcional)
`cop_pyro_advect`	Pirosimulación COP: advectar un campo mediante una velocidad VectorVDB (Pyro Advect).	`input`, `velocity` (+12 opcional)
`cop_pyro_buoyancy`	Pirosimulación COP: añadir fuerza de flotabilidad impulsada por temperatura a la velocidad (Pyro Buoyancy).	`input`, `temperature` (+13 opcional)
`cop_pyro_dissipate`	Pirosimulación COP: disipar un campo con el tiempo (Pyro Dissipate).	`input` (+17 opcional)
`cop_pyro_disturbance`	Pirosimulación COP: añadir detalle de perturbación a la velocidad (Pyro Disturbance).	`input` (+12 opcional)
`cop_pyro_turbulence`	Pirosimulación COP: añadir detalle de turbulencia / ruido curl a la velocidad (Pyro Turbulence).	`input` (+15 opcional)
`cop_pyro_uniform_force`	Pirosimulación COP: aplicar una fuerza direccional uniforme / arrastre a la velocidad (Pyro Uniform Force).	`input` (+13 opcional)
`cop_pyro_activate`	Pirosimulación COP: crecer / activar la región de vóxeles activos de la simulación (Pyro Activate).	`input` (+12 opcional)
`cop_pyro_advect_by_map`	Pirosimulación COP: advectar un campo mediante un mapa de advección directa/inversa precalculado (Pyro Advect by Map).	`input`, `fwd_map` (+5 opcional)
`cop_pyro_build_advection_map`	Pirosimulación COP: construir un mapa de advección directa/inversa desde un campo de velocidad (Pyro Build Advection Map).	`input` (+7 opcional)
`cop_pyro_axis_force`	Pirosimulación COP: fuerza de vórtice / eje / órbita alrededor de un eje (Pyro Axis Force).	`input` (+17 opcional)
`cop_pyro_light_ambient`	Pirosimulación COP: contribución de luz ambiental / de entorno en un campo de densidad (Pyro Light Ambient).	`input` (+14 opcional)
`cop_pyro_light_from_points`	Pirosimulación COP: dispersión de luz puntual / direccional en un campo de densidad (Pyro Light from Points).	`input` (+14 opcional)
`cop_pyro_light_scatter`	Pirosimulación COP: luz de dispersión múltiple a través de densidad + emisión (Pyro Light Scatter).	`input` (+8 opcional)
`cop_pyro_project_electrostatic`	Pirosimulación COP: hacer un campo de velocidad no divergente mediante proyección electrostática (Pyro Project Non Divergent Electrostatic).	`input`, `reference` (+12 opcional)
`cop_pyro_packed_mipmap`	Pirosimulación COP: construir un mipmap de densidad empaquetado (Pyro Packed Mipmap) — el acelerador que alimenta la entrada `mipmap` de los microsolvers de luz (cop_pyro_light_ambient / cop_pyro_light_from_points).	`input` (+3 opcional)
`cop_pyro_block_begin`	Pirosimulación COP: inicio del bucle de bloque de retroalimentación pyro (Pyro Block Begin) — siembra el estado de campo por iteración.	`input`, `velocity`, `temperature` (+11 opcional)
`cop_pyro_block_end`	Pirosimulación COP: fin del bucle de bloque de retroalimentación pyro (Pyro Block End) — cierra el bucle y contiene los controles del bucle.	`input`, `velocity`, `temperature`, `block_begin` (+14 opcional)
`cop_pyro_solver`	MACRO de pirosimulación COP (una llamada): estampar un BUCLE mínimo de solve de retroalimentación pyro nativo de COP — conecta automáticamente cop_pyro_block_begin (inicio del bucle, siembra densidad/v/temperatura por iteración) → un CUERPO mínimo de pyro-advect (advecta la densidad del bucle mediante la velocidad del bucle) → cop_pyro_block_end (cierra el bucle, contiene los controles del bucle), y establece el enlace de bloque begin<->end.	`input`, `velocity`, `temperature` (+6 opcional)
`cop_vdb_leafpoints`	COP: emitir puntos en los centros de hojas/vóxeles VDB (VDB Leaf Points).	`input` (+2 opcional)
`cop_layer_to_vdb_leafpoints`	COP: puntos de muestreo de hojas VDB desde una capa (Layer to VDB Leaf Points).	`input`, `thickness_layer` (+3 opcional)
`cop_vdb_activate_from_points`	COP: activar regiones de vóxeles VDB desde posiciones de puntos (VDB Activate from Points).	`input`, `points` (+5 opcional)
`cop_vdb_reshape`	COP: conformar un VDB a la transformación / marco de topología de un VDB de referencia (VDB Reshape).	`input`, `reference` (+1 opcional)
`cop_stamp_point`	COP: estampar una capa en posiciones de puntos (Stamp Point).	`points`, `stamps` (+17 opcional)
`cop_curve_scatter`	COP: dispersar estampados a lo largo de curvas (Curve Scatter).	`curves`, `stamps` (+18 opcional)
`cop_shape_scatter`	COP: dispersar estampados a través de una rejilla de imagen (Shape Scatter) — no se necesita geometría.	`stamps` (+18 opcional)
`cop_rasterize_layer`	COP: re-rasterizar / reproyectar una capa existente (Rasterize Layer).	`input` (+5 opcional)
`cop_vdb_visualize`	COP: sombrear un VDB de densidad en una imagen (VDB Visualize).	`input` (+10 opcional)
`cop_vdb_visualize_slice`	COP: visualización VDB de plano de corte (VDB Visualize Slice).	`input` (+9 opcional)
`cop_vdb_visualize_tree`	COP: visualización VDB de árbol / topología (VDB Visualize Tree).	`input` (+8 opcional)
`cop_vdb_visualize_velocity`	COP: visualización VDB de campo de velocidad (VDB Visualize Velocity).	`input` (+9 opcional)
`cop_raytrace`	COP: raytrace de geometría a mapas de AO / curvatura / grosor / cavidad / borde (Raytrace).	`geometry`, `origins`, `directions` (+16 opcional)
`cop_bake_geometry_textures`	COP: hornear mapas de normal/AO/curvatura/posición/grosor/altura desde geometría (Bake Geometry Textures).	`low` (+17 opcional)
`cop_file`	COP generator: leer una imagen desde disco (File).	`filename` (+1 opcional)
`cop_rop_image`	COP output driver: escribir el flujo COP de entrada en una imagen en disco (ROP Image Output).	`input`, `output` (+3 opcional)
`cop_font`	COP: renderizar texto como una imagen (Font).	4 opcional
`cop_onnx`	COP: ejecutar inferencia de modelo ONNX sobre una imagen (ONNX Inference).	`input` (+2 opcional)
`cop_slapcomp_import`	COP: extraer el buffer de render slap-comp en memoria (Slap Comp Import).	4 opcional
`cop_cache`	COP: un caché en memoria por fotograma de la capa de entrada (Cache).	`input` (+3 opcional)
`cop_fetch`	COP generator: obtener la salida de otro nodo COP por ruta (Fetch).	2 opcional
`cop_camera_import`	COP generator: importar los parámetros de una cámara de escena (Camera Import).	2 opcional
`cop_ocio_transform`	COP: aplicar una transformación de espacio de color OpenColorIO (OCIO Transform).	`input` (+5 opcional)
`cop_live_video`	COP generator: capturar fotogramas de un dispositivo de video/webcam en vivo (Live Video).	3 opcional
`cop_denoise_ai`	COP: reducir ruido con IA de la capa de entrada (Denoise AI).	`input` (+2 opcional)
`cop_cryptomatte`	COP filter: extraer una mate de cobertura única de una capa cryptomatte (Cryptomatte).	`input` (+3 opcional)
`cop_cryptomatte_decode`	COP filter: decodificar una capa cryptomatte empaquetada en pares de id/rango de cobertura (Cryptomatte Decode).	`input` (+1 opcional)
`cop_cryptomatte_encode`	COP filter: codificar pares de id/rango de cobertura en una capa cryptomatte empaquetada (Cryptomatte Encode).	`input`, `cov_a`, `id_b`, `cov_b` (+1 opcional)
`cop_grunge_aurora`	COP generator: patrón de desgaste aurora/vetado (Grunge Aurora).	21 opcional
`cop_grunge_birchbark`	COP generator: patrón de material de corteza de abedul (Grunge Birch Bark).	24 opcional
`cop_grunge_layered_noise`	COP generator: ruido compuesto de 4 capas (Grunge Layered Noise) — ruido base + células base + ruido secundario + células secundarias.	29 opcional
`cop_grunge_pinebark`	COP generator: patrón de material de corteza de pino (Grunge Pine Bark).	21 opcional
`cop_grunge_rust`	COP generator: patrón de óxido/corrosión (Grunge Rust).	22 opcional
`cop_cable_merge`	COP: combinar dos cables Copernicus (Cable Merge) — `input` = input_cable (entrada 0), `reference` = el segundo cable (entrada 1). operation (unión/intersección/diferencia/copia/unión total/renombrar) controla cómo se combinan los dos conjuntos de cables.	`input` (+3 opcional)
`cop_cable_split`	COP: particionar los cables de un cable Copernicus en dos cables (Cable Split).	`input` (+16 opcional)
`cop_cable_pack`	COP: ensamblar cables con nombre en un solo cable Copernicus (Cable Pack).	`input` (+2 opcional)
`cop_cable_unpack`	COP: extraer cables con nombre de un cable Copernicus (Cable Unpack).	`input` (+2 opcional)
`cop_cable_filter`	COP: eliminar cables vacíos de un cable Copernicus (Cable Filter).	`input` (+1 opcional)
`cop_cable_sort`	COP: ordenar alfabéticamente los cables de un cable por nombre (Cable Sort).	`input` (+2 opcional)
`cop_cable_switch`	COP: seleccionar uno de dos cables (Cable Switch).	`input` (+3 opcional)
`cop_cable_rename`	COP: renombrar los cables de un cable mediante reemplazo de patrón (Cable Rename).	`input` (+5 opcional)

Imagen / textura

Herramienta	Qué hace	Parámetros clave
`sbs_archive`	SideFX Labs SBS Archive — un GENERADOR Cop2 que lee un archivo Substance `.sbsar` y produce su textura renderizada en el cop2net compartido /obj/cops2.	3 opcionales
`blackbody_texture`	SideFX Labs Blackbody (labs::blackbody_cop) — un generador Cop2 que mapea la temperatura (Kelvin) al color de cuerpo negro emitido a través de la imagen, desde temperature_low hasta temperature_high, con controles de tonemap / gamma / adaptación / burn.	12 opcionales
`attribute_to_texture`	SideFX Labs Attribute Import (labs::attribute_import) — un generador Cop2 que rasteriza un ATRIBUTO de punto/vértice de geometría en una textura sobre el layout UV de la geometría.	6 opcionales
`grid_texture`	SideFX Labs Grid Texture (labs::grid_texture) — un generador Cop2 que produce una textura de referencia de cuadrícula/ajedrez UV con texto, bordes y colores opcionales por mosaico.	12 opcionales
`normal_color`	SideFX Labs Normal Color (labs::normal_color) — un generador Cop2 que emite un campo de color de mapa normal de espacio tangente plano (la normal 'arriba' por defecto, RGB 0.5/0.5/1) en la resolución elegida; la capa base sobre la que compones las normales de detalle.	2 opcionales
`normal_map`	SideFX Labs Normal Map (labs::normal_map) — un FILTRO Cop2 que convierte una imagen de entrada de altura/escala de grises (entrada 0) en un mapa normal de espacio tangente.	`input` (+5 opcionales)
`normal_combine`	SideFX Labs Normal Combine (labs::normal_combine) — un FILTRO Cop2 que superpone un mapa normal de detalle (entrada 1) sobre un mapa normal base (entrada 0) con una mezcla de normales reorientadas correcta.	`input`, `input2` (+1 opcional)
`normal_invert`	SideFX Labs Normal Invert (labs::normal_invert) — un FILTRO Cop2 que invierte los ejes seleccionados de un mapa normal de espacio tangente (entrada 0).	`input` (+4 opcionales)
`normal_levels`	SideFX Labs Normal Levels (labs::normal_levels) — un FILTRO Cop2 que aplica un remapeo de niveles/gamma a un mapa normal (entrada 0).	`input` (+4 opcionales)
`normal_rotate`	SideFX Labs Normal Rotate (labs::normal_rotate) — un FILTRO Cop2 que rota los vectores normales de espacio tangente de un mapa normal de entrada (entrada 0) `angle` grados alrededor de la normal de la superficie (mantiene el mapa consistente cuando la textura se rota en los UV).	`input` (+2 opcionales)
`normal_normalize`	SideFX Labs Normal Normalize (labs::normal_normalize) — un FILTRO Cop2 que re-normaliza cada píxel de un mapa normal de entrada (entrada 0) de vuelta a la longitud unitaria (corrige normales no unitarias después de mezclar o filtrar).	`input` (+1 opcional)
`vector_normalize`	SideFX Labs Vector Normalize (labs::vector_normalize) — un FILTRO Cop2 que reescala una imagen vectorial de entrada (entrada 0) a un rango normalizado: `enable` lo activa; `min`/`max` establecen el rango objetivo en el que se ajustan las magnitudes vectoriales.	`input` (+4 opcionales)
`demosaic`	SideFX Labs Demosaic (labs::demosaic) — un FILTRO Cop2 que desempaqueta un atlas de sprites / hoja de flipbook de filas x columnas (entrada 0) en un fotograma individual: `frame` selecciona el mosaico, `start_frame` desplaza la numeración.	`input` (+5 opcionales)

Solaris / LOP / USD

Herramienta	Qué hace	Parámetros clave
`usd_layer`	Ensamblaje de escenario USD / Solaris de múltiples ramas y composición de capas (LOP). op=merge combina varias ramas LOP en un solo escenario (`inputs` entradas cableadas input0..N; mergestyle establece el estilo de composición/fusión de capas, por defecto flattenloplayers = Simple Merge). op=sublayer compone archivos externos .usd/.usda/.usdc como subcapas (`files`, confinado a lectura; `input` = un LOP sobre el cual componer capas). op=graft inserta un subárbol fuente bajo un prim de destino (`input`=Escenario de Entrada, `source`=el LOP a injertar en input1, `primpath`=prim padre de destino, `src_prims`/`dst_prims`=rutas de prim de origen y destino).	10 opcionales
`usd_configure`	Autoriza metadatos de prim USD / activo (LOP configureprimitive) o selecciona una variante -- metadatos puros, sin shader/VEX. op=configure establece, en los prims que coinciden con `primpattern`: kind (assembly\|group\|component\|subcomponent, la jerarquía de activos), purpose (default\|proxy\|render\|guide), drawmode (default\|origin\|bounds\|cards -- LOD proxy nativo de USD para que los activos pesados se dibujen como bounds/cards en el escenario de ensamblaje y geometría completa en el render), instanceable (bool), visibility (inherit\|invisible\|visible -- mostrar/ocultar un prim), y specifier (def\|over\|class). op=variant selecciona un conjunto/nombre de variante (cambio de LOD o de look).	12 opcionales
`sop_import`	Lleva la geometría de una red SOP al escenario USD -- el puente SOP->Solaris.	`soppath` (+6 opcionales)
`usd_import`	Compone un archivo USD en el escenario como referencia / payload / subcapa.	`path` (+4 opcionales)
`usd_light`	Añade/da forma a una luz USD/Karma en el escenario (light::2.0 o domelight::3.0).	27 opcionales
`usd_camera`	Añade/da forma a un prim de cámara en el escenario USD (camera LOP).	20 opcionales
`karma_render_settings`	SOLO CABLEADO: construye el grafo de render de Karma en LOP (prim de render-settings + ROP usdrender).	14 opcionales
`render_geo_settings`	Autoriza ajustes de render de Karma POR PRIM en un escenario USD (Render Geometry Settings LOP) — el caballo de batalla de la línea de entrega: visibilidad de rayos primarios (establece `visibility` en un glob de categoría de Karma — excluye la cámara para un prim FANTASMA / solo-reflexión), modo holdout/MATTE, desenfoque de movimiento y velocidad, interpretación de volumen uniforme y calidad de dicing.	`input` (+9 opcionales)
`karma_fog_box`	Añade un VOLUMEN DE NIEBLA atmosférico a un escenario USD (Karma Fog Box LOP) — niebla uniforme o modulada por ruido dentro de un límite de caja/esfera/etc., para bruma de horizonte / rayos de dios / profundidad.	17 opcionales
`physical_sky`	Construye un cielo + sol de Karma basado en físicas en el escenario (karmaphysicalsky) -- el primitivo de estudio solar de terreno/globo.	20 opcionales
`light_link`	Restringe qué geometría (des)ilumina una luz mediante un LOP lightlinker -- solo cadenas de patrón de prim basadas en datos, sin expresiones.	`light`, `geo` (+4 opcionales)
`assign_usd_material`	SOLO CABLEADO: autoriza un material MaterialX Standard Surface y lo VINCULA a prim_pattern en el escenario USD — la ruta tipada hacia un fotograma de Karma TEXTURIZADO (materiallibrary + mtlxstandard_surface + assignmaterial; sin VEX, sin código).	`prim_pattern` (+24 opcionales)
`material_graph_create`	Crea un grafo de material MaterialX PROCESAL vacío — un materiallibrary de LOP en /stage que llenas con shader_node_add / shader_connect / shader_set_param y vinculas con material_graph_assign.	2 opcionales
`shader_node_add`	Añade UN nodo MaterialX a un grafo de material (biblioteca de material_graph_create). node_type = un tipo mtlx* de lista blanca: mtlxstandard_surface (terminal de shader PBR), mtlximage/mtlxtriplanarprojection (textura), mtlxnoise3d/mtlxfractal3d/mtlxworleynoise3d (ruido), mtlxramplr/mtlxramp4 (rampa), mtlxgeompropvalue (LEE un atributo de geometría/capa de terreno), mtlxmix/mtlxremap/mtlxmultiply/mtlxclamp (matemática), mtlxnormalmap/mtlxdisplacement (normal/desplazamiento). signature establece el tipo de datos del nodo.	`library`, `node_type` (+2 opcionales)
`shader_connect`	Conecta la salida de un nodo MaterialX a la entrada de otro (construye una arista de grafo). dst_input es el NOMBRE de la entrada (p. ej. base_color, specular_roughness, normal, texcoord, in1) o un índice numérico; src_output por defecto es 'out' (la salida única de cada nodo mtlx).	`dst`, `dst_input`, `src` (+1 opcional)
`shader_set_param`	Establece un literal TIPADO en un nodo MaterialX — maneja automáticamente la trampa del sufijo de signature. param = el nombre BASE del parámetro (p. ej. amplitude, valuel, valuer, geomprop, file, octaves, inlow, outhigh); value = un número, una lista [r,g,b]/[x,y,z], o una cadena.	`node`, `param`, `value`
`material_graph_assign`	Vincula un grafo de material construido a geometría en el escenario USD (materiallibrary + assignmaterial). shader = el nodo TERMINAL (mtlxstandard_surface, o un collect/mtlxsurfacematerial que une surface+displacement); prim_pattern = la ruta/patrón de prim de geometría a vincular (obligatorio; establece is_pattern para un comodín).	`library`, `shader`, `prim_pattern` (+2 opcionales)
`material_ramp_on_attribute`	Receta HÉROE de una llamada: impulsa un canal de shader de COLOR desde una RAMPA sobre un ATRIBUTO DE GEOMETRÍA — el idiom de altura de terreno -> color.	10 opcionales
`material_noise_channel`	Receta de una llamada: impulsa un canal de shader ESCALAR desde RUIDO procesal.	12 opcionales
`usd_prim_cube`	Crea un prim USD Cube en el escenario (cube LOP): tamaño + transformación.	12 opcionales
`usd_prim_cone`	Crea un prim USD Cone en el escenario (cone LOP): eje, altura, radio, transformación.	12 opcionales
`usd_prim_cylinder`	Crea un prim USD Cylinder en el escenario (cylinder::2.0 LOP): eje, altura, radios.	12 opcionales
`usd_prim_sphere`	Crea un prim USD Sphere en el escenario (sphere LOP): radio + transformación.	12 opcionales
`usd_prim_capsule`	Crea un prim USD Capsule en el escenario (capsule::2.0 LOP): eje, altura, radios.	12 opcionales
`usd_prim_mesh`	Crea un prim USD Mesh vacío + metadatos de subdivisión (mesh LOP).	12 opcionales
`usd_prim_points`	Crea un prim USD Points en el escenario (points LOP): transformación.	12 opcionales
`usd_prim_basiscurves`	Crea un prim USD BasisCurves en el escenario (basiscurves LOP): tipo, base, wrap.	12 opcionales
`usd_prim_hermitecurves`	Crea un prim USD HermiteCurves en el escenario (hermitecurves LOP): transformación.	12 opcionales
`usd_prim_primitive`	Crea un único prim USD genérico de cualquier tipo de esquema (primitive LOP).	7 opcionales
`usd_instancer`	Construye un PointInstancer USD / instancias basadas en referencias en el escenario (instancer LOP).	17 opcionales
`usd_component_geometry`	Crea un contenedor componentgeometry impulsado por su subred SOP interna (sin parámetros de archivo).	10 opcionales
`usd_component_geometry_variants`	Empaqueta varios escenarios de entrada en un conjunto de variantes en un componente (componentgeometryvariants LOP).	8 opcionales
`usd_component_material`	Vincula materiales a un componente y opcionalmente construye un conjunto de variantes de material (componentmaterial LOP).	`input` (+8 opcionales)
`usd_layout`	Dispersa/coloca instancias de un prim prototipo en el escenario (layout LOP).	14 opcionales
`usd_scene_import`	Importa objetos de escena /obj (geo/luces/cámaras) al escenario (sceneimport::2.0 LOP).	11 opcionales
`usd_graft_stages`	Injerta el subárbol de otro escenario bajo un prim de destino (graftstages LOP).	9 opcionales
`usd_graft_branches`	Injerta ramas de un escenario fuente en prims de destino, manteniendo posición/material (graftbranches LOP).	12 opcionales
`usd_restructure_scenegraph`	Re-padrea/renombra prims y elimina arcos de composición (restructurescenegraph LOP).	`input` (+13 opcionales)
`usd_split_scene`	Divide el escenario en una rama seleccionada y el resto (splitscene LOP).	`input` (+4 opcionales)
`usd_isolate_scene`	Aísla parte del escenario para una iteración más rápida (isolatescene LOP).	`input` (+7 opcionales)
`usd_scope`	Crea un prim Scope (agrupación), opcionalmente re-padreando prims coincidentes bajo él (scope LOP).	10 opcionales
`usd_collection`	Autoriza una colección USD (conjunto nombrado de prims) en el escenario (collection::2.0 LOP; parámetro de icono excluido).	11 opcionales
`usd_prune`	Desactiva u oculta prims en el escenario (prune LOP).	7 opcionales
`usd_split_primitive`	Divide prims compuestos en prims editables por separado (splitprimitive LOP).	`input` (+8 opcionales)
`usd_xform`	Autoriza una transformación (xformOp) en prims coincidentes (xform LOP).	`input` (+14 opcionales)
`usd_create_xform`	Crea un nuevo prim Xform con una transformación (createxform LOP).	14 opcionales
`usd_point_xform`	Transforma prims mediante atributos de punto de un SOP (pointxform LOP).	`input` (+5 opcionales)
`usd_transform_uv`	Transforma coordenadas UV/textura en prims coincidentes (transformuv LOP; parámetro de archivo de mapa excluido).	`input` (+13 opcionales)
`usd_resample_transforms`	Remuestrea muestras de tiempo de transformación animada en un intervalo fijo (resampletransforms LOP).	`input` (+4 opcionales)
`usd_duplicate`	Duplica prims coincidentes N veces con una transformación acumulativa por copia (duplicate LOP).	`input` (+15 opcionales)
`usd_retime_instances`	Desplazamientos de tiempo por instancia / re-tiempo de un PointInstancer (retimeinstances LOP).	`input` (+11 opcionales)
`usd_extract_instances`	Extrae instancias de PointInstancer en prims reales (extractinstances LOP).	`input` (+12 opcionales)
`usd_merge_point_instancers`	Fusiona varios PointInstancers en uno (mergepointinstancers LOP).	`input` (+3 opcionales)
`usd_split_point_instancers`	Divide un PointInstancer en subconjuntos por prototipo/atributo (splitpointinstancers LOP).	`input` (+7 opcionales)
`usd_modify_point_instances`	Edita instancias individuales de un PointInstancer — transformación por instancia (modifypointinstances LOP).	`input` (+8 opcionales)
`usd_coordsys`	Vincula un prim de sistema de coordenadas (coordsys) nombrado para espacios de textura/proyección (coordsys LOP).	`input` (+13 opcionales)
`usd_edit_material`	Abre un material USD para edición / para basar un nuevo material en él (editmaterial LOP).	6 opcionales
`usd_edit_material_properties`	Autoriza/edita propiedades en un prim de material (editmaterialproperties LOP).	12 opcionales
`usd_material_variation`	Varía los parámetros de shader de un material vinculado entre prims (materialvariation LOP).	`input` (+8 opcionales)
`usd_unassign_material`	Elimina vinculaciones de material de prims coincidentes (unassignmaterial LOP).	7 opcionales
`usd_vary_material_assignment`	Varía aleatoria/espacialmente qué material está vinculado entre prims (varymaterialassignment LOP).	`input` (+16 opcionales)
`usd_light_distant`	Crea un UsdLux DistantLight (sol) en el escenario (distantlight::2.0 LOP).	15 opcionales
`usd_light_portal`	Crea un UsdLux PortalLight (portal de dome-light) en el escenario (portallight LOP).	10 opcionales
`usd_light_geometry`	Convierte geometría coincidente en una luz de área emisiva (geometrylight LOP).	15 opcionales
`usd_light_mixer`	Agrupa y transforma luces mediante colecciones de luces para look-dev (lightmixer LOP).	17 opcionales
`usd_shadow_catcher`	Convierte prims coincidentes en superficies shadow-catcher para compositing (shadowcatcher LOP).	6 opcionales
`usd_light_filter_library`	Autoriza una biblioteca de prims de filtro de luz y los asigna a luces (lightfilterlibrary LOP).	10 opcionales
`usd_add_variant`	Empaqueta escenarios de entrada en un conjunto de variantes en un prim (addvariant LOP).	15 opcionales
`usd_explore_variants`	Distribuye cada variante de un conjunto de variantes lado a lado (explorevariants::2.0 LOP).	`input` (+16 opcionales)
`usd_create_lod`	Construye variantes de nivel de detalle polirreducido de un prim (createlod LOP).	`input` (+14 opcionales)
`usd_auto_select_lod`	Auto-selecciona una variante LOD según la distancia de cámara (autoselectlod LOP).	`input` (+7 opcionales)
`usd_draw_mode`	Establecer el modo de dibujo de imágenes USD (bounds/cards/origin proxy) en prims coincidentes (drawmode LOP).	14 opcional
`usd_configure_property`	Configurar metadatos en propiedades USD coincidentes (configureproperty LOP).	9 opcional
`usd_configure_stage`	Configurar reglas de población/carga/mute a nivel de stage (configurestage LOP).	11 opcional
`usd_edit_properties`	Crear/editar prims y sus propiedades en bloque (editproperties LOP).	12 opcional
`usd_store_parameter_values`	Almacenar valores de parámetros nombrados como datos de stage para reutilización (storeparametervalues LOP).	5 opcional
`usd_set_extents`	Autor/Recomputar el hint de extent (bbox) en prims coincidentes (setextents LOP).	`input` (+8 opcional)
`usd_edit_xform`	Editar transformaciones de prims coincidentes (edit LOP).	16 opcional
`usd_layer_break`	Insertar un layer break para que las ediciones posteriores vayan a un layer nuevo (layerbreak LOP).	2 opcional
`usd_set_variant`	Seleccionar qué variante de un variant set está activa en prims coincidentes (setvariant LOP).	`input` (+5 opcional)
`usd_copy_property`	Copiar una propiedad/atributo de prims de origen a prims de destino (copyproperty LOP).	`input` (+7 opcional)
`usd_shot_split`	Dividir las ediciones del stage en layers por shot para la entrega editorial (shotsplit LOP).	`input` (+8 opcional)
`usd_shot_switch`	Cambiar entre stages de entrada candidatos por índice para el ensamblaje de shots (shotswitch LOP).	4 opcional
`shot_load`	Cargar layers de shot en /stage desde el pipeline de shots (shotload LOP) — el punto de entrada editorial que puebla un stage desde shots configurados.	5 opcional
`shot_output`	SOLO WIRE: construir un ROP LOP de Output de Shot (shotoutput) que guarda el stage a disco para un shot — configurado pero NUNCA ejecutado (tú disparas la escritura). la salida está confinada a WRITE; los parámetros SCRIPT pre/post render nunca se exponen.	`input`, `output` (+5 opcional)
`shot_layer_edit`	Enrutar ediciones del stage a un layer de shot específico (shotlayeredit LOP) — el targeter de capas editorial.	`input` (+6 opcional)
`usd_value_clip`	Autor un prim de value-clip USD que transmite animación desde un conjunto de archivos de clip (valueclip LOP). clip_files y manifest_file están confinados a realpath en el directorio de trabajo.	9 opcional
`usd_geometry_sequence`	Importar una SECUENCIA de archivos de geometría animados al stage (geometrysequence LOP) — el puente de lectura de streaming para un caché por frame .bgeo/.vdb. file está confinado a READ (pon un token $F para una secuencia).	`file` (+7 opcional)
`usd_geo_clip_sequence`	Cargar/escribir una secuencia de value-clip de geometría USD (geoclipsequence LOP) — cachear un subárbol de stage animado a archivos de clip por frame y transmitirlo de vuelta. load_clip_file (READ) y save_clip_file (WRITE) están confinados a realpath.	13 opcional
`usd_blend_constraint`	Autor una restricción de Blend USD — mezclar la transformación de un prim entre prims fuente y destino (blendconstraint LOP).	`input` (+9 opcional)
`usd_followpath_constraint`	Autor una restricción de Follow-Path USD — deslizar un prim a lo largo de una curva (followpathconstraint LOP).	`input` (+14 opcional)
`usd_lookat_constraint`	Autor una restricción de Look-At USD — apuntar un prim a un objetivo (lookatconstraint LOP).	`input` (+11 opcional)
`usd_parent_constraint`	Autor una restricción de Parent USD — parentar la transformación de un prim a un objetivo (parentconstraint LOP).	`input` (+14 opcional)
`usd_points_constraint`	Autor una restricción de Points USD — restringir un prim a puntos ponderados de un objetivo (pointsconstraint LOP).	`input` (+13 opcional)
`usd_surface_constraint`	Autor una restricción de Surface USD — fijar un prim a una ubicación UV en una superficie objetivo (surfaceconstraint LOP).	`input` (+14 opcional)

Aspecto, luces y cámara

Herramienta	Qué hace	Parámetros clave
`build_globe`	Construye un globo elipsoide WGS84 con un drapeado UV analítico de lon/lat (la 'piel'), de modo que una textura equirectangular y teselas ancladas a ECEF se alineen por construcción.	`name` (+12 opcionales)
`add_light`	Añade una luz que abarca toda la paleta de tipos hlight más cúpula.	21 opcionales
`add_camera`	Crea una cámara para COINCIDIR CON UNA FOTO DE REFERENCIA / recrear una imagen / resolver una toma con cámara — establece los intrínsecos para que un render se alinee con una imagen objetivo. distancia focal (mm) + apertura (mm) = campo de visión / compresión de perspectiva (distancia focal más corta o apertura más amplia = FOV más amplio); resx/resy = puerta de resolución; aspecto.	17 opcionales
`camera_aim`	Apunta una cámara existente a un objetivo -- solo datos (sin expresión/restricción de look-at).	`camera` (+6 opcionales)
`camera_path`	Anima una cámara OBJ a lo largo de una curva SOP -- solo datos (fotogramas clave literales calculados, SIN restricción Follow-Path / expresión $F).	`curve` (+6 opcionales)
`setup_karma`	SOLO CABLEADO: construye un grafo de render Karma en contexto OBJ (el ROP /out `karma` conectado a una cámara + resolución + imagen de salida) y devuélvelo SIN RENDERIZAR — el humano lo ejecuta (esto elimina la superficie de DoS de recursos / congelación de escenas pesadas). la imagen se escribe en el directorio de trabajo (PNG/EXR/JPG según extensión).	9 opcionales
`setup_prorender`	SOLO CABLEADO: construye un ROP de render USD de Solaris (/stage) configurado para AMD Radeon ProRender (el delegado Hydra `HdRprPlugin`) y devuélvelo SIN RENDERIZAR — el humano lo ejecuta (misma postura que setup_karma / karma_render_settings; elimina la superficie de DoS de recursos / congelación de cocción de GPU).	5 opcionales
`substance_material`	SideFX Labs Substance Material — asigna un material Substance a la geometría de entrada (entrada 0).	`input` (+9 opcionales)
`quickmaterial`	SideFX Labs Quick Material — asigna UN material (Principled / MatCap / Labs PBR) a la geometría de entrada (`input`), opcionalmente a una primitiva `group`, controlado por mapas de textura (`*_texture`, restringido a lectura) y palancas escalares (roughness / metallic / ior).	`input` (+14 opcionales)
`set_view_camera`	Controla el viewport del Scene Viewer: mira a través de una cámara (vincula el viewport a ella) y/o cambia a una vista estándar ortográfica/perspectiva (superior/inferior/frontal/trasera/izquierda/derecha/persp), y opcionalmente encuadra toda la geometría para ajustarla a la vista.	4 opcionales
`flightcam`	Cámara de vuelo con fotogramas clave controlada por un poses .json, con la nube de origen cargada como contexto.	`poses` (+7 opcionales)
`assign_material`	Asigna un material / shader PBR (Principled Shader principledshader::2.0) al SOP de entrada mediante un SOP de Material para que se renderice con un aspecto de superficie — solo parámetros literales tipados + mapas de textura (sin creación de VOP/grafo de shader).	`input` (+26 opcionales)
`bake_texture`	SOLO CABLEADO: construye el grafo de horneado de texturas (Bake Texture 3.0) con una salida confinada; no se ejecuta.	`output` (+3 opcionales)
`three_point_light`	Crea un rig OBJ de luz de tres puntos (three_point_light) — un nodo que agrupa luces clave / de relleno / de borde / de rebote apuntando a un objetivo compartido.	18 opcionales
`indirect_light`	Crea una luz OBJ indirecta (rebote de iluminación global) (indirectlight). el atenuador escala la contribución indirecta.	6 opcionales
`ambient_light`	Crea una luz ambiental OBJ (ambient) — un relleno plano y uniforme añadido a toda la escena.	8 opcionales
`environment_fog`	Crea una niebla ambiental OBJ (fog) — un contenedor de volumen atmosférico que llena la escena. t/r/s/escala dimensiona y coloca la caja de niebla.	5 opcionales
`reference_image`	Crea una imagen de referencia OBJ (refimage) — un plano de imagen plano para referencia de modelado / coincidencia. image_file es realpath restringido a lectura del directorio de trabajo.	9 opcionales
`stereo_camera`	Crea una cámara estéreo OBJ (stereocam) — un contenedor que agrupa una cámara izquierda + derecha.	7 opcionales
`stereo_camera_rig`	Crea un rig de cámara estéreo OBJ (stereocamrig) — un rig estéreo totalmente paramétrico con controles de interaxial / paralaje cero e intrínsecos de cámara.	14 opcionales
`vr_camera`	Crea una cámara VR OBJ (vrcam) — una cámara panorámica estéreo para renders de VR (esfera/cilindro = panoramas equirectangulares / cilíndricos).	14 opcionales

Escena, navegación y viewport

Herramienta	Qué hace	Parámetros clave
`scene_info`	Informa de la escena actual de Houdini: archivo hip, fotograma, versión y contenido de /obj.	—
`read_network`	Lee la ESTRUCTURA de una red como texto: el mapa duradero y de bajo coste de tokens para reconstruir tu imagen de un grafo de nodos grande (especialmente tras una compactación de contexto) SIN gastar presupuesto en una captura de pantalla.	5 opcionales
`set_frame`	Establece el fotograma / cabezal de reproducción actual de la línea de tiempo: salta a un punto en el tiempo para que los cooks, instantáneas, exportaciones o lecturas de simulación posteriores se evalúen en ese fotograma.	`frame`
`set_display`	Establece el flag de visualización y/o renderizado en un nodo SOP u OBJ: control limpio sobre lo que se muestra/renderea.	`node` (+2 opcionales)
`delete_node`	Elimina un nodo (SOP u OBJ) de la escena.	`node` (+1 opcional)
`clear_scene`	Empieza de cero en la red /obj sin un File->New destructivo. mode='hide' (PREDETERMINADO, no destructivo + reversible) apaga el flag de visualización en cada objeto /obj para que el viewport se limpie pero los nodos permanezcan; mode='delete' ELIMINA los objetos /obj (destructivo, como borrar cada uno).	2 opcionales
`save_scene`	Guarda / escribe toda la escena de Houdini (todos los nodos y redes) en un archivo de proyecto .hip / .hipnc / .hiplc en disco, limitado al directorio de trabajo: la operación de 'guardar mi trabajo' / instantánea de la sesión.	`path`
`select_node`	Selecciona un nodo (limpiando cualquier selección previa) y lo convierte en el nodo actual.	`node` (+1 opcional)
`frame_selected`	Encuadra el Scene Viewer en un nodo: el equivalente a Shift+H 'home selected', para un encuadre preciso en escenas de escala mixta donde frame-all es inútil.	1 opcional
`layout_nodes`	Reorganiza automáticamente los hijos de una red para que los nodos recién añadidos no se apilen: el equivalente a Shift+L.	`parent`
`find_error_nodes`	Diagnóstico de solo lectura: escanea un subárbol en busca de nodos en estado de error (y opcionalmente de advertencia) e informa de sus rutas, tipos y mensajes para que un agente de IA pueda autocorregirse. root (por defecto /obj) delimita el escaneo (root más todos los descendientes); se intenta un cook protegido por nodo para que un nodo roto (p. ej. un File SOP que apunta a una ruta inexistente) aparezca como un error capturado, no como una excepción lanzada.	2 opcionales
`batch`	Ejecuta hasta 64 operaciones de herramienta en UNA llamada para reducir la latencia por llamada (p. ej. construir una cadena de nodos en un solo viaje de ida y vuelta).	`ops` (+1 opcional)
`capabilities`	Empieza aquí: primeros pasos, cómo usar este servidor, una visión general de lo que puede hacer, orientación y primeros pasos para un agente nuevo.	—
`node_reference`	Consulta la referencia autoritativa de nodos de Houdini 21.0.671 sondeada en vivo: tipos de nodo verificados y sus nombres de parámetros reales, la fuente de verdad sobre qué cadenas de nodos son posibles.	3 opcionales
`vex_reference`	Consulta la referencia autoritativa offline de VEX de Houdini 21.0.671: 1073 funciones integradas (firmas textuales, resúmenes, grupos de ayuda) más una guía curada de flujos de trabajo/patrones de wrangle.	4 opcionales
`recipe_reference`	Recetas de flujo de trabajo canónicas y mapeadas a herramientas: cómo HACER realmente X con las herramientas de este servidor, y el ROUTER que elige qué receta encaja con lo que estás viendo.	4 opcionales
`viewport_display`	Activa/desactiva las superposiciones de visualización/análisis del Scene Viewer (marcadores de puntos, normales de punto/prim/vertex, números de punto/prim, posiciones de puntos, estelas de puntos) para que una captura de snapshot/capture_ui sirva para el análisis de geometría.	9 opcionales
`read_geo_stats`	Lee estadísticas estructuradas de geometría de un nodo: recuentos de puntos/primitivas/vértices, caja delimitadora (min/max/tamaño/centro) y la lista completa de atributos de punto/prim/vértice/detalle con sus tipos, mediante intrinsics rápidos (seguro en nubes de puntos de varios GB; sin bucle Python por punto).	`node` (+1 opcional)
`isolate`	Recorta una nube de puntos a una región de interés: conserva solo los puntos que caen dentro de un objeto de caja de recorte orientada (usa la transformación mundial propia del OBJ de caja, por lo que una caja rotada recorta un volumen orientado) y elimina el resto: reduce un escaneo a un edificio/habitación/zona. box = un OBJ de caja que actúa como límites del recorte. out opcionalmente escribe la nube recortada a un .bgeo/.ply confinado.	`input`, `box` (+1 opcional)
`object_merge`	Referencia / importa / trae uno o muchos flujos de geometría SOP u OBJ a una red POR RUTA, SIN copiar la geometría: la primitiva de ensamblaje de escenas grandes, venues y multiobjeto (reúne muchos objetos / combina / agrupa / instancia geometría de otras partes de la escena; sobrevive a escenas enormes porque no se duplica nada).	`sources` (+7 opcionales)
`subnet_organize`	Organiza / ordena / limpia el grafo de nodos (solo datos, sin cook, sin cambio de geometría): op=collapse agrupa un conjunto de nodos hermanos en una subred (agrupa nodos juntos); op=create crea un contenedor de subred vacío; op=tag etiqueta un nodo con un color del editor de redes, un comentario/nota y/o una clave/valor de datos de usuario para que un grafo ensamblado sea navegable y legible.	9 opcionales
`matchsize`	Ajusta / redimensiona / reescala / reposiciona / alinea una entrada de geometría para que coincida con una caja delimitadora de referencia o un tamaño objetivo explícito: el nodo tipado de 'colocar este asset en la escena con el tamaño y la posición correctos' / 'normalizar / ajustar a límites' (matchsize SOP).	`input` (+9 opcionales)
`scene_assemble`	Macro de ensamblaje/composición de escena multipieza por etapas en una sola llamada (la primitiva de portfolio de venue): construye una escena ensamblada y navegable completa a partir de muchas geometrías fuente en un único /obj geo nuevo.	`name`, `pieces` (+2 opcionales)
`list_node_types`	Descubre / enumera / busca la paleta de tipos de nodo disponibles de Houdini: qué tipos de operador (SOP/OBJ/LOP/DOP/COP/ROP/VOP/...) existen por nombre, con recuentos por categoría.	3 opcionales
`reload_node`	Fuerza a un nodo a releer su archivo fuente del disco y refrescar / recocinar: úsalo después de que el .bgeo/.obj de un File SOP (o cualquier archivo en caché) haya sido reescrito externamente para que Houdini recoja el nuevo contenido.	`node`
`mem`	Informa del conjunto de trabajo del proceso + RAM del sistema + memoria de Houdini + VRAM de GPU (total/usada/disponible de toda la tarjeta: la señal del techo de congelación) para el auto-monitoreo y el dimensionamiento de operaciones gobernado por memoria: ¿me estoy quedando sin memoria?, ¿cuánto margen de VRAM / memoria de GPU queda?, ¿cuál es mi presupuesto de memoria?, ¿cuánto más puedo construir antes de que se congele.	—
`viewport_snap`	Establece / configura el SNAPPING del Scene Viewer: ajuste a cuadrícula, ajuste a puntos / prims / geometría / plantillas / otros objetos / guías / drawables.	6 opcionales
`view_message`	Muestra / destella / presenta un mensaje orientado al operador (notificación, toast en pantalla, prompt en la línea de estado) en el Scene Viewer: la UX de tripulación observada para decirle al humano lo que el agente está haciendo. type=flash es una superposición transitoria (duración en s); type=prompt establece el prompt persistente de la línea de estado en un nivel de severidad.	`message` (+3 opcionales)
`home_view`	Lleva / restablece / recentra / encuadra todo el viewport actual a la DIRECCIÓN de vista predeterminada para un objetivo (all \| selected \| grid \| non_templated): distinto de frame_selected, que reencuadra pero MANTIENE la dirección de vista actual.	1 opcional
`save_view_to_camera`	Hornea / guarda la vista interactiva actual del viewport (transformación + ajustes de lente) EN un nodo OBJ de cámara: 'guardar vista en cámara' / crear una cámara desde esta vista.	`camera` (+1 opcional)
`construction_plane`	Muestra / oculta / redimensiona la CUADRÍCULA del plano de construcción del Scene Viewer: visibilidad, tamaño de celda, número de celdas, celdas por línea de regla.	4 opcionales
`ui_reference`	Descubrimiento / ayuda de la superficie de control de solo lectura (hermano de node_reference/vex_reference): DESCUBRE las herramientas de la superficie de control + los tokens de enum confirmados y, cuando hay una GUI activa, LEE el estado actual de la UI manejable (modo de snapping, visibilidad del plano de construcción, nombre del estado del viewer, nombres de desktops).	1 opcional
`switch_desktop`	Cambia / activa un DESKTOP (espacio de trabajo / diseño de paneles guardado: Build, Animate, Solaris, …) por nombre.	`desktop`
`pane_focus_node`	Salta / navega / apunta un panel basado en rutas (parm \| network \| scene) A un nodo (navegación rápida): lo convierte en el nodo actual del panel; para network también puedes sumergirte en la propia red del nodo.	`node` (+2 opcionales)
`pane_pin`	Fija / desfija (o establece el grupo de enlace de) un panel basado en rutas para que DEJE de seguir la selección: congela el panel parm/network/scene en el nodo actual.	3 opcionales
`pane_tab`	Abre / crea / cierra / cambia / clona / reescribe PESTAÑAS de panel por tipo (solo datos): añade una pestaña de Network Editor / Parameters / Spreadsheet / Details, cierra una o haz que una sea la actual. op=query lista los tokens paneTabType válidos + las pestañas actuales (ejecútalo PRIMERO para descubrir ids/tipos de panel); create/set_type/current/clone/close actúan sobre el panel objetivo.	3 opcionales
`pane_layout`	Divide / maximiza / restaura / organiza el diseño de PANELES del desktop actual (UI de sesión reversible): divide un panel horizontal o verticalmente, maximízalo o restáuralo.	`op` (+1 opcional)
`network_navigate`	Navega / salta / sumérgete en el Network Editor a través del grafo de nodos: sumérgete en una red (path), selecciona + haz un nodo actual (current_node) y/o encuadra la selección (frame).	3 opcionales
`hotkey_reference`	Lector de solo lectura del mapa de atajos de teclado / hotkeys predeterminados desde hou.hotkeys (hermano de vex_reference/node_reference): busca / encuentra atajos de teclado: contexto → comando → teclas asignadas + etiqueta legible, con un filtro de búsqueda opcional o modo de categoría.	5 opcionales
`set_node_flags`	Establece / alterna FLAGS DE NODO en un nodo: display, render, template, bypass, lock, soft-lock, highlight, debug, visible, xray, display-comment, descriptive-name, mediante setGenericFlag.	`node` (+13 opcionales)
`node_organize`	Organiza / ordena / arregla / etiqueta / codifica por color UN nodo en la red: establece su color, FORMA de nodo, comentario (texto solo de visualización), nombre (renombrar) y POSICIÓN en la red.	`node` (+6 opcionales)
`viewport_appearance`	Establece los ajustes de visualización / inspección / sombreado del GeometryViewport para que la geometría sea VISIBLE para el bucle de aceptación visual / captura de pantalla: modo de sombreado/visualización (wireframe · shaded · flat · matcap · hidden-line · bounding-box), mostrar marcadores de punto/prim/vértice · normales · números, eliminación de caras traseras, texturas, oclusión ambiental, esquema de color, iluminación.	19 opcionales
`viewport_layout`	Establece el DISEÑO de viewports del Scene Viewer: cómo se divide el panel en viewports (variantes single \| quad \| double \| triple).	`layout` (+1 opcional)
`enter_state`	Entra / activa uno de los cinco estados de herramienta FIJOS integrados del Scene Viewer por nombre (solo datos por construcción): view (mirar alrededor) \| translate \| rotate \| scale (estados de manejador de transformación) \| current_node (el estado de herramienta propio del nodo actual).	`state`
`viewport_optimize`	Acelera un Scene Viewer lento / con retraso / pesado aplicando palancas de rendimiento solo de visualización: reduce la calidad de volumen, limita la visualización de polígonos de la escena, activa el culling empaquetado basado en distancia, reduce el nivel de detalle y el antialiasing.	1 opcional
`rivet`	Crea un OBJ Rivet (rivet): una transformación bloqueada a un punto/primitiva en una superficie deformable (el clásico adjunto de 'pegar un accesorio a una malla animada').	10 opcionales
`sticky`	Crea un OBJ Sticky (sticky): una transformación fijada a una coordenada UV en una superficie, de modo que se desliza con la superficie mientras se deforma.	11 opcionales
`blend_sticky`	Crea un OBJ Blend Sticky (blendsticky): un Sticky cuya posición es una MEZCLA ponderada de varios objetos sticky fuente (haz que los stickies fuente sean sus hijos).	8 opcionales

Parámetros

Herramienta	Qué hace	Parámetros clave
`set_parm`	Establece / escribe / conduce un parámetro de nodo a un valor LITERAL (solo literal, nunca una expresión) — la contraparte segura y solo-de-datos de un setter de parámetros genérico.	`node`, `parm`, `value` (+1 opcional)
`get_parm`	Lee / obtiene / inspecciona el valor de un parámetro de nodo (solo lectura, solo datos): devuelve el valor evaluado, el valor crudo / sin expandir, el tipo de parámetro, si actualmente contiene una expresión o keyframes (con la cadena de expresión), y si es un parámetro de código denegado (para que una expresión inyectada sea visible).	`node`, `parm` (+1 opcional)
`set_keyframe`	Establece / agrega un keyframe para animar un parámetro numérico en un fotograma con un valor numérico LITERAL + una interpolación opcional en lista blanca (constante / lineal / bezier / ease / …) — animación de valor literal para parámetros float / int / toggle / menu.	`node`, `parm`, `frame`, `value` (+2 opcionales)
`delete_keyframes`	Elimina / limpia / borra keyframes en un parámetro para que vuelva a un valor literal estático (des-animar).	`node`, `parm` (+3 opcionales)
`list_keyframes`	Lista de solo lectura de los keyframes / animación de un parámetro — el fotograma de cada keyframe, valor literal y cadena de interpolación (p. ej. 'bezier()'), para que un agente pueda inspeccionar la animación.	`node`, `parm` (+1 opcional)

Entregar y exportar

Herramienta	Qué hace	Parámetros clave
`export_geometry`	Cocina un SOP y escríbelo en UN SOLO archivo de geometría (el ROP /out `geometry`; ejecuta la escritura).	`input`, `output` (+1 opcional)
`batch_export`	Divide la geometría `input` en PARTICIONES y escribe UN archivo confinado por partición — la solicitud recurrente #1 de los TDs ("divide esto por grupo/nombre/atributo y exporta cada pieza"). split_by=name (predeterminado) escribe un archivo por cada valor distinto del atributo de primitiva `name`; split_by=group escribe un archivo por cada grupo de primitivas/puntos; split_by=attribute escribe un archivo por cada valor distinto del atributo de punto/primitiva nombrado en `attribute`.	`input` (+7 opcionales)
`export_pointcloud`	Exporta una nube de puntos / geometría a PLY dentro del directorio de trabajo — la salida para nubes importadas mediante import_pointcloud/las_import.	`input`, `output` (+2 opcionales)
`export_alembic`	Exporta un SOP a un Alembic .abc (el ROP /out `alembic`; ejecuta la escritura) — el intercambio estándar para geometría animada/deformada hacia Maya/Nuke/Blender/UE. frames=[start,end] escribe un caché ANIMADO en el único .abc; omítelo para un fotograma estático. formato ogawa (moderno, más rápido, más pequeño — recomendado) \| hdf5 (heredado) \| predeterminado.	`input`, `output` (+3 opcionales)
`capture_ui`	Captura / ve / lee la interfaz EN VIVO de Houdini, AISLADA a un solo panel a petición.	5 opcionales
`snapshot`	Ve/captura el resultado 3D — un único PNG OpenGL del viewport/cámara devuelto INLINE en el resultado de la herramienta (los ojos del agente para verificación de imagen->3D).	6 opcionales
`niagara`	SideFX Labs Niagara — SOP exportador SOLO-CABLE que empaqueta las partículas/puntos entrantes (`input`, entrada 0) para el sistema Niagara de Unreal.	`input` (+8 opcionales)
`pcg_export`	SideFX Labs PCG Export — SOP exportador SOLO-CABLE que empaqueta los puntos de instancias entrantes (`input`, entrada 0) para el framework PCG de Unreal.	`input` (+7 opcionales)
`unreal_groom_export`	SideFX Labs Unreal Groom Export — empaqueta un groom de Houdini para el sistema de groom de Unreal y escríbelo como Alembic.	13 opcionales
`unreal_spline`	SideFX Labs Unreal Spline — empaqueta la curva entrante (`input`, entrada 0) como un spline de Unreal; la salida SOP cocinada pasa la curva (opcionalmente etiquetada). orient_along_curve escribe orientación por punto; prim_tags escribe etiquetas por primitiva.	`input` (+4 opcionales)
`vector_field`	SideFX Labs Vector Field — remuestrea un campo de velocidad entrante (`input`, entrada 0 — volúmenes de velocidad o puntos que portan un atributo de velocidad) en una cuadrícula uniforme y prepara una exportación de campo vectorial .fga para Unreal/Unity; la salida SOP cocinada visualiza el campo muestreado. input_type elige volúmenes(0) o puntos(1); velocity_volumes/velocity_attr nombran la fuente; div establece el divisor de resolución de la cuadrícula.	`input` (+9 opcionales)
`niagara_rop`	SideFX Labs Niagara ROP — la forma /out Driver del exportador de Niagara: referencia un SOP por ruta (`soppath`) y lo escribe para el sistema Niagara de Unreal.	6 opcionales
`rbd_to_fbx`	SideFX Labs RBD to FBX — un /out Driver que exporta una simulación RBD empaquetada (referenciada por `node_to_export`) como un FBX de cuerpo rígido para un motor de juego.	9 opcionales
`vertex_animation_textures`	SideFX Labs Vertex Animation Textures — el exportador VAT insignia: hornea un SOP animado (referenciado por `soppath`) en texturas de posición/rotación/color + una malla base para shaders VAT de Unreal/Unity.	11 opcionales
`xyz_pointcloud_exporter`	SideFX Labs XYZ Pointcloud Exporter — un /out Driver que escribe los puntos de un SOP (referenciados por `objpath1`) a una nube de puntos XYZ/CSV de texto plano.	3 opcionales
`texture_sheets`	SideFX Labs Texture Sheets — renderizador SOLO-CABLE de hojas de textura / flipbook (Mantra ROP).	18 opcionales
`goz_export`	SideFX Labs GoZ Export — exportador SOLO-CABLE que entrega geometría a ZBrush mediante el puente GoZ.	`input` (+2 opcionales)
`filecache`	SideFX Labs File Cache — caché de geometría SOLO-CABLE.	`input` (+6 opcionales)
`static_fracture_export`	SideFX Labs Static Fracture Export — exportador SOLO-CABLE para las piezas de un objeto fracturado (`input`).	`input` (+5 opcionales)
`simple_baker`	SideFX Labs Simple Baker — horneador de mapas SOLO-CABLE.	`input` (+19 opcionales)
`unreal_pivotpainter`	SideFX Labs Unreal Pivot Painter — exportador SOLO-CABLE que hornea texturas de pivote / jerarquía para animación de viento UE4/5.	`input` (+10 opcionales)
`zibravdb_filecache`	SideFX Labs ZibraVDB File Cache — caché VDB comprimido SOLO-CABLE.	`input` (+3 opcionales)
`rop_zibravdb_compress`	SideFX Labs ROP ZibraVDB Compress — ROP VDB comprimido SOLO-CABLE.	`input` (+3 opcionales)
`games_baker`	SideFX Labs Games Baker — un /out Driver que hornea mapas de textura (basecolor / normal / AO / roughness / metallic / curvature / thickness / position / …) desde una malla fuente de alta resolución sobre una malla objetivo de baja resolución mediante el horneado nativo COP/Karma de Houdini.	40 opcionales
`csv_exporter`	SideFX Labs CSV Exporter — un /out Driver que escribe los atributos de punto/primitiva de un SOP (referenciados por export_node) a un archivo CSV de texto plano.	12 opcionales
`json_exporter`	SideFX Labs JSON Exporter — un /out Driver que escribe los atributos de un SOP (referenciados por export_node) a un archivo JSON.	5 opcionales
`export_usd`	Escribe un stage USD desde una red LOP a una ruta de salida confinada (el ROP /out `usd`; ejecuta la escritura).	`output` (+3 opcionales)
`export_fbx`	Escribe un FBX (.fbx) desde el OBJ que contiene `input` a una ruta de salida confinada (el ROP /out `filmboxfbx`; ejecuta la escritura) — el intercambio estándar con rig/animación para Maya/Max/UE/Unity.	`input`, `output` (+2 opcionales)
`export_gltf`	Escribe un glTF/GLB desde el SOP `input` a una ruta de salida confinada (el ROP /out `gltf`; ejecuta la escritura) — el intercambio web/tiempo real (three.js, model-viewer, UE/Unity, AR quicklook). exporttype auto (desde la extensión — predeterminado) \| gltf (.gltf + buffers externos) \| glb (binario de archivo único). frames=[start,end] escribe un glTF ANIMADO; omítelo para un fotograma estático.	`input`, `output` (+3 opcionales)
`export_cache`	Escribe un caché de geometría versionado — una secuencia .bgeo.sc por fotograma — sobre un rango de fotogramas (el ROP /out `geometry`; ejecuta la escritura).	`input`, `output` (+2 opcionales)
`flipbook`	Renderiza una secuencia de vista previa OpenGL rápida (el ROP /out `opengl`; ejecuta la escritura) — un flipbook de calidad de viewport para revisar movimiento, NO un render final (usa setup_karma/karma_render_settings para eso).	`output` (+5 opcionales)
`export_package`	Exportación / entrega / escritura de paquete USD SOLO-CABLE: construye y configura completamente un ROP `usd` (Driver) que escribe un stage LOP ensamblado a un archivo .usd/.usda/.usdc/.usdz confinado, pero NO lo ejecutes — como setup_karma / bake_texture, un aplanado de stage completo puede ser una escritura pesada, así que el llamador/humano lo dispara (devuelve rendered=false).	`loppath`, `output` (+3 opcionales)
`define_hda`	Empaqueta un subnet SOP existente en un Digital Asset de Houdini reutilizable y confinado a rutas — la operación de 'convertir esta red en una herramienta reutilizable'.	`node`, `output`, `type_name` (+6 opcionales)
`usd_export_sop`	Escribe la geometría SOP `input` a un archivo USD (el `usdexport` de contexto SOP — el puente de escritura desde SOPs nativos hacia un stage USD; ejecuta la escritura). la salida está confinada por WRITE con realpath al directorio de trabajo; la extensión elige el formato (.usd/.usda/.usdc/.usdz).	`input`, `output` (+8 opcionales)
`usd_stitch`	SOLO-CABLE: construye un USD Stitch ROP (/out usdstitch) que fusiona varias capas USD de entrada en una capa de salida — configurado pero NUNCA ejecutado (tú disparas la escritura).	`input_files`, `output` (+1 opcional)
`usd_stitch_clips`	SOLO-CABLE: construye un USD Stitch Clips ROP (/out usdstitchclips) que ensambla clips USD por fotograma en una topología de clips de valor + plantilla — configurado pero NUNCA ejecutado.	`input_files`, `output_template` (+5 opcionales)
`usd_zip`	SOLO-CABLE: construye un USD Zip ROP (/out usdzip) que empaqueta capas USD de entrada en un archivo .usdz — configurado pero NUNCA ejecutado.	`input_files`, `output` (+2 opcionales)

Render y salida (SOLO-CABLE)

Herramienta	Qué hace	Parámetros clave
`render_mantra`	ROP de render de imagen por CPU de Mantra (ifd, out/) — SOLO-CABLEADO: construye y cablea el render de Mantra en /out; TÚ lo ejecutas.	11 opcionales
`render_karma_rop`	ROP de render de imagen de Karma en contexto Driver (karma, out/) — SOLO-CABLEADO: construye y cablea el render de Karma en /out; TÚ lo ejecutas.	11 opcionales
`render_usd`	ROP de render de USD/Husk en contexto Driver (usdrender, out/) — SOLO-CABLEADO: construye y cablea el render de Husk en /out; TÚ lo ejecutas.	10 opcionales
`render_comp`	ROP de escritura de imagen de composite/red COP (comp, out/) — SOLO-CABLEADO: construye y cablea la escritura de composite en /out; TÚ lo ejecutas.	8 opcionales
`render_image`	ROP de render de imagen COP (image, out/) — SOLO-CABLEADO: construye y cablea la escritura de imagen COP en /out; TÚ lo ejecutas.	8 opcionales
`export_ifd_archive`	ROP de exportación de archivo de escena IFD de Mantra (ifdarchive, out/) — SOLO-CABLEADO: construye y cablea la exportación de archivo en /out; TÚ lo ejecutas.	7 opcionales
`render_settings_usd`	Primitiva USD RenderSettings (LOP rendersettings de Solaris) — SOLO-CABLEADO: construye y cablea la configuración de render de nivel superior (resolución, muestras, cámara) que un renderizador posterior lee; tú ejecutas el render.	7 opcionales
`render_product`	Primitiva USD RenderProduct (LOP renderproduct de Solaris) — SOLO-CABLEADO: nombra la IMAGEN DE SALIDA (ruta, tipo, encuadre) que un renderizador escribirá; tú ejecutas el render.	7 opcionales
`render_var`	Declaración USD RenderVar / AOV (LOP rendervar[::2.0] de Solaris) — SOLO-CABLEADO: declara un AOV / variable de salida de render (fuente + tipo de datos) para que un renderizador la produzca.	6 opcionales
`render_vars_additional`	RenderVars adicionales (LOP additionalrendervars de Solaris) — SOLO-CABLEADO: agrega una fila extra de AOV / RenderVar al conjunto de salidas de render de la escena.	7 opcionales
`karma_render_properties`	Propiedades de render de Karma (LOP karmarenderproperties de Solaris) — SOLO-CABLEADO: construye y cablea una configuración combinada de ajustes de render de Karma + producto en la escena; tú ejecutas el render.	9 opcionales
`karma_render_products`	Paquete de productos de render de Karma (LOP karmarenderproducts[::2.0] de Solaris) — SOLO-CABLEADO: construye y cablea un conjunto de productos de salida de Karma (beauty + AOVs) en la escena; tú ejecutas el render.	7 opcionales
`karma_render_vars`	RenderVars estándar de Karma (LOP karmastandardrendervars[::2.0] de Solaris) — SOLO-CABLEADO: construye y cablea el conjunto de AOV estándar de Karma (beauty, divisiones diffuse/glossy/volume, etc.) en la escena; tú ejecutas el render.	4 opcionales
`karma_cryptomatte`	Configuración de AOV Cryptomatte de Karma (LOP karmacryptomatte de Solaris) — SOLO-CABLEADO: construye y cablea salidas de máscaras de ID cryptomatte en la escena; tú ejecutas el render.	5 opcionales
`husk_image_metadata`	Metadatos de imagen de Husk (LOP huskimagemetadata de Solaris) — SOLO-CABLEADO: construye y cablea metadatos (qué atributos de qué prims incrustar) en la imagen de salida renderizada; tú ejecutas el render.	3 opcionales
`rop_geometryraw`	Salida de geometría ROP — CRUDO (`rop_geometryraw`, contexto SOP) — SOLO-CABLEADO: construye y cablea un ROP de exportación de geometría cruda dentro de la red SOP después de `input`; tú ejecutas la escritura.	`input` (+4 opcionales)
`dopio`	E/S de DOP (`dopio`, contexto SOP) — SOLO-CABLEADO: construye un nodo de caché de disco de campo/geometría DOP (sin entrada SOP — referencia una red DOP por ruta y escribe un archivo); tú ejecutas el caché.	6 opcionales
`heightfield_output`	Salida de Heightfield (`heightfield_output`, contexto SOP) — SOLO-CABLEADO: construye y cablea un ROP de exportación de heightmap de heightfield/terreno después de `input`; tú ejecutas la escritura.	`input` (+8 opcionales)
`export_channel`	ROP de exportación de canal/movimiento CHOP (channel, out/Driver) — SOLO-CABLEADO: construye y cablea un exportador de canal/movimiento CHOP; tú lo ejecutas. choppath es una ruta de CHOP de escena (datos); output -> chopoutput (restringido).	7 opcionales
`export_mdd`	ROP de exportación de caché de puntos MDD (mdd, out/Driver) — SOLO-CABLEADO: construye y cablea un exportador de caché de puntos MDD; tú lo ejecutas. soppath es una ruta de SOP de escena (datos); output -> file (restringido).	8 opcionales
`render_dsm_merge`	ROP de fusión de Deep-Shadow-Map (dsmmerge, out/Driver) — SOLO-CABLEADO: construye y cablea una fusión DSM; tú la ejecutas. output -> dsm_output (restringido a escritura); dsm_source1/2 son entradas restringidas a lectura.	8 opcionales
`export_brickmap`	Generador de Brick-map (brickmap, out/Driver) — SOLO-CABLEADO: construye y cablea un generador de nube de puntos/i3d -> brick-map; tú lo ejecutas. sop es una ruta de SOP de escena (datos); output/geofile/ptcfile/i3dfile están restringidos.	9 opcionales
`bake_animation_rop`	ROP de animación de horneado (bake_animation, out/Driver) — SOLO-CABLEADO: construye y cablea un horneado de animación de objetos a keyframes/canales CHOP; tú lo ejecutas. source y write_to_chop_channel son datos de escena (verbatim).	7 opcionales
`export_geometry_raw`	ROP de flujo de geometría cruda (geometryraw, out/Driver) — SOLO-CABLEADO: construye y cablea un volcado de flujo de geometría cruda; tú lo ejecutas. soppath es una ruta de SOP de escena (datos); output -> sopoutput (restringido).	7 opcionales
`export_ml_example_raw`	ROP crudo de ejemplo de ML (ml_exampleraw, out/Driver) — SOLO-CABLEADO: construye y cablea un exportador crudo de ejemplos de entrenamiento de ML; tú lo ejecutas. soppath es una ruta de SOP de escena (datos); output -> sopoutput (restringido).	9 opcionales
`export_ml_example_output`	ROP de salida de ejemplo de ML (ml_exampleoutput, contexto SOP) — SOLO-CABLEADO: construye y cablea un escritor de dataset de ejemplos de ML después de un SOP (entrada 0); tú lo ejecutas. output -> sopoutput (restringido).	`input` (+4 opcionales)
`export_ml_example_raw_sop`	ROP crudo de ejemplo de ML (rop_ml_exampleraw, contexto SOP) — SOLO-CABLEADO: construye y cablea el exportador crudo de ejemplos de ML a nivel SOP después de un SOP (entrada 0); tú lo ejecutas. soppath es dato de escena; output -> sopoutput (restringido).	`input` (+9 opcionales)
`render_ml_cv_synthetics`	ROP Karma de síntesis ML-CV de Labs v1.0 (labs::ml_cv_synthetics_karma_rop::1.0, lop/Solaris) — SOLO-CABLEADO: construye y cablea un renderizador de datos sintéticos de Karma (beauty + gran conjunto de AOV) en /stage; tú ejecutas el render. camera/primpath/primpattern son datos del grafo de escena USD; salidas de imagen restringidas; res/samples/frames limitados; botones de render nunca presionados.	16 opcionales
`render_ml_cv_synthetics_v11`	ROP Karma de síntesis ML-CV de Labs v1.1 (labs::ml_cv_synthetics_karma_rop::1.1, lop/Solaris) — SOLO-CABLEADO: misma postura que render_ml_cv_synthetics para el asset ::1.1 (2 entradas; importsecondaryinputvars). camera/primpath/primpattern son datos USD; salidas de imagen restringidas; res/samples/frames limitados; botones de render nunca presionados.	16 opcionales
`bake_karma_texture`	Horneador de texturas de Karma (karmatexturebaker, lop/Solaris) — SOLO-CABLEADO: construye y cablea el horneado de UV/textura de Karma en /stage y lo configura; tú ejecutas el horneado.	26 opcionales
`bake_impostor_texture`	Textura de Impostor de Labs (labs::impostor_texture, out/Driver) — SOLO-CABLEADO: construye y cablea el horneador de atlas de impostor octaédrico en /out; tú ejecutas el horneado. source_geo/camera_rig son rutas de nodos de escena; output_sequence/anim_output_sequence/sopoutput restringidos; res de sprite + muestras de rayo limitados; execute/renderdialog nunca presionados.	24 opcionales
`bake_motion_vectors`	Vectores de movimiento de Labs (labs::motion_vectors, out/Driver) — SOLO-CABLEADO: construye y cablea el horneador de atlas de vectores de movimiento en /out; tú ejecutas el horneado. export_node/camera son rutas de nodos de escena; vm_picture restringido; res de atlas + rango de frames limitados; execute/render_map/render_sequence/renderdialog nunca presionados.	10 opcionales
`bake_flipbook_textures`	Texturas de Flipbook de Labs (labs::flipbook_textures::1.0, out/Driver) — SOLO-CABLEADO: construye y cablea el horneador de hojas de textura flipbook en /out; tú ejecutas el horneado.	23 opcionales
`bake_haircard_texture`	Textura de Hair Card (haircardtex, out/Driver) — SOLO-CABLEADO: construye y cablea el horneador de textura de hair card en /out; tú ejecutas el horneado. hairobjects es un bundle de objetos, camera una ruta de nodo de escena; vm_picture restringido; tokens de nombre por mapa sanizados; res/samples limitados; execute/renderdialog nunca presionados.	23 opcionales
`export_geo_to_i3d`	Geometría a i3d (geo2i3d, out/Driver) — SOLO-CABLEADO: construye y cablea la exportación de textura de volumen geometría->i3d en /out; tú la ejecutas. filename (salida) e image (entrada, lectura) restringidos; res/rango de frames limitados; execute/renderdialog nunca presionados.	19 opcionales
`export_image_to_i3d`	Generador de texturas 3D (image3d, out/Driver) — SOLO-CABLEADO: construye y cablea el generador de texturas 3D i3d en /out; tú lo ejecutas. soppath/shoppath son rutas de nodos de escena; salida de imagen restringida; token de compresión sanizado; res/muestras/rango de frames limitados; execute/renderpreview/renderdialog nunca presionados.	27 opcionales

Referencias

Cuatro superficies de descubrimiento respaldan el catálogo de herramientas. capabilities es el índice de inicio — imprime punteros a todos los demás (incluida la URL del servidor de ayuda en vivo), así que en caso de duda llámalo primero.

Catálogo de herramientas — la lista enumerada de cada operación tipada (reference/catalog.json, el conteo autoritativo), presentada en las tablas anteriores; el detalle por parámetro proviene de la herramienta MCP node_reference y reference/NODE_REFERENCE.md. Esta es la frontera de seguridad: si no está en el catálogo, el servidor no puede hacerlo.
Referencia de nodos — la herramienta MCP node_reference responde "¿qué parámetros toma el nodo X?" a partir de la verdad fundamental sondeada en vivo; el archivo legible por humanos es reference/NODE_REFERENCE.md (SOP / OBJ / LOP / Driver / COP), anotado con qué herramienta expone cada nodo.
Referencia de VEX — la herramienta MCP vex_reference busca funciones VEX seguras validadas; la guía curada es reference/VEX_REFERENCE.md.
Servidor de ayuda de Houdini sin conexión — la documentación completa de SideFX de nodos/VEX/HOM, servida localmente y lanzada junto al puente. No tiene herramienta MCP; la salida de capabilities imprime su URL.

Datos geoespaciales del mundo real

Este es el diferenciador. acquire_terrain es la única operación de red — dale una lat/lon (+ radio) o una caja delimitadora explícita, y automáticamente selecciona una fuente, obtiene, reproyecta y prepara tiles listos para Houdini en tu directorio de trabajo. La cobertura es global (ver DOWNLOADER_SCOPE.md para la matriz completa):

Estados Unidos — USGS 3DEP (1 m lidar / 10 m / 30 m) + varios portales de lidar estatales.
Global de 30 m — Copernicus GLO-30, SRTM o JAXA ALOS AW3D30 (todos anónimos, sin clave), por lo que cualquier punto en la Tierra devuelve terreno.
Nacional de alta resolución — Países Bajos 0,5 m, Reino Unido 1 m, Francia 1 m / 0,5 m, España 5 m, Australia 5 m (selección automática cuando una solicitud "grande"/alta resolución cae completamente dentro de un país cubierto).
Opt-in con clave — API global de OpenTopography, usando la clave gratuita del propio usuario (HMCP_OPENTOPO_KEY), nunca incluida.

Dos modos de colocación:

plano — heightfields métricos locales para un sitio único, importados con elevación real con import_heightfield.
globo — tiles ECEF fijados en un globo WGS84 (build_globe + import_ecef_tile) para que un escaneo quede en un marco terrestre correcto y los tiles adyacentes se registren por construcción.

Debido a que un origen de proyecto se mantiene entre llamadas, los tiles sucesivos comparten un marco y se alinean automáticamente. La obtención está restringida a un pequeño conjunto de hosts DEM confiables; ninguna URL arbitraria cruza la frontera.

Convención 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)

La negación de Z es la trampa del espejo clásica — costó una sesión de depuración completa. Un origen se mantiene por proyecto para que los tiles sucesivos compartan un marco y se alineen automáticamente. Un <tile>.npy preparado necesita su acompañante <tile>.npy.json (cols, rows, res_m, houdini_center_x/z, nodata) junto a él.

Gotchas — Houdini 21.0.671

LIDAR/DEM del mundo real en Houdini se rompe de maneras poco obvias. Estos están confirmados en 21.0.671 y son el valor original ganado con esfuerzo de este proyecto:

GeoTIFF no es legible por COP2 de Houdini / heightfield_file. Todo el I/O de GeoTIFF ocurre en Python del sistema (rasterio) → .npy; solo los arrays cruzan a Houdini.
convertheightfield produce 0 prims desde volúmenes createVolume de estilo antiguo — pero convierte limpiamente desde un volumen SOP heightfield adecuado (verificado: 249k polígonos desde un heightfield por defecto).
heightfield_mosaic / heightfield_wrangle no existen en H21 — usa heightfield_patch / volumewrangle en su lugar.
El "congelamiento de 12 GB" es la teselación GL del viewport, no la RAM. Un heightfield pesado tesela cientos de millones de vóxeles en la GPU. Solución: construir con display-OFF, transmitir tiles empaquetados con un proxy de caja, y reducir la calidad del volumen (viewport_optimize). La RAM de datos no es un problema.
Nunca hagas flipbook o render OpenGL de una escena con heightfield pesado — puede colgar Houdini. Usa capture_ui (una captura de pantalla a nivel de SO) en su lugar.
Un volumen SOP heightfield necesita un atributo primitivo name='height', y los arrays LIDAR están ordenados por fila-norte-primero, por lo que las filas se invierten antes de setAllVoxels.
El viewport GL no muestra el bump del Principled Shader (solo render Karma); el relieve real necesita desplazamiento de geometría.

Opcional: renderizado GPU AMD (ProRender)

El camino GPU Karma XPU de Houdini es solo NVIDIA/OptiX. Si tienes una tarjeta AMD Radeon (RDNA2 / gfx1030+) y deseas renderizado GPU, este repositorio incluye una compilación desde fuente del delegado hdRpr de AMD Radeon ProRender adaptado a Houdini 21 / USD 25 — AMD no publica un plugin H21 precompilado. Se instala como un renderizador Hydra nativo ("RPR") en Solaris y es completamente opcional e independiente del MCP central.

Estado: funcionando (recompilado con el toolset v143 de MSVC; "RPR" es un renderizador Hydra seleccionable y los VOP de material RPR / ajustes de render LOP / Biblioteca de Materiales cargan). Una brecha de conveniencia conocida: el diálogo Render Devices del menú RPR aún necesita un port de binding de Python para USD-25 — no es necesario para renderizar. Consulta AMDProRender/README.md para la versión precompilada, pasos de compilación desde fuente y el parche del port.

Configuración

La mayoría de la configuración ocurre en la GUI y se escribe en un archivo de configuración compartido que ambas partes leen en vivo. La única variable de entorno que el cliente MCP necesita es el indicador de modo headless.

Configuración	Ubicación	Descripción
`HMCP_GW_HEADLESS`	env (config del cliente)	`1` = ejecuta el binario como pasarela MCP stdio headless; sin definir = abre la ventana GUI.
`HMCP_MIN_ACTION_INTERVAL_MS`	env (config del cliente)	Aceleración de acciones (por defecto `0` = desactivado). Cuando se define, la pasarela aplica este intervalo mínimo de tiempo real, en milisegundos, entre llamadas de herramientas destructivas sucesivas (`delete_node`, `save_scene`, `delete_keyframes`) — las acelera con una breve pausa, nunca rechaza. Un gobernador de seguridad para que un bucle descontrolado o una inyección de prompt no pueda disparar llamadas destructivas de escena. Las herramientas no destructivas (construcciones, lecturas) nunca se retrasan.
Directorio de trabajo	GUI → Working dir	Tu raíz de proyecto. Cada lectura/escritura de archivo está confinada bajo ella por `realpath`. Cambia + Aplicar tiene efecto en vivo, sin reiniciar.
Puerto del ejecutor	GUI → Configuración	Puerto loopback compartido por la pasarela y el ejecutor dentro de Houdini.
Token de sesión	GUI → Configuración	El secreto compartido entre la pasarela y el ejecutor. Se genera por ti.
Auto-armar Houdini	GUI → Configuración	Arma el ejecutor automáticamente cuando la GUI de Houdini inicia.

Seguridad

El modelo de seguridad es el límite mismo, no una caja de arena:

Solo datos por construcción. Sin código arbitrario, sin driver de nodo genérico, sin VEX o Python crudo que jamás llegue a Houdini. El catálogo es la superficie de ataque, y el catálogo son operaciones con forma de datos. Una prueba de regresión asegura que las primitivas RCE (exec / node_op / wrangle) nunca pueden aparecer en el catálogo.
Directorio de trabajo confinado por realpath. Cada operación de archivo resuelve y vuelve a verificar contra una raíz, con escapes de symlink/junction cerrados. Las lecturas deben existir bajo la raíz; las escrituras pueden crear una nueva hoja pero nunca escapar.
Armado con cierre por defecto. El ejecutor se niega a armarse a menos que una regla de firewall bloquee conexiones entrantes a su puerto loopback (ver Paso 4).
Los renders son solo de cable. setup_karma y bake_texture construyen gráficos pero nunca ejecutan — los disparas en Houdini.
batch no otorga privilegios. La meta-herramienta batch ejecuta hasta 64 operaciones en una llamada para reducir la latencia, pero cada operación se envía a través del mismo camino exacto que una llamada directa: validado por esquema, números limitados, rutas de archivo confinadas por realpath, y auditadas en orden. Un lote solo puede invocar herramientas reales del catálogo (sin código arbitrario, sin nombres no catálogo) y no puede anidar (se rechaza una operación llamada batch). Es un sobre de latencia, no un atajo para evadir el límite.
Aceleración de acciones opcional. HMCP_MIN_ACTION_INTERVAL_MS (por defecto desactivado) acelera herramientas destructivas (delete_node, save_scene, delete_keyframes) con una breve pausa para que un bucle descontrolado/inyección no pueda destruir la escena rápidamente. Ralentiza, nunca bloquea; las herramientas ordinarias no se ven afectadas (ver Configuración).
El Python incrustado de Houdini no está en sandbox, por lo que la garantía es lo que la IA puede pedir, validado en la pasarela — no aislamiento de procesos. Trata a la IA como entrada semi-confiada.
Postura prevista: loopback, un solo usuario confiable, máquina confiable. Esta es una herramienta local. El transporte debe permanecer en el host local.

Una auditoría a nivel de código confirma que el límite de solo datos se mantiene tal como está construido. Para el modelo de amenazas completo, el estado actual de endurecimiento y los elementos residuales conocidos, consulta SECURITY.md — léelo antes de ejecutar esto en cualquier lugar que no sea una máquina confiable individual.

Solución de problemas

Consulta docs/TROUBLESHOOTING.md para soluciones detalladas y docs/GUIDE.md para operación diaria.

Lista rápida:

La píldora de estado de la GUI dice Armado con tu versión de Houdini.
Houdini se lanzó después de que se instaló el paquete y se habilitó el auto-armado.
El paso de endurecimiento del firewall (Paso 4) se ejecutó — el ejecutor está en cierre por defecto sin él.
La configuración del cliente MCP apunta al houdini-bridge-mcp.exe compilado con HMCP_GW_HEADLESS establecido en 1.
Las rutas en la configuración del cliente usan doble barra invertida (C:\\...).
El cliente se reinició por completo después de editar su configuración.
Las rutas de archivo que pasas a las herramientas viven dentro del directorio de trabajo configurado.

Licencia

Dual-licencia. Gratuito para uso no comercial — personal, educativo, investigación y evaluación — bajo la PolyForm Noncommercial License 1.0.0. El uso comercial, empresarial y de producción requiere una licencia de pago; consulta COMMERCIAL-LICENSE.md para obtenerla.

La herramienta no incluye ningún dato de elevación — los descarga por ti en tiempo de ejecución. Las fuentes globales son de dominio público / abiertas (USGS 3DEP, Copernicus, SRTM, JAXA AW3D30); las fuentes nacionales de alta resolución requieren atribución bajo sus propias licencias abiertas (Países Bajos AHN y España IGN — CC-BY 4.0; Reino Unido EA — OGL; Francia IGN — Etalab OL 2.0; Australia GA — CC-BY 4.0). Consulta DOWNLOADER_SCOPE.md para la licencia/atribución por fuente. Los avisos de dependencias de terceros se generan en THIRD-PARTY-LICENSES.md para versiones publicadas (ver CONTRIBUTING.md).

Soporte

Si esto te ahorró tiempo y lo usas de forma no comercial, una propina siempre se aprecia — ko-fi.com/eviscerations. Es voluntaria y no otorga licencia; el uso comercial está cubierto por COMMERCIAL-LICENSE.md.

Desarrollo y pruebas

Las pruebas se ejecutan en tres niveles en dos entornos (Niveles 1–2 en CI, Nivel 3 local), divididos por lo que una máquina sin licencia de Houdini puede demostrar honestamente — consulta docs/TESTING.md para el método completo:

CI en la nube (cada push, sin licencia de Houdini): el cargo test en Rust protege los invariantes de seguridad de la pasarela — el catálogo nunca expone una herramienta de código arbitrario, los nombres de herramientas son únicos, y confine_path rechaza escapes de ../, symlink y junction. El trabajo de Python ejecuta el corpus de equipo rojo del validador safe-VEX, el límite de recorrido confined_path + escape de symlink, una verificación de paridad catálogo↔ejecutor en cada herramienta (cada herramienta se asigna a exactamente un endpoint de solo datos, ninguno con forma de RCE), y un smoke de construcción que llama al manejador de cada herramienta contra un Houdini simulado para detectar regresiones de código. Estos verifican que la superficie de herramientas es estructuralmente sólida y que el código de cada manejador se ejecuta — no cocinan geometría.
Local (antes de un push, con hython con licencia): la suite de comportamiento en tests/executor/ cocina geometría real y fija pruebas de regresión. Ejecuta hython tests/executor/run_tests.py.

El método completo está documentado para contribuyentes en docs/TESTING.md.

Contribuciones

Se aceptan pull requests — consulta CONTRIBUTING.md. Si pruebas en hardware o una configuración de Houdini no listada aquí, abre un issue con tus resultados.