Idee per la simulazione dell'acqua 2D

Sto cercando qualsiasi input sulla simulazione dell'acqua in 2D, rispetto a un array piuttosto grande (chiamalo) bloccato / non bloccato (visto di lato). Ho escogitato le seguenti idee:

Automi cellulari

Fai una simulazione massicciamente parallela sulla CPU, usando gli automi cellulari . Con regole semplici come:

• Se c'è una cella aperta verso il basso, spostati su di essa.
• Controlla le celle sinistra e destra, scegline una casuale tra le due e passa ad essa.

Professionisti

• Semplice da implementare.
• Significativo / deterministico in un sistema multiplayer.

Contro

• Probabilmente molto lento.
• Non convincente.

Fluid Dynamics sulla GPU

Esegui un'approssimazione approssimativa della fluidodinamica sulla GPU su una trama come la seguente:

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

Professionisti

• Probabilmente molto veloce.
• Potrebbe essere abbastanza convincente.
• Un ulteriore pixel shader potrebbe renderlo direttamente.

Contro

• Difficile da implementare.
• Difficile da modificare.
• Non riesco ad allocare una singola trama delle dimensioni del mio livello.
  • Potrei sovrapporre le aree della griglia, ma ciò aggiungerebbe ulteriore complessità.

Particelle

Usa le particelle per simulare l'acqua. Durante il rendering utilizzando la fusione additiva e quindi applicare una funzione di moltiplicazione al canale alfa per dare bordi nitidi all'acqua.

Professionisti

• Probabilmente avrà un bell'aspetto.
• Facile da implementare.
• Facile da rendere.
• Significativo in un sistema multiplayer, anche se richiederebbe un po 'di larghezza di banda per il trasferimento.

Contro

• Gli effetti tra le particelle saranno probabilmente lenti (ricerca del vicinato).
• Potrebbe portare all'acqua "che perde" attraverso spazi solidi (perché lo spazio solido è piccolo, ad esempio 1px).
• Potrebbe portare a strani buchi nell'acqua a seconda della dimensione delle particelle.
• Entrambi i precedenti potrebbero essere mitigati consentendo alle particelle di avvicinarsi più vicine delle loro dimensioni reali, tuttavia causerebbero problemi con le prestazioni inter-particella e particella / paesaggio.

Altre idee?

Nota: questa è un'approssimazione, non sto cercando acqua fisicamente corretta qui - solo qualcosa che è "abbastanza buono" (punti bonus per veloce e sporco). Il gioco è multiplayer, quindi purtroppo l'intero livello deve essere simulato continuamente.

ogni volta che ho provato a simulare l'acqua, ho appena finito di applicare un filtro passa-basso su una trama che rappresenta il livello dell'acqua. È molto semplice da implementare, ma fallisce ogni volta che si verificano enormi cambiamenti nel livello dell'acqua che possono generare grandi onde. In questo metodo ci sono alcuni luoghi in cui l'acqua ha sempre un livello costante, come le estremità del fiume. in quei casi hai appena il colore giusto per quel pixel specifico.

Professionisti:

• facile da implementare
• risultati realistici in caso di acque calme
• calcolo veloce tramite GPU
• facile da definire livelli di acqua statica o fonti d'acqua

Contro:

• incapace di simulare le onde

per le acque ondulate uso in qualche modo simile al tuo algoritmo Cell Automata ma con una piccola modifica che mi permetterà di usare gli shader per calcolare il passo successivo dalla situazione attuale, ecco un codice sudo, di nuovo ho una trama che rappresenta il livello dell'acqua in ogni colore dei 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;
}

questo algoritmo ha caratteristiche tutte simili alla precedente ma funziona meglio in acque ondulate invece di quelle calme. a tua scelta in base al mare che stai simulando per utilizzare uno di essi.

alla fine hai una trama che ti dice il livello dell'acqua per ogni posizione, nel prossimo passo devi disegnare i risultati in qualche modo, il modo più semplice è generare una mesh basata sui dati del livello dell'acqua.