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. As experiências frequentemente incluem cachoeiras por estética visual, como para melhorar o ambiente ou criar um ponto de interesse visual, ou por razões funcionais de jogabilidade, como esconder recursos ou fazer a transição de jogadores entre diferentes áreas no próprio lugar.

Usando o arquivo .rbxl da Ilha Cachoeira 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 conforme desce de um penhasco.
Configurar respingos para emular a aerosolização da água à medida que as cascatas impactam a piscina de queda subjacente.
Configurar água branca para emular água aerada turbulenta onde o fluxo colide com seixos.
Configurar espuma para emular uma onda capilar quebrando a tensão superficial.
Configurar névoa para emular vapores de névoa subindo para longe e para cima 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.

Desmembrar 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, a experiência de Ilha Cachoeira utiliza as Cataratas Snoqualmie no estado de Washington para informar todas as decisões de design de texturas e VFX relacionadas à cachoeira e seu terreno circundante.

Uma visão distante das Cataratas Snoqualmie.

Enquanto uma cachoeira é um fluxo contínuo e conectado de água que envolve múltiplos estados de 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 amostra de cachoeira 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 quando a fonte de água se aproxima da borda do penhasco.
Espuma – A água aerada que se espalha horizontalmente na colisão das cascatas com a piscina de queda.
Névoa – A água em forma de nuvem que evapora no ar como resultado da cachoeira como um todo.

Cataratas Snoqualmie 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 aprofundada 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 várias propriedades de Beam e ParticleEmitter, você aprenderá como utilizar VFX para resolver os requisitos ambientais únicos para suas próprias experiências.

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 do volume de água e da escala de sua queda na piscina. Por exemplo, a queda principal da amostra parece cair mais devagar porque há um grande volume de água caindo sobre uma grande distância, mas a segunda queda da amostra parece cair mais rápido 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 este princípio, a amostra utiliza múltiplos objetos Beam com texturas suaves 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 da queda principal no arquivo de lugar da amostra Ilha Cachoeira:

Crie a saída da água em cascata.
1. Na janela Explorer, crie uma Pasta no Workspace para conter todos os objetos de saída, e então 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 a saída comece e mova OutflowStop para a borda do penhasco.
4. Insira uma fenda em ambas OutflowStart e OutflowStop, então gire as fendas até que a ajuda visual amarela aponte para cima.
5. Insira um Beam na pasta Outflow, e renomeie-o para OutflowWater.
6. Atribua a fenda de cada parte a OutflowWater.
  1. Na janela Explorer, selecione OutflowWater.
  2. Na janela Properties,
    
    Defina Attachment0 para a fenda em OutflowStart.
    
    Defina Attachment1 para a fenda em OutflowStop. O beam renderiza sua textura padrão entre as duas fendas.
7. Personalize a aparência visual do beam 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 como rbxassetid://4787437624 para renderizar uma nova textura que pareça espuma fluindo.
    
    Defina Width0 como 60 para alargar a textura a partir do eixo que começa a renderizar.
    
    Defina Width1 como 20 para afunilar a textura até a borda do penhasco.
    
    Defina TextureSpeed como 0.4 para desacelerar o fluxo da textura.
    
    Defina TextureLength como 64 para esticar o comprimento da textura.
    
    Defina TextureMode como Wrap para repetir a textura na quantidade do comprimento total do beam no mundo 3D entre as fendas dividido por sua TextureLength. Isso permite que a textura pareça muito mais realista em relação à água fluindo.
    
    Defina Color como uma sequência de cores que altera entre tons de azul escuro e claro para branco.
    
    Clique na propriedade Color e depois no botão ⋯. Uma janela pop-up de sequência de cores aparece.
    
    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 do 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 como uma sequência numérica que faz a água se tornar mais vibrante conforme se aproxima da borda do penhasco.
    
    Clique na propriedade Transparency e depois no botão ⋯. Uma janela pop-up de sequência numérica aparece. 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
    
    Redimensione cada parte para garantir que a textura cubra a largura da piscina de saída. A saída agora parece estar fluindo em direção à borda do penhasco de todos os ângulos.
Crie a água em cascata de movimento rápido da queda principal.
1. Na janela Explorer, crie uma Pasta no Workspace para conter todos os objetos de água em cascata, e então 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á abaixo da piscina de queda.
4. Configure as fendas para todos os beams de água em cascata da queda principal para usar para renderizar suas texturas.
  1. Insira uma fenda em MainDropStart, e então gire a fenda até que a ajuda visual amarela aponte para longe do penhasco.
  2. Insira uma fenda em MainDropStop, e então gire a fenda até que a ajuda visual amarela aponte para o penhasco.
