Crie cachoeiras com VFX | Documentação - Central de Criadores Roblox

Uma cachoeira é um ponto em um rio ou riacho onde a água flui sobre uma ou mais quedas verticais em um corpo de água. Os jogos frequentemente incluem cachoeiras por razões estéticas visuais, como para melhorar o ambiente ou criar um ponto de interesse visual, ou para propósitos funcionais de jogabilidade, como esconder recursos ou transitar jogadores entre diferentes áreas no próprio local.

Usando o arquivo Waterfall Island .rbxl como referência, este tutorial mostra como criar uma cachoeira com objetos VFX que representam o comportamento físico do mundo real, incluindo orientações sobre:

Dividir material de referência em componentes individuais com características visuais e comportamentais distintas.
Configurar cascatas que caem em diferentes taxas para emular a dispersão da água à medida que desce de um penhasco.
Configurar respingos para emular a água se tornando aerosolizada à medida que as cascatas impactam a piscina de queda subjacente.
Configurar água branca para emular água turbulenta aerada onde o escoamento colide com rochas.
Configurar espuma para emular uma onda capilar quebrando a tensão superficial.
Configurar névoa para emular vapores de névoa subindo e se afastando do ponto de impacto, criando um arco-íris que os jogadores podem ver de qualquer ângulo.

Você pode criar suas próprias texturas em ferramentas de criação de texturas de terceiros e acompanhar seu próprio design. Para informações sobre como importar texturas para uso no Studio, consulte Gerenciador de Ativos.

Dividir referência

Para criar cachoeiras credíveis, é importante referenciar características naturais do mundo real no processo de design, pois isso permite que você divida o assunto em componentes individuais com características visuais e comportamentais distintas. Por exemplo, o jogo de amostra Waterfall Island faz referência às Snoqualmie Falls no estado de Washington para informar todas as decisões de design de textura e VFX relacionadas à cachoeira e ao terreno circundante.

Uma visão distante das Snoqualmie Falls.

Enquanto uma cachoeira é um fluxo contínuo e conectado de água que envolve múltiplos estados da matéria com movimento dinâmico de fluido e ar, é útil dividir esse sistema complexo em componentes individuais para que você possa planejar como utilizar diferentes objetos VFX para imitar seus equivalentes do mundo real. Para demonstrar, este tutorial divide a cachoeira de amostra em cinco componentes únicos:

Cascatas – A água que desce do penhasco.
Respingos – A água que se espalha à medida que as cascatas colidem com a piscina de queda subjacente.
Água Branca – A água turbulenta que surge à medida que a fonte de água se aproxima da borda do penhasco.
Espuma – A água aerada que se espalha horizontalmente ao colidir com as cascatas e a piscina de queda.
Névoa – A água em forma de nuvem que evapora no ar como resultado da cachoeira como um todo.

Snoqualmie Falls com todos os cinco componentes destacados.

A cachoeira de amostra com os mesmos cinco componentes destacados para comparar a imagem de referência com o resultado final.

As seções a seguir fornecem uma análise detalhada das diferentes decisões de design e técnicas que você pode usar para recriar cada um desses componentes de cachoeira que compõem a queda principal no espaço 3D da amostra. À medida que você revisa essas decisões e experimenta com várias propriedades de Beam e ParticleEmitter, você aprenderá como utilizar VFX para resolver os requisitos ambientais únicos para seus próprios jogos.

Configurar cascatas

Uma cascata é a água que cai sobre a borda de penhascos ou falésias em piscinas de queda subjacentes. As cascatas caem em diferentes taxas dependendo tanto do seu volume de água quanto da escala de sua queda na piscina de queda. Por exemplo, a queda principal da amostra parece cair mais lentamente porque há um grande volume de água caindo sobre uma grande distância, mas a segunda queda da amostra parece cair mais rapidamente porque um volume menor de água está caindo sobre uma curta distância.

Queda principal

Segunda queda

