Instâncias de material expandidas

Alterar as propriedades do material de um ativo durante a jogabilidade é uma maneira útil de fornecer feedback visual durante a interação, informações de jogabilidade ou criar imersão. Por exemplo:

• As aparências da pessoa jogadora podem mudar para sinalizar diferentes efeitos de status.

• Os itens podem brilhar para atrair a atenção de pessoas próximas.

• Quando estiver chovendo, a transição do solo de seco para molhado pode aumentar a imersão.

Neste tutorial, você usará Blueprints para alterar as propriedades de materiais no tempo de execução em uma demonstração técnica interativa. Para esta demonstração, você criará uma bola de água que encharca o chão conforme ela é empurrada pelo nível.

Você também experimentará materiais emissivos, máscaras simples e interruptores estáticos para criar um cenário que se reflete no chão molhado.

Como criar um ativo de piso pronto para uso em jogos

O primeiro ativo que você construirá para a demonstração técnica será o piso. No Cômodo 3 do Lvl_Adventure, você criará um ativo de piso com superfície pronta para o jogo para substituir a malha provisória do piso.

Antes de começar, considere sua abordagem. No tutorial anterior, você aprendeu que ladrilhar texturas é uma maneira econômica de revestir malhas grandes, como um piso. Você também aprendeu que os UVs de uma malha afetam a aparência das texturas.

O piso provisório no Cômodo 3 é formado por três malhas, e cada uma tem UVs diferentes.

Na demonstração a seguir, observe que as texturas de ladrilhamento parecem ter tamanhos diferentes devido às inconsistências de UV entre as malhas. Isso representa um desafio para revestir o piso de forma coesa.

Você resolverá esse desafio usando a projeção triplanar. A projeção triplanar é uma técnica de revestimento que desconsidera os UVs e faz com que a textura se alinhe ao mundo. Ela é útil para casos em que não podemos corrigir os UVs ou estamos trabalhando com uma geometria em que é difícil mapear os UVs.

Com essa abordagem em mente, você usará expressões para fazer com que M_Surfaces se alinhem ao mundo. Como as instâncias herdam as propriedades dos materiais pais, MI_Surfaces_Floor também ficará alinhado ao mundo. Em seguida, você aplicará MI_Surfaces_Floor a um Blueprint que substituirá as malhas provisórias.

Como criar um material alinhado ao mundo

Para deixar seu material pai alinhado ao mundo, siga estes passos:

1. No Navegador de Conteúdo, acesse All, Content, AdventureGame, Artist, Materials e abra M_Surfaces.

2. Selecione todos os nós na caixa de comentários UV Tiling, o mapa difuso e o mapa de normais. Exclua-os.

   

3. Clique com o botão direito no gráfico e procure Texture Object (objeto de textura). Crie dois desses nós.

   

4. Selecione o primeiro objeto de textura. No painel Detalhes, defina Texture como DefaultDiffuse.

5. Clique com o botão direito no objeto de textura e selecione Convert to Parameter. Dê ao novo parâmetro o nome de Diffuse.

6. Selecione o segundo objeto de textura. No painel Detalhes, defina Texture como DefaultNormal.

7. Clique com o botão direito no objeto de textura e selecione Convert to Parameter. Dê ao novo parâmetro o nome de Normal.

8. No nó Diffuse, arraste da saída e adicione um nó World Aligned Texture (textura alinhada ao mundo).

   

9. Conecte a saída XYZ Texture à entrada A do nó Multiply (dentro da caixa de comentários "Diffuse Hue").

10. No nó Normal, arraste da saída e adicione um nó World Aligned Normal (normal alinhada ao mundo).

11. Conecte a saída XYZ Texture à entrada Normal do nó-raiz do material M_Surfaces.

12. Clique com o botão direito no gráfico e procure Scalar Parameter (parâmetro escalar). Dê a ele o nome de Texture Scaling.

13. Defina o Default Value (valor padrão) como 214.

14. Conecte a saída de Texture Scaling às entradas TextureSizeV3 nos dois nós WorldAligned.

15. Salve seu material.

O gráfico de material deve ter ficado assim:

Em seguida, você criará um Blueprint que substituirá o piso provisório.

Como criar um Blueprint de piso

Para criar o Blueprint, siga estes passos:

1. No Navegador de Conteúdo, no caminho All, Content, AdventureGame, Artist, clique com o botão direito e selecione New Folder (Nova pasta).