5. Insira um Beam na pasta Cascades, e renomeie-o para FastDrop.
6. Atribua a fenda de cada parte a FastDrop.
  1. Na janela Explorer, selecione FastDrop.
  2. Na janela Properties,
    
    Defina Attachment0 para a fenda em MainDropStart.
    
    Defina Attachment1 para a fenda em MainDropStop. O beam renderiza sua textura padrão entre as duas fendas.
7. Personalize a aparência visual do beam para que pareça água em cascata de movimento rápido da queda principal.
  1. Na janela Explorer, verifique se FastDrop ainda está selecionado.
  2. Na janela Properties,
    
    Defina Texture como rbxassetid://16808804567 para renderizar uma nova textura que pareça água fluindo.
    
    Defina Width0 como 5 para alargar a textura a partir do eixo que começa a renderizar.
    
    Defina Width1 como 10 para alargar a textura enquanto ela encontra a piscina de queda.
    
    Defina CurveSize0 como 10 para curvar a textura para longe do penhasco.
    
    Defina CurveSize1 como 20 para curvar a textura para a piscina de queda.
    
    Defina TextureSpeed como 1.3 para fazer a textura fluir rapidamente.
    
    Defina TextureLength como 2 para levemente esticar o comprimento da textura.
    
    Defina Color como uma sequência de cores que altera entre tons de azul escuro e claro para 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 como 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 como 2 para deslocar a textura um pouco 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 de movimento lento da queda principal.
1. Duplique FastDrop, e renomeie o beam duplicado para SlowDrop.
2. Personalize a aparência visual do beam para que pareça água em cascata de movimento lento da queda principal.
  1. Na janela Explorer, selecione SlowDrop.
  2. Na janela Properties,
    
    Defina Width1 como 20 para alargar ainda mais a textura enquanto encontra a piscina de queda.
    
    Defina TextureLength como 1.5 para encurtar levemente o comprimento da textura.
    
    Defina TextureSpeed como 1 para fazer a textura fluir menos rápido.
    
    Defina ZOffset como 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 como 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 separa de si mesma para produzir gotas que se espalham em várias direções.

Para demonstrar esse processo, a amostra utiliza 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 conforme 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 do mundo 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 aerosolizada densa antes de se separar. — Textura Densa = rbxassetid://16829556885

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

Para recriar os respingos na base da queda principal no arquivo de lugar da amostra Ilha Cachoeira:

Na janela Explorer, crie uma Pasta no Workspace para conter todos os objetos de respingo, e então renomeie a pasta para Splashes.
Insira uma parte bloco em Splashes, e então renomeie-a para MainDropSplashes.
Posicione e redimensione MainDropSplashes para cobrir toda a área 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 como rbxassetid://16829556885 para renderizar partículas que parecem respingos densos.
  2. Defina Color como 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 como 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 como 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 suas vidas 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 como 0.25, 0.35 para definir aleatoriamente o tempo de vida de cada partícula entre 250 e 350 milissegundos.
  2. Defina Rate como 30 para emitir 30 partículas por segundo.
  3. Defina Rotation como -45, 45 para orientar aleatoriamente cada partícula entre -45 e 45 graus por segundo.
  4. Defina RotSpeed como -40, 40 para emitir aleatoriamente cada partícula entre -45 e 40 graus por segundo.
  5. Defina Speed como 20, 35 para emitir aleatoriamente cada partícula entre 20 e 35 studs por segundo.
  6. Defina SpreadAngle como 50, 50 para emitir partículas em um ângulo ao longo do eixo X e Z.
  7. Defina Acceleration como 0, -40, 0 para simular a gravidade e puxar as partículas para baixo.
  8. Defina LightEmission como 0.5 para iluminar as partículas.
  9. Defina LightInfluence como 0.1 para reduzir significativamente como 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 como rbxassetid://17082061238 para renderizar partículas que parecem gotas.
  2. Defina Size como 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 como uma sequência numérica na qual as partículas começam transparentes, rapidamente tornam-se opacas, e então começam a se tornar transparentes novamente perto do meio de suas vidas.
  - 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 como 0.15, 0.6 para definir aleatoriamente o tempo de vida de cada partícula entre 150 e 600 milissegundos.
  2. Defina Rate como 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 como 1 para tornar os blocos invisíveis.

Configurar água branca

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

Para imitar esse processo, a amostra utiliza dois objetos ParticleEmitter que emitem partículas que parecem respingos fortemente aerados onde a saída colide com os seixos 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 aerosolizada densa enquanto colide com seixos. — Textura Água Branca = rbxassetid://16808075391