Além disso, as cachoeiras frequentemente têm camadas de cascatas que caem em diferentes taxas porque a água se dispersa à medida que desce na piscina de queda. Para demonstrar esse princípio, a amostra usa múltiplos objetos Beam com texturas contínuas que renderizam entre objetos Attachment em velocidades e comprimentos variados. Além de fornecer à queda principal um comportamento de queda mais realista, essa técnica também cria uma ilusão de paralaxe para fazer a cascata parecer ter uma sensação de profundidade e volume, mesmo sendo apenas uma imagem 2D.

Esta cachoeira parece natural porque a água desce e se dispersa em várias taxas.

Esta cachoeira parece não natural porque a água desce e se dispersa na mesma taxa.

Para recriar as cascatas para a queda principal no arquivo de lugar da amostra Waterfall Island:

Crie o escoamento para a água em cascata.
1. Na janela Explorer, crie uma Pasta no Workspace para conter todos os objetos de escoamento, e renomeie a pasta para Outflow.
2. Insira duas partes bloco na pasta Outflow, e renomeie-as para OutflowStart e OutflowStop, respectivamente.
3. Mova OutflowStart para onde você deseja que o escoamento comece, e mova OutflowStop para a borda do penhasco.
4. Insira um anexo em OutflowStart e OutflowStop, e então gire os anexos até que a ajuda visual amarela aponte para cima.
5. Insira um Beam na pasta Outflow, e renomeie-o para OutflowWater.
6. Atribua o anexo de cada parte ao OutflowWater.
  1. Na janela Explorer, selecione OutflowWater.
  2. Na janela Properties,
    
    Defina Attachment0 para o anexo em OutflowStart.
    
    Defina Attachment1 para o anexo em OutflowStop. O feixe renderiza sua textura padrão entre os dois anexos.
7. Personalize a aparência visual do feixe para que pareça água fluindo em direção à borda do penhasco.
  1. Na janela Explorer, verifique se OutflowWater ainda está selecionado.
  2. Na janela Properties,
    
    Defina Texture para rbxassetid://4787437624 para renderizar uma nova textura que pareça espuma fluindo.
    
    Defina Width0 para 60 para alargar a textura a partir do eixo que começa a renderizar.
    
    Defina Width1 para 20 para afunilar a textura até a borda do penhasco.
    
    Defina TextureSpeed para 0.4 para desacelerar o fluxo da textura.
    
    Defina TextureLength para 64 para esticar o comprimento da textura.
    
    Defina TextureMode para Wrap para repetir a textura na quantidade do comprimento total do feixe no mundo 3D entre os anexos dividido pelo seu TextureLength. Isso permite que a textura pareça muito mais realista em relação à água fluindo.
    
    Defina Color para uma sequência de cores que alterna entre azul escuro e claro até branco.
    
    Clique na propriedade Color, e então clique no botão ⋯. Um pop-up de sequência de cores será exibido.
    
    Cada triângulo no eixo inferior da sequência de cores é um ponto-chave que determina o valor da cor da propriedade naquele ponto da vida útil da partícula.
    
    Defina as seguintes propriedades de tempo e valor ao longo da sequência de cores:
    
    Time = 0, RGB Value = 208, 247, 255
    
    Time = 0.135, RGB Value = 146, 235, 255
    
    Time = 0.248, RGB Value = 255, 255, 255
    
    Time = 0.384, RGB Value = 128, 183, 202
    
    Time = 0.757, RGB Value = 166, 213, 248
    
    Time = 1, RGB Value = 255, 255, 255
    
    Defina Transparency para uma sequência numérica que faz a água se tornar mais vibrante à medida que se aproxima da borda do penhasco.
    
    Clique na propriedade Transparency, e então clique no botão ⋯. Um pop-up de sequência numérica será exibido. Por padrão, o gráfico é uma linha reta e a imagem permanece com a mesma transparência da esquerda para a direita.
    
    Cada quadrado no início e no final da sequência numérica é um ponto-chave que determina o valor de transparência da propriedade naquele ponto da textura da esquerda para a direita.
    
    Defina as seguintes propriedades de tempo e valor ao longo da sequência numérica:
    
    Time = 0, Value = 1
    
    Time = 0.375, Value = 0.725
    
    Time = 0.615, Value = 0
    
    Time = 0.92, Value = 1
    
    Time = 1, Value = 1
    
    Escale cada parte para garantir que a textura cubra a largura da piscina de escoamento. O escoamento agora parece estar fluindo em direção à borda do penhasco de todos os ângulos.
