Ideas para la simulación 2D del agua

Estoy buscando cualquier entrada sobre la simulación de agua en 2D, en contra de una matriz bloqueada / no bloqueada bastante grande (llamada) (vista desde el lado). Se me ocurrieron las siguientes ideas:

Autómatas celulares

Realice una simulación masiva en paralelo en la CPU, utilizando autómatas celulares . Con reglas tan simples como:

• Si hay una celda abierta en la parte inferior, muévase hacia ella.
• Verifique las celdas izquierda y derecha, elija una aleatoria de las dos y muévase a ella.

Pros

• Simple de implementar.
• Significativo / determinista en un sistema multijugador.

Contras

• Probablemente muy lento.
• No es convincente.

Dinámica de fluidos en la GPU

Realice una aproximación aproximada de la dinámica de fluidos en la GPU contra una textura como la siguiente:

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

Pros

• Probablemente muy rápido.
• Podría ser bastante convincente.
• Un sombreador de píxeles adicional podría representarlo directamente.

Contras

• Difícil de implementar.
• Difícil de modificar.
• No puedo asignar una sola textura del tamaño de mi nivel.
  • Podría superponer las áreas de la cuadrícula, pero esto agregaría más complejidad.

Partículas

Usa partículas para simular el agua. Durante el renderizado, utilice la combinación de aditivos y luego aplique una función de multiplicación al canal alfa para dar al agua bordes nítidos.

Pros

• Probablemente se verá bien.
• Fácil de implementar.
• Fácil de renderizar.
• Significativo en un sistema multijugador, aunque requeriría bastante ancho de banda para transferir.

Contras

• Los efectos entre partículas probablemente serán lentos (búsqueda de vecindario).
• Podría provocar que el agua 'se filtre' a través de espacios sólidos (porque el espacio sólido es pequeño, por ejemplo, 1 px).
• Podría conducir a agujeros extraños en el agua dependiendo del tamaño de partícula.
• Todo lo anterior podría mitigarse permitiendo que las partículas se acerquen más que su tamaño real, sin embargo, causaría problemas con el rendimiento entre partículas y partículas / paisaje.

¿Alguna otra idea?

Nota: Esta es una aproximación, no estoy buscando agua físicamente correcta aquí, solo algo que 'es lo suficientemente bueno' (puntos de bonificación por rápida y sucia). El juego es multijugador, por lo que desafortunadamente todo el nivel debe simularse continuamente.

Cada vez que intenté simular el agua, terminé aplicando un filtro de paso bajo en una textura que representa el nivel del agua. Es muy sencillo de implementar, pero falla cada vez que se producen cambios masivos en el nivel del agua que pueden generar grandes olas. En este método hay algunos lugares donde el agua siempre tiene un nivel constante, como los extremos del río. en esos casos, simplemente sobre el color correcto para ese píxel específico.

Pros:

• fácil de implementar
• resultados realistas en caso de aguas tranquilas
• cálculo rápido con GPU
• niveles de agua estáticos fáciles de definir o fuentes de agua

Contras:

• incapaz de simular olas

para aguas onduladas, utilizo algo similar a su algoritmo Cell Automata, pero con un pequeño cambio que me permitirá usar sombreadores para calcular el siguiente paso de la situación actual, aquí hay un código sudo, nuevamente tengo una textura que representa el nivel del agua en cada color de píxel:

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;
}

Este algoritmo tiene características similares a las anteriores, pero funciona mejor en aguas onduladas que en aguas tranquilas. es su elección en función del mar que está simulando utilizar cualquiera de ellos.

al final tienes una textura que te dice el nivel del agua para cada posición, en el siguiente paso debes dibujar resultados de alguna manera, la forma más fácil es generar una malla basada en los datos del nivel del agua.