Para recriar a água branca onde a saída colide com os seixos do penhasco no arquivo de lugar da amostra Ilha Cachoeira:

Na janela Explorer, crie uma Pasta no Workspace para conter todos os objetos de água branca, e então renomeie a pasta para WhiteWater.
Insira uma parte bloco em WhiteWater, e então renomeie-a para MainDropWW.
Posicione e redimensione MainDropWW para cobrir toda a área da superfície onde a saída começa a fluir sobre o penhasco.
Crie a água branca menos turbulenta onde a saída principal colide com os seixos ao redor.
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 como rbxassetid://16808075391 para renderizar partículas que parecem respingos fibrosos.
  2. Defina Color como 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 como uma sequência numérica que aumenta continuamente 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 como uma sequência numérica onde partículas começam transparentes, tornam-se opacas, e então têm picos leves para se tornarem transparentes novamente ao longo de suas vidas.
  - 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 como 2 para deslocar a textura um pouco para longe do penhasco.
  2. Defina Lifetime como 1.25, 1.5 para definir aleatoriamente o tempo de vida de cada partícula entre 1250 e 1500 milissegundos.
  3. Defina Rate como 12 para emitir 12 partículas por segundo.
  4. Defina Rotation como -45, 45 para orientar aleatoriamente cada partícula entre -45 e 45 graus por segundo.
  5. Defina RotSpeed como -40, 40 para emitir aleatoriamente cada partícula entre -45 e 40 graus por segundo.
  6. Defina Speed como 15, 18 para emitir aleatoriamente cada partícula entre 20 e 35 studs por segundo.
  7. Defina SpreadAngle como 5, 5 para emitir partículas em um pequeno ângulo ao longo dos eixos X e Z.
  8. Defina Acceleration como 0, -35, 0 para simular a gravidade e puxar as partículas para baixo.
  9. Defina Drag como 0.25 para fazer as partículas perderem velocidade com decaimento exponencial.
  10. Defina LightEmission como 0.6 para iluminar as partículas.
  11. Defina LightInfluence como 0.1 para reduzir significativamente como a luz ambiental afeta a cor das partículas.
Crie a água branca mais turbulenta onde a saída principal colide com os seixos ao redor.
1. Duplique GentleWW, e então renomeie-o para TurbulentWW.
2. Selecione TurbulentWW, e então na janela Properties,
  1. Defina Size como 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 como uma sequência numérica onde partículas começam transparentes, tornam-se opacas, e então tornam-se transparentes novamente perto do meio de suas vidas.
  - 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 como 0.25, 0.5 para definir aleatoriamente o tempo de vida de cada partícula entre 250 e 500 milissegundos.
  2. Defina Rate como 20 para emitir 20 partículas por segundo.
  3. Defina Speed como 5, 6 para emitir aleatoriamente cada partícula entre 5 e 6 studs por segundo.
  4. Defina Acceleration como 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 como 1 para tornar os blocos invisíveis.

Configurar espuma

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

Para imitar esse efeito, a amostra utiliza um objeto ParticleEmitter para emitir partículas que parecem ondulações de espuma, e a emite lentamente paralela à 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 espalha para longe do ponto 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 Ilha Cachoeira:

Na janela Explorer, crie uma Pasta no Workspace para conter todos os objetos de espuma, e então renomeie a pasta para Foam.
Insira uma parte bloco em Foam, então renomeie-a para MainDropFoam.
Posicione e redimensione MainDropFoam para cobrir toda a área da superfície onde a parte mais densa da cascata principal impacta a piscina de queda.
Insira um ParticleEmitter em MainDropFoam, então renomeie o emissor para FoamRipples.
Na janela Explorer, selecione FoamRipples, e então na janela Properties,
1. Defina Texture como rbxassetid://16811365086 para renderizar partículas que parecem ondulações de espuma.
2. Defina Orientation como VelocityPerpendicular para emitir partículas perpendiculares à direção de seu movimento.
3. Defina Transparency como uma sequência numérica onde as partículas começam transparentes, rapidamente se tornam opacas, e logo se tornam transparentes novamente no final de suas vidas.
  - 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 como 0.5, 0.7 para definir aleatoriamente o tempo de vida de cada partícula entre 500 e 700 milissegundos.
5. Defina Rate como 5 para emitir 5 partículas por segundo.
6. Defina Rotation como 0, 360 para orientar aleatoriamente cada partícula em um círculo a partir do ponto de emissão.
7. Defina RotSpeed como -15, 15 para emitir aleatoriamente cada partícula entre -15 e 15 graus por segundo.
8. Defina Speed como 0, .01 para emitir aleatoriamente cada partícula entre 0 e .01 studs por segundo.
9. Defina LightEmission como 0.25 para iluminar levemente as partículas.
10. Defina LightInfluence como 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 suas vidas 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 como 1 para tornar os blocos invisíveis.

