Transcripts
1. Introduction: On these lessons, let's
see how to create a beautiful waterfall in unity. Hi, I'm Gabriel Le gia, founder of the Gabriel
Llega Prod YouTube Channel, where we teach
Visual Effects games in Unity in real and in goto. And we also have one of
the biggest libraries of visual effects assets
ready to be used in games. I'm also the founder
of Golden Box Studios, where we are developing
Rabbits tale. Today, let's create a
beautiful waterfall in unit. With UIT VffetGrap
and ShadoGraph, we're also going to use Blender. We will show you how to build
everything from scratch. So without further ado,
let's get on with it.
2. Scene Overview, Waterfall Meshes, Shaders and Textures Creation: Let's have a quick
overview of this scene because I know some of
you are interested. We basically have
this lake which contains water shader from
this through right here, from way back, it's
very straightforward. And then we have some trees, the sand itself, and
the rocks, right? And this is where we
are going to place our waterfall right
here in the middle. As for the sky itself, we have the sky material
set to a cube map, and the texter
itself is also set to cube on the texter shape. That's how we have this
beautiful sky around us. So as you can see, we don't
have any three D model. We are going to show
you how to model it right now in blender. If you don't have blender
around, make sure to get it. It's very straightforward,
and we are going to guide you
through the best we can. Basically, we want
an empty scene. So if you have
anything, delete it. And then with Shift A, you
want to begin with a plane. This is going to
be our waterfall. Let's rotate it with R on the X 90 degrees and then
press Enter and scale it. Only on the Z axis, you can press Z, a value
of more or less six. And then let's
enter in edit mode so we can edit this
mesh with tab. And with Control R, we are going to add
three vertical cuts. You can scroll up
and down to add more edge loops or
less edge loops, and we can use,
again, Control R to add a few edge
loops horizontally. Going to shape this
grid to look like a waterfall so it
fits our scenario. We want now to press one pad so you can go to the
front orthographic view, and we want this to be
larger at the bottom. So we are going to select this bottom edge loop
and scale it up, as you can see, and we
are going to go through each edge loop and scale
it up a little bit. We want a shape similar to
this one, as you can see. Then the idea is to
select the edge loops on the extremities and push them
with G only on the y axis. If we select and push the edge loop on the
center outwards, we get this shape, so it has
a little bit more volume. And if we go to
the side view now we can make sure it
has an inclination. It has a little bit of
slope exactly like this. We can do a shade smooth. If you go to object,
you can find it here. And in UV editing, we are just going
to make sure that this is the order of the UVs. As you can see, from
the top to the bottom, we see both things being
selected in the same order. For the next step,
we can increase the polycunt easily by using a modifier in this case,
subdivision modifier. We don't need to
increase that much and be careful because this will
increase the poly count, something like this, and then
press Apply. Here we go. This is a good waterfall that we can use for our scenario. Let's push this up just
because we want to make sure that the
origin is at the bottom. If you go to object, we can do it right here. Exactly. So it scales
from the bottom. I made a few more
adjustments, nothing special. I just straighten this. So it looks like it
comes from a river. But what's really important
is that with Control A, we press Apply scale,
and that's it. Let's rename this to
Waterfall mesh 01. And if we go to file in Export, we can choose FBX.
Use the same name. Make sure selected
objects is turned on, so we export only the waterfall and export it to your
project, basically. Once we are in unity,
this is the mesh we have. We can set the scale factor
to 100 and then press Apply, so it matches unity units. So even though we could use the meshes directly
with the shaders, it's much easier to
create a VFX graph so we can control the parameters
in an easy way. So right click VFX graph, let's begin with
the minimal system. Call this one Vx graph
score Waterfall. Double click to open
it up. And here we go. First things first, let's
switch the bounds mode to manual so we can say it's
100 on the X, Y, and Z. This is to make
sure it's visible, even though the camera is not looking directly
at the waterfall. Rename it Waterfall. We need to spawn
something, right? So up here, let's use a
single burst. Particle. We don't need to use lifetime. It's going to live
forever, and the output, in this case, we need
to output a mesh. So let's remove and replace by shader graph mesh
exactly because we are going to create a shade
to mimic a waterfall. And then we can assign the waterfall mesh
we just created, here we go, and add set size to control its size.
Let's at it one. I'm going to dock
the window around here and leave the scene
on the left so we can see what's happening and
dragon drop the VFX graph to the scene and then position the Vfx graph on the
waterfall location. We could directly rotate
the Vfx graph or we can use a set angle and rotate it
180 degrees. Here we go. Now that we have our
waterfall in place, let's create a shader so we
can create the water, right? Right, click Create
shader graph URP. It can be unlit so
it isn't affected by the lights and rename
it to Waterfall Shader. Double click to open
it up and here we go. On the graph inspector, enable support VFX graph. You can also disable
already cast shadows unless you want to cast
shadows, of course. And the first node
we can use is one of the noisiest texts that
comes nutty and Voronoi. It's a little bit
heavier, by the way, compare it to use
the external texter, but this will allow us to animate it and
you will see how. Now connect it to
the base color, save it so we can apply
this to our Vfx graph. Now we can see in real time what's happening more or less. So as you can see, we
have this angle of set. Angle of set is really amazing. Cell density controls
the scale, right. These are two values that
are extremely useful. Let's create a float.
Let's expose these values. First one, we can call it the Voronoi scale with
default value of, let's say, 12 and connect
it to the cell density. The second perempt is actually a vector two for
the ripple speed, so we can ban this Varanoi. Ripple speed with
a default value of zero at five on the y axis. The way it works is
by dragging this, multiplying with the then you could use Talgan
offset node or you can use a UV node and add it to what we already have
and connect these to the UVs. And here we go. It's
spanning already. Now, the first parameter is the Voronoi speed for
our angle of set. The default value of three, you can drag it here and then multiply it with
the time as well, so it's animated over time, and connect to the angle of set. Let's save it. And here we go, it's banning and the angle
of set it's working. Still not quite water. What we can do is a way
to dissolve this Varanoi. Let's create a power node, replace the connection
to the base. And now let's create a float
and call it the ipulsamount. With the default value
of three dot three, for example, connect
it right here. If you save it, as you can see, it's beginning to look
like ripples or foam. Cool. And if we
were to tint this, the dark values would be too intense because this
is way too dark. So let's connect this to a map. On the map, we have the in
values, the values that enter. We are going to leave
them at zero and one, then we are going
to remap the zeros to be zero t one
to put it simply. Zero represents dark values, so this becomes a
little bit more gray. Save it. Here we go. Now, since it's a waterfall, we want the bottom
to have more foam. You could use an
external texture or you can come up here
to the UV, split it. If you use the green channel, connect to one minus to
invert that grading. We get this output, which means now if we connect
this to a power node, we can control the
graded intensity. Let's create a float for that. Call it, for example,
bottom strength. We could leave it
completely white or we can mix it with the noise. Again, you could use an
external texta for the noise, but to make things easier, you can create a simple
noise with a scale of 20 and multiply
it with the power. Here we go. That's exactly
the kind of gradient we want. Once again, we can remap this. By doing so we can control how intense the
white values are, which is the Y parameter
on the output. In other words, you can
connect a vector two here, create another parameter, another float for
bottom brightness, how bright we want
the bottom to be. We connect to vector two, and now we have that possibility, it may seem very complex, but it is quite straight
as you can see. And now all we need is to
add this gradient to what we already have and then replace the connection
to the base color. And if we save, here we go. It's really bright at the
bottom, as you can see. It's beginning to
look pretty cool, and I think it will look even
better when we add color. So let's create a
color property, set the mode to HDR
so we can control its intensity and the
default color to white, drag and drop the
color and simply multiply this and
connect to the base. Save it. Let's go back to
VFX graph, and in here, we can choose a bluish color, one that looks
closer to the lake, color intensity to one
dot five, one dot eight. Here we go looking better. And now we can begin working
on the ripples of the lake. Let's copy and paste. With Control C and
Control V waterfall this system, call it ripples. And in this case, we want a constant
spa rate of only one. You can then adjust it if you
want more or less ripples, and we want a
lifetime because we want this to
continuously spa 2-4. And at this point,
we need a new mesh. It's a very straightforward one. If you go back to blender, which if A, you want to
begin with a circle. If you press tab, you can
enter an edit mode and then press E to extrude and Z, so we lock it on the Z
axis with a value of one, press Enter, and then scale it down more
or less zero or 25. Then we G, lock it in the Z and push it a
value of minus one, so it's flat, as you can see. You can make the hole
a little bit smaller. Now, let's create the UVs. Like everything, press U, Light map pack and
now select one of these faces and select
follow active quad. We get this stretched
rectangle that we need to fit inside
this UV square. So let's scale it down with
S and then go to UV up there and turn on constrate to image bounds and scale
it as much as you can. Basically, make sure the edges are touching the extremities. Now let's subdivide this
mesh with Control R. Be careful because we are going
to add a few more faces. The polycot is
going to increase, another one more or less around here and another one around here and a smaller one closer
to the hole. Here we go. And all of these edge loops are meant to make
the mesh smoother, and it will influence
how the texture pans through this mesh
because of the UVs. And you will see all
of it in a moment. Let's just rename it to ripples mesh and then export it indeed, export as an FBX directly
to your project. Now back to Unity, you
can assign the mesh to the ripples output here we go. We probably won't see anything because we need to make
a few adjustments. For example, we need to
rotate it 90 degrees on the X and only on the X and
increase its size to eight. Oh, and probably we don't see it because it's below the lake. So let's use a set position and push the value of
one on the Y axis. Here we go. We are
beginning to see something. As you can see, we're still
using the waterfall shader, which doesn't quite
work for these ripples. So let's create a
new lead shader graph and call it
the scroll shade. First things first, let's
enable support VFX graph, and set the surface type to transparent and the
blending mode to additive. Just disable cast
shadows, by the way. It will look weird
if it cast shadows. Let's save the shader, assign it right
here so we can see what's going on as
we edit the shader. Yeah, it's looking weird because we don't have
anything on this shade. First thing is text D. You
can call it main text, and for now assign it
to ripples texter. We will show you in just a
moment how to create one. And then we need to sample
this text with the sample textu two D. And since
it's a scroll shader, let's create a vector two
for the scroll speed. It can have a default value of 03 on the y axis, for example. Let's drag it down here. And if we want this to
automatically move, we use the time node that we
multiply with a vector two, and we could use a
tiling and offset node right here or with
a UV up there, add this to the
UVs and connect to this UV of the Sepal
text to D. And lastly, a color will be super useful. Let's create one. Let's say it's an HDR mode so we can
control its intensity. With a default value of
white, alpha at 100, drag it around here, multiply it with the main texture.
Connect it right here. We need to take
care of the Alpha, which is a transparency.
It's very simple. We split these vector four. As you can see, there's
out and then a four, which means it's a vector four. If we split it, we have
access to the Alpha value. We can connect it right
here, and that's it. So this is what we
get at this point. I know you are missing the text, so let's take care of that. For this texter, we
actually find it easier to use Krita or Photoshop. The idea is that we create a
new document, 2048 by 2048. It's more than
enough. Let's just paint the background
to black with the bucket two and then
create a new layer. And on that new layer,
let's select the brush too. And up here, we want to
choose this brush right here. And if you click here,
we can edit the brush. It's the brush editor. We want to make sure that
it's faded like this, as you can see, you can control how intense you
want this brush to be. Make sure you are paging
with white and with a brush size of something
100-150 pixels. That should do just fine.
Now, the idea is to use ShiftW to enter wrap mode so we can create a
seamless texture. It's extremely useful. We want to paint diagonally a wave from the
top to the bottom. And we can create
another ripple, another wave in the middle. You could decrease the
size, for example, but let's go ahead and create
a simpler wave like this. Connect down here, and that's disabled rap
mode by pressing Shift W. One tiny final trick we can do is duplicate this layer. We are going to add a glow. We can enter in rap mode again. Then go to filter blur, select the Goshen blur and increase the
horizontal radius. You can control how
much glow you want. Here we go. Looking very good, very soft, very nice. And that's it. We have
our repulse texture. Let's hide the black background
and export as a PNG. You can export it
directly to your project. Now back tinty, make
sure you assign it to the main text. Save it. If you don't see it,
you can go back to VFX graph and assign
it right there, and you should have
something similar now, there's another tiny problem. As you can see, we
have those art edges when it reaches the
end of the mesh. They are extremely visible
and extremely annoying. Fortunately, there's a very
easy fix for this where we are going to mask it
out. How do we do so? Well, we use another
text or a text to the called the mask text and we are going to
assign it a gradients. We will show in a
moment how to do it. For now, drag and drop
it, simple this texture. And the way this works is by multiplying these
with the main text. And now it will
mask the main text, replace the connection, save it. And as for the texture, it's actually very
straightforward and an empty new layer. With the same brush
we used before, we are going to edit this brush. We are going to change
the mask type to Gaussian and the
shape to square. You can control how much of that fate we want 0.5 is enough. We get this huge square, and you can click
one or two times to make the square more intense. And then with Control
T, you want to expand this to fit
the ball area. That's it. You have created this gradient, very
straightforward. Let's save it again as a PNG. Back in unity, you can
assign it right there. And if you save, you
will notice now that the ripples are smooth
around the edges. The shedder we are
showing you is quite powerful and complex. Another thing we can add is distortion to the main texture. Because as you can see, the
pattern is quite predictable. We want to break it. We
are going to use a AP. A LAP will interpolate
between A and B, based on the T value
that we go 0-1, connected to the UV and the A option is what
we already have. Now, as for the B,
we want this to be completely distorted
by Vernoi texto. Let's just first add a float
for distortion amount with a default value of zero dot one and connect to the set T option. So let's already create
a Voronoi speed vector two with a default
value of zero at four. We can multiply this
with the time we already have here and go search for the Voronoi that is already built
in onto the graph. I recommend using
external Voronoi text. It's much more
lightweight, by the way. But for the sake of this
tutorial, let's move on. We need to also add
the UVs right here. Connect to the Varoni can
also adjust these values. For example, a float
for a Varoni scale. We a default value of ten, connect to the cell density, and then we can connect this
to the B option of the larp. We made things a little
bit more complex. You don't actually
need it, but feel free to follow along. But once you save
it, you will notice two things. The edge is gone. If you have saved before, you already notice it, and
this is completely distorted, and we have the
distortion amount that controls this
type of effect, as well as the Voronoi spit, so it wobbles like crazy
and Voronoi scale as well. Feel free to play along with these values or copy our values. What we can do is fade out these ripples at the end
and animate only the Alpha. The way we do it is
with a simple curve. Where we connect
age over lifetime. Basically the lifetime
of this particle itself. And on the curve, we
can use something like this where it fades
in and then it fades out. Fades in quicker,
fades out slower. Open the color, connect it to
the Alpha, and here we go. I fades at end, very smooth. But it's not quite there yet. We can improve the
shader itself. It's a complex shader like
I said in the beginning. Connect this to a larp where the A option is the
ripples as they are, and we multiply
the main text with Varna connect to the B option, and now all we need is a float
for the dissolve amount, with a default value of
zero dot four more or less. Connect to the T option. Here we go. And connect this to a power node,
replace the connection. The power node helps
dissolve this even further. We can create a new float, call it the dissolve power. The default value
of five Here we go. We get this sharp Voronoi. Let's save it. We get
these beautiful ripples, as you can see, but
we can do even more. If the set angle is random, let's make sure
it's 90 on the X, but it can be random
0-360 on the y axis. And this is the
type of effect we get very beautiful
ripples, as you can see. Feel free to adjust
the dissolve power and the dissolve amount as well. You have a very powerful
shader right here, and all we need is to increase, maybe a little bit
more the rate, so we can get more
ripples, as you can see. And now it looks much better. And that's the wallpoint
of this shade. Let's just improve
the waterfall so we can get really white foam. Don't mind these
three nodes up here. We were just testing
vertex of set. Feel free to copy
it if you want, but we don't actually
need it in the end. On the shader, let's create
a float called erosion. It's going to be very useful. We want this to be a slider 0-1. We can dragon drop it and
the idea is to connect this to a one minus node. So the ones become zeros
and the zeros become one. If you go to the graph inspector
on the graph settings, let's enable Alpha clipping. Alpha clipping will allow
us to erode the mesh, to clip the mesh
based on a text. Now, all we need is that text. We already have it. Before
the call, we can use this. We are going to invert it so
it becomes exactly like this with a one minus and connect to the Alpha
eclipt threshold. This way, if we copy and paste this waterfall,
call it foam. Down here, we can
actually push it a little bit forward
on the Z axis. So it's in front of the
original waterfall. Make it white with
intensity of 22, two. And if we begin eroding this, what we are left with is
with the brightest parts of the waterfall,
which become foam. You can also adjust
the bottom brightness. That's the beauty of
it, the bottom strength and the other parameters
we have added. And you can customize
your foam just this way. Thanks to erosion, we
only get that white part. Now, let's add
even more ripples, white ones on the ground. Let's copy the ripples, the effects graph, Controls control V. And for these ones, we can actually use the
waterfall shader so you can see how different the result can be by changing the shader. Let's say the
constant span rate is only one and it leaves
half of the lifetime. It has one and two. It's
also going to be smaller. Four, I should do
it, give it a try. As for the scale of the var
we can leave it as it is, but the speed, let's
increase it to three, and let's increase
the ripples amount to two dot five to dot seven, as well as the bottom strength
and the bottom brightness. Let's begin eroding this
and you will notice it. We don't need to fade out this. Matter of fact, we
can use this color white eight on the RGB, can increase the
speed a little bit. You can play a bit
with these values. You can turn off random
rotation for the angle, and we can say it's
actually 180 on the Y axis. I think it was facing
the wrong direction. Now it looks much better. Oh, that's really cool. We get these bright, beautiful
ripples on the ground, which are totally
different from the others, but they match perfectly with
each other in this style. But, you get the general idea. And that's it for this lesson. On our next lesson, we
are going to see how to add a few more details
like some splashes, some water drops, some
ripples on the water drops. Basically, we are going to
polish these even further.
3. Splashes, LiquidSplash texture and Drops: So on this lesson,
let's see how to polish this waterfall even further and make it even more beautiful. So let's work on adding splashes
and a few more details. So this waterfall
becomes even more alive. We can actually begin
by creating a template, a simple burst for the splash. Let's select this spun block and say the loop
duration is infinite, so it keeps on
looping indefinitely. And instead of a burst, we want a constant spun rate
of around 200 particles. It's going to be a lot. It's
VFc graph and it can handle. It also means we
need to increase the capacity and bounce mode, so it's visible,
whatever the camera is, let's increase it to
100 in X, Y, and Z. Don't worry we have also
disabled the ripples, so we can focus only
on the splashes. Now, the set position shape
is quite useful here. Let's actually set it to a cone. Hate mode can be base. We are basically
going to cut it in half the cone and point
it towards the lake only. So there's no particles
going behind the wall. What really matters that we manipulate the shape,
the scale of the cone. We want it to be tree
on the X and on the Z, so it becomes flat
on the Y axis. Going to push it
up on the Y axis, the position, a value of 05
because it's below the leg. As you can see, we see some
particles, which is great. Now we can control the arc. For example, 314, it's
half of the cone. And if you push it in
front, as you can see, we have only half of the cone spawning particles,
which is the point. You can clearly see
we need to rotate it 90 degrees on the Y axis, so it faces only the lake. Now let's say the Z position is more or less one not eight. They are going inwards, but we will take care of
that in a moment. The top radius of
the cone can be one. Let's increase the minimum and the maximum speed on the
velocity two and four. In this case, we don't
want that much of gravity. We can decrease to minus five. I know it sounds weird, but
it will work really well. You will see in a moment. You
can remove the linear drag. We are trying to get a
really nice splash motion. Now down here, you can see the color is really
bright with a set color, four on the X Y and Z, and we can randomize the size between zero
at five and one. On the gradient, we want to use this only to fade
out the particle. It's bright in the
beginning, it's white. Let's actually remove this key. It's visible in the beginning, and then we fade it out
at the end, like this. It's great. It's very basic
particles going on right now. If you put everything
together, as you can see, it actually really improves
the waterfall a lot already. We can improve it even
further if we copy and paste this system and use
it for a liquid splash. Basically, we are going to mimic liquid by using a texter. This text right here. This text took quite some time
to get it right. We can show you the process
to get a similar one. This way, you also learn how
to create texts by hand. Going to try our
best to guide you. It's not an easy process, but it can be very rewarding, knowing how to create
texts by hand. We are going to do it in Krita. You can also follow
along with Photoshop. So basically, you want a black background and an empty layer. And from there, we're going
to use this brush right here, which has a solid edge, increase the radius
to about 250, 350, make sure you are
painting with white, and create a shape
similar to this one. This is going to be our base. From here, we want to
select this brushwire here, which has a soft edge and use the rates to increase
a little bit the size, maybe decrease the opacity
so it isn't so strong. And raise the inside like this. Then we want to decrease the opacity and
increase the radius a tiny bit and remove a little
bit more here and there. So we can create these
holes, basically. Basically, the idea is to use the Blender smear brush,
this brushwre here. He did this brush so we
can say the fade is zero, so it becomes smooth,
increase the radius. And remember that the opacity controls the strength
of this brush size. And basically, we are going to push from the inside
to the outside, and we are going to soften these hard edges all around too. This is basically
a liquidify brush, and the idea is to
pass this all around. Also push what's
inside outwards. The idea is to mimic a splash. You can push these pointy
white ends that we have here even more
outside like this. Maybe sometimes
push them inside. Basically, with this
brush, you can make this look a lot better and smoother. And once you have done
that, another trick we usually use is to go back to the solid
edge brush, this one, decrease the size, and we
are going to highlight this white spots even further
here and there, like this. Once you have highlighted a
few of these white spots, you can go back to smear tool and blend these
in, as you can see. It's basically as if you were putting even more
white paint in here, and then you smudge it, right. Yeah. So like I said, this is a process and it
takes some time, but in the end, it's
quite worth it. You can then also add a
few splashes all around, a few strokes here and there, with a solid edge brush. And then, again, with
the smear tool, well, smear it all around like
this and there you go. You should have something
similar to this. Once you have it, you can hide the black background
and export as a PNG. We forgot to hide
the black background and then go back to Unity. Once you have a signed
the texture here, you thebnd mode is additive. And we are starting
to see something, but let's make sure it's even
bigger, like three and six. That should do it. It's
quite big right now, but we are going to
fix it in a moment. There's also a lot of
particles spawning. Maybe 15 in the spawn
rate is enough, and maximum lifetime can be
one dot five, for example. They have a weird behavior. That's mostly
because of the size of a lifetime down here. Instead of starting big and then shrinking, let's
do the opposite. Let's make sure they start
small and they grow. And since we are fading them
with the color of life, it creates a really cool effect, as you can see, obviously, you could use a special
Shader for this, but this is quite good already. Another thing we
can make sure is to add random rotation with set angle and make sure it's
random in the Z axis 0-360. There you go. Maybe increase a little bit more the intensity. That should do it.
Color of lifetime, you can use a curve. If we switch this
mod to uniform, we can say it
starts fully white, and then it dissolves
away, it fades away. It makes quite a difference. Also adjust the cone, make sure it's larger
on the top radius, and increase a
little bit velocity, three and five because they need to spread a
bit more from the base. And as you can see, this
is the result we get. Pretty cool, looking very
good these splashes. You could apply one of the
shades we created here, but it already
looks pretty cool. Now moving on, we
are going to work on little water droplets
that splash all round. Duplicate this slash system, decrease the spond rate to ten, adjust lifetime,
so it's 2 seconds. Increase the minimum and the maximum speed to four and eight. As for the gravity, it's going to be bigger, I understand, and we need to
make sure they are aligned with velocity so they rotate along the velocity vector because we are going
to stretch them. Let's remove the size of life and the color of life
and add a set scale, and in here, we can
squeeze them on the X to a value of zero to 25. And now, if we want
them to collide with a L because collisions in
VFX Graph are very limited, we can make it collide
with all the environment. Use a collision shape on
the update particle and say it's a plane and control
how high that plane is. As you can see, if
we set it to one, it looks like it's
bouncing off of the lake, and we want to make sure they completely die when
they touch the lake, so lifetime loss to one. And they stopped spuning
probably because they are a bit below the plane and
they die immediately. So let's make sure we increase
here the position shape, the cone to 15 on the Y axis. Here we go. And now, whenever they collide, we
want to spun something else. Trigger event on collide. But in order for the trigger
event on collide to work, as you can see, we
have a warning. Need to go back to
the collision shape, and on the inspector, we have these collision
attributes that it's not writing
anything at all. We need to make sure
you write, for example, on punctual contact only, only when it collides. Now, if we save it, the warning goes away and we
can work with that. And what we want from
here is the following. We want to first
emit the GPU event, and to that GPU event, we can connect another system. For example, let's
copy the ripples. It will emit ripples, Control C, Control V, and connect the GPU event right here to the
initialized particle. It would be great if it
worked out of the box, but we actually just need
to make a few adjustments. We have the set
position down here. Let's move it up there
to disialized particle. Needs to know where to spawn if we select it,
we have the source, and we can set the source
to be the source itself, which are the drops. Whenever they collide, they emit the location and we
can get that location. You can see, we have the ripple. They are huge, and they may live a little
bit way too long. Let's decrease the lifetime
to zero at five and one, and let's make sure
they are smaller. They can be random, actually, between zero at three and one. Here we go. And the cool thing is that we have this shade and, for example, the
scale is way off, should be smaller like five. Maybe we can have a little
bit more ripples amount, and we can control the erosion to zero at seven, for example. Let's make sure they all
have a random rotation. It's 90 on the X and
0-360 on the y axis, this way, it looks a
little bit more random. B squint is pound
out of nowhere. We can fix that by using a set size over
life so they grow. We just need to make sure it's multiply so it doesn't override the previous values
and then select this curve right here,
and that should do it. We believe these
values work well, but feel free to test
them, obviously. Can take advantage
of this Shader even further by eroding. If we use age of lifetime, which is the age of the particle and connect this
to a sample curve, we can use any curve we want. For example, let's
select this one and make sure the first
key has a value of 04. And then it erodes
away, as you can see. That looks much nicer,
much more professional. And to conclude the
drops are huge, let's decrease their
size, and that's it. Feel free to play with it, to tweak values to
see where it can go, but that's essentially it. Now you know how to create
a beautiful waterfall in Unity with visual effect
Graph and Shader Graph. How to create a few
texts with Krita, how to model in Blender. We have seen a lot of things, and I hope you have enjoyed it. And we have plenty more
of these lessons and courses where create
visual effects for games. So feel free to check my profile to find out more about it. So that's it. Thanks
for watching, and I hope to see
you on the next one.