Descripción: Utiliza grafos deformadores para definir comportamientos de renderizado capilar con deformaciones de malla. SEO-Description: Utiliza grafos deformadores para definir comportamientos de renderizado capilar con deformaciones de malla en Unreal Engine. Type: Overview Parent: working-with-content/hair-rendering Engine-Concept: Designing Visuals, Rendering, and Graphics Track: GameDev Skill-Family: Foundation Tags: Renderizado Tags: Física Tags: Pelo Tags: Renderizados capilares Tags: MetaHumans Topic-image: Hero-image: working-with-content/hair-rendering/Hair_Banner.png Version: 5.4 Order: 14
Deformer Graph es un complemento con el que puedes crear y editar recursos de grafo deformador que realizan y personalizan deformaciones de malla para cualquier malla articulables en Unreal Engine. Con los grafos deformadores, puedes crear y modificar lógica que ajusta la geometría de la malla para afinar los comportamientos de deformación o crear deformaciones completamente nuevas dentro del motor. Los grafos deformadores se suelen usar para ajustar con precisión los comportamientos de piel, tejido y renderizado capilar en movimiento de los personajes, o para animaciones únicas, que son más fáciles de crear con lógica de deformación que con animaciones manuales.
Este es un ejemplo de un renderizado capilar con (izquierda) y sin deformador que «enderece» cada curva.
 |
 |