Crie a água em cascata que flui rapidamente da queda principal.
1. Na janela Explorer, crie uma Pasta no Workspace para conter todos os objetos de água em cascata, e renomeie a pasta para Cascades.
2. Insira duas partes bloco na pasta Cascades, e renomeie-as para MainDropStart e MainDropStop, respectivamente.
3. Mova MainDropStart para a borda do penhasco, e mova MainDropStop para onde está embaixo da piscina de queda.
4. Configure anexos para todos os feixes de água em cascata da queda principal para usar para renderizar suas texturas.
  1. Insira um anexo em MainDropStart, e então gire o anexo até que a ajuda visual amarela aponte para longe do penhasco.
  2. Insira um anexo em MainDropStop, e então gire o anexo até que a ajuda visual amarela aponte em direção ao penhasco.
5. Insira um Beam na pasta Cascades, e renomeie-o para FastDrop.
6. Atribua o anexo de cada parte ao FastDrop.
  1. Na janela Explorer, selecione FastDrop.
  2. Na janela Properties,
    
    Defina Attachment0 para o anexo em MainDropStart.
    
    Defina Attachment1 para o anexo em MainDropStop. O feixe renderiza sua textura padrão entre os dois anexos.
7. Personalize a aparência visual do feixe para que pareça água em cascata de rápido fluxo da queda principal.
  1. Na janela Explorer, verifique se FastDrop ainda está selecionado.
  2. Na janela Properties,
    
    Defina Texture para rbxassetid://16808804567 para renderizar uma nova textura que pareça água fluindo.
    
    Defina Width0 para 5 para alargar a textura a partir do eixo que começa a renderizar.
    
    Defina Width1 para 10 para alargar a textura à medida que encontra a piscina de queda.
    
    Defina CurveSize0 para 10 para curvar a textura para longe do penhasco.
    
    Defina CurveSize1 para 20 para curvar a textura em direção à piscina de queda.
    
    Defina TextureSpeed para 1.3 para fazer a textura fluir rapidamente.
    
    Defina TextureLength para 2 para esticar ligeiramente o comprimento da textura.
    
    Defina Color para uma sequência de cores que alterna entre azul escuro e claro até branco.
    
    Time = 0, RGB Value = 208, 247, 255
    
    Time = 0.135, RGB Value = 210, 246, 255
    
    Time = 0.25, RGB Value = 255, 255, 255
    
    Time = 0.384, RGB Value = 163, 187, 202
    
    Time = 0.757, RGB Value = 214, 229, 248
    
    Time = 1, RGB Value = 255, 255, 255
    
    Defina Transparency para uma sequência numérica que permite que a água em cascata seja mais vibrante entre os pontos de anexo.
    
    Time = 0, Value = 1
    
    Time = 0.115, Value = 0
    
    Time = 0.835, Value = 0
    
    Time = 0.881, Value = .994
    
    Time = 1, Value = 1
    
    Defina ZOffset para 2 para deslocar a textura ligeiramente para longe do penhasco.
    
    Ative FaceCamera para garantir que a água em cascata seja visível, não importa o ângulo do jogador em relação à água.
Crie a água em cascata que flui lentamente da queda principal.
1. Duplicar FastDrop, e então renomeie o feixe duplicado para SlowDrop.
2. Personalize a aparência visual do feixe para que pareça água em cascata de rápido fluxo da queda principal.
  1. Na janela Explorer, selecione SlowDrop.
  2. Na janela Properties,
    
    Defina Width1 para 20 para alargar ainda mais a textura à medida que encontra a piscina de queda.
    
    Defina TextureLength para 1.5 para encurtar ligeiramente o comprimento da textura.
    
    Defina TextureSpeed para 1 para fazer a textura fluir menos rapidamente.
    
    Defina ZOffset para 0 para permitir que a textura flua diretamente da borda do penhasco.
Na janela Explorer, selecione todas as partes de bloco na pasta Outflow, e então na janela Properties, defina Transparency para 1 para tornar os blocos invisíveis.

Configurar respingos

