Partículas no Godot 4: Efeitos com GPUParticles2D Passo a Passo
Partículas no Godot 4 na prática: aprenda GPUParticles2D e CPUParticles2D para fazer fogo, fumaça, explosão, poeira e faíscas com código tipado.
O que são partículas no Godot e por que usar
Partículas no Godot são pequenos elementos que nascem, se movem, mudam de cor e morrem sozinhos, tudo controlado por um único node. Em vez de você animar cada faísca de uma explosão à mão, você configura regras (velocidade, gravidade, tempo de vida) e o motor gera dezenas ou milhares de cópias seguindo essas regras. É assim que se faz fogo, fumaça, poeira, faíscas de impacto, respingo de água e brilho mágico sem desenhar frame por frame.
No Godot 4 você tem dois nodes para isso no 2D: o GPUParticles2D e o CPUParticles2D. Eles fazem quase a mesma coisa visualmente, mas por caminhos diferentes. Este guia mostra quando usar cada um, como funciona o material que dá vida às partículas, a diferença entre disparo único e contínuo, como acionar tudo por código tipado e quatro receitas prontas que você copia e adapta: explosão, fumaça, poeira ao andar e faíscas de impacto.
GPUParticles2D vs CPUParticles2D: qual escolher
A diferença está em quem faz a conta.
O GPUParticles2D empurra o cálculo para a placa de vídeo. A GPU processa milhares de partículas em paralelo, então o custo para a CPU do jogo fica baixíssimo. É a escolha padrão para desktop e a maioria dos celulares modernos. A configuração vive num ParticleProcessMaterial.
O CPUParticles2D calcula tudo no processador. Ele aguenta menos partículas antes de pesar, mas tem duas vantagens reais: roda em hardware antigo ou dispositivos que não lidam bem com os shaders de partícula, e suporta colisão 2D de verdade contra o mundo do jogo. Se você precisa que a poeira bata no chão físico da cena, o CPU resolve.
Regra prática: comece sempre com GPUParticles2D. Só troque para CPUParticles2D se testar num aparelho fraco e as partículas sumirem ou travarem, ou se precisar de colisão física real. O bom é que o Godot tem um atalho: com o GPUParticles2D selecionado, o menu do editor oferece "Convert to CPUParticles2D", que recria o efeito quase idêntico no outro node. Você monta uma vez e converte se precisar.
Uma dica de fluxo: se você ainda está juntando seu kit de trabalho, vale conhecer as ferramentas gratuitas para criar jogos antes de mergulhar fundo nos efeitos, porque o Godot combina bem com editores de imagem e som livres para gerar as texturas das partículas.
Anatomia do ParticleProcessMaterial
O GPUParticles2D sozinho não faz nada. Ele precisa de um ParticleProcessMaterial atribuído na propriedade Process Material do inspetor. Esse material é onde mora todo o comportamento. Vale entender os grupos principais:
Emission (emissão). Define de onde as partículas nascem. O padrão é um ponto, mas você pode escolher uma forma de emissão (Emission Shape) como esfera ou caixa para espalhar o nascimento numa área. Para fumaça larga, uma caixa achatada funciona bem.
Direction e Spread (direção e abertura). A direção base para onde as partículas vão e o ângulo de espalhamento em graus. Spread 0 lança tudo reto; spread 180 joga para todos os lados, ideal para explosão.
Gravity (gravidade). Um vetor que puxa as partículas. Para fumaça você inverte a gravidade padrão e coloca um valor negativo no Y para subir. Para faíscas caindo, gravidade positiva no Y.
Initial Velocity (velocidade inicial). A força com que cada partícula sai. Tem valor mínimo e máximo, então cada partícula ganha uma velocidade aleatória na faixa, o que evita aquele visual robótico de tudo igual.
Scale (escala). O tamanho das partículas, também com faixa mínima e máxima. Uma curva de escala (Scale Curve) permite crescer ou encolher ao longo da vida, ótimo para explosão que incha e some.
Color e Color Ramp (cor e gradiente). Você pode dar uma cor fixa ou, melhor, um Gradient na propriedade color_ramp. A partícula percorre esse gradiente durante o lifetime. Fogo que vai de amarelo para vermelho para transparente sai daqui. Colocar o alpha caindo para zero no fim do gradiente faz a partícula desaparecer suave em vez de piscar.
No próprio node (não no material) ficam três valores que você mexe o tempo todo: amount (quantas partículas existem), lifetime (quantos segundos cada uma vive) e emitting (se está emitindo agora ou não).
one_shot vs contínuo: rajada ou fluxo
A propriedade one_shot do node decide o ritmo da emissão.
Com one_shot desligado (o padrão), a emissão é contínua. O node fica soltando partículas em loop enquanto emitting estiver ligado. É o comportamento certo para fogo de tocha, fumaça de chaminé, brilho de um item mágico, qualquer coisa que dura.
Com one_shot ligado, o node solta um lote de partículas de uma vez e para. É o comportamento de explosão, salto de poeira, respingo de sangue: um evento único disparado num instante. Depois de emitir o lote, o emitting volta sozinho para false.
Entender isso é o que separa um efeito que funciona de um que fica travado no loop. Explosão sempre com one_shot ligado.
Disparar partículas no Godot por código
Aqui entra o GDScript. Você raramente deixa o efeito emitindo desde o início; normalmente dispara no momento certo. Duas ferramentas resolvem quase tudo:
emitting = true/emitting = falseliga e desliga a emissão contínua.restart()reinicia a emissão do zero, o que é a forma correta de disparar umone_shot.
Referencie o node com @onready tipado para o código ficar seguro e legível:
extends Node2D
@onready var explosao: GPUParticles2D = $Explosao
@onready var fumaca: GPUParticles2D = $Fumaca
func _ready() -> void:
# fumaca comeca ligada e continua, explosao fica em espera
fumaca.emitting = true
explosao.emitting = false
func disparar_explosao() -> void:
# one_shot ligado no inspetor: restart() solta o lote uma vez
explosao.restart()
O restart() é importante porque, num one_shot, apenas setar emitting = true pode não redisparar se o efeito já rodou. O restart() zera o estado interno e garante a nova rajada toda vez.
Receita 1: explosão com one_shot
Crie um GPUParticles2D, atribua um ParticleProcessMaterial e no inspetor:
one_shot: ligadoamount: 24lifetime: 0.6emitting: desligado (só dispara por código)- No material: Spread 180, Initial Velocity entre 120 e 260, Gravity Y por volta de 200, Scale Curve caindo para zero e um color_ramp de branco para laranja para transparente.
No código, dispare no ponto do impacto:
extends Node2D
@onready var explosao: GPUParticles2D = $Explosao
func explodir_em(posicao: Vector2) -> void:
explosao.global_position = posicao
explosao.restart()
Você move o node para onde o inimigo morreu e chama restart(). Como é one_shot, ele solta 24 partículas de uma vez, elas incham, caem com a gravidade e somem em 0.6 segundo.
Receita 2: fumaça contínua
Fumaça é o oposto: fluxo lento, para cima, sem parar. Num GPUParticles2D:
one_shot: desligadoamount: 16lifetime: 2.5- No material: Gravity Y negativo (algo como -40) para subir, Initial Velocity baixa entre 10 e 30, Spread pequeno perto de 15, Scale crescendo com o tempo e color_ramp de cinza claro para transparente.
O lifetime longo e a velocidade baixa dão aquele movimento preguiçoso. Ligue e desligue a chaminé por código:
extends Node2D
@onready var fumaca: GPUParticles2D = $Fumaca
func acender_fogueira() -> void:
fumaca.emitting = true
func apagar_fogueira() -> void:
fumaca.emitting = false
O mesmo esqueleto vira fogo se você trocar o gradiente para amarelo e vermelho e inverter a escala. Fogo e fumaça costumam ser dois nodes empilhados na mesma posição.
Receita 3: poeira ao andar
Poeira é um efeito que reage ao estado do jogo. A ideia: emitir só quando o personagem se move no chão. Coloque um GPUParticles2D como filho do personagem, apontando para os pés, one_shot desligado, amount baixo, lifetime curto perto de 0.4, Spread pequeno e um pouco de gravidade positiva.
No script do personagem, ligue a emissão pela velocidade:
extends CharacterBody2D
@onready var poeira: GPUParticles2D = $Poeira
func _physics_process(_delta: float) -> void:
var andando: bool = is_on_floor() and absf(velocity.x) > 10.0
poeira.emitting = andando
Enquanto o personagem corre no chão, a poeira sai dos pés; quando ele para ou pula, para na hora. Esse padrão de ligar emitting por uma condição serve para trilha de nave, rastro de habilidade e muito mais. Se você curte esse tipo de efeito ambiental, vale ver como um sistema de clima com chuva no Godot usa a mesma lógica de partículas em escala de cena inteira.
Receita 4: faíscas de impacto
Faíscas são uma explosão pequena, rápida e brilhante, disparada quando algo bate em algo. É one_shot, amount entre 8 e 16, lifetime curto perto de 0.4, Spread médio perto de 60 (as faíscas saltam mais na direção do impacto que para todo lado), Initial Velocity alta, gravidade positiva e um color_ramp branco para amarelo para transparente.
Dispare no ponto e, se quiser, aponte a direção da batida:
extends Node2D
@onready var faiscas: GPUParticles2D = $Faiscas
func bater(ponto: Vector2, direcao: Vector2) -> void:
faiscas.global_position = ponto
faiscas.rotation = direcao.angle()
faiscas.restart()
Girar o node com rotation faz o leque de faíscas apontar para onde o golpe veio, o que vende muito melhor a sensação de impacto do que faíscas saltando iguais para todo lado.
Dicas de performance
Partículas no Godot são baratas com GPUParticles2D, mas alguns hábitos evitam quedas de FPS:
- Não exagere no amount. Antes de subir a quantidade, teste se um número menor com textura melhor já convence. Muitas vezes 20 partículas bem feitas batem 200.
- Encurte o lifetime. Partícula que vive mais tempo significa mais partículas vivas ao mesmo tempo. Efeitos de impacto podem viver frações de segundo.
- Reuse o mesmo material. Vários nodes de faísca iguais podem compartilhar um único
ParticleProcessMaterial, o que economiza memória. - Cuidado com a textura. Uma imagem enorme de partícula multiplicada por centenas pesa. Texturas pequenas de partícula (32 ou 64 pixels) resolvem quase tudo.
- Desligue o que não está à vista. Efeitos contínuos fora da tela ainda consomem. Deixe
emitting = falsequando o node sai do campo de visão.
Do efeito ao jogo completo
Dominar partículas transforma o feeling do seu jogo: cada golpe ganha faísca, cada morte ganha explosão, cada passo levanta poeira. E se o seu jogo é 3D, a lógica é a mesma com outro nó: veja como criar partículas 3D com o GPUParticles3D pra levar fumaça, fogo e faísca pro espaço tridimensional. Mas efeito bonito é só uma peça. Um projeto que sai do papel precisa de física, personagem, inimigos, som, telas e a cola que junta tudo, e aprender isso de forma solta pela internet costuma virar um monte de peças que nunca se encaixam.
Se você quer ir do "consigo fazer uma explosão" para o "terminei e publiquei meu jogo", faz diferença seguir uma trilha ordenada. O curso de criação de jogos para iniciantes da CursoGame.Dev pega você desde o básico do Godot e te leva até um jogo jogável, com as partículas no lugar certo e tudo o mais que um jogo de verdade precisa. Comece pelas receitas acima, quebre, conserte, e quando quiser a estrutura completa, o caminho está montado.
Perguntas frequentes
Qual a diferença entre GPUParticles2D e CPUParticles2D?
O GPUParticles2D calcula as partículas na placa de vídeo, aguenta milhares de partículas com custo baixo de CPU e é a escolha padrão. O CPUParticles2D calcula tudo no processador, funciona em hardware antigo ou celulares fracos que travam no shader e permite colisão 2D real com o mundo.
Como disparo uma explosão só uma vez por código no Godot 4?
Ative a propriedade one_shot no inspetor e, no script, chame particulas.restart() no momento do impacto. O restart() reinicia a emissão do zero, dispara o lote de partículas uma única vez e para sozinho.
Minhas partículas não aparecem, o que verificar?
Cheque se a propriedade emitting está ligada, se o node tem um ProcessMaterial atribuído e se o amount e o lifetime são maiores que zero. Sem ProcessMaterial o GPUParticles2D não sabe como mover nada e fica invisível.
Como faço poeira aparecer só quando o personagem anda?
Deixe emitting em false por padrão e ligue via código quando a velocidade horizontal do personagem passar de um limite, desligando quando ele para. Assim o efeito acompanha o movimento sem emitir parado.
Partículas no Godot pesam no desempenho?
GPUParticles2D é barato mesmo com muitas partículas, mas amount alto, texturas grandes e lifetime longo somam custo. Reduza a quantidade, encurte o lifetime e reuse o mesmo material entre nodes iguais para manter o jogo leve.
Preciso de shader ou material especial para colorir as partículas?
Não. O gradiente de cor fica dentro do ParticleProcessMaterial, na propriedade color_ramp. Você monta um Gradient no editor e as partículas mudam de cor ao longo da vida sem escrever shader nenhum.