Configurar névoa

À medida que as cascatas fazem impacto na 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 a iluminação da mesma forma que superfícies sólidas; em vez disso, refletem a luz de maneiras muitas vezes inesperadas para parecerem brilhantes dentro do ambiente geral até evaporarem 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. As partículas de ambos os emissores são brilhantes no início de suas vidas, e lentamente se tornam transparentes em direção ao final de suas vidas enquanto 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 de frente para a câmera, não importa o ângulo do jogador em relação à cachoeira, para produzir uma ilusão óptica de luz capturando no 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 Ilha Cachoeira:

Na janela Explorer, crie uma Pasta no Workspace para conter todos os objetos relacionados à névoa, e então 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 então renomeie-a para BaseMist.
2. Posicione, oriente e redimensione BaseMist para ficar voltada para longe da parte mais densa da localização 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, então na janela Properties,
  1. Defina Texture como rbxassetid://16830667309 para renderizar partículas que parecem névoa densa.
  2. Defina Color como 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 como 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 como uma sequência numérica na qual partículas começam transparentes, rapidamente tornam-se levemente opacas, e logo se tornam transparentes novamente ao final de suas vidas.
  - Time = 0, Value = 1, Envelope = 0
  - Time = 0.0971, Value = 0.8, Envelope = 0.0625
  - Time = 1, Value = 1, Envelope = 0
  1. Defina ZOffset como 2 para deslocar a textura para um pouco mais longe da piscina de queda.
  2. Defina Lifetime como 0.5, 1 para definir aleatoriamente o tempo de vida de cada partícula entre 500 e 1000 milissegundos.
  3. Defina Rate como 20 para emitir 20 partículas por segundo.
  4. Defina Rotation como -360, 360 para orientar aleatoriamente cada partícula em um círculo.
  5. Defina RotSpeed como -50, 50 para emitir aleatoriamente cada partícula entre -50 e 50 graus por segundo.
  6. Defina Speed como 35, 50 para emitir aleatoriamente cada partícula entre 35 e 50 studs por segundo.
  7. Defina SpreadAngle como 25, 25 para emitir partículas em um pequeno ângulo ao longo dos eixos X e Z.
  8. Defina Acceleration como -10, -25, -10 para simular o impacto da explosão da respingos para fora da piscina de queda.
  9. Defina Drag como 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. Duplique BaseMist, então renomeie-o para RiseMist.
2. Oriente RiseMist para que a parte superior da peça que emite partículas fique voltada para o céu.
3. Selecione seu emissor de partículas filho, então na janela Properties,
  1. Defina Lifetime como 4 para definir a vida de cada partícula para 4 segundos.
  2. Defina Rate como 3 para emitir 3 partículas por segundo.
  3. Defina RotSpeed como -10, 10 para emitir aleatoriamente cada partícula entre -10 e 10 graus por segundo.
  4. Defina Speed como 25 para emitir cada partícula a 25 studs por segundo.
  5. Defina Acceleration como 0, 0, 0 para remover a simulação anterior.
  6. Defina Drag como 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 25 studs ao longo de suas vidas 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 então renomeie-a para RainbowPart.
2. Posicione RainbowPart um pouco 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 como rbxassetid://16828911033 para renderizar partículas que parecem um arco-íris sutil.
  2. Defina Size como 25 para renderizar partículas grandes.
  3. Defina Transparency como uma sequência numérica na qual as partículas começam transparentes, tornam-se levemente opacas, e depois se tornam transparentes novamente ao longo de suas vidas.
  - Time = 0, Value = 1, Envelope = 0
  - Time = 0.497, Value = 0.363, Envelope = 0.05
  - Time = 1, Value = 1, Envelope = 0
  1. Defina Lifetime como 2, 4 para definir aleatoriamente o tempo de vida de cada partícula entre 200 e 400 milissegundos.
  2. Defina Rate como 0.25 para emitir uma partícula a cada 4 segundos.
  3. Defina Rotation como -20 para orientar cada partícula em um leve ângulo.
  4. Defina Speed como 0 para emitir cada partícula a 0 studs por segundo.
  5. Defina Drag como 1 para fazer as partículas perderem velocidade com decaimento exponencial.
  6. Defina LightEmission como 1 para usar a 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 como 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 como 1 para tornar os blocos invisíveis.