Quando as cascatas impactam a densidade da piscina de queda subjacente, a água se projeta para cima a partir do ponto de impacto para criar respingos. À medida que essa água aerosolizada se projeta para cima, ela se expande e se quebra em si mesma para produzir gotas que se espalham em várias direções.

Para demonstrar esse processo, a amostra usa dois objetos ParticleEmitter na base da queda principal. O primeiro emissor de partículas emite partículas que parecem respingos densos que representam o peso da água que começa a se projetar para cima à medida que as cascatas impactam a piscina de queda. O segundo emissor de partículas emite partículas que parecem gotas que representam a água se tornando aerosolizada.

Quando você configura esses emissores de partículas para emitir ambas as partículas ao mesmo tempo, mas em taxas diferentes, o efeito visual resultante emula o comportamento físico real dos respingos. Esses tipos de detalhes contribuem para o realismo de seus VFX e imergem os jogadores no espaço 3D.

A textura 2D que representa água altamente aerosolizada antes de se quebrar. — Textura Densa = rbxassetid://16829556885

A textura 2D que representa água altamente aerosolizada enquanto se quebra. — Textura de Gotas = rbxassetid://17082061238

Para recriar os respingos na base da queda principal no arquivo de lugar da amostra Waterfall Island:

Na janela Explorer, crie uma Pasta no Workspace para conter todos os objetos de respingo, e renomeie a pasta para Splashes.
Insira uma parte bloco em Splashes, e renomeie-a para MainDropSplashes.
Posicione e escale MainDropSplashes para a área total da superfície onde a cascata impacta a piscina de queda.
Crie o respingo denso onde a água em cascata da queda principal impacta a piscina de queda.
1. Insira um ParticleEmitter em MainDropSplashes, e então renomeie o emissor para SplashDense.
2. Selecione SplashDense, e então na janela Properties,
  1. Defina Texture para rbxassetid://16829556885 para renderizar partículas que parecem respingos densos.
  2. Defina Color para uma sequência de cores que começa azul e depois se torna branca.
  - Time = 0, RGB Value = 189, 246, 255
  - Time = 1, RGB Value = 255, 255, 255
  1. Defina Size para uma sequência numérica que aumenta constantemente de tamanho com uma janela de variação.
  - Time = 0, Value = 1.81, Envelope = 0.562
  - Time = 1, Value = 5.75, Envelope = 1.31
  1. Defina Transparency para uma sequência numérica na qual as partículas começam transparentes, tornam-se opacas e depois tornam-se transparentes novamente ao longo de sua vida útil com uma grande janela de variação.
  - Time = 0, Value = 1, Envelope = 0
  - Time = 0.5, Value = 0.181, Envelope = 0.181
  - Time = 1, Value = 1, Envelope = 0
  1. Defina Lifetime para 0.25, 0.35 para definir aleatoriamente a vida útil de cada partícula entre 250 e 350 milissegundos.
  2. Defina Rate para 30 para emitir 30 partículas por segundo.
  3. Defina Rotation para -45, 45 para orientar aleatoriamente cada partícula entre -45 e 45 graus por segundo.
  4. Defina RotSpeed para -40, 40 para emitir aleatoriamente cada partícula entre -45 e 40 graus por segundo.
  5. Defina Speed para 20, 35 para emitir aleatoriamente cada partícula entre 20 e 35 studs por segundo.
  6. Defina SpreadAngle para 50, 50 para emitir partículas em um ângulo ao longo dos eixos X e Z.
  7. Defina Acceleration para 0, -40, 0 para simular a gravidade e puxar as partículas para baixo.
  8. Defina LightEmission para 0.5 para iluminar as partículas.
  9. Defina LightInfluence para 0.1 para reduzir significativamente o quanto a luz ambiental afeta a cor das partículas.
