Idéias para simulação em água 2D

Eu estou procurando qualquer entrada na simulação de água em 2D, contra uma matriz bastante grande (chame) bloqueada / não bloqueada (vista de lado). Eu tenho as seguintes idéias:

Cell Automata

Faça uma simulação massivamente parralel na CPU, usando autômatos celulares . Com regras simples como:

• Se houver uma célula aberta na parte inferior, vá para ela.
• Verifique as células esquerda e direita, escolha uma aleatória dentre as duas e vá para ela.

Prós

• Simples de implementar.
• Significativo / determinístico em um sistema multiplayer.

Contras

• Provavelmente muito lento.
• Não convincente.

Dinâmica de Fluidos na GPU

Execute uma aproximação aproximada da dinâmica de fluidos na GPU contra uma textura como a seguinte:

+------+-----+-----+-------+
|R     |G    |B    |A      |
+------+-----+-----+-------+
|vX    |vY   |NULL |Density|
+------+-----+-----+-------+

Prós

• Provavelmente muito rápido.
• Pode ser bastante convincente.
• Um sombreador de pixel adicional pode renderizá-lo diretamente.

Contras

• Difícil de implementar.
• Difícil de ajustar.
• Não consigo alocar uma única textura do tamanho do meu nível.
  • Eu poderia sobrepor as áreas da grade, mas isso aumentaria a complexidade.

Partículas

Use partículas para simular a água. Durante a renderização usando mistura aditiva e, em seguida, aplique uma função de multiplicação ao canal alfa para obter as bordas nítidas da água.

Prós

• Provavelmente ficará bonito.
• Fácil de implementar.
• Fácil de renderizar.
• Significativo em um sistema multiplayer, embora exija bastante largura de banda para ser transferido.

Contras

• Os efeitos entre partículas provavelmente serão lentos (pesquisa na vizinhança).
• Pode causar vazamento de água através de espaços sólidos (porque o espaço sólido é pequeno, por exemplo, 1px).
• Pode levar a buracos estranhos na água, dependendo do tamanho da partícula.
• Ambos os itens acima podem ser mitigados, permitindo que as partículas se aproximem mais do que seu tamanho real; no entanto, causariam problemas com o desempenho entre partículas e partículas / paisagem.

Alguma idéia adicional?

Nota: Esta é uma aproximação, não estou procurando água fisicamente correta aqui - apenas algo que 'seja bom o suficiente' (pontos de bônus para uma limpeza rápida e suja). O jogo é multiplayer, então, infelizmente, todo o nível precisa ser simulado continuamente.

toda vez que tentava simular a água, acabava aplicando um filtro passa- baixo em uma textura representando o nível da água. É muito simples de implementar, mas falha sempre que ocorrem grandes mudanças no nível da água, o que pode gerar grandes ondas. Neste método, existem alguns lugares onde a água sempre tem um nível constante, como as extremidades do rio. nesses casos, você simplesmente corta o pixel certo para esse pixel específico.

Prós:

• fácil de implementar
• resultados realistas em caso de águas calmas
• computação rápida usando GPU
• fácil definir níveis estáticos de água ou fontes de água

Contras:

• incapaz de simular ondas

para águas onduladas eu uso de alguma forma semelhante ao seu algoritmo Cell Automata, mas com uma pequena alteração que me permite usar shaders para calcular o próximo passo da situação atual, aqui está um código sudo, novamente eu tenho uma textura representando o nível da água em cada cor do pixel:

foreach (pixel p) in oldTexture
{
    newtexture.pixels[p.x,p.y]    += p.color / 5;
    newtexture.pixels[p.x+1,p.y]  += p.color / 5;
    newtexture.pixels[p.x-1,p.y]  += p.color / 5;
    newtexture.pixels[p.x,p.y+1]  += p.color / 5;
    newtexture.pixels[p.x,p.y-1]  += p.color / 5;
}

esse algoritmo possui recursos semelhantes ao anterior, mas funciona melhor em águas onduladas em vez de em águas calmas. é sua escolha com base no mar que você está simulando para usar qualquer um deles.

no final, você tem uma textura que indica o nível da água para cada posição; no próximo passo, é necessário desenhar resultados de alguma forma, a maneira mais fácil é gerar uma malha com base nos dados do nível da água.