2. Dê à pasta o nome de Blueprints.

3. Clique com o botão direito na pasta Blueprints, selecione Blueprint Class e selecione Actor como a classe pai.

4. Dê ao Blueprint o nome de BP_Floor e clique duas vezes para abri-lo no Editor de Blueprint.

5. No Navegador de Conteúdo, selecione a pasta All e procure SM_Cube.

   

6. Arraste SM_Cube para o painel Components do Editor de Blueprint, como um filho de BP_Floor.

   

7. Dê ao "SM_Cube" o nome de Floor.

8. No painel Detalhes, certifique-se de que a escala esteja definida como 1.0, 1.0, 1.0.

9. Ao lado de Materials, Element 0, defina o material como MI_Surfaces_Floor.

   

10. Na aba Components, selecione DefaultSceneRoot, clique em Add e adicione Box Collision (caixa de colisão).

11. Dê a ela o nome de Trigger.

    

12. No painel Detalhes, defina a escala de "Trigger" como 1.5, 1.5, 1.5.

13. Defina a posição de Trigger como 50, 50, 55.

14. Salve e compile o Blueprint.

Arraste uma instância de BP_Floor para o seu nível e movimente-a. Observe que, conforme você move a malha, a textura permanece no mesmo lugar. Se você tentar dimensioná-la, a malha se alterará, mas a textura não.

Em seguida, você substituirá o revestimento provisório no Cômodo 3 por instâncias de BP_Floor.

Como substituir as malhas provisórias

Agora você pode substituir as malhas provisórias no Cômodo 3 por BP_Floor na disposição que preferir. Criamos um piso que corresponde aos elementos provisórios:

Se preferir usar o que foi mostrado acima, pode copiar este nível seguindo estes passos:

1. Verifique se atualizou M_Surfaces e criou BP_Floor seguindo o tutorial acima.

2. No Organizador, selecione tudo dentro da pasta "Room 3" e pressione Delete.

3. Copie o trecho a seguir.

   Console Output

   Begin Map
      Begin Level
         Begin Actor Class=/Script/Engine.StaticMeshActor Name=StaticMeshActor_2 Archetype="/Script/Engine.StaticMeshActor'/Script/Engine.Default__StaticMeshActor'" ExportPath="/Script/Engine.StaticMeshActor'/Game/SFEFWFWEEEWEF.SFEFWFWEEEWEF:PersistentLevel.StaticMeshActor_2'"
            Begin Object Class=/Script/Engine.StaticMeshComponent Name="StaticMeshComponent0" Archetype="/Script/Engine.StaticMeshComponent'/Script/Engine.Default__StaticMeshActor:StaticMeshComponent0'" ExportPath="/Script/Engine.StaticMeshComponent'/Game/SFEFWFWEEEWEF.SFEFWFWEEEWEF:PersistentLevel.StaticMeshActor_2.StaticMeshComponent0'"
            End Object
            Begin Object Name="StaticMeshComponent0" ExportPath="/Script/Engine.StaticMeshComponent'/Game/SFEFWFWEEEWEF.SFEFWFWEEEWEF:PersistentLevel.StaticMeshActor_2.StaticMeshComponent0'"
               StaticMesh="/Script/Engine.StaticMesh'/Game/LevelPrototyping/Meshes/SM_Cylinder.SM_Cylinder'"
               StaticMeshImportVersion=1
               bUseDefaultCollision=False
               StaticMeshDerivedDataKey="STATICMESH_FD1BFC73B5510AD60DFC65F62C1E933E_228332BAE0224DD294E232B87D83948FQuadricMeshReduction_V2$2e1_6D3AF6A2$2d5FD0$2d469B$2dB0D8$2dB6D9979EE5D2_CONSTRAINED0_100100000000000000000000000100000000000080FFFFFFFFFFFFFFFFFFFFFFFF000000000000803F00000000000000803F0000803F00000000000000003D19FC1626C9B2485E57DB4B8EC731318B8215AE8D46FAD400000000010000000100000000000000010000000100000000000000000000000100000001000000400000000000000001000000000000000000F03F000000000000F03F000000000000F03F0000803F00000000050000004E6F6E65000C00000030000000803FFFFFFFFF0000803FFFFFFFFF0000000000000041000000000000A0420303030000000000000000_RT00_0"
   
   Expand code Copy full snippet(2319 lines long)