Crie as gotas onde a água em cascata da queda principal impacta a piscina de queda.
1. Duplicar SplashDense, e então renomeie-o para SplashDroplets.
2. Selecione SplashDroplets, e então na janela Properties,
  1. Defina Texture para rbxassetid://17082061238 para renderizar partículas que parecem gotas.
  2. Defina Size para uma sequência numérica que aumenta rapidamente de tamanho com uma janela de variação.
  - Time = 0, Value = 1.81, Envelope = 0.562
  - Time = 1, Value = 8.69, Envelope = 1.31
  1. Defina Transparency para uma sequência numérica na qual as partículas começam transparentes, tornam-se rapidamente opacas e depois lentamente começam a se tornar transparentes novamente perto do meio de sua vida útil.
  - Time = 0, Value = 1, Envelope = 0
  - Time = 0.104, Value = 0.0625, Envelope = 0.0625
  - Time = 0.429, Value = 0.0562, Envelope = 0.0562
  - Time = 1, Value = 1, Envelope = 0
  1. Defina Lifetime para 0.15, 0.6 para definir aleatoriamente a vida útil de cada partícula entre 150 e 600 milissegundos.
  2. Defina Rate para 20 para emitir 20 partículas por segundo.
Na janela Explorer, selecione todas as partes de bloco na pasta Splashes, e então na janela Properties, defina Transparency para 1 para tornar os blocos invisíveis.

Configurar água branca

Água branca surge à medida que a fonte de água se torna mais turbulenta ao ganhar velocidade ao se aproximar de sua descida e colidir com objetos em seu caminho. Isso resulta em água aerada e emaranhada que aparece branca devido a mais bolhas de ar na fonte de água.

Para imitar esse processo, a amostra usa dois objetos ParticleEmitter que emitem partículas que parecem respingos altamente aerados onde o escoamento colide com as rochas na borda do penhasco. O emissor não usa iluminação embutida e, em vez disso, prioriza tons brancos e cinzas com várias taxas de queda para demonstrar a quantidade de ar na água.

A textura 2D que representa água altamente aerosolizada enquanto colide com rochas. — Textura de Água Branca = rbxassetid://16808075391

Para recriar a água branca onde o escoamento colide com as rochas do penhasco no arquivo de lugar da amostra Waterfall Island:

Na janela Explorer, crie uma Pasta no Workspace para conter todos os objetos de água branca, e renomeie a pasta para WhiteWater.
Insira uma parte bloco em WhiteWater, e renomeie-a para MainDropWW.
Posicione e escale MainDropWW para a área total da superfície onde o escoamento começa a fluir sobre o penhasco.
Crie a água branca menos turbulenta onde o escoamento principal colide com as rochas circundantes.
1. Insira um ParticleEmitter em MainDropWW, e então renomeie o emissor para GentleWW.
2. Selecione GentleWW, e então na janela Properties,
  1. Defina Texture para rbxassetid://16808075391 para renderizar partículas que parecem respingos emaranhados.
  2. Defina Color para uma sequência de cores que começa azul e depois se torna branca.
  - Time = 0, RGB Value = 189, 246, 255
  - Time = 1, RGB Value = 255, 255, 255
  1. Defina Size para uma sequência numérica que aumenta constantemente de tamanho com uma janela de variação.
  - Time = 0, Value = 1.13, Envelope = 0.562
  - Time = 1, Value = 5.56, Envelope = 0.563
  1. Defina Transparency para uma sequência numérica na qual as partículas começam transparentes, tornam-se cerca de metade opacas e depois têm picos ligeiros para se tornarem transparentes novamente ao longo de sua vida útil.
  - Time = 0, Value = 1, Envelope = 0
  - Time = 0.143, Value = 0.462, Envelope = 0.0625
  - Time = 0.336, Value = 0.462, Envelope = 0.0562
  - Time = 0.622, Value = 0.788, Envelope = 0.0538
  - Time = 1, Value = 1, Envelope = 0
  1. Defina ZOffset para 2 para deslocar a textura ligeiramente para longe do penhasco.
  2. Defina Lifetime para 1.25, 1.5 para definir aleatoriamente a vida útil de cada partícula entre 1250 e 1500 milissegundos.
  3. Defina Rate para 12 para emitir 12 partículas por segundo.
  4. Defina Rotation para -45, 45 para orientar aleatoriamente cada partícula entre -45 e 45 graus por segundo.
  5. Defina RotSpeed para -40, 40 para emitir aleatoriamente cada partícula entre -45 e 40 graus por segundo.
  6. Defina Speed para 15, 18 para emitir aleatoriamente cada partícula entre 20 e 35 studs por segundo.
  7. Defina SpreadAngle para 5, 5 para emitir partículas em um pequeno ângulo ao longo dos eixos X e Z.
  8. Defina Acceleration para 0, -35, 0 para simular a gravidade e puxar as partículas para baixo.
  9. Defina Drag para 0.25 para fazer as partículas perderem velocidade com decaimento exponencial.
  10. Defina LightEmission para 0.6 para iluminar as partículas.
  11. Defina LightInfluence para 0.1 para reduzir significativamente o quanto a luz ambiental afeta a cor das partículas.
