Como posso fazer as partículas brilharem e lançar luz sobre os arredores?

No momento, estou tentando fazer um efeito de vaga-lume em uma floresta escura. O nível tem pouca luz e o jogador é uma das poucas fontes de luz. Para deixar o jogador ver melhor o nível, estou tentando fazer com que vaga-lumes brilhantes apareçam aleatoriamente no mapa. Uma maneira é usar um sistema de partículas. Mas eu não posso fazer as partículas lançarem luz nos arredores. Existe uma maneira de fazer isso?

Agora, as partículas emissoras de luz são um recurso do Unity integrado no 5.5.

Simplesmente ative Luzes no inspetor de partículas, faça uma referência a uma pré-fabricada de luz (as luzes de ponto e de ponto funcionam) e altere a Relação para 1.

E voilà, partículas que emitem luzes:

Acontece que esta é uma configuração bastante otimizada, rodando a 1500 + fps no meu equipamento, mesmo com o máximo de luzes nas centenas.

Edit: Após algumas observações, parece-me que as luzes das partículas alternam entre iluminação por fragmento e iluminação de vértice (presumivelmente para otimização?). Isso pode produzir pequenas quantidades de artefatos visuais se o máximo de luzes estiver definido muito alto.

Edit2: Como apontado pelo DMGregory, os artefatos são um subproduto das otimizações de renderização direta. A iluminação diferida resolve o problema. Added nicer gif

Atenção:

Esta resposta está desatualizada. A unidade agora suporta partículas de luz pontuais nativamente. Por favor, veja esta resposta para mais detalhes.

Vou deixar esse post aqui para qualquer pessoa curiosa, ou usando versões antigas do Unity, ou precisando de mais controle manual do que o método nativo oferece - observe que o suporte nativo provavelmente será muito mais eficiente e escalável do que a abordagem apresentada abaixo.

Não sei por que tantas respostas afirmam que isso é difícil ou impossível. O manuseio de algumas dezenas de luzes de ponto dinâmico é bastante convencional para um pipeline de renderização diferida moderno em execução no PC.

Aqui está um exemplo rápido que eu preparei:

Eu uso esse script para gerar dinamicamente luzes suficientes para minhas partículas máximas (certifique-se de ajustar as configurações do sistema de partículas para que o máximo seja razoável - o padrão de 1000 não deixará sua placa gráfica muito feliz) e atualize-as para seguir as instruções ativas partículas:

[RequireComponent(typeof(ParticleSystem))]
public class ParticleLights : MonoBehaviour {

    public Light lightPrefab;

    ParticleSystem _system;
    ParticleSystem.Particle[] _particles;
    Light[] _lights;


    void Start () {
        _system = GetComponent<ParticleSystem>();
        _particles = new ParticleSystem.Particle[_system.maxParticles];

        _lights = new Light[_system.maxParticles];
        for(int i = 0; i < _lights.Length; i++)
        {
            _lights[i] = (Light)Instantiate(lightPrefab);
            _lights[i].transform.parent = transform;
        }
    }

    void Update () {

        int count = _system.GetParticles(_particles);
        for(int i = 0; i < count; i++)
        {
            _lights[i].gameObject.SetActive(true);
            _lights[i].transform.localPosition = _particles[i].position;

            // Looks like the GetCurrentColor function was added in 5.3.
            // You can use other methods in earlier Unity versions.
            _lights[i].color = _particles[i].GetCurrentColor(_system);
        }

        for (int i = count; i < _particles.Length; i++)
        {
            _lights[i].gameObject.SetActive(false);
        }
    }
}

Editar: você pode criar uma pré - fabricada criando primeiro um objeto de jogo (neste caso, Criar -> Luz -> Luz de ponto), configurando-o com o nome / parâmetros / scripts / filhos que deseja e arrastando-o da sua Hierarquia para seu explorador de projetos. Isso salva o objeto como um ativo que você pode reutilizar em várias cenas e scripts, com um grau de herança. Você pode excluir a cópia em sua cena e o ativo permanecerá na pasta Ativos para ser referenciado quando necessário.

Certifique-se de que o lightPrefab tenha um alcance relativamente pequeno e não seja transmitido por sombras, para oferecer o máximo de desempenho para tudo o que acontece na sua cena. Você não precisa tornar o lightPrefab verde (ou a cor dos seus vaga-lumes) - ele será absorvido pela cor das partículas.

Você pode achar que tem um controle melhor sobre o voo dos vaga-lumes se criar cada um seu próprio GameObject, com um quad de outdoor e uma luz anexada a um script de movimento / piscada personalizado, pois obter uma caminhada convincente requer mais arte do sistema de partículas do que Eu sei. ;)

Anos atrás, antes que as luzes dinâmicas fossem acessíveis, simplesmente usaríamos um efeito de partícula em outdoor em 2D com mistura aditiva. Isso iluminaria a cena em direção ao branco. Ao desenhá-lo com a profundidade correta do vaga-lume, você obtém a classificação quase correta. O alfa aditivo não precisa ser classificado quando se desenrola em comparação com a mistura alfa. Não iluminará TODA a cena, mas iluminará a área ao redor do vaga-lume. Você pode pegar uma luz dinâmica e escolher um dos vaga-lumes a cada poucos segundos para realmente iluminar a cena, se necessário.

Já existe uma pergunta e resposta sobre efeitos de brilho Como obter uma iluminação como esta no Unity para jogos 2D?

Infelizmente, eu não tive muita experiência com o Unity em sua forma atual (eu brinquei com ele há muitos anos), então não sei exatamente com quais conjuntos de recursos você deve trabalhar no mecanismo.

De qualquer forma, não importa com qual mecanismo você trabalhe, as luzes dinâmicas são algo a evitar sempre que possível. Eles são muito caros em termos computacionais e tendem a adicionar complexidade de cena de maneira muito exponencial. No entanto, como é a ordem do dia para a maioria das renderizações em 3D, há muitas maneiras de obter efeitos semelhantes trapaceando;

Uma maneira possível de obter um efeito semelhante é mapear uma textura de brilho pré-fabricada para o terreno abaixo dos vaga-lumes (assumindo um sistema de coordenação Y = para cima / para baixo) com as posições X e Z controlando a localização do brilho no terreno e o deslocamento Y do terreno que controla o alfa da textura (mais brilhante = mais próximo do terreno)

Obviamente, existem várias desvantagens neste método. Você não projeta sombras porque nenhuma luz é usada e não afeta nenhuma outra geometria no mundo (adereços, folhagem etc.)

Use Lightna origem do fogo e brinque com seu tamanho no script para que ele dê efeito de queima. E use seu sistema de partículas :)