4. Na janela de visualização, pressione CTRL+V.

   

A seguir, você criará a esfera de água e usará instâncias de material dinâmicas para transformar o chão de seco para molhado.

Como alterar os materiais usando a interação no jogo

A bola de água será um objeto habilitado por física que aciona uma alteração de propriedade no chão, fazendo-o parecer molhado.

Como criar uma bola de água

Para criar e levar à superfície a bola de água, siga estes passos:

1. No Navegador de Conteúdo, na pasta Blueprints, clique com o botão direito para criar uma nova classe de Blueprint.

2. Selecione Actor como a classe pai.

3. Dê a ele o nome de BP_WaterBall e abra-o no Editor de Blueprint.

4. Na aba Components, clique em Add e procure Sphere.

5. No painel Detalhes, defina Materials, Element 0 como M_Water.

   M_Water vem com a Unreal Engine; você não precisa baixá-lo ou criá-lo. Se esse ativo não estiver visível, clique no botão Settings no seletor de ativos ou no Navegador de Conteúdo e habilite Plugin Content.

   

6. Ainda no painel Detalhes, em Physics, selecione Simulate Physics.

   

7. Salve e compile o Blueprint.

8. Arraste uma instância de BP_WaterBall para o nível.

Teste a bola de água no nível clicando com o botão direito na janela de visualização e selecionando Play From Here. A bola deve quicar no chão quando você encostar nela.

Em seguida, você usará a lógica dentro de BP_Floor para criar uma instância de material dinâmica.

Como criar uma instância de material dinâmica

Uma instância de material dinâmica é uma instância de material gerada por código (como Blueprint) que pode alterar suas propriedades no tempo de execução.

Nesta seção, você criará uma lógica de Blueprint que referencia o material atribuído à malha do piso (MI_Surfaces_Floor), gera uma instância de material dinâmica a partir dele e atribui a nova instância ao piso. Em seguida, a instância de material dinâmica altera as propriedades expostas no tutorial anterior, "Roughness" e "Diffuse Hue", para simular um chão molhado.  

Durante o tempo de execução, essa troca fará parecer que o piso está encharcado com uma fina camada de água.

Para criar uma instância de material dinâmica, siga estes passos:

1. No Navegador de Conteúdo, clique duas vezes em BP_Floor para abri-lo no Editor de Blueprint.

2. No EventGraph, exclua todos os nós, exceto o Event BeginPlay.

3. Na aba Components, arraste uma instância de Floor para o gráfico de eventos.

4. Da saída de Floor, arraste e procure Get Material.

   

5. Da saída de Return Value de Get Material, arraste e adicione um nó Create Dynamic Material Instance em que o destino é a Kismet Material Library.

   

6. Conecte a saída de Event BeginPlay à entrada Exec pin de Create Dynamic Material Instance.

   

7. De Return Value de Dynamic Material Instance, arraste e selecione Promote to Variable.

8. No painel Detalhes, mude o nome desta variável para Dynamic Mat Ref.

9. Arraste outra instância de Floor para o gráfico de eventos.

10. Da saída de "Floor", arraste e procure Set Material.

11. Conecte a saída white Exec no nó "Set" à entrada Exec do nó Set Material.

12. Conecte a saída azul do nó "Set" à entrada Material do nó "Set Material".

    

13. Para manter o gráfico organizado, selecione todos os nós e pressione a tecla C. Dê à caixa de comentários o nome de Create Dynamic Material.

14. Salve e compile.

O gráfico de eventos deve ficar assim:

Como chamar eventos

Para acionar a aparência molhada do chão, você precisará de um evento que verifique se BP_Floor está se sobrepondo a BP_WaterBall e um evento que chame o visual correto como resultado.

Vamos esboçar a lógica:

• Quando um ator se sobrepõe a BP_Floor:

  • Verifique se o outro ator é (igual a) BP_WaterBall. Se for (verdadeiro), então:

    • Chame o visual molhado do BP_Floor.

  • Caso contrário, se não for verdadeiro (falso), então:

    • Não faça nada.

Para criar essa lógica, siga estes passos:

1. Clique com o botão direito em EventGraph de BP_Floor e procure Add Custom Event. Dê a este nó o nome de Call Wet Look.

2. Na aba Components, clique com o botão direito em Trigger e crie Add Event, Add OnComponentBeginOverlap.

   

   

   OnComponentBeginOverlap procura colisão.