Crie a água branca mais turbulenta onde o escoamento principal colide com as rochas circundantes.
1. Duplicar GentleWW, e então renomeie-o para TurbulentWW.
2. Selecione TurbulentWW, e então na janela Properties,
  1. Defina Size para uma sequência numérica que aumenta sutilmente de tamanho com uma janela de variação.
  - Time = 0, Value = 1.6, Envelope = 0.562
  - Time = 1, Value = 2.63, Envelope = 0.563
  1. Defina Transparency para uma sequência numérica na qual as partículas começam transparentes, tornam-se opacas e depois tornam-se transparentes novamente perto do meio de sua vida útil.
  - Time = 0, Value = 1, Envelope = 0
  - Time = 0.156, Value = 0.0437, Envelope = 0.0437
  - Time = 0.55, Value = 0.075, Envelope = 0.0252
  - Time = 1, Value = 1, Envelope = 0
  1. Defina Lifetime para 0.25, 0.5 para definir aleatoriamente a vida útil de cada partícula entre 250 e 500 milissegundos.
  2. Defina Rate para 20 para emitir 20 partículas por segundo.
  3. Defina Speed para 5, 6 para emitir aleatoriamente cada partícula entre 5 e 6 studs por segundo.
  4. Defina Acceleration para 0, -15, 0 para simular a gravidade e puxar as partículas para baixo.
Na janela Explorer, selecione todas as partes de bloco na pasta WhiteWater, e então na janela Properties, defina Transparency para 1 para tornar os blocos invisíveis.

Configurar espuma

Diferente dos respingos que se projetam para cima à medida que as cascatas impactam a piscina de queda, a espuma é água aerada que se irradia para fora da base do ponto de impacto. Semelhante aos respingos, a espuma se expande e se quebra em si mesma em gotas semelhantes a teias à medida que se torna aerosolizada.

Para imitar esse efeito, a amostra usa um objeto ParticleEmitter para emitir partículas que parecem ondulações de espuma, e as emite lentamente paralelamente à piscina de queda. Isso permite que a partícula emule o efeito visual e comportamental de uma onda capilar quebrando a tensão superficial da piscina de água subjacente.

A textura 2D que representa a água aerosolizada que se irradia para longe de onde as cascatas impactam a piscina de queda. — Textura de Ondulações de Espuma = rbxassetid://16811365086

Para recriar a espuma na base da queda principal no arquivo de lugar da amostra Waterfall Island:

Na janela Explorer, crie uma Pasta no Workspace para conter todos os objetos de espuma, e renomeie a pasta para Foam.
Insira uma parte bloco em Foam, e renomeie-a para MainDropFoam.
Posicione e escale MainDropFoam para a área total da superfície onde a parte mais densa da cascata impacta a piscina de queda.
Insira um ParticleEmitter em MainDropFoam, e então renomeie o emissor para FoamRipples.
Na janela Explorer, selecione FoamRipples, e então na janela Properties,
1. Defina Texture para rbxassetid://16811365086 para renderizar partículas que parecem ondulações de espuma.
2. Defina Orientation para VelocityPerpendicular para emitir partículas perpendiculares à direção de seu movimento.
3. Defina Transparency para uma sequência numérica na qual as partículas começam transparentes, rapidamente tornam-se opacas e depois rapidamente tornam-se transparentes novamente ao final de sua vida útil.
  - Time = 0, Value = 1, Envelope = 0
  - Time = 0.143, Value = 0.119, Envelope = 0.1
  - Time = 0.664, Value = 0.125, Envelope = 0.112
  - Time = 1, Value = 1, Envelope = 0
