Particle System na Unity: Fogo, Fumaça e Faíscas

O Unity Particle System (também chamado de Shuriken) é o sistema de partículas que roda na CPU e vem embutido na engine: você cria com GameObject > Effects > Particle System e monta o efeito ligando módulos no Inspector. Para ir do quadrado branco padrão a um fogo convincente, você só precisa entender meia dúzia de módulos: Main, Emission, Shape, Color over Lifetime, Size over Lifetime, Noise e Renderer.

Aqui você monta três efeitos do zero no Unity 6.3 LTS com URP (fogo, fumaça e faíscas), configura o material certo para não ver partícula rosa e escreve um script que dispara efeitos por código sem instanciar um objeto novo a cada tiro.

Particle System na Unity: o que é cada módulo que importa

Selecione o Particle System. O Inspector mostra o módulo principal e uma lista de módulos com caixa de ligar:

• Main (o bloco do topo): Duration, Looping, Start Lifetime (quanto tempo cada partícula vive), Start Speed, Start Size, Start Color, Gravity Modifier, Simulation Space (Local ou World) e Max Particles.
• Emission: quantas partículas nascem. Rate over Time para fluxo contínuo, Bursts para rajadas.
• Shape: de onde nascem e para onde vão. Cone, Sphere, Box, Edge, Mesh.
• Color over Lifetime: gradiente de cor e transparência ao longo da vida.
• Size over Lifetime: curva de tamanho.
• Noise: turbulência, para o movimento não parecer reto.
• Collision: colide com o mundo (planos ou física da cena).
• Texture Sheet Animation: anima a partícula com uma sprite sheet (chama desenhada à mão, por exemplo).
• Renderer: material, modo de render (Billboard, Stretched Billboard, Mesh), ordem de desenho.

Dica de valor: os campos com setinha (Start Lifetime, Start Size) podem virar Random Between Two Constants. Quase todo efeito melhora com variação aleatória entre dois valores.

Fogo: Shape cone, cor ao longo da vida e additive

1. GameObject > Effects > Particle System. Gire o objeto para o cone apontar para cima (X = -90).
2. Main: Start Lifetime entre 0,6 e 1,0. Start Speed entre 1 e 2. Start Size entre 0,4 e 0,8. Simulation Space World, para a chama ficar para trás quando a tocha se move.
3. Emission: Rate over Time 30.
4. Shape: Cone, Angle 10, Radius 0,2.
5. Color over Lifetime: gradiente de amarelo claro para laranja e depois vermelho escuro. No alpha, 255 no início, 0 no fim.
6. Size over Lifetime: curva que começa em 1 e cai para 0. Chama afina ao subir.
7. Noise: Strength 0,3, Frequency 1. A chama ondula.
8. Renderer: material com textura de brilho suave e blending Additive (veja a seção de material).

Additive soma a cor da partícula à cor do fundo. Partículas sobrepostas ficam mais claras, que é exatamente o comportamento de fogo e luz. Para tremer de verdade, coloque uma Point Light filha com intensidade variando por script.

Fumaça: tamanho crescente, Noise e alpha

Crie um segundo Particle System como filho do fogo, levemente acima.

1. Main: Start Lifetime entre 2 e 3. Start Speed entre 0,5 e 1. Start Size entre 0,5 e 1. Start Rotation entre 0 e 360. Start Color cinza escuro.
2. Emission: Rate over Time 8. Fumaça é pouca partícula grande, não muita partícula pequena.
3. Shape: Cone, Angle 15.
4. Size over Lifetime: curva de 0,5 para 2. Fumaça se espalha ao subir.
5. Rotation over Lifetime: Angular Velocity entre -30 e 30 graus. Evita que toda puff pareça a mesma imagem.
6. Color over Lifetime: alpha de 0 para 0,5 no primeiro quinto e de volta para 0 no fim. Entrada suave evita a fumaça "nascer" dura.
7. Noise: Strength 0,5, Frequency 0,5, e ative Scroll Speed para a turbulência mudar com o tempo.
8. Renderer: material com blending Alpha (não Additive). Fumaça escurece, não brilha.

O erro clássico da fumaça é Additive: ela vira névoa brilhante. Fumaça escura precisa de blending Alpha.

Faíscas: Burst, gravidade e Collision

1. Main: Looping desligado, Duration 0,5. Start Lifetime entre 0,4 e 0,8. Start Speed entre 4 e 8. Start Size entre 0,03 e 0,06. Gravity Modifier 1. Play On Awake desligado (o script dispara).
2. Emission: Rate over Time 0. Em Bursts, clique no + e coloque Count entre 15 e 25 no tempo 0.
3. Shape: Sphere ou Hemisphere, Radius 0,05.
4. Color over Lifetime: amarelo claro para laranja, alpha caindo no fim.
5. Collision: Type World, Mode 3D (ou 2D em jogo 2D), Bounce 0,3, Lifetime Loss 0,2. As faíscas quicam no chão e perdem vida a cada batida.
6. Renderer: Render Mode Stretched Billboard, Speed Scale 0,05. A partícula estica na direção do movimento e vira um risco, que é o que o olho espera de faísca.

Collision World tem custo: cada partícula faz consulta de física. Para faísca, com 20 partículas por vez, não pesa. Para chuva com mil gotas, use Collision Planes ou desligue.

Material de partícula no URP (Particles/Unlit)

O Particle System novo num projeto URP já vem com um material de partícula da pipeline. Para criar o seu:

1. Create > Material. Em Shader, escolha Universal Render Pipeline/Particles/Unlit.
2. Surface Type: Transparent.
3. Blending Mode: Additive para fogo e faísca, Alpha para fumaça. As opções no 6.3 são Alpha, Premultiply, Additive e Multiply.
4. Em Base Map, uma textura de círculo suave (branco no centro, transparente na borda). A cor vem do Particle System.
5. Soft Particles suaviza o corte duro onde a partícula atravessa o chão. Exige Surface Type Transparent e Depth Texture ligada no URP Asset.

Existe também Particles/Simple Lit, que reage à luz da cena. Para fumaça em cena com iluminação forte, ajuda; para fogo, que emite a própria luz, Unlit é o certo.

Disparar por código: Play, Stop e Emit

Efeito de impacto não precisa de Instantiate a cada acerto. Um único Particle System parado, com Simulation Space World, pode emitir em qualquer ponto do mapa.

Arquivo ImpactSparks.cs:

using UnityEngine;

public class ImpactSparks : MonoBehaviour
{
    [SerializeField] private ParticleSystem sparks;
    [SerializeField] private int sparksPerHit = 20;

    private void Awake()
    {
        if (sparks == null)
        {
            sparks = GetComponent<ParticleSystem>();
        }

        ParticleSystem.MainModule main = sparks.main;
        main.simulationSpace = ParticleSystemSimulationSpace.World;
        main.playOnAwake = false;
    }

    public void SpawnAt(Vector3 position, Vector3 surfaceNormal)
    {
        sparks.transform.SetPositionAndRotation(position, Quaternion.LookRotation(surfaceNormal));
        sparks.Emit(sparksPerHit);
    }
}

Chame SpawnAt(hit.point, hit.normal) a partir do raycast da arma. Como a simulação é World, as faíscas de um acerto anterior continuam onde nasceram enquanto o emissor pula para o próximo ponto.

Para efeitos contínuos, como a fogueira que acende e apaga:

Arquivo CampfireToggle.cs:

using UnityEngine;

public class CampfireToggle : MonoBehaviour
{
    [SerializeField] private ParticleSystem fire;

    public void Light()
    {
        if (!fire.isPlaying)
        {
            fire.Play(true);
        }
    }

    public void Extinguish()
    {
        fire.Stop(true, ParticleSystemStopBehavior.StopEmitting);
    }
}

Play(true) inclui os filhos (a fumaça). StopEmitting para de criar partículas, mas deixa as que existem terminarem a vida: o fogo some de forma natural. StopEmittingAndClear apaga tudo na hora, útil ao trocar de cena.

Note o ParticleSystem.MainModule main = sparks.main;. Os módulos são structs especiais: você guarda numa variável local e altera nela, e a mudança vai direto para o sistema. Escrever sparks.main.playOnAwake = false; numa linha só não compila.

Fogo bonito no editor é metade do caminho. A outra metade é o efeito nascer na hora certa, no lugar certo, sem derrubar o frame rate quando dez inimigos explodem juntos, e conversar com áudio, câmera e animação. Esse encaixe dentro de um jogo completo é o que costuma travar quem estuda sozinho, e é o que o curso de Unity pratica em projeto.

Partículas em jogo 2D: sorting e escala

Particle System funciona em 2D sem mudança de sistema, com três ajustes:

• Ordem de desenho: no módulo Renderer, defina Sorting Layer e Order in Layer, como num Sprite Renderer. Sem isso, a partícula some atrás do cenário.
• Escala: em jogo 2D com Pixels Per Unit 16 ou 32, um personagem tem 1 a 2 unidades de altura. Start Size 0,5 já é meio personagem. Reduza tudo.
• Collision: troque Mode para 2D, para colidir com os Collider2D da cena.

Em pixel art, use uma textura de partícula em pixel art, com Filter Mode Point, e evite Size over Lifetime contínuo, que borra a grade. Texture Sheet Animation com 4 a 6 frames desenhados combina muito mais com o estilo. Se você também usa Godot, o post sobre partículas 2D na Godot com GPUParticles2D mostra os mesmos conceitos (emissão, forma, cor ao longo da vida) com os nomes da outra engine.

Erros comuns: partícula rosa, invisível ou pesada

Partícula rosa. Material com shader da Built-In num projeto URP. Troque para Universal Render Pipeline/Particles/Unlit, ou rode o Render Pipeline Converter (Window > Rendering) para converter os materiais importados de assets antigos.

Partícula invisível. Start Size minúsculo para a escala da cena, alpha zerado no Color over Lifetime, Sorting Layer atrás do cenário em 2D, ou Max Particles baixo demais.

Fumaça brilhando. Blending Additive. Troque para Alpha.

Corte duro onde a partícula toca o chão. Ligue Soft Particles no material e Depth Texture no URP Asset.

Efeito pesado. Partículas grandes e transparentes sobrepostas cobrindo a tela (overdraw) pesam mais que muitas partículas pequenas. Reduza tamanho e quantidade da fumaça antes de mexer no resto. No Profiler, o custo aparece na GPU, não no módulo de partículas da CPU.

Próximo passo

Monte os três efeitos, junte numa fogueira, e faça uma arma que solta faíscas com o ImpactSparks onde o tiro acerta. Depois ajuste com olhar de game feel: o post sobre game feel e juice mostra como partícula, tremida de câmera e som curto transformam um acerto comum em um acerto que dá vontade de repetir.

Quando um efeito precisar de milhares de partículas (portal, tempestade, enxame), é hora de olhar o VFX Graph na Unity e entender quando ele vale a troca.