3. Na saída Other Actor em OnComponentBeginOverlap, arraste e crie Get Class.

4. Da saída Return Value, arraste e crie um nó Equal.

5. Clique com o botão direito no campo Select Class e selecione Promote to Variable.

6. Dê à variável o nome de WaterBall e compile o Blueprint.

   

7. No painel Detalhes, defina o valor padrão de WaterBall como BP_WaterBall.

   

8. Da saída do nó Equal, arraste e crie um nó Branch.

9. No pin True do nó Branch, arraste e pesquise Call Wet Look.

10. Conecte a saída Exec de OnComponentBeginOverlap à entrada Exec do nó Branch.

O gráfico de eventos deve ficar assim:

Como controlar as propriedades dos materiais

Agora, você construirá a variação molhada do chão. Como o piso tem textura de pedra e é poroso, ele deve escurecer conforme absorve água (Diffuse Hue). Como há uma fina camada de água sobre ela, a superfície deve ter um aspecto lustroso (Roughness).

Para criar a lógica do visual molhado, siga estes passos:

1. Arraste a variável Dynamic Mat Ref para o EventGraph e selecione Get na lista.

   

2. Arraste o pin de saída e crie um nó Set Scalar Parameter Value.

3. Do mesmo pin de saída, arraste e crie Set Vector Parameter Value.

   Lembra dos parâmetros que você expôs em M_Surfaces? Roughness é uma escalar (valor único) e o Diffuse Hue é um vetor (três valores; RGB).

4. No nó Set Scalar Parameter Value, clique com o botão direito em Parameter Name e selecione Promote to Variable. Dê à variável o nome de Roughness.

5. No nó Set Vector Parameter Value, clique com o botão direito em Parameter Name e selecione Promote to Variable. Dê à variável o nome de Diffuse Hue.

6. Compile o Blueprint e digite valores para o nome de cada parâmetro:

   1. Selecione a variável "Roughness" e insira Roughness como o valor padrão.  

   2. Selecione a variável Diffuse Hue e insira Diffuse Hue como o valor padrão.

      

      Os valores padrão devem corresponder aos parâmetros em M_Surfaces.

7. Conecte o pin de Exec de saída do nó Set Scalar Parameter Value ao pin de Exec de entrada do nó Set Vector Parameter Value.

   

Além de passar de seco para molhado, você pode usar lógica para controlar a velocidade com que essa mudança ocorre. Como saturar uma substância leva tempo, você fará a transição gradual das propriedades do material de um estado para o outro. Você pode fazer isso com um nó de interpolação linear (lerp).

Para criar um lerp, siga estes passos:

1. Da entrada Value do nó Scalar Parameter, arraste e crie um Lerp. Assim, controlamos a rugosidade.

   

2. No Lerp, defina o valor A como 1.0. Esse será o valor da rugosidade para o visual seco. Deixe o valor B em 0.0. Esse será o valor do visual molhado.

   No tutorial anterior, você aprendeu que a rugosidade definida como 1 é fosca e como 0, lustrosa. Queremos que a água fique lustrosa.  

3. Da entrada Value do nó Set Vector Parameter Value, arraste e crie um Lerp (Linear Color). Isso vai controlar o matiz difuso.

   

4. Arraste e selecione Promote to Variable (linear color) do valor A do novo Lerp. Dê à variável o nome de Unsaturated.

   

5. Do valor B do Lerp, arraste e selecione Promote to Variable. Dê à variável o nome de Saturated.

6. Compile seu Blueprint. No painel Detalhes, defina o valor padrão de Unsaturated como CDDAFFFF.

   

7. No painel Detalhes, defina o valor padrão de Saturated para algo mais escuro, como 656C7FFF.

O gráfico de eventos deve ficar assim:

Acabamos de criar um novo visual para o piso usando a lógica do Blueprint. Porém, falta um mecanismo para alimentar essa lógica: uma Timeline (linha do tempo).

Impulsione sua lógica com linhas do tempo

De forma semelhante à linha do tempo em um software de animação, os nós Timeline determinam valores entre keyframes ao longo do tempo. Usaremos esse nó para controlar a interpolação entre os visuais seco e molhado durante um período específico.

Para criar uma linha do tempo, siga estas etapas:

1. Clique com o botão direito no EventGraph, procure e crie Add Timeline.

   