4. Defina Lifetime para 0.5, 0.7 para definir aleatoriamente a vida útil de cada partícula entre 500 e 700 milissegundos.
5. Defina Rate para 5 para emitir 5 partículas por segundo.
6. Defina Rotation para 0, 360 para orientar aleatoriamente cada partícula em um círculo a partir do ponto de emissão.
7. Defina RotSpeed para -15, 15 para emitir aleatoriamente cada partícula entre -15 e 15 graus por segundo.
8. Defina Speed para 0, .01 para emitir aleatoriamente cada partícula entre 0 e .01 studs por segundo.
9. Defina LightEmission para 0.25 para iluminar sutilmente as partículas.
10. Defina LightInfluence para 0 para evitar que a luz ambiental afete a cor das partículas.
Na Command Bar, insira a seguinte string para aumentar o tamanho de cada partícula de 5 para 20 studs ao longo de sua vida útil com uma pequena janela de variação:
workspace.Foam.MainDropFoam.FoamRipples.Size = NumberSequence.new{NumberSequenceKeypoint.new(0,5,0), NumberSequenceKeypoint.new(1,20,5)}
Na janela Explorer, selecione todas as partes de bloco na pasta Foam, e então na janela Properties, defina Transparency para 1 para tornar os blocos invisíveis.

Configurar névoa

À medida que as cascatas impactam a piscina de queda, parte da água evapora e se condensa no ar fresco e úmido para criar névoa. Vapores de névoa não capturam luz da mesma forma que superfícies duras; em vez disso, eles refletem a luz de maneiras muitas vezes inesperadas para parecer brilhantes dentro do ambiente geral até que evaporam completamente.

A amostra emula esse processo usando dois objetos ParticleEmitter na base da queda. O primeiro emissor de partículas emite energeticamente partículas para longe do ponto de impacto e do penhasco, e o segundo emite partículas que sobem lentamente em direção ao céu. Ambas as partículas dos emissores de partículas são brilhantes no início de sua vida útil e lentamente se tornam transparentes ao final de sua vida útil à medida que evaporam.

Semelhante ao mundo real, o processo de evaporação da névoa permite que um arco-íris se forme à medida que a luz reflete nas pequenas gotas de água, o que a amostra também emula com um objeto ParticleEmitter que emite partículas de arco-íris com uma vida útil curta. Essas partículas ficam voltadas para a câmera, não importa o ângulo do jogador em relação à cachoeira, para produzir uma ilusão óptica de luz capturando o vapor em si.

A textura 2D que representa a névoa. — Textura de Névoa = rbxassetid://16830667309

A textura 2D que representa o arco-íris. — Textura de Arco-íris = rbxassetid://16828911033

Para recriar a névoa que se move para fora e para cima a partir da base da queda principal no arquivo de lugar da amostra Waterfall Island:

Na janela Explorer, crie uma Pasta no Workspace para conter todos os objetos relacionados à névoa, e renomeie a pasta para Mist.
Crie a névoa que irradia para longe do impacto da cascata na piscina de queda.
1. Insira uma parte bloco em Mist, e renomeie-a para BaseMist.
2. Posicione, oriente e escale BaseMist para ficar voltada para longe da parte mais densa do local onde a cascata principal impacta a piscina de queda.
3. Insira um ParticleEmitter em BaseMist, e então renomeie o emissor para Mist.
4. Selecione Mist, e então na janela Properties,
  1. Defina Texture para rbxassetid://16830667309 para renderizar partículas que parecem névoa espessa.
  2. Defina Color para uma sequência de cores que começa azul e depois se torna branca.
  - Time = 0, RGB Value = 171, 244, 255
  - Time = 0.339, RGB Value = 251, 254, 255
  - Time = 1, RGB Value = 255, 255, 255
  1. Defina Size para uma sequência numérica que aumenta constantemente de tamanho.
  - Time = 0, Value = 8, Envelope = 0
  - Time = 1, Value = 10, Envelope = 0
  1. Defina Transparency para uma sequência numérica na qual as partículas começam transparentes, rapidamente tornam-se ligeiramente opacas e depois rapidamente tornam-se transparentes novamente ao longo de sua vida útil.
  - Time = 0, Value = 1, Envelope = 0
  - Time = 0.0971, Value = 0.8, Envelope = 0.0625
  - Time = 1, Value = 1, Envelope = 0
  1. Defina ZOffset para 2 para deslocar a textura ligeiramente para longe da piscina de queda.
  2. Defina Lifetime para 0.5, 1 para definir aleatoriamente a vida útil de cada partícula entre 500 e 1000 milissegundos.
  3. Defina Rate para 20 para emitir 20 partículas por segundo.
  4. Defina Rotation para -360, 360 para orientar aleatoriamente cada partícula em um círculo.
  5. Defina RotSpeed para -50, 50 para emitir aleatoriamente cada partícula entre -50 e 50 graus por segundo.
  6. Defina Speed para 35, 50 para emitir aleatoriamente cada partícula entre 35 e 50 studs por segundo.
  7. Defina SpreadAngle para 25, 25 para emitir partículas em um pequeno ângulo ao longo dos eixos X e Z.
  8. Defina Acceleration para -10, -25, -10 para simular o impacto do respingo explodindo para fora da piscina de queda.
  9. Defina Drag para 1.5 para fazer as partículas perderem velocidade com decaimento exponencial.
