Transcripts
1. Introduction: On these lessons,
let's see how to build an epic black hole in unity. Hi, I'm Gabriel Leger, founder of the Gabriel
LegiaPd YouTube Channel, where we teach Visual
Effects for games in Unity in real and 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 Bug Studios, where we are developing
rabid still. And today we are going to show you how to create
a black hole from scratch with UT VFX
graph and shader graph. We are also going to use blender and material
maker for texters. We will show you how to build
everything from scratch and how to create also the
heat distortion shader. So without further ado,
let's get on with it.
2. Scene Overview, Black Hole Texture and Mesh Creation: Let's begin with a very quick overview of this scene because I know some of you want to
know how this was made. Basically, if you go
to Window in ranging, you get lighting, and here
you have environment. And on this skybox material, we have added this
galaxy material, which is basically a cube map. And by that, I mean, on
the shade or dropdown you can select Skybox cube Map. And then you can download any Galaxy texter or
create one yourself. But what's important is that
you set it to cube map. Textor shape, cube.
And there you have it, you get this very
cool environment. So let's begin by
creating a VFX graph, which I have previously
installed on the package manager,
Visual effect graph. We have all of these templates, but we can start with
the minimal system. We name it to VfxGraph
score Blackhle and double click to open it up. This VFX graph, in particular, is going to be used to create the illusion of a black
hole at the center. We are going to use a sphere. So let's call it exactly that. To make sure this VFX
graph is visible, even if the camera is not
pointing at the black hole, we want to see the bounds
is set to manual and increase the volume to
100 in X, Y, and Z. Begin emitting a particle, we go up here on the spa
and use a single burst, in this case of one particle, and it's going to live forever since we don't set the lifetime. We have the update particle,
and then the output, which is what's
going to be visible, this is where the
particles are rendered. And in our case,
we need to replace this output because we
want to use Shadow graph. Create a specific shader. We can use output particle
shader graph mesh. And the mesh we are going
to use here is the sphere. If you don't see one,
you can unload blender, create a sphere, and
export it as an FBX. But usually, Unity comes with a default one, and
it should do it. Now, I'm going to
dock this window right here so we can
see what's happening. And let's drag and drop the
VFX graph to the scene, reset transform, and this is
what we should have so far. Now, if you really
want that black hole with bright edges,
we need a shader. So with the right click,
I'm going to go ahead and create Shadograph
URP lead Shadograp, which means it isn't affected
by the lights of the scene. Let's call it frenel shader and then the idea is to
create a franel effect. This node right here. We can expose some
of these parameters. As a matter of fact, we can
create a color parameter. So we can control the
color of the prenyl. Let's open the graph inspector. We want to make sure the mode is HDR so we can control
the intensity, say the color is white, and then dragon drop it
more or less around here because now we want to multiply it with
the fnol effect. Here we go and connect
to the base color. As you can see, we
have this power node which is quite
useful to control. So let's create a
float for that, call it the fnlPower
with a default value of one and connect it right here. Lastly, very important
on the graph settings, let's make sure we
enable support VFX graph so it works with Vx graph. Don't forget to save
the shader and then let's go back to VFX graph. And once we click here,
it should show up. Here we go Franl shader. Now it's a little bit up to you, but in our case, we want
to increase the size. I'm going to use a set
size with a value of one, and in this case, we are going to go with a
different aesthetic. This is the call we
are going to use. But with a Ipnal
power of around ten. We can get that bright ring
around the black hole. Fantastic. Now let's move on to the rings around the black hole. With Control C and Control V, copy this sphere Vfx graph and call it the Ring VFX graph. Now, we need a
very specific mesh to put around the black hole. And if you don't have blender, go ahead and download it, it's very easy to pick up, and now we'll guide you through. Basically, we are going
to create a ring mesh, kind of a doughnut,
really, but kind of. And we can start by deleting
everything on your scene, make sure it's clean,
and then with Shift A, you can add a circle. We can scale it up to seven, press S and then seven and
then Enter. Here we go. And let's enter and edit bolt so we can edit this mesh
with tab and we can extrude with E and press S to immediately
scale it a value of 0.15, and then press enter, and
this is what you should get. Now, we need to add
a few edge loops. It's going to increase the
polycon, so be careful there. You can press
Control R and scroll up to add three edge
loops, and that's it. We press seven and the numpad to go to the top
orthographic view, we can select this ring
right here while holding out and shrink them down a
little bit towards the center. We are doing this
because now if we press one and numpad to go to the
side orthographic view, we want to proportionally
edit this and by that I mean that if you go up
here and click on this icon, we are going to turn on
proportional editing. This way, if we push this up and scroll up or down
with mouse wheel, we can control the influence. How much it influenced
nearby vertices. We want to push the silla
bit up not too much, just so it has some
volume like this. Next step is the UV mapping. If we enter the Dt mode,
select everything, we can press U to access the UV mapping menu and
select Light Map back. And this is the trick we
are going to show you. You get a bunch of squares.
No worries about that. Just select one of these in face mode, select
everything again, as you can see that
Quad has become active, and now we can do something
called follow active quads. You can press Okay, and
you get this stripe, which is very
useful because this means it's unwrapped
properly now, and we can fit this
properly on the square by making sure that we enable
constraint to image bounds. Push it to the center and
scale this to the sides and up until it fills everything
properly. And that's it. We are trying to achieve a
very specific effect with this black hole
where the motion of the ripples all go
through the same side, which is counterclockwise, we are going to go to
object mode by pressing tab and then pressing
Shift D to duplicate this and then press escape
so it stays right there. But with R rotated only on
the X axis, 180 degrees. This way, we have this disc, this kind of very
extremely flat donut. And now let's enter
in the Did mode so we can go to UVs
because we need to flip them if we want to make sure the ripples go
all in the same direction. So we can mirror
these on the X axis. And that's it. And if we show again the other circle,
this is what we get. We just need to join them with Control J or search for join. Here we go. It's one mesh now. And I know this is weird, but we need to flip this again and mirror this on the X again
so it's properly mapped. Feel free to test it
without all of these steps, and you will understand
the result easily. Now, we can rename this to
Ring 01 and export as an FBX. Make sure you turn
on selected objects and export to your project. Back in VFX graph, we can assign the
ring mesh right here. We are currently using the
same shade, the Franl Shad. But for this specific
case, we need a new one. So let's go ahead and
create the Shader graph, URP and lead once again and
call it the scroll shader. We are going to pan a texter
and add a couple of effects. And right from the start, we want to say that
the surface type is transparent and the
bleeding mode too additive, or you can turn on allow
material overweight to edit these values as you
go and very importantly, turn on support VFX graph. This shader begins
by sampling a text, an external texter, which
means we can create a text to the parameter
for the noise texter. For now, I'm going to assign
one that I have here, but we will show you
in a moment how to create one and
then drag and drop the noise text parameter
right here and connect to the sample text
to D. This is what we get. You can assign a
default texter for now. In this shader,
what's important is the ability to
control, it's offset. So let's create a
tiling and offset node, and then let's create two
parameters, one for the tiling, and then another for the offset, a vector two called noise tiling with a default
value of one by one. Connected to the tiling, and then another vector to
for the noise speed. We can use a default value
of one on the X only. If we want to automatically
animate this, we are going to multiply this noise speed
with a time node. Otherwise, you can pan this manually without
the time node. Connect to the offset, and that's pretty much
as you can see, the texture itself
is already panning, which was the main objective. Now, as for the text itself, we can show you
how to create one. If you go ahead and search
for material maker, which is a tool based on nodes to create texters,
it's very useful. You can download it for free or contribute to the project. Once you open it up,
this is what you get, and we want to
begin by searching. Or shape because with the shape, we can say it's a circle. As you can see on the
preview to the window, we get a preview of the
node you are selecting. First parameter is
for the site count, and the second one is
to control the size. We want to begin with
something small like Zoda two, and last parameters control the fade. Let's set it to one. We get this tiny circle, this tiny bub of light,
and there's a cool trick. If we connect this
to a tiler node. I will tie this in
whatever way we want. I've tested a couple of values, and these are the ones that are best for the text we
are going to create. Feel free to test
different values, but essentially the
tile X and the tile Y, you can set it ten by ten, so we can increase
the intensity. Overlap is up match. They can overlap
with each other. Let's set it to four,
and now let's scale them up with zero to seven
on the X and on the Y. Fixed offset to one, so
we move horizontally, but most importantly
random offset. All crazy and we break
that grid pattern. Random rotation, since
there are circles, we don't notice it, but
random scale of Zot eight, and we get some circles
that are bigger, others that are smaller, and that's great, because this will allow us to invert
this gray scale, and we get a pretty
cool texture. It looks like skinning
under microscope or some kind of weird component
under a microscope. But we can go even
further and use a blur, a Gasian blur, for example. Increase the grid size first so it has a
better resolution, and that will fix it, or you
can play with the Sigma. And to finish off
a color wise node, we'll do the trick just fine if we push the black
key to the right. As you can see, we get
even more darker values, and that creates a pretty
interesting contrast, which is super
useful for our text. To export this, we can click
on this icon right here. You can rename it,
choose the resolution, and click Exportasimage,
typically as a PNG. Now back to unity, we need to mask that out to
soften those edges. It's very simple
to create a mask. Basically, we create
another sample texter. And another text to D parameter. Call it mask texture,
drag and drop it, connect to the
sample text two D, and then multiply these
two sample texters. Depending on the gradient that
we feed to the mask text, we can fade some edges, which is extremely useful. Let's see help to
create that gradient. Fortunately, it's
a very easy text. Back to material maker, we can begin by
searching for gradient literal and we can
rotate it -90 degrees, so it fades from the
bottom to the top because UVs were
made in that way. And the cool thing is that
we can edit our gradient. For example, we can add the key more or less around here and make sure it's not that
dark and then play with it, as you can see, we can leave
it more or less around here because we want a bigger range for
the darker values. And that's it, we can go ahead, click that button to export it, choose the resolution
and where to export it, rename it as well, and
then go back to unity. Now, once you have added the gradingt to
the mask texture, all we need now is a way to control the color
of this shader, so let's create a color
para make sure it's in HDR mode with white
color by default and then multiply these two
together and connect only to the base color
because for the Alpha, for the transparency,
we want to split this and connect only the Alpha. Back to VFX graph, we can assign the scroll shader. Here we go. That's much better. As you can see, we already have a mini black hole, awesome, and we can, for example,
play with the noise tiiling so we can have
more rings around it. Or use a different
gradient texture depending on how much
you want to dissolve. Basically, if you go
back to material maker, you can use the same technique, create a gradient node, rotate it -90 degrees. And in this case, we want to click the dark values even more, which means we can place a
key more or less around here, say it's a dark gray. And the last key, it's going
to be a very light gray. Then you can go ahead and
export it once again, call it gradient zero, two, and then you can
adjust the color, obviously, and
adjust the intensity so it's less or more bright. The speed, in this case, we're going to use these values, so it rotates on the
opposite direction and slower because
it's a black hole. We don't want it
to be super fast, even though this is a
stylized black hole and not a super realistic one, but it looks awesome, and it looks even better if we increase these rings
with the set size. Can also set the angle here or on the
initialized particle. We can rotate this horizontally. It was vertical, even
though we are in space, there's no orientation,
but it looks better. In case you wanted to know,
that's how you do it. 90 degrees on X,
and then you can adjust the size of the
sphere, for example, so it's a little bit
more proportional with the rings and basically, you can also use a set scale on the rings to control
only a certain axis. For example, this ring, it's a little bit thicker, we are going to flat it out on the Z axis a little bit
zero at seven, for example. The cool thing with VFX
graph is that we can use this system and output
different things. So let's copy this
output, for example, connect the update right here, and in this case, we are going to use
a different noise. This noise text right here
that we can see right now how to create because it creates a very different
feeling, as you can see. Basically, back to
material maker. We want to begin with
a noise, sharp noise. Increase its sharpness, its definition to zero at eight more or less and scale it up on the X and on Y to
a value of ten. Now how many times we want this to fall, let's
increase it to one. As you can see, we get a very distinct
noise texture already. We can leave it
durations at four, play with persistence
maybe zero at seven, and that should get us really
close to what we need. With a colorized node now we can control those dark values.
We can increase them. And if we want to add
even more noise to these, we can use a dirt node. Is literally dirt. We just need to increase
its scale to three. And we can put
these two together literally with a math note, but we want to divide A with B. And we get this very
bright texture. Try to imagine the
opposite of this. As a matter of fact,
you don't need to imagine because if you
use the invert note, you will get exactly that, and it looks like
tin foil, basically. That's what we were
aiming for, kind of. You can export up
there, rename it. Now you can even switch
between two gradients if you want this to be
less or more visible. We can decrease the intensity of the color as well as the speed. And we didn't even
touch the size, only the gradient
and the noise taxa, and we get a totally
different feeling in terms of the rings,
which is pretty cool. And that's it for this lesson. On our next lesson,
we are going to add a few more details and see how to create the heat
distortion shadow.
3. Heat Distortion Shader, Orbital Particles and Polishments: This lesson, let's see how to polish the black
hole even further. Now, we could use the same
mesh for this detail, but this one is another ring, and it's a bit more allow. We're going to use the
same process, pretty much, a clean sin pressift
to create a circle. Make sure you select
vertices and extrude with E, and scale it one dot seven. Then add three edge
loops with control R, scroll up to increase
the edge loop count. Once again, the
polycunt is going to be a bit I depending
on the platform. Maybe don't subdivide
the mesh that much. Then we can go ahead
and for the UVs, use again light map pack. We get all of these squares, choose an active
quad, select faces, and then press U again for the UV map options and
select follow active quad. Press Okay, and this
is what we get. Once again, we need to fit
this inside the UV space. Make sure the outer ring is
at the bottom on the UV side, as you can see, and the
inner ring is at the top, because that's motion
we are going to follow with the shade as
we have seen previously, when scrolling the texter, the UVs influence that. Select everything. We have
constrained to bounce enable, by the way, on the UV
dropdown Nu up there. And in this case, we need to redistribute a little
bit the edge loops. It will influence how the
scroll happens, by the way, and we are going to push the
edges to their extremity, the bottom one, the left one, and then the right one. By squeezing the inner loop, when binding the texture, it will happen slower at the center of our mesh,
basically. That's it. We have created another ring in a little bit more
practice with modeling. Make sure to apply scale
by pressing Control A, so it goes exactly with
this size to Unity. And with this mesh selector, let's go to Export as an FBX, turn selected
objects and export. All right, so let's add a couple more details to
the sphere itself. For example, we can duplicate
the Sphere VFX Graph. We want to add some flavor, some texture, rename
it Sphere Texture. Let's just disable
the single burst of the other two VFX graphs so
we can focus on this one. And now, since we have both of the shaders done, cool thing is, we can go down here and
switch the Shader from the frenel to the Scroll Shader and use the ring
mesh we created. And if you move
around on the scene, it's always facing the same
direction, and on this case, it's useful if it's facing
the camera continuously. So whenever we want
to orient this, we use an orient block and
in this case, facing camera. Way, it always faces the viewer. Now, in terms of details, we can play with these settings. For example, the noise bit, it probably looks best if it spins in the opposite
direction and slower. Now we can play with color. Our black hole is a
little bit stylized, so maybe an orange to match the rest will
look really nice. Let's just enable the sphere,
the black hole itself. Maybe we can decrease
a little bit its size, so it's visible
only on the edge of the sphere. Yeah, that's nice. As a matter of fact, we
can add even more flavor, for example, by duplicating this output and
switching the textures. Here we go. Adjust the
tiling in the Y axis. Spin even slower on the
eggs, and that's it. We have added even more
flavor to this blackle. And yeah, it looks really cool. Now, one of the most
intriguing parts is the Heat Distortion
itself, right? So let's focus on that. You can once again duplicate the sphere, Control C, Control V, and rename this for the
Heat Distortion. It's trickier, but it's doable. One of the things we must
change is the output. We don't need an output
Shader Graph mesh. We instead want an output
Shader Graph quad, which by default, uses
a quad as its own mesh. A quad, it's basically a
plane with two triangles. So let's focus on creating the heat wave
distortion shader that fits really well with this black create a new Shader Graph, URP, unleadRnam it to
Heat Distortion Shader. Double click to open
it up, and by default, we want this surface type to be transparent and to be visible from both sides of the mesh
of the quad in this case. Render face both
and make sure you enable support VFX Graph so
it works with VFX Graph. Once you do it, you can
save it and you can add it directly to VFX Graph so we
can see what's happening. Cubicle. We have
this little square, which for now, it isn't much. Now, back in our Shader, a Heat Distortion wave works
by getting the scene color, which enables us to access
the camera color buffer. Basically almost what
the camera sees. And if you save it, you will notice that it
becomes invisible. But if you enable
selection outline in the Gizmus, you
can see it's there. Let's maybe increase its size to two with a set size node. So imagine as if on that square, we have the camera buffer, what the camera sees. And now, if we distort it
and since it is transparent, it will create that
heat wave feeling. So we need a UV node
to map correctly the square itself or any other
mesh and some kind of noise, in this case, we can use one of the procedural noises that comes with Chelegraph even though it's heavier, watch out. If you want, you can use
a simple texture and give it a seamless noise
texture, so it's lightweight. And we can add
these two together and then connect to
the scene color. And if we save this,
we immediately see the distortion
happening quite a lot because we are essentially
using what the camera sees and spitting that to that square and
then distorting it. We can use a power node to control the contrast
of the simple noise. As you can see,
this will influence the aspect of the distortion
as well. It will be useful. And if we replace this UV
node by screen position, we get a much better result because it's mapping
through the view, as you can see if you press
S. It's already pretty cool. Now, there's several ways to control the distortion amount. In this case, let's remap the value that
goes to the power. Instead of being minus one, the in, it's going to be
positive. It's going to be one. And for this input
mean and maximum, we want to create a vector
two where we control the Y axis with a distortion amount float
that we can create up here, it's going to be a slide 0-1, and we connect it to Y axis. This way, it's
possible to control the distortion amount through
here, as you can see. In our case, we don't
want a square, right? So we can actually mask out
whatever we don't want and show only what we want if we sample a texture
and use a proper text. So let's do it.
Let's also create a text to the parameter
called mask text. For this texture right here, we want something like this, a circle which
fades on its edges. It's very easy to create. If we go back to material maker, shape node can be set to circle. Once you select it, it's very close to what
we need already. We can, for example, make it
a little bit smaller like 07 and increase
its fatness to 02. And here's a letric
if you don't want this to be a blob of light, you can use a Gaussian blur, set it to 512 or 1024, and
that's pretty much it. Select the last node and
export this texture. It's going to work as a mask. And basically, we multiply the simple noise and replace the connection
to the power node. This way, whatever is
black is not distorted. If we save it,
that's what we get. The circle distorted
at the center. Awesome. That's
exactly what we need. This doesn't end here. If we distort the simple noise with one of my favorite nodes, the 12 node, you will get a
very satisfying end result. As a matter of fact, let's
create a rotation amount with a default value of one
and a 12 strength. The default value of 25. The 12 strength goes
to the strength, and before seeing the rotation, let's connect these to
the UV of the noise. Save it, and here we go. Look how awesome that
is. Cool, right? Now, what if we animated this? That's where the rotation
amount comes in handy. If we multiply it with the
time node and then add a rotate node so we can and
you guess rotate it properly. This rotate is special
because it rotates the UVs. So it's connect to
the UV of the 12. And if we save this, here we go. Look how awesome that is. It's rotating and
it's distorting. And we can increase its size. In this case, we already
know it's to 12, so it fits with the rest and we are going to rotate
it horizontally with a set angle 90 degrees
on the X and then enable the other VFX graphs look
how awesome that is yeah, smaller volume of the distortion
amount will look better. We can turn on the rings
and the Sphere Texture. And as you can see,
nothing really happens. It's like they are hidden
or they went away. Basically, the distortion is
rending on top of the rings. And if we select
this output particle of distortion on the inspector, we have the sorting priority. You can say it's below by
putting it to minus one. And here we go. It's
rendered below now, and that looks much better. Now, let's duplicate
this one so we can also distort around
the black hole, the sphere itself, I mean. I have hidden the
other VFX graphs, but in this case, we can
remove the set angle. We want it to be vertical,
but much smaller, like four, so it fits around
the sphere, basically. It's a nice detail,
and we can even make sure it faces always
the camera like we did previously for the
Sphere Texture around the black hole and maybe can
spin a little bit slower. Yeah, you can test those values. What's important is that you say the sorting priority is
rendered below everything else, something like minus two. If we re enable everything, so we can see how it is
with all of its elements, here we go, This is what
we get. It looks awesome. Pretty cool, right? You can obviously tweak a
lot of these values, a lot of this stuff, but
that's looking really nice. Another detail we can work on
is some orbiting particles. Let's begin by duplicating
the sphere VFX Graph, rename it to orbital particles. And instead of a burst, we want a constant spun rate, so it continuously
spas particles. Value of, well, let's say 100, for example, which means if
we have increased the rate, we need to increase
the capacity of this VFX Graph right here
on initialized particles, so it can handle
much more particles. It also becomes a
tiny bit heavier. Be careful with this
number and capacity. And instead of living forever, we want to control
their lifetime. Let's use set lifetime. And if we set this module, the spector we can say
random is uniform. A value 1-3 will do just fine. And in this case, instead of using Shader Graph
on the output, we want to use the
basic output particle, quad, and let this one. We don't see anything because
set size is not existent, so let's use a set size node, which could be random
as well, by the way. And as you can see, the particle is not facing the camera. Once again, let's use
an orient module, so it faces the
camera. Here we go. And you may not see
it, but it's spowning. A lot of particles, they
are just overlapped. So let's make sure they
orbit around our black hole. On the initialized particle, you can control their
initial position. There's a lot of stuff here, but if we begin by
searching set position, you will see that there's a
set position, shape sphere. That's exactly the one we need. You can select the shape,
the position mode, if it's surface or volume, the spun mode, et
cetera, et cetera. In our case, we want to control
the sphere. It's radius. We can increase to two to
five, and as you can see, we have all the particles
spounding now we can see all of but they are static. They don't move around. That's something we can
do on update particle. The way we do it is by setting the position again,
but very importantly, we are going to get
the previous position, the one we have set on the
position shape on the sphere. First, let's connect here the rotate TD module that will allow us to
rotate each particle, and we have an input
for the position, as you can that's where we
can search get position. We are going to get position, the current position before it reaches the update particle. And as you can see now, they go back to the sphere position. They are not yet rotating. That's something we can
control on the angle. We can connect a
random float here, so they rotate randomly.
They are going crazy. They spin a lot because
the value is way too high. But if you use
something small like 0003 for the maximum,
this is what we get. A very soft motion looking good. So as I was saying, the
set size can be random. They are way too big, so
let's try smaller values, something between
zero.01 and zero at one. Yeah. Okay, that should do it. It's looking good. It's
already very interesting. But since it is a black hole, it would be very nice to see them go towards
the center, right? So that's another motion. We can add something that
we can update the particle. And there's a very
simple module here, which is the tractor
shape sphere. It bounds the particles on the other sphere that we have set on the initialized particle. Attractor will attract them with a certain velocty and with a certain force to
another sphere. That sphere currently has a radius is a little
bit too high. Let's try something like 03. Very interesting result. We can control the
attraction force so they aren't attracted so abruptly to five and we can say the attraction
speed is random. This is where you will
notice bigger difference. As you can see, 0-1,
it creates already a very interesting
motion, softer and nicer. If you quickly want to get rid of the sphere shape itself, you could do a set
position again. And give it an
empty vector tree. But go get the position
they previously had. And pass only the X and Z axis. It gets flattened the sphere.
That's one way to do it. Or you can go up there to the set position shape
sphere, and in there, you can control the
scale of the sphere easily and shrink it on
the y axis, basically. But with this method right here, you probably get to
better understand how set position works and how the stack works and how
you can manipulate values. We can still give it a
random value on the y axis. So it isn't a flat disc, so it has a little
bit of thickness between minus 01 and zero
dot one, for example. A small detail we
can take care of is the particles
disappear out of nowhere. And if you use a size over life, we can set their composition to multiply so it doesn't erase the previous set size values and use a curve similar to this one where they
go from big to small. This way, they
shrink when they get towards the center of
the black hole, right? It's a sliced black hole, and it's very useful
to show you all of these tricks we have
seen so far, right? Can do the same with color. They can fade out at the end. And even at the beginning, we can use this multiply
color over life, and we get this very
satisfying feeling where particles are pushed
towards the center. They are sucked towards
the black hole. Now, if you zoom out, you may notice this artifactor
around these circles. No worries about that. It's not the UVs of your mesh or
anything else or your shaders. It's just the text
or the gradients. If we select them,
we need to say that the wrap mode instead of
repeat is set to clamp, then press apply and voila. This way, tin knows that those texts aren't
supposed to repeat. They are simply clamped. Now, one of the last
things we can show, and it's pretty cool because
since it's Vfx graph, you can expose all of
these values here. So you can later on create variations or you can give
this effect to someone and they can create variations only on the inspector
without opening VFX Graph. So let me show you
a small example that you can do as you wish. On the sphere, let's
say you want to control the color without
opening VFX Graph. You can basically go to
properties and press T plus sign, and you have all of these
properties that you can expose. There are a bunch and you can expose pretty much
anything you want. And you can have everything
organized, for example, by creating a category
here and call it Sphere. And inside of this all of the properties of
the sphere itself. For example, on the plus sign, let's add a color, and we can
call it the Sphere color. You can expand this
and, for example, copy the same values we
have on our VFX Graph, which is 906-30-1208 lot eight, round it up to 29,
close it and drag and drop it right here and
connect to the color property. We left Alpha at zero
transparency by mistake, but you can set it to one, and if you save it, here we go. If you select VFX Graph, on the inspector now you can control color as you
wish and as you go, which is pretty cool and you can create awesome
variations with this. Size, you could
control it as well. It's a float, by the way. But, for example, you want to change the text of something without opening VFX Graph,
you can do that as well. Let's first create a
group, for example, for the rings, and inside it, create a textu two D, and we can call it noise texture 01, or you can call it Ring
text 01, for example. Basically, we can assign
the same noise that we have on our first
output of the ring. There is one right here.
And then drag and drop it and connect it to the
noise texter. Here we go. And you can do
this to a bunch of settings and end
up with a lot of properties for people
to customize or for you to create
variations. So that's it. Now you know how to create
the black hole with Unity VFX Graph
and Shader Graph. We have seen how to use
Blender and Material Maker. It came out great. I hope
you have enjoyed it. We have plenty more
of these lessons and courses where we create
visual effects for games. So feel free to
check my profile. So that's it, and I hope to
see you on the next one.