2. Clique duas vezes no nó Timeline para abrir a aba Timeline_Template.

3. Clique em Track e selecione Add Float Track na lista.

4. Dê à faixa o nome de Alpha. O nome da faixa aparecerá como um pin de saída no nó Timeline.

5. Defina o extensão da linha do tempo como 3.0 segundos.

   

6. Clique com o botão direito na linha do tempo e selecione Add Key.

7. Com o keyframe selecionado e destacado em azul, defina Time e Value para esse keyframe como 0.0.

   

8. Crie um segundo keyframe e defina Time e Value como 1.0.

9. Clique com o botão direito no primeiro keyframe e selecione User.

   

   A configuração de User permite controlar a transição da animação. Optamos por aumentar lentamente a velocidade do efeito saturado.

   

10. Salve e compile.

Essa linha do tempo agora gera um valor que mescla de 0 a 1 durante três segundos. Agora você pode conectar os nós restantes à linha do tempo:

1. Voltando ao gráfico de eventos, conecte a saída Call Wet Look à entrada Play na linha do tempo.

2. Conecte a saída Update na linha do tempo à entrada Exec de Set Scalar Parameter Value.

3. Conecte a saída Alpha da linha do tempo às entradas Alpha nos dois Lerps.

   

4. Selecione os nós e pressione C para comentar. Dê à caixa de comentários o nome de Lerp Dynamic Materials.

   

5. Salve e compile.

O gráfico de eventos completo deve ficar assim:

Para testar seu trabalho, clique com o botão direito no nível e selecione Play From Here. Quando você empurrar a bola de água pelo cômodo, o chão deve "inundar".

É difícil ver a refletividade da superfície molhada à luz do dia. Para mostrar a refletividade do chão, escureça o nível e adicione iluminação usando um Emissive Material (material emissivo).

Materiais emissivos

Os materiais emissivos são uma maneira barata de criar autoiluminação. Eles podem ser usados para criar brilho incorporado em materiais mais complexos, como LEDs na armadura de ficção científica de um personagem ou nas luzes de freio de um carro.

Os materiais emissivos também podem interagir com o Sistema de Iluminação Global e Reflexos do Lumen, o que significa que interagem com o ambiente ao seu redor.

O brilho de um material emissivo pode ser controlado com valores de float que variam de 0 (sem luz) a 1 (luz emissiva) ou acima de 1 (luz emissiva que cria bloom).

Os materiais emissivos e os reflexos são mais perceptíveis em níveis escuros. Para alterar a iluminação geral no seu nível, siga estes passos:

1. No Organizador, selecione Directional Light.

2. Na janela de visualização, pressione CTRL+L e mova o mouse para ajustar a posição da luz direcional e a hora relativa do dia no nível.

   

Como criar um material emissivo

Neste tutorial, você construirá letreiros de neon que refletem na pedra molhada quando posicionados ao redor do nível. Para isso, você criará um material pai flexível que pode propagar os seguintes parâmetros às instâncias filhas:

• A cor emissiva;

• O brilho emissivo; e

• A máscara de textura.

Para criar um material emissivo, siga estes passos:

1. No Navegador de Conteúdo, no caminho All, Content, AdventureGame, Artist, Materials, crie um novo Material.

2. Dê ao material o nome de M_EmissiveSign e clique duas vezes nele para abrir o Editor de Material.

3. No gráfico de material, arraste a entrada Emissive Color do nó-raiz do material e adicione um nó Multiply da lista de seleção.

4. Arraste da entrada A do nó Multiply e adicione um Constant3Vector.

   

5. Clique com o botão direito em Constant3Vector e selecione Convert to Parameter.

6. Renomeie o parâmetro como Color.

7. Clique duas vezes na amostra de cores e escolha uma cor para o emissivo.

8. Arraste da entrada B do nó Multiply e adicione um nó Constant da lista de seleção.

   

9. Converta a constante em um parâmetro, dê a ele o nome de Brightness e defina o valor como 25.

O gráfico de material deve ter ficado assim:

Limite os parâmetros com fixadores

Embora o brilho emissivo não tenha limite superior, você pode definir seus próprios limites personalizados para o brilho mínimo e máximo no material pai usando um fixador. A fixação pode facilitar o ajuste de valores com uma barra, especialmente ao lidar com números pequenos e ajustes sensíveis.

