Comment créer une cascade physique 2D

J'essaie de créer une cascade qui ressemble à la première image ci-dessous (veuillez vérifier cette vidéo pour une meilleure idée de ce que je veux réaliser) avec des propriétés physiques afin qu'elle puisse déplacer ou contourner des objets avec des collisionneurs sur son parcours (similaire à la deuxième image ci-dessous). Bien que la cascade liée soit 3d, je suis intéressé par une implémentation 2D.

Notez que les objets sont dynamiques et certains se déplacent fréquemment, la cascade doit donc remodeler chaque image. Les objets se déplacent lentement en se déplaçant vers différentes positions ou en tournant. Comment cela peut-il être fait?

Je voulais voir si je pouvais retirer cela sans régénérer dynamiquement le maillage de la cascade à chaque image. Il s'avère qu'il y a un moyen. :RÉ

Chaque objet qui peut bloquer la cascade (objets portant un WaterCatcherscript dans mon prototype) a un maillage de contour qui entoure son périmètre. (Cela peut être généré automatiquement à l'avance en utilisant la forme du collisionneur)

Ce maillage de contour rend l'eau qui coule le long de l'objet. J'utilise un shader pour clipsortir la partie sous l'objet. Je trace également un point de capture gauche et droit où une cascade atterrit sur l'objet et coule respectivement à gauche ou à droite, donc je peux clipsortir la partie qui est à gauche de la cascade de droite et à droite de la cascade de gauche.

Les chutes verticales ne sont alors que des primitives quadruples de base, étirées à la longueur appropriée. J'utilise un autre shader pour faire défiler la texture de la cascade sur les chutes et l'effacer aux extrémités supérieure et inférieure. Ensuite, je couche sur un système de particules de mousse au point d'impact pour aider à couvrir le mélange.

Voici un gros plan pour voir les composants.

Au sommet, j'ai une cascade "racine" pour lancer les choses. Chaque image, après que tous les Update()scripts ont été exécutés pour déplacer les choses, il tire CircleCastvers le bas, pour voir si son eau frappe quelque chose. S'il frappe un WaterCatcher, il lui indique de montrer sa peau d'eau en aval du point de coup.

Je détermine «en aval» en utilisant la normale de frappe - si elle est très proche de la verticale, ou si la cascade entrante s'étend sur des bords qui s'inclinent dans les deux directions, alors nous renversons à gauche et à droite.

Chacun WaterCatchera sa propre cascade gauche et droite, qu'il active et positionne sur son bord éloigné s'il se déverse dans cette direction - sinon ils restent cachés. Ces chutes d'eau à leur tour tirent CircleCastvers le bas pour trouver ce qu'elles renversent, et ainsi de suite ...

Le prototype a encore quelques problèmes visuels qui pourraient être améliorés - le flux d'eau le long d'un objet apparaît tout d'un coup au lieu de s'animer, et les règles de flux pourraient utiliser un peu de tolérance ou d'hystérésis supplémentaires afin de ne pas couper aussi facilement sur objets en rotation. Je pense cependant que ces problèmes devraient être assez résolubles.

Fond, roches et textures de plate-forme tournante via Kenney

Voici les astuces que j'utilise dans mon shader de fragment de capteur d'eau:

// My wraparound geometry is build so the "x+" UV direction
// points "outward" from the object.
// Using derivatives, I can turn this into a vector in screen space.
// We'll use this below to clip out water hanging off the bottom.
float2 outward = float2(ddx(i.uv.x), ddy(i.uv.x));

// i.worldX is the worldspace x position of this fragment
// (interpolated from the vertex shader)

// _LeftX is a material property representing the worldspace x coordinate
// of the rightmost water flow that's spilling left,
// and _RightX the wold x of the leftmost water flow that's spilling right.
float left = _LeftX - i.worldX;   // +ve if we're to the left of a left spill.
float right = i.worldX - _RightX; // +ve if we're to the right of a right spill.

float limit = max(left, right); // +ve if we're in the path of either flow.

// If the "outward" vector is pointing down, make this negative.
limit = min(limit, outward.y + 0.001f);

// If any of the conditions above make limit <= 0, abort this fragment.
clip(limit);

// Otherwise, scroll the water texture!
// Counter-clockwise if we're in the left flow, clockwise otherwise.
i.uv.y -= sign(left) * _Time.y;

1. Vous pouvez déformer le maillage en cascade lors de la collision d'objets pour correspondre au modèle de collisionneur requis.

2. Le système de particules à usage intensif le plus simple et le plus précis, mais le plus performant - crée un système de particules avec collisionneurs et utilise chaque particule comme une goutte d'eau. Mais cela semble un peu étrange si vous avez un sprite par défaut et si le nombre de particules est petit et trop grand. Mais ses performances sont lourdes, vous ne voulez donc pas de simulation de molécules dans votre jeu.

J'irais avec 1.

• Mais CPU de déformation de maillage - c'est lent, mais peut fonctionner pour vous.
• J'utiliserais des shaders pour y parvenir - exemple de shader d'eau - le maillage a des effets comme il entre en collision avec d'autres maillages et il est beaucoup plus rapide que les méthodes précédentes. Je suppose qu'il est possible de faire du maillage pour arrêter le rendu dans une forme projetée - c'est le changement que vous devez apporter au shader à eau normal, c'est compliqué à réaliser si vous n'êtes pas familier avec les shaders.

Pas de solution facile avec de bonnes performances.

Résultat du système de particules: (Pour changer les valeurs j'ai dû attendre environ 3-4s, c'est lent)