VFX Graph na Unity: Quando Usar no Lugar de Partículas

O Unity VFX Graph (Visual Effect Graph) simula partículas na GPU, por compute shader, e por isso aguenta efeitos com dezenas de milhares de partículas onde o Particle System, que simula na CPU, já estaria derrubando o frame rate. A troca tem preço: exige hardware com compute shader, não roda em WebGL 2, ainda é preview para mobile segundo a documentação do pacote e conversa pior com a física e a lógica de gameplay.

A regra curta: use VFX Graph quando o efeito é muito grande e principalmente visual (portal, tempestade, enxame, magia de tela cheia) e a plataforma alvo é PC ou console. Use Particle System para o resto. Aqui você vê o critério completo, monta um portal com milhares de partículas no Unity 6.3 LTS e controla o efeito por script.

VFX Graph vs Particle System: a diferença que importa

Os dois desenham partículas, mas a simulação acontece em lugares diferentes:

• Particle System (CPU): cada partícula é calculada pelo processador. A CPU tem acesso a tudo do jogo: física, colliders, scripts. Por isso ele colide com o mundo real, dispara eventos de colisão para C# e funciona em qualquer plataforma. O limite é a quantidade: milhares de partículas ativas começam a pesar.
• VFX Graph (GPU): a simulação roda em compute shaders na placa de vídeo, que processa milhares de partículas em paralelo. A GPU, em compensação, não conhece seus colliders nem seus scripts. Colisão é feita contra formas simples ou contra o buffer de profundidade, e devolver informação para o gameplay é limitado.

O VFX Graph também muda o jeito de trabalhar: é um editor de nós, organizado em contextos (Spawn, Initialize, Update, Output), em vez de módulos com caixas de ligar no Inspector.

Quando o VFX Graph vale a pena

• Volume alto de partículas: portal com 20 mil pontos, chuva densa cobrindo o mapa, enxame de vagalumes, explosão com estilhaço fino.
• Efeito que vive de movimento complexo: turbulência, atração para formas, partículas seguindo uma malha. O VFX Graph tem blocos para isso que, no Particle System, pediriam script.
• Alvo PC e console: onde compute shader é garantido.
• Efeito que o jogador olha, mas não toca: o portal é cenário; o que importa para o gameplay é o trigger em volta dele, que é um collider comum.

Quando NÃO usar: mobile fraco, WebGL, lógica de gameplay

A documentação de requisitos do pacote Visual Effect Graph diz, para a linha 17.x que acompanha o Unity 6:

• Exige suporte a compute shaders e a Shader Storage Buffer Objects.
• Não saiu de preview para URP (suporta só parte das plataformas do URP) e não saiu de preview para mobile.
• Não suporta OpenGL ES.

Na prática, isso descarta três cenários:

1. Jogo mobile para aparelho modesto. Celular antigo com OpenGL ES fica de fora. Mesmo onde roda, você estaria apostando em recurso em preview.
2. Jogo de navegador em WebGL. WebGL 2 não tem compute shader. O backend WebGPU tem, e vem evoluindo nas versões recentes da Unity, mas confira o status na versão do seu editor antes de depender dele.
3. Partícula que faz parte da lógica. Faísca que precisa causar dano ao tocar o inimigo, cápsula de bala que o jogador chuta, gota que apaga fogo: isso pede colisão real e callback em C#. O Particle System tem OnParticleCollision; no VFX Graph você teria que contornar.

Esse é o caso em que o VFX Graph é a escolha errada: usar em jogo indie 2D para mobile só porque "é o sistema novo". O Particle System continua mantido, roda em tudo e cobre a imensa maioria dos efeitos de jogo pequeno e médio. O post sobre o Particle System na Unity mostra fogo, fumaça e faíscas com ele.

Instalar o VFX Graph no URP

1. Window > Package Manager. Em Unity Registry, procure Visual Effect Graph e instale. A versão do pacote acompanha a do editor (no Unity 6.3, a linha 17.3), então use a que o Package Manager oferecer.
2. Confira que o projeto está em URP. O VFX Graph trabalha com URP ou HDRP, não com a Built-In.
3. No Project, Create > Visual Effects > Visual Effect Graph. Um assistente abre com modelos iniciais; escolha um loop simples para começar.
4. Arraste o asset para a cena. A Unity cria um GameObject com o componente Visual Effect apontando para o asset.

O pacote também traz amostras (Samples) no Package Manager com efeitos de estudo. Vale importar e desmontar.

Primeiro efeito: portal com Spawn, Initialize, Update e Output

Abra o asset (duplo clique). Um VFX Graph tem quatro contextos encadeados:

Spawn: quantas nascem. Bloco Constant Spawn Rate, Rate 5000. Isso já é mais do que o Particle System aguenta confortavelmente em mobile, e no VFX Graph em PC é tranquilo.

Initialize Particle: como nascem.