Como outros parâmetros, os fixadores são propagados para instâncias de material.

Para fixar a constante de brilho, siga estes passos:

1. No gráfico de material, selecione o parâmetro Brightness.

2. No painel Detalhes, defina Slider Max como 50.

   

Em seguida, você fornecerá o conteúdo do letreiro usando máscaras de textura.

Como criar uma máscara simples

Uma máscara de textura é um mapa de textura em tons de cinza (alfa) ou de canal único, usado para revelar ou ocultar certas áreas de um material. Você pode imaginar uma máscara alfa como camadas; a área branca da máscara revela informações de uma camada inferior e a área preta as oculta.

No material emissivo, você usará uma máscara alfa para revelar ou bloquear áreas de brilho emissivo para criar o conteúdo do letreiro neon.

Para criar uma máscara dentro do material pai M_Emissive, siga estes passos:

1. Sem nós selecionados, acesse o painel Detalhes. Ao lado de Blend Mode, clique no menu suspenso e selecione Masked.

   

2. No gráfico de eventos, clique com o botão direito e crie um elemento Texture Sample.

3. No painel Detalhes, ao lado de Texture, procure T_UE_Logo_M.

   Essa textura vem com a Unreal Engine; você não precisa baixá-la ou criá-la.

4. Conecte a saída RGB em "Texture Sample" à entrada Opacity Mask no nó-raiz do material.

5. Clique com o botão direito na Texture Sample e selecione Convert to Parameter. Dê ao parâmetro o nome de LED Sign.

O gráfico de material deve ter ficado assim:

Você criou um material que imita um letreiro neon. A seguir, você aumentará a flexibilidade do material pai e a quantidade de ativos únicos que pode criar invertendo a máscara:

Máscara original.	Máscara invertida.

Para conseguir isso, crie instâncias de material exclusivas para as máscaras invertida e não invertida. Em vez disso, você usará um Static Switch (interruptor estático) para alternar a inversão em qualquer instância de material criada a partir de M_EmissiveSign.

Alterne os parâmetros com interruptores estáticos

No tutorial anterior, você aprendeu sobre a hierarquia de propagação de materiais; instâncias filhas herdam as propriedades dos materiais pais.

Uma instância pode personalizar um parâmetro herdado, mas não pode ignorá-lo completamente, a menos que você use um interruptor estático. Interruptores estáticos, definidos no material pai, permitem que instâncias filhas ativem ou desativem os parâmetros.

Como os parâmetros desativados não são compilados, os interruptores estáticos podem melhorar o desempenho no tempo de execução. No entanto, como cada booleano cria uma nova permutação de shader, isso pode aumentar drasticamente o tempo de compilação (dependendo da complexidade do material). O valor dos interruptores depende de como você os utiliza e das necessidades de desenvolvimento do seu projeto.

Para criar um interruptor estático que controla a inversão da máscara, siga estes passos:

1. No gráfico de material, selecione o nó LED Sign e duplique-o pressionando CTRL+D.

2. Renomeie o novo nó como Screen.

3. Da saída RGB de Screen, arraste e procure One Minus.

4. Clique com o botão direito no gráfico e procure Static Switch Parameter. Dê ao interruptor o nome de Flip Mask?

5. Conecte a saída de One Minus à entrada False do interruptor.

6. Conecte a saída RGB do letreiro de LED à entrada True do interruptor.

7. Conecte a saída do interruptor à entrada Opacity Mask do nó-raiz do material.

8. Salve seu material.

O gráfico de material deve ter ficado assim:

Agora você pode criar instâncias de material a partir de M_EmissiveSign que controlam com exclusividade o brilho, a cor, o mapa de textura ou a inversão de máscara.

Aplique instâncias de M_EmissiveSign a malhas novas ou existentes no nível para criar uma cena de sua escolha. Conforme você rola a bola de água pelo nível, os letreiros vão refletir no chão molhado usando o Sistema de Iluminação Global e Reflexos do Lumen, que está ativado por padrão. Você aprenderá mais sobre Lumen e outros sistemas de reflexos no próximo tutorial.

A seguir

No próximo tutorial, você aprenderá mais sobre reflexos em volumes de pós-processamento, sistemas de iluminação e como aplicar diferentes efeitos na câmera no seu nível.

• 

  Como adicionar volumes de pós-processamento

  Crie volumes de pós-processamento para controlar o visual e o desempenho de um nível.