Crie a névoa que sobe a partir da piscina de queda.
1. Duplicar BaseMist, e então renomeie-o para RiseMist.
2. Oriente RiseMist para que a parte superior da parte que emite partículas fique voltada para o céu.
3. Selecione seu emissor de partículas filho, e então na janela Properties,
  1. Defina Lifetime para 4 para definir a vida útil de cada partícula para 4 segundos.
  2. Defina Rate para 3 para emitir 3 partículas por segundo.
  3. Defina RotSpeed para -10, 10 para emitir aleatoriamente cada partícula entre -10 e 10 graus por segundo.
  4. Defina Speed para 25 para emitir cada partícula a 25 studs por segundo.
  5. Defina Acceleration para 0, 0, 0 para remover a simulação anterior.
  6. Defina Drag para 1 para fazer as partículas perderem velocidade com decaimento exponencial.
4. Na Command Bar, insira a seguinte string para aumentar o tamanho de cada partícula de 20 para 20 studs ao longo de sua vida útil com uma pequena janela de variação:
workspace.Mist.RiseMist.Mist.Size = NumberSequence.new{NumberSequenceKeypoint.new(0,20,1), NumberSequenceKeypoint.new(1,25,5)}
Crie o arco-íris.
1. Insira uma parte bloco em Mist, e renomeie-a para RainbowPart.
2. Posicione RainbowPart ligeiramente acima das outras partes de bloco.
3. Insira um ParticleEmitter em Rainbow, e então renomeie o emissor para Rainbow.
4. Selecione Rainbow, e então na janela Properties,
  1. Defina Texture para rbxassetid://16828911033 para renderizar partículas que parecem um arco-íris suave.
  2. Defina Size para 25 para renderizar partículas grandes.
  3. Defina Transparency para uma sequência numérica na qual as partículas começam transparentes, tornam-se ligeiramente opacas e depois tornam-se transparentes novamente ao longo de sua vida útil.
  - Time = 0, Value = 1, Envelope = 0
  - Time = 0.497, Value = 0.363, Envelope = 0.05
  - Time = 1, Value = 1, Envelope = 0
  1. Defina Lifetime para 2, 4 para definir aleatoriamente a vida útil de cada partícula entre 200 e 400 milissegundos.
  2. Defina Rate para 0.25 para emitir uma partícula a cada 4 segundos.
  3. Defina Rotation para -20 para orientar cada partícula em um leve ângulo.
  4. Defina Speed para 0 para emitir cada partícula a 0 studs por segundo.
  5. Defina Drag para 1 para fazer as partículas perderem velocidade com decaimento exponencial.
  6. Defina LightEmission para 1 para usar mistura aditiva para renderizar as partículas com as cores atrás delas. Este passo também remove o fundo preto da textura em si.
  7. Defina LightInfluence para 0 para evitar que a luz ambiental afete a cor das partículas.
Na janela Explorer, selecione todas as partes de bloco na pasta Mist, e então na janela Properties, defina Transparency para 1 para tornar os blocos invisíveis.