• Capacity: 20000. É o máximo de partículas vivas ao mesmo tempo; o VFX Graph reserva memória para isso. Calcule: taxa × tempo de vida, com folga.
• Bloco de posição com forma de círculo (ou toro), raio 2. As partículas nascem na borda do anel.
• Set Lifetime aleatório entre 2 e 4 segundos.
• Set Velocity pequeno e aleatório, para o anel não ficar perfeito.
• Set Color com um gradiente entre roxo e azul.
• Set Size aleatório entre 0,02 e 0,05.

Update Particle: como se movem.

• Turbulence, com intensidade baixa (1) e frequência média. O anel ganha vida.
• Um bloco que mantenha as partículas presas à forma e girando em volta do eixo do portal: Conform to Sphere para puxá-las de volta ao anel, ou uma velocidade tangencial calculada a partir da posição (a direção perpendicular ao raio) somada no Add Velocity. A ideia é o anel girar.
• Linear Drag leve para as partículas não fugirem.

Output: como aparecem. Um contexto de Output de partícula em Quad, com textura de ponto suave, Blend Mode Additive e Set Color over Life com alpha caindo no fim. Ligue Bloom no Volume da câmera para o brilho estourar.

Com 5000 por segundo e vida de 2 a 4 segundos, você tem algo entre 10 e 20 mil partículas vivas. Abra o Profiler e compare com um Particle System tentando o mesmo número: é aí que a diferença fica visível.

Efeito bonito sozinho na cena é a parte gratificante. A parte que trava quem aprende sozinho é decidir o que entra em cada sistema, manter o jogo rodando liso na plataforma alvo e ligar o efeito ao estado do jogo (portal fechado, abrindo, ativo). No curso de Unity os efeitos entram dentro de projetos completos, com essas decisões feitas junto com o resto do jogo.

Controlar o efeito por script com VisualEffect e exposed properties

Na Blackboard do VFX Graph, crie propriedades e marque Exposed:

• SpawnRate (Float), ligada no Rate do Constant Spawn Rate.
• PortalColor (Color ou Gradient), ligada no Set Color.
• Um evento chamado OnPulse: no contexto Spawn, adicione um Spawn com Single Burst de 3000 partículas disparado por esse evento.

Arquivo PortalController.cs:

using UnityEngine;
using UnityEngine.VFX;

public class PortalController : MonoBehaviour
{
    private static readonly int SpawnRateId = Shader.PropertyToID("SpawnRate");
    private const string PulseEvent = "OnPulse";

    [SerializeField] private VisualEffect portalEffect;
    [SerializeField] private float closedRate = 0f;
    [SerializeField] private float openRate = 5000f;
    [SerializeField] private float openDuration = 1.5f;

    private float currentRate;
    private float targetRate;

    private void Awake()
    {
        if (portalEffect == null)
        {
            portalEffect = GetComponent<VisualEffect>();
        }

        currentRate = closedRate;
        targetRate = closedRate;
        ApplyRate();
    }

    private void Update()
    {
        if (Mathf.Approximately(currentRate, targetRate))
        {
            return;
        }

        float step = Mathf.Abs(openRate - closedRate) / openDuration * Time.deltaTime;
        currentRate = Mathf.MoveTowards(currentRate, targetRate, step);
        ApplyRate();
    }

    public void Open()
    {
        targetRate = openRate;
        portalEffect.SendEvent(PulseEvent);
    }

    public void Close()
    {
        targetRate = closedRate;
    }

    private void ApplyRate()
    {
        if (portalEffect.HasFloat(SpawnRateId))
        {
            portalEffect.SetFloat(SpawnRateId, currentRate);
        }
    }
}

Por que assim:

• Shader.PropertyToID com o nome da propriedade exposta dá um id que o SetFloat aceita, sem converter string a cada frame.
• HasFloat evita erro silencioso: se alguém renomear a propriedade no graph, o script não tenta escrever num nome que não existe.
• SendEvent dispara o burst de 3000 partículas uma vez, no momento em que o portal abre. É assim que efeito de GPU conversa com o gameplay: o C# avisa, o graph reage.
• O trigger que teleporta o jogador é um collider comum ao lado do efeito. O VFX Graph só desenha.

Para depurar, portalEffect.aliveParticleCount devolve quantas partículas estão vivas. Mostre num texto de debug e você entende na hora se a Capacity está estrangulando o efeito.

Tabela de decisão rápida

Próximo passo

Se você ainda não domina o Particle System, comece por ele: os conceitos (taxa, vida, forma, cor ao longo da vida) são os mesmos e você vai reconhecer cada bloco no VFX Graph. Depois, monte o portal deste post e meça no Profiler com 5 mil, 20 mil e 50 mil partículas.

Para entender o que pesa num efeito além da contagem de partículas (overdraw, transparência, resolução), leia o post sobre otimização para 60 FPS. E se esse lado de efeitos visuais te atrai como carreira, o post sobre o que faz um artista de VFX de jogos mostra o dia a dia da função.