|---|---|
| Renderizado capilar con deformador. | Renderizado capilar sin deformador que «enderece» cada curva. |
Grafo deformador de renderizado capilar
Un grafo deformador expresa la deformación aplicada como un grafo en el que el nodo Custom Compute Kernel contiene el código que gestiona la deformación. La entrada para la deformación puede provenir de varias fuentes, como datos de escena, renderizados capilares y guías. La salida del grafo escribe los valores del renderizado capilar, como la posición y los atributos.
Para ver una introducción más detallada sobre cómo usar el grafo deformador y familiarizarte con su editor, consulta Grafo deformador.
El gráfico deformador tiene varias áreas clave que conviene conocer:
- Paneles de código fuente y de parámetros
- Grafo deformador
- Panel de detalles
- Panel del editor de texto del sombreador
Los elementos clave que componen un grafo deformador son:
* El nodo Primary establece una vinculación con el tipo de datos que proporciona. Debería establecerse como componente de renderizado capilar.
* Los nodos de entrada Groom y Guides. Proporcionan acceso a los datos de las guías y del renderizado capilar, respectivamente.
* El nodo Custom Compute Kernel (MyKernel) define la deformación aplicada al renderizado capilar y las guías.
* El nodo de salida Write Groom escribe los datos del renderizado capilar modificado.
Este nodo tiene algunas limitaciones: Utiliza los resultados de Position o Radius para escribir la posición y el radio del renderizado capilar. Utiliza el salida Position y Radius para escribir tanto la posición como el radio. Solo se pueden escribir los atributos existentes dentro de un renderizado capilar. Por ejemplo, solo puedes escribir la dureza y no el color si un recurso de renderizado capilar tiene el atributo de dureza pero no el de color. En el editor de texto del sombreador puedes ver las declaraciones (de solo lectura) del nodo Custom Compute Kernel y añadir tu código HLSL personalizado para definir la deformación del renderizado capilar.
Configuración de un grafo deformador de renderizado capilar
Para usar esta función, primero debes activar el complemento Deformer Graph en el explorador de complementos y reiniciar el motor para que se apliquen los cambios.
Para configurar un renderizado capilar con un grafo deformador:
- Crea un recurso de grafo deformador en el explorador de contenido.
- En el panel Fuente, configura el desplegable del nodo Primary como componente de renderizado capilar y arrastra el nodo al grafo.
-
Haz clic derecho en el grafo y añade los siguientes nodos:
- Un nodo de interfaz de datos llamado Groom que da acceso a todas las propiedades del renderizado capilar principal.
- Un nodo de interfaz de datos de salida llamado Write Groom que da acceso a todas las propiedades de escritura del renderizado capilar principal.
- Un nodo Custom Compute Kernel para definir la lógica de deformación de este renderizado capilar.
-
Conecta los nodos del grafo de la siguiente forma:
Al arrastrar y soltar un cable de salida en el pin Nueva entrada del nodo **Custom Compute Kernel, la interfaz de usuario del nodo se configura automáticamente con el tipo y la frecuencia. También puedes realizar la configuración manualmente en el panel Detalles de este nodo.
-
Selecciona el nodo Custom Compute Kernel. En el panel Detalles debajo de Configuración, elige una de las configuraciones siguientes para Dominio de ejecución:
Curva usa un subproceso de GPU por curva. Puntos de control usa un subproceso de GPU por punto de control
-
Utiliza el editor de texto del sombreador para introducir tu código HLSL personalizado para la lógica de deformación de este renderizado capilar.
- Compila y guarda el grafo deformador.
Una vez que se configura el del deformador, puedes aplicar un deformador de retoque facial a un componente de renderizado capilar añadido a una malla esquelética. Utiliza el cuadro de selección Deformadores de malla para aplicar el deformador de renderizado capilar que has creado.
Otros aspectos a tener en cuenta a la hora de configurar un deformador de renderizado capilar:
Con la lógica de blueprint, puedes acceder a datos adicionales, como datos de escena o parámetros de entrada.
El kernel de computación define la lógica de deformación. Consume entradas y calcula salidas. Cada entrada tiene un tipo (float, int, float3, etc.) y una **frecuencia** (puntos de control o curvas) específicos. Puedes arrastrar y conectar cables de entrada desde la interfaz de renderizado capilar hasta el kernel de computación personalizado para que la interfaz de usuario configure automáticamente el tipo y la frecuencia, o puedes configurarlo manualmente en el panel Detalles.
Todos los efectos que dependen del tiempo y del juego en un renderizado capilar solo son visibles cuando el editor está reproduciendo o simulando**.
Ejemplo de código del sombreador del grafo deformador de renderizado capilar
En el siguiente ejemplo, se aplica un deformador de renderizado capilar a un renderizado capilar que contiene cuatro mechones verticales. El deformador solo cambia la posición del renderizado capilar con el tiempo para crear un efecto de «onda». El renderizado capilar de la izquierda no tiene deformador, mientras que el de la derecha sí.
El renderizado capilar de la izquierda no está deformado. El renderizado capilar de la derecha tiene un deformador.
Para conseguir este tipo de efecto con un grafo deformador, es necesario leer la Posición de reposo y la Coordenada U del renderizado capilar a lo largo de cada mechón para calcular un desfase dinámico basado en el tiempo.
El código del kernel para lograr tal deformación sería el siguiente:
if (Index < ReadControlPointCount())
{
const float3 P = ReadInPosition(Index);
const float U = ReadInCoordU(Index);
const float T = abs(sin( U * ReadTime()));
WriteOutPosition(Index, P + T * float3(5,0,0));
}
El kernel tiene implícita una variable Index que define el índice global de subprocesos de la GPU. Se usa para leer los puntos de control correctos usando la función de lectura de entrada:
ReadInPosition(Index)
ReadInCoordU(Index)
Solo tienes que garantizar de que no se accede a datos no válidos, ya que el kernel se distribuye en grupos de x subprocesos (donde el valor predeterminado es 64 subprocesos). Para ello, se añade la siguiente condición:
if (Index < ReadControlPOintCount())
El salida se escribe mediante la función de interfaz de salida WriteOutPosition de la siguiente forma:
WriteOutPosition(Index, MyTransformedPosition)
Editor de texto del sombreador
En el editor de texto del sombreador modificarás la programación de nodo Custom Compute Kernel usando lenguaje de sombreador de alto nivel (HLSL) para controlar comportamientos de deformación de malla específicos.
Este panel se encuentra en la esquina inferior derecha del grafo deformador. Se compone de dos partes: las declaraciones y el texto del sombreador. La sección de declaraciones muestra las funciones de entrada y salida del kernel y es de solo lectura. El código HLSL personalizado se introduce en la sección de texto del sombreador.
El panel del editor de texto del sombreador muestra las declaraciones y parte del código de deformación personalizado.
Cuando compiles el grafo deformador, usa el panel Salida del compilador debajo del grafo para comprobar que no haya errores. Aquí se muestran los errores encontrados durante la compilación.
Para obtener más información y ver ejemplos de cómo usar el editor de texto del sombreador del grafo deformador, consulta: