Como configurar um gráfico do deformador de tratamento

O gráfico do deformador é um plugin com o qual você pode criar e editar ativos do Deformer Graph que realizam e personalizam deformações de malha para qualquer malha revestida na Unreal Engine. Com gráficos do deformador, você pode criar e modificar a lógica que ajusta a geometria da malha para refinar comportamentos de deformação ou criar deformações totalmente novas dentro da engine. Os gráficos de deformador costumam ser usados para ajustar comportamentos de revestimento, tecido e tratamento em movimento de personagens ou para animações pontuais que são mais fáceis de criar usando lógica de deformação do que animações criadas à mão.

Este é um exemplo de tratamento com (esquerda) e sem um deformador "endireitando" cada curva.

Gráfico do deformador de tratamento

Um gráfico do deformador expressa a deformação aplicada como um gráfico em que o nó "Custom Compute Kernel" contém o código que processa a deformação. A entrada para a deformação pode vir de várias fontes, como dados de cena, tratamentos e guias. A saída do gráfico grava os valores do tratamento, como posição e atributos.

Para obter uma visão geral mais detalhada de como usar o gráfico do deformador e se familiarizar com seu editor, consulte gráfico do deformador.

O gráfico do deformador tem várias áreas principais que você deve conhecer:

1. Painéis "Source" e "Parameters"
2. Gráfico do deformador
3. Painel "Details"
4. Painel do editor de texto do shader

Os principais elementos que compõem um gráfico do deformador são:

• O nó Primary fornece uma vinculação com o tipo de dados fornecido. Isso deve ser definido para o componente de tratamento.

  

• Os nós de entrada Groom e Guides. Fornecem acesso aos dados do tratamento e do guia, respectivamente.

  

• O nó Custom Compute Kernel (MyKernel) define a deformação aplicada ao tratamento e às guias.

  

• O nó de saída Write Groom grava dados de tratamento modificados.

  
• Este nó inclui algumas limitações:
  • Use as saídas Position ou Radius para escrever a posição e o raio do tratamento. Use a saída Position and Radius para escrever a posição e o raio.
  • Apenas atributos existentes em um tratamento podem ser substituídos. Por exemplo, você só poderá escrever rugosidade e não cor se um ativo de tratamento tiver um atributo de rugosidade, mas não um atributo de cor.
• No Shader Text Editor, você pode ver as declarações (somente leitura) do nó "Custom Compute Kernel" e adicionar o código HLSL personalizado para definir a deformação do tratamento.

Configure um gráfico do deformador de tratamento

Para usar essa funcionalidade, habilite o plugin Deformer Graph no navegador Plugins e reinicie a engine para que as alterações tenham efeito.

Para configuração um tratamento com um gráfico do deformador:

1. Crie um ativo Deformer Graph no Navegador de Conteúdo.
2. No painel Source, defina o menu suspenso do nó Primary para Groom Component e arraste o nó para o gráfico.

3. Clique com o botão direito no gráfico e adicione os seguintes nós:

   • Um nó de interface de dados Groom que dá acesso a todas as propriedades do tratamento principal.
   • Um nó de interface de dados de saída Write Groom que dá acesso a todas as propriedades editável do tratamento principal.
   • Um nó de Custom Compute Kernel para definir a lógica de deformação desse tratamento.

4. Conecte os nós no gráfico, que ficará assim:

   
   • Arraste e solte um fio de saída no pin New Input do nó Custom Compute Kernel para configurar automaticamente a interface de usuário do nó com o tipo e a frequência. Você também pode configurá-las manualmente no painel "Details" deste nó.

5. Selecione o nóCustom Compute Kernel. No painel Details, em Settings, defina Execution Domain como uma das seguintes opções:

   
   • Curve usa uma thread de GPU por curva.
   • Control Points usa uma thread de GPU por ponto de controle

6. Use o Editor de Texto Shader para inserir o código HLSL personalizado para a lógica de deformação do tratamento.

   
7. Compile e Salve o gráfico do deformador.

Após configurar o gráfico do deformador, você pode aplicar um deformador de tratamento a um componente de tratamento adicionado a uma malha esquelética. Use a caixa de seleção Mesh Deformers para aplicar o deformador do tratamento que você criou.

Algumas coisas adicionais a serem consideradas ao configurar um deformador de tratamento:

• Você pode acessar dados de cena ou parâmetros de entrada, com lógica de Blueprint.
• O kernel do computador define a lógica de deformação. Ele consome entradas e computa as saídas. Cada entrada tem um Tipo específico (Float, int, float3 e assim por diante) e uma Frequência (pontos de controle ou curvas). Você pode arrastar e conectar os fios de entrada da interface do tratamento ao kernel de computação personalizado para que a interface do usuário configure o tipo e a frequência automaticamente. Outra opção é fazer uma configuração manual no painel "Details".
• Todos os efeitos que dependem do tempo e do jogo em um tratamento só ficam visíveis quando o editor está Jogando ou Simulando.

Exemplo de código de shader gráfico do deformador de tratamento

O exemplo a seguir demonstra um deformador de tratamento aplicado a um tratamento que contém quatro fios verticais. O deformador só muda a posição do tratamento ao longo do tempo para criar um efeito de "aceno". O da esquerda não tem deformador, enquanto o da direita tem.

O tratamento à esquerda não está deformado. O tratamento da direita tem um deformador.

Para conseguir esse tipo de efeito com um gráfico do deformador , a Rest Position e a U Coordinate do tratamento ao longo de cada fio precisam ser lidas para calcular um deslocamento dinâmico com base no tempo.

O código do kernel para obter essa deformação é mais ou menos assim:

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));
}
Copy full snippet

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)); }

O kernel tem uma variável "Index" implícita que define o índice global de threads da GPU. Isso é usado para ler os pontos de controle corretos usando a função de leitura de entrada:

ReadInPosition(Index)
ReadInCoordU(Index)
Copy full snippet

ReadInPosition(Index) ReadInCoordU(Index)

Você só precisa garantir que dados inválidos não sejam acessados, pois o kernel é expedido em grupos de x threads (em que o padrão é 64 threads). A seguinte condição é adicionada para isso:

if (Index < ReadControlPOintCount())
Copy full snippet

if (Index < ReadControlPOintCount())

A saída é escrita usando a função de interface de saída "WriteOutPosition" como esta:

WriteOutPosition(Index, MyTransformedPosition)
Copy full snippet

WriteOutPosition(Index, MyTransformedPosition)

Editor de texto do shader

O Shader Text Editor é onde você modifica a programação de nó do Custom Compute Kernel usando linguagem de shader de alto nível (HLSL) para controlar comportamentos específicos de deformação da malha.

Esse painel fica no canto inferior direito do gráfico do deformador. Ele contém duas partes: Declarations e Shader Text. A seção de declarações exibe as funções de entrada e saída do kernel e é somente leitura. HLSL entrada na seção de texto do shader.

_O painel "Shader Text Editor" exibe as declarações e alguns códigos de deformação personalizados

Ao compilar o gráfico do deformador, use o painel Compiler Output abaixo do gráfico para verificar se há erros. Quaisquer erros encontrados durante a compilação são exibidos aqui.

Para obter informações adicionais e exemplos de como usar o editor de texto de Shader do gráfico do deformador, consulte:

• Gráfico do deformador
• Como criar um guia no gráfico do deformador
• Documentação de referência e guia de programação da High Level Shader Language da Microsoft