Procedural Modelling In Blender With Geometry Nodes

Transcripts

1. Welcome To The Course: Have you heard about a future of the CG industry? Its notes, procedural modelling has arrived in Blender and it looks set to change the gain of the CG in the string. If you want to learn about this awesome new way of creating objects and entire scenes in blender. Then this is the watts course for you. Here whereby you design. Our goal is to give you the best possible educational concepts and resources to upscale in any CG related topic, from 3D modelling to texture painting to animation. Who is this course aimed towards? This course is for users or blender free day who want to upskill in creating objects and scenes completely procedurally. This will allow them to create their objects and then edit post objects using nondestructive methods to improve overall workflow, both in terms of creating an individual objects and also an entire scene. Using the right notes. A basic knowledge of 3D morphing in blender and the use of nodes to create materials will go a long way for you in the early stages. As these will help you to cover the basic concepts of using geometry nodes. Beyond that, it is important that you have blender version 2.92 or newer installed on your device as geometry nodes do not exist in older versions, such as better version 2.91 and older. In this course, we starts off simple introducing the note editor system that those who may not be familiar with notes. We then create our first shape using nodes, which will be a simple share using a combination of just two different swipes of notes that will be used to create an entire object. We create a few more basic shapes, introducing more nodes along the way, such as booleans and the objects in from node a to further manipulate our shapes. Then in the next section, we begin making our objects truly procedural by creating and exposing parameters that will allow us to adjust our models that we create in real time. This is where we really explore the power of procedural modeling using notes. Going through. We will cover the roles of each node that we use to create our models. Explaining how they work and how different combinations of nodes will affect the final outcome. After that, we take things to the next level, once again, by going from creating 3D objects to entire scenes, by using what are known as points nodes. Think of this as the node system’s way of creating particle systems. And then up again are we introduce, describe, and demonstrate new notes in this section and how they work, including the aforementioned point nodes to create our object instances and the attribute nodes for controlling things like the rotation and scale of our individual objects. The main goal of this course is to beat the one-stop shop course for you to learn everything he needs to know about geometry nodes in blender. There has never been a better time than right now to begin learning this brand new skill. Not only is it in new to you, but it’s also new to Blender itself. And it looks and to change the gain or free day for many years to come. Site, what are you waiting for? Let’s get started.
2. Accessing The Workspace: To begin our journey, we first of all need to access the geometry nodes workspace. You do have the option of just recreating the layout workspace
to use geometry nodes. For example, we can click and drag to
bring up the timeline. Then we can change the timeline to the geometry nodes editor. This will allow us to
begin working with geometry nodes in the
layout workspace. However, for the
sake of consistency, we’re going to be using the predefined geometry
nodes workspace. Come up to your workspace tabs at the top of the
blender interface. And off the compositing, you should find geometry nodes. Depending on the font size
of your user interface, this might not be visible. You might need to scroll through this list to reach
the geometry nodes tab. Left-click, and it
will take you to the geometry nodes workspace. This workspace is
comprised of five panels. The first panel in the top
corner is the outline panel, which is used in most
workspaces and allows you to select objects and
the objects hierarchy. Then we have the
properties panel. This is going to be useful
later on once we begin using our geometry node
tree as a modifier. We then have our 3D view port, which is going to allow us
to view the changes that we’re making to our 3D objects. The node editor, which
is currently empty, is soon going to be filled
with many different nodes that will allow us to procedurally
recreate our objects. Finally, we have
the spreadsheet, which is effectively
just a data sheet that comprises of
different forms of data, like the positioning of
our vertices or even the ability to define the smooth shading for
our individual phases. There’s a lot of potential
with the spreadsheet, but we’re going to
be coming back to this at a later point. For now, we’re just
going to focus on the fundamentals of using notes.
3. Adding Your First Node: Now that we have access
to our node setup, we need to add our first
nodes into Blender. To do this, just click on the New button
that you see here. This will add two notes, the group inputs
and the outputs. The group output is
primarily used to show the results of your
node tree on your model. The group inputs allows you to edit this result
using the motor file, which we can actually see here. You can take values that
you use in your no tree. You can connect them to
this group input node. Then they will be
visible here in the motor forearm where you can edit the effects that sure
modifier has on your objects. If we take a closer look
at each of these nodes, you will see that we
have a socket for the group inputs
labeled as geometry. This is actually an outputs coming from the
group input node. The opposite is true for
the group output node, which has a geometry
inputs socket. This geometry refers to the base objects which
in this case is a cube. The output is what
happens to the object after it has been transferred
form the group inputs, fruit of various nodes that
we use into the group output. So any changes made in the node tree would
be visible here. At the moment, nothing
is going to change with our objects because there are no nodes in-between these two. We’re going to add
our first node. Now, if you’ve ever done
programming before, then you might be familiar with the first ever lesson for most
courses that you’ll find, which is to print hello
world on your screen. Board Geometry notes, we
have something similar. We always start
with the same node, just so we can understand
the basic concepts of the geometry node system and
that is the transform node. To add a node, you can go to the Add
menu located here. You can also use the
hotkey Shift and I, which is what I’m going to do, bring up my Add menu. There are many different types of nodes that we can work with. By the way, at the
time of recording, we’re using Blender
version free 0.1. We recommend you have
at least upgraded to this version to
continue the course. Going back to our Add menu, we have various different types of nodes that we
can choose from. The one that I’m going to choose here is the geometry time. In this list, we can find transform because there
are so many nodes, you might find it easier to search for the node if
you know what it is cold. So you can click Search and
then type in transform. It predicts what you
want to type in, which is very handy. So we can just select transform. Now what we can do is as
we hover the transform node over disconnection
or noodle as it’s called, the noodle blue highlights. This indicate that if
we were to left-click, then the transform node would automatically attach
to this noodle. We’re going to left-click. And now the noodle
is now flowing into the geometry input
voltage transform node. And then out of the
geometry output. For this transform node, we can manipulate the
translation, rotation, and scale. This is very similar
to using the grab, rotate and scale tools
in the 3D viewport. So we can just
manipulate the X1 and Z values to change the
location of our cube. We can manipulate
the rotation here. We can also manipulate
the scale of our objects. The key difference to
note here is that we are editing the geometry
of our objects, not the object itself. We have our objects origin
located at the center. If we manipulate the
cube on the z-axis, you will see that the objects
origin is not moving. This is very important
to remember as it changes the way the actual
objects can behave. If you were to then rotates in the 3D view
port or even scale. Because now the
geometry has been positioned away from
the objects or chain, which changes its behavior. Now, I’m just going to
reset this back to 0.
4. Introducing Data Types With Vectors And Floats: When working with
geometry nodes, we can manipulate various
different types of data. With the transform node, we are looking at factors for our translation,
rotation and scale. Effects are basically represents
the use of free values. This can be the free
axis, x, y, and z, or it could also be the R, G and B current channels depending on the nose
that you are using. If we take a closer
look at the sockets, you will notice that the
geometry socket is green. Both of the inputs
and the outputs. The translation,
rotation, and scale values all have these
purple sockets instead. Purple in the case
the vector type. What we can do though, is we can change our various datatypes using different nodes and approaches. For example, let’s say I
wanted to change the X, Y, and Z values of the scale form a factor to a float,
a single value. I can do this by adding a special type of node
called a value node. I’m going to hit shift and I, the value node is located
in this input category. Come over to where
it says value. And left-click, I’m going to
position my value node here. You can see that the
value socket is gray. This indicates the
use of a float value. I’m going to click and drag
and connect it to the scale. The factors for my
scale disappear, as does my cube. But now we’ve connected
it up to this value node. The reason why the cube is disappeared is because
the scale is set to 0. If I click and drag
on this value node, you can see that we are
able to scale up our cube. If I type in a value of
one that is the same as scaling it up by a
value of one on the x, y, and z axes at the same time.
5. Isolating Vector Channels: To get even more control, what we can do is we can isolate effector into free
individual float values. In the case of our scale, if we just disconnect this, we have our x1 and Z channels. We can manipulate
these independently we want by separating them. To separate your vector, we actually have to use a
node called combine XYZ. That might sound confusing, but it’s named that
because of the way that your no tree is going to
flow when it’s completed. We’re going to hit Shift I. And this time let’s just search for our combined XYZ node, which we’ll find here. Left-click and position. The combined XYZ node
allows us to attach it to a vector using this vector output and
then manipulate the x, y, and z values as
individual flows. We’re going to
left-click and drag to connect our fixer
output to the scale input. But before we do that, I’m going to zoom in. And you will notice that the shape of the
sockets changes. In the case of our
combine XYZ node, we’re working with
what are known as fields or potentially
working with fields. A field is a function that is used to manipulate the
data flow of our setup. As you continue to learn
the various nodes, you will see that our sockets
will ever be circular, which indicates specific data in the form of floats or
vectors, geometry, etc. You will also notice diamonds. Sockets, sometime in sockets will be completely filled in, like the circles, which in the case of pure
functional values, they are purely used for flows. On the other hand, you see certain sockets that are
of the diamond shape, but also look like they have a little dot in
the middle of them. This is in the case
that the socket can use either a float or
traditional data. Now, we’re going to click and drag and connect the
vector to the scale. Now what we can do
is we can manipulate free values independently
on the x, y, and z. This doesn’t appear to be any
different to what we could do in the transform node itself. If we just disconnect that, we can see we can
do the same thing in the transform node. What’s the point? Well, there are many reasons
as to why you would want to isolate these three
channels as individual flows. By the way, you will notice
that the sockets have changed shape because now they are
representing data values. What we can do is we
can, for example, connects the z value to the value node and use the value node to
control the z-axis. But again, we’re not
changing the behavior, each just changing where we
can manipulate the value. One thing that we
can do, however, is connected this value
output to multiple inputs. We could connect it up to the
x-axis and also the y-axis. Then manipulate the value node so that we scale on both of
those axes at the same time. This gives us the ability to adjust the
whites of our cube, as well as the width and
depth at the same time. This is a very simple
example of what we can use the combined
XYZ node four.
6. Exposing Parameters To The Modifier: So far we’ve introduced a couple of different
types of nodes. And we’ve also
introduced the types of sockets that are used in
the geometry nodes system. But what we’re
going to do now is focus on the modifier aspects. As we mentioned a few
lectures previous, we have this group input node. If we zoom in on
the group input, you will see we have an empty
socket which we can use. What we can do is we can expose certain parameters in our node
tree to this group inputs. For example, the
translation vector is available for connection. If I hover over this input, it gives us little prompt telling us exactly
what data is stored. Here. We have the data of our
translation set to 0, zeros 0. If we increase this value, then the value changes in this little plums as we hover our cursor over this socket. This means that the data from this socket is going to
be transferred to here. Once it’s connected. I’m just going to
revert that back to 0. Then we’re just going to connect
this to our translation. This does a couple of things. First of all, it adds
translation to the group input, but we can’t actually
change anything here. Instead, we have to
go to the modifier. Now if you’re not on
the modifies tab, who might be here? Come down to where
we have this wrench. And left-click. You can now see that we have and what geometry
nodes modifier. And we have exposed the
translation values. We have the ability
to adjust the X, Y, and Z values of our objects, or at least the
objects geometry. We can use our group
inputs to expose the various types of data that
we use in geometry nodes. Not only can we use
it for better values, we can use individual
floats as well. Here I’m going to
click and drag more at c value and position
it in the group input. This gives it the name z. If we just move our value node, you can see we have
that connection. We also have the
availability to edit this parameter in
the modifier itself. Like with the value node here, we can use a single output
socket for the group inputs. We can position it in
multiple different inputs. I’m just going to
delete the value node because we won’t need
it for the moment. I’m just kind of click and
drag to connect the x-axis. And then using the same socket, click and drag again
and connect to the one. Next, I’m going to just
open up my side panel. I can do this by
pressing the N key. I wanted to do is I
want to, first of all, reorder these two here. And then I want to rename them. I’m going to come down
to where it says group, where we have our
inputs and outputs. I’m going to select the C input. I’m going to click
on this button here. So we have these up
and down arrows, which can allow us to reposition
the theories sockets. Left-click. It basically swaps
these two over and just cleans things up here
with our connections. So there’s not as
much overlapping. I’m now going to rename this, which we can do down here. Left-click and rename it as
heights and press Enter. Now it’s renamed as Hunt, both in the group
inputs as well as here in the geometry
nodes modifier. This is where the
true potential of geometry nodes starts to
become more apparent. Because you can isolate
the values used to control your creations and expose
them to your modifier. You can’t get full control over your procedural objects form a single motor phone I block. This makes it easier
compared to waste is changing the same values in the geometry
nodes tree itself. With the x-value. We’re going to rename this
as size and press Enter. Now, we can adjust the height of the cube and its
size independently.
7. Using Two Of The Same Node: When we look at
our current setup, we might notice a
problem that would appear if we were to use
this setup to create, say, a building where we wanted to increase the height
of that building. When you want to
scale the height, you want the geometry
to go up, but not down. You want the base to mine
exactly where it is. For example, I’m going to shift and I in the 3D view port. And I’m just going to
add a plane object, open up the operator panel
and increase the scale. We have small plane here. And at the moment, our cube or building as it were, is half above, half
below the plane. If we select the cube
and increase the height, it will increase the
height correctly. But it actually increases the height both
upwards and down. What we want is to be
able to have the base of the cube sat on applying
when we increase the height, only increase the
height upwards. To understand how to fix this, we need to have an
understanding of data flow. Data flow is where we have the geometry that is being
input into this node tree. And it’s being moved
across through the various nodes towards
the group outputs. As we add different nodes, they lie on the node before them to edit
the actual model. When we using a single
transform node, this is a single point in
the process of our Dataflow. When we manipulate the
location, rotation, and scale, here, we are doing so
at the same points. But what we can
do is we can edit the translation
or location using one node and then
use another node for the scale that they are at different parts of
data-flow process. What does this mean in practice? Well, for us, we’re going to
use a second transform node. I’m going to detach
the combined x, y, and z from here
at the moment. What this basically
means is that the size and heights
parameters that we created no longer work on the model because
they’re not actually connected to the
data flow that goes from the geometry inputs
to the group output. What we will do next, however, is duplicate our transform node. I’m going to hit Shift M to create a second
transform node. Hover it over here
and left-click. This is interesting in how
it works because before, if we manipulated
the scale here, it would manipulate the
scale from the center point. We were to increase the translation on the
z-axis to a value of two. Then increase the scale again, the behavior is
exactly the same. However, if I just position
this to a value of one, we now have the cube
on top of our plane. Adjusting the same scale value still doesn’t work no matter what position we place
it on the z-axis. But watch what happens
if I manipulate the Z value of the
second Transform. Click and drag. And now it’s being
pushed upwards. But note down, this is
because of dataflow. We have the base geometry. We manipulate the
translation value using this node which is currently
exposed to our motor file. Whether it’s exposed or not, it doesn’t matter because it’s
still does the same thing, just in a different place. The next node, the
second transform node, is the next step in the
dataflow is process. It is using the data from the first transform
node as the base. This is what allows us to manipulate the
scale differently. For this transform node, the value of CBO on the z-axis is the value of 0.5
or the value of one. Here. The question
now is going to be, what do you link the
combining z1, z1, z2. Is it going to be attached to the first transform scale,
the second transform? The answer is the
second transform, because we want to
expose the behavior of the scale from
this second node. Click and drag to connect. Now if we adjust the size, it works the same as before. But if we adjust the height, we are now able, if we just zoom out a bit, we are now able to
adjust the height of our building without any of the geometry falling below
the surface of the plane.
8. Changing Input Types: When working with
the various inputs for our group input node, we have the ability to change the type of data that
it wants to use. Berg sample, we’re
currently using float values for our
height and size. What if we wanted to use
just whole numbers instead? Currently, we can manipulate
based on a decimal point, which is what a float value is. But what if you wanted to just manipulate in whole numbers? So 123, etc. Do that. You would simply select the
inputs from the side panel, come down to where it says type. Left-click. And you have all of these different data
types that you can use. Here. I’m going to change this
from float to an integer. Now if we take look
at the modifier, the height is set to 0. But if I click on
the arrow here, it increases to one
click again and increases the 234, etcetera. This is preferable depending on the type of parameters
that you want to use. In the case of a building, you may only want to
create the height of your building in increments
and control it as such. The same might
apply for the size, select the size value, and change it to integer. You will notice again that the different sockets
have different colors. This is a good opportunity
to experiments between these various different
datatypes and just memorize the colors that are used to
represent each type of data. I’ve changed the
type to string here, which is this light sky blue. In the no trees self, the noodle that connects the size to our x and
y-axis appears red. This indicates that we have incompatible
connections here. We can’t connect a string
value to a float value. This is just a useful visual
marker that will allow us to see whenever we have incompatible data types
connected to each other. Make sure to go through
each of these just to see and memorize which cannot
represents which datatype. You don’t need to know
exactly what all of these data types are
used for whites now. But it is a good opportunity to familiarize yourself
with each of them. For now, we’re going to keep
the size set to integer. Finally, let’s just temporarily change the Fetzer translation. We can change the type of effector and let’s
change it to a float. Remember that with
the effects of value, we have free different
values to control. If we were to change this
from a vector to a float, we are able to use it. But now if we manipulate
the translation value, just increase the
size and height. Then it’s going to move our object the same
value on all three axes. This is an example
where even though we could change the
datatype of our inputs, it’s not actually going
to be useful for us. This way. We can
see when we need to change our different data
types and when not to. For this, I’m just
going to revert it back to a traditional vector. Then set the z value. One.
9. Changing Values With The Math Node: The next node that
we’re going to introduce is the math node. The math node is going to
be your best friend for controlling the
various parameters that your geometry node
tree is going to create. For example, we have
our height value, which allows us to increase our heights in increments
of single meters. This is based on the original
sizing of the cubes. We can increase the
amount of control that we have over this parameter by
introducing a math node, I’m going to click
and drag to move my transform node up just a bit, then hit Shift and I. Under the utilities category, we will have our math
node left-click, and we’re going to
position it in-between the combined XYZ node
as well as the scale. If we do it here, then we will be able to manipulate all free
of our combined X, Y, and Z values. Here, I’m going to change the math function
from add to divide. Then I’m going to
increase this value. We’re going to
increase it to two. This basically halves the effect that this number
has on our model. Default cube has a
height of two meters. By creating a math node that
divides the value by two. Then this height value here goes from two meters
down to a single meter. If we were to increase
this value here even more to evaluate a four, then we’re taking the which
new scale and dividing it by four before we pass it through
the combined XYZ node. This means that our height
and size values now represent a value
of 0.5 on the x, y, and c axis. The position of the math node is going to change its behavior. For our node tree. Let’s reposition our math node Saturday only
affects the height. We can do this by
repositioning it between the height inputs for the group input node and the z-value of the
combined XYZ node. It is recommended
when using nodes to have the Node Wrangler
add-on enabled. This will allow you to do certain things that you
can’t do without it. To enable the Node Wrangler, just go to the preferences panel located here under
the Edit menu. Go to the Adams tab. And in the search bar, just type in node and make
sure Node Wrangler is ticked. Then close the
preferences panel. For the sidetrack. It’s just very important that
you have the Node Wrangler add-on enabled to maximize
your functionality. Next, hold down the Alt key and left-click on
the divide node. Then grab and G will see that it disconnects from the
component x, y, and z node. And the noodle reconnects
in-between combine X1, z and the scale. Now we’re going to highlight it over the heart
noodle and release. At this point, the math node
will only affect the value. It will no longer affect
the x and y values. You can see the
difference to this mix, to the cube itself. If we increase the
height to two, then the whites of our
cube is one meter. Again, remember that the
original height was two meters. I value of two divided
by four equals one. We can increase the height to increase the total
height of our cube. And we can manipulate this
divide value here to change exactly how much influence this parameter has on
the height of our model.
10. Creating Fake Users: Let’s now take a step back
from the notes themselves and just focus on a couple of
little house cleaning tips. The first thing I’m
going to show you in this video is just
renaming your node tree. Currently we have our geometry, we know it’s modifier, and within it we’re using
the geometry nodes tree. By left clicking here, we can rename the no tree. We just rename this as one to indicate that this is our first node tree
and press Enter. This changes the name
here, as well as here. What we can do is we can unlink this node
tree from modifier. Do that, just click
on this X pattern. When we do this,
everything vanishes. While we have our
geometry nodes modifier, it’s currently not in
use because we’re not using our one no tree. We can left-click here
in the modifier and select the one no
tree from this list. You’ll notice there’s
a 0 next to it. This indicates that that no tree is not being used
by any objects. If you were to close Blender, even after saving it, you would lose this node tree when you return
to your projects. If we were to click on
this New button again, we would add a
brand new no tree. So we’re just going to
rename this as two. If we open up this same many, but this time from here, you can see that we have
122 is company being used. So there’s no 0 in front of
it because one is not used. It has a 0. This indicates that
when we close Blender, one will be deleted, but two will be kept. If you will know
tree is valuable, but it’s not currently in use. You might want to create a
fake user for that node tree. To create a fake user, click on the shield icon
located next to that night. Left-click and it will appear blue with a tick in
the shield icon. If we return to this menu, one has a 02, has an F stands for 0, uses. F stands for fake user. This means that regardless
of whether or not the second node tree labeled two is being used by an object. It is always being used by a fake user or an object
that doesn’t actually exist. This means that if we
were to change back to our one no tree and
return to this menu, we can still see that F
is the prefix to two. Even though too is no longer
being used by an object, it will be maintained
by our Blender project. When we save and close, ensure, make sure to add a fake user to any node
trees that you want to make sure our maintains when you shut
down your projects.
11. Using Your Node Tree With Other Objects: One of the biggest
advantages to using a procedural no tree
is the ability to transfer that data
very quickly and very easily to any of the
objects in your scene. Sample. We have our base cube here. And I’m just going to get
rid of my divine node, or rather just use the
default value to one, which is the same as it
not doing anything at all. And then I’m going to position my key back
on top of the plane. So this is the
functionality that we had a couple of lectures ago, where we have our cube sat on top of applying and we can meet any appellate both its
height as well as its size. Where this is useful is
when we were to create a second object and then use the same node
setup for that object. I’m going to hide my cube object by clicking
on this button here. Then I’m going to
hit shift and I go mesh and select cylinder. Now we have a completely
different objects for our projects. What I’m going to do here
is instead of click New, I’m going to left-click and
we have our 12 nitrates. If I select one,
nothing happens. The reason why is, even though we do have that
no tree in our project, we don’t have the
geometry nodes modifier active on the specific model. We need to click
on this new option first to create
our new modifier. And you can see it
in the modifies tab. Now we’re going to open
this up and select one. As soon as we do that. We can see once again, all of the nodes form
our first no tree. We can no longer see
the cylinder because the values refer back to
their default values. You can control
these default values here in the side panel. For example, I might want to set the default height
and size to one H. So I can change
this value to one. Then this value to one. That’s not gonna
change anything in the modifier when it’s
already been created. But now if I was to just
delete this objects, so I’ll hit delete. Then we add a cylinder, create a new geometry node tree. Bring in my one no tree. You can see that
the size and height are this time set to one. H. Can do the same with
more at translation. Set this up to one
as my default. That would be applied
the next time I attached this geometry knowledge
tree to a new objects. But going back to the power
of the modifier itself, we can now use the same no tree that we
created for our cube. We can use it to adjust the height and the size
of our cylinder object. Even though it’s a
completely different model, we’re able to edit it in the same way that
we did our key. That is really the true power
of using the node system.
12. Replacing Object Geometry With A Mesh Primitive: You don’t always need to use the geometry form your
original objects. You can also choose to use what are known as mesh primitives. Let’s take the
cylinder for example, and I’m just going to rename the cylinder blank in the
k. That is a blank canvas. We’re not going to use the geometry of this
cylinder anymore. Instead we’re going to use
a Mesh primitive node. Hit Shift and I to bring up your Add menu and then go to where it says Mesh Primitives. Here we have a list of all the primitive objects that you can use as the
base of a new model. For example, let’s select cube. Then we’re going to connect
it on the noodle between the geometry output and the
translations geometry input. When we do this, you
will notice that it disconnects from
the geometry output of the group input node. This is because it
has nowhere to go to. The cube itself is now
creating the geometry. It doesn’t need the data
from this geometry output. This is different
from just using the default cube in
the 3D viewport. Because now we have
the ability to procedurally edit the
base size of our cube, as well as the amount of
geometry that it possesses. I’m just going to revert
the size back to one. You can see by the way
that even though we have changed the target once
again to Mesh primitive, the effects that the other
nodes have remained the sign. Here. We’re going to just
change the sizing to two so that it mimics
the original cube. And we can also edit the vertex count on
the x, y, and z-axis. If I zoom in, you can get a better
view of all of the values that you can
change for the cube objects. It’s difficult to see the vertices on your cube
in the current setup. So I’m just going to make a couple of changes
in the viewport. I’m going to open up
this overlays menu here. And we have this wireframe
option for our geometry. I’m just going to left-click
to enable this option. If I was to increase more
vertex count on the x-axis, for example, you will
now be able to see the geometry in solid
view in the 3D viewport. This is a useful method
for being able to fuel your geometry without having to go to wireframe, for example. Again, the beauty of using
the node system allows you to switch out this primitive with other primitive
objects as well. So you can test the
different objects that you have available to
switch out a node, hold down the Shift
key and press S. This will work with the Node
Wrangler add-on enabled. So make sure that that box is ticked in the
preferences panel. I’m going to change this
Mesh primitive to account. Now, we are using a cone object. Instead of a cube objects. We can manipulate
its vertex count. For example, the number
of sides, segments, segments which you would
find at the bottom, as well as the radius on the
top and bottom of our cone. Just as a few examples for what we can do with this object. We could also use
say, a cylinder. So Shift S, switch to Mesh
Primitives and then cylinder. Again, we can manipulate
the vertex count, the sides segments,
the field segments, which you can now
see at the top, the radius, and the depth, all from this single node. Then we can get
more control over some of these parameters
like the scale, by using the transform and combine nodes and then exposing
them to the group input. So again, even
though we have made changes to the base model, if we manipulate the heights, that behavior is still the
same as it was before.
13. Creating Instances Of Geometry With The Join Geometry Node: Let’s dive a little
bit deeper into the world of data flow now by introducing instances
of your geometry. Every time we send data from a Mesh primitive
node or the geometry node out to something
like a transform node. We are creating an
instance of that geometry. Let’s revert back to
a simpler node setup. We’ll choose our two now tree here and start from scratch. I’m going to add a
simple cube note here. Shift I. I’m going to go to Mesh
primitive and select cube, and then left-click here. I’m also just going
to get rid of the plane objects for now. So we can just see
our cube model. We have the basic data here for the size and the
number of vertices. But we can manipulate the transforms of this
cube as we already know, by adding a transform node. I’m just going to
go to Geometry, select Transform
and position here. This again allows us to
manipulate the location, rotation, and scale
of Fisk cube. Now this transform node follows the data flow coming
from the cube node, true to the group output. This is one tree, one instance. We can create a second branch by adding another
transform node. For this first transform, I’m just going to move it along the x-axis by a
value of minus two. Then I’m going to hit Shift D to duplicate and position a second transform node
directly underneath. I’m then going to position
this node to 0 on the x-axis. Because the node is not
connected to our Dataflow, it has no impact on our model. We can click and drag
form our mesh output for the cube node and plug
it into our geometry. Again, this changes nothing
because even though the dataflow is sending the
cube data to both transforms, only one of them continues
to the group output. If we click and drag the second transform node and connect it to
the group output, we can now see the data
for that transform node, but it replaces the first one. What we want to do here is use both of these instances
at the same time. We can do this by using what is known as a join geometry node. I’m going to hold down
Shift and press i. Then I’m going to
go to geometry. And this time select
joint geometry and position here just in
front of the group output. If we zoom in on our
joint geometry node, it looks fairly straightforward. We have a geometry input
and a geometry output, but the shape of the geometry input is different to what
we’ve seen so far. It’s a more oval shape compared to the circle
shape that we normally see. This indicates an
input socket that can hold multiple flows, a Beta. In the case of the
joint geometry node, it can take data from various instances and
join them together. For example, we
can click and drag the first transform and position in the
joint geometry node. Remembering to of course connect the joint geometry node
to the group output. And there’s our first cube. Next we can take the
second transform node and also plug it in to our
joint geometry node here. Now, our second appears. With the joint geometry node. We are able to see both data
flows coming form our keep. The effects of both
transforms on our node setup. We can add one more node here. So I’m going to hit
Shift D position. The third transform here. Set it to a value of two. On the x-axis and just take the cube output and connect
it into the transform, and then connect the transform
to the joint geometry. Now I have a grand total
of free cubes in my scene. As a result of my
geometry, nodes tree, little housecleaning
tip, you can minimize your nodes
by just clicking. If I just zoom in on
the transform node, just clicking on the little icon at the top of the
node to hide it. You can also press the H
key to do the same thing. If you press Control
and height h, then you can hide all of the sockets that
are not being used. If I just press
control and hij again, you can see we’ve
got our translation, rotation and scale values, but they’re not being used or connected
to any other nodes. If I hold down control
and then press H, I can hide the unused data. We can do the same thing with
the other two transforms. We’ve control and height h. And that just reduces
the amount of clutter in our node setup. If you remember back when we
introduced the math nodes, then using the nodes in specific areas will change the way that they
affect our objects. What we can do here is we can control the location, rotation, and scale of all free of
our cubes at the same time. To do this, we can
add a transform node. After we have joined
the geometry. I’m going to hit
shift and I go to geometry and select Transform,
then position here. Now, if I manipulate the
z-value for myLocation, it affects all free of my keeps. If I manipulate the
Y rotation, again, it affects the rotation
of all free cubes, but it does so the origin point. Again, this can be different
to the effects that you will see in the individual
transform nodes for each cube instance. If we manipulate on the y-axis, in this end transform, you can see that the two side cubes orbit around
the center one. However, if we select
this transform note here, hit Control H to view everything and then change the rotation
value on the y-axis. Then it rotates on its own axis or not the
center points located here. We can also
manipulate the scale. I’m just going to restore this back to where it
was before we control H. And we can manipulate the scale
of all free of our cubes. At the same time. Let’s finish things off
with a mini exercise. As we continue to go
through the course, we’re going to be introducing
mini exercises is based on the skills that you have learned in
previous lectures. So in the previous lectures so far we’ve learned through
many different things. And one of the things
that we were able to learn with the ability to use
multiple transform nodes, two edits, the
location, rotation, and scale at different points
of the data-flow process. I have a little mini
challenge for you. I want you to position the individual cubes
up on the z-axis by a value of either 0.5 or one wherever it takes to position them on top of the grid plane. Then I want you to
be able to scale the individual buildings or
blocks using the scale value. But do you remember the
best way to do this? Just give that a quick
go and then we’ll recap. What we’re going to do now
is we’re going to start with this top transform and just hit Control H to bring
everything back into view. I’m just going to use a z
value of 0.5 and press Enter. Now that positions this first
cube on top of the grid. But if we manipulate the
scale as we already know, it’s going to scale
in both directions. What we can do instead is we
can add another transform node holding Shift and I, going geometry and
then transform. And then we’re just going
to position it here. The reason why we don’t
duplicates the which controls form is because if we
were to duplicate it, it would just mimic
the location values. If we don’t want it to, do, we want to keep those
location values back to where they
were initially. That’s why we just add a new
one in, in this instance. Instead of duplicating. Again, I’m just
going to hide that. And now if we
manipulate the scale, it manipulates the
scale but keeps the base in the same location. So all that’s left
is just to repeat this process for the two
nodes below in the no tree. Here, we can duplicate it. We hit Shift and
D position here. Then we’re going to
just open this up. We’ve controlled and H If we were to increase
it, it doesn’t work. But if we were to change
the transform node beforehand to evaluate
at 0.5 on our c-axis. Then now we should be able
to get the correct behavior. Excellent. Let’s just repeat this
process one final time. Shift a position, open
up the transform node, change the z value, 0.5. Close it with control
and H. Open up this one. I manipulate the z-value. Now we have the transform nodes used to create each
cube and position them. And then we have a second
transform node for each flow of data that is used to scale
each of these independently. We join these geometry nodes together with the
join geometry node. And then we use the
transform node after it to manipulate
the translation, rotation, and scale
of the entire group. We can once again use this exact setup for
different objects. So we can just take
our first objects, which is the cube, hit Shift and S and change it to something else
like a cylinder. We might need to change
some of the values, such as the radius
and the depth, make it a bit smaller. But if we were to control any of the values for our
various nodes, then we will notice that the
behavior is very similar. Now because I’ve just created a random value
here for the cylinder. You can see that as we scale, it’s not quite
correct because at the moment there’s
a little bit of the cylinder that’s
below the surface. We always need to make
sure that we are going to successfully resize any objects that we add in to get
the same behavior. Now that I’ve produced a
depth to a single meter, if we increase the scale, we can increase the scale
for this single instance. We come over to
the end transform. We can do the same
for all three. So just to summarize, because I know that’s
a lot to take in and we’re starting to use
more and more nodes here. I’m going to just recap
exactly how this works. We start with our geometry, which comes in the form of EVA, the base geometry of our
object or a Mesh primitive. Each noodle that we create form this mesh output of our Mesh primitive goes to
a transform node, which creates a new instance
of that primitive objects. We do this three times to create free different cylinders. The next step in the dataflow is to use a second transform for each individual
cylinder so that we can control the scale after
it has been repositioned. So we hit Control H. To bring this into view. We can see the first transform creates the cylinder
and positions it. Then we move on to
the second transform, which is used to scale
and scale that cylinder, form the new position because it uses the data in
the previous node. With that applied to all
free of our instances, we join them together
so that they can become a single object in
our free DVI ports. To control these three
cylinders as a how. We then add a final
transform node. Once they have been
joined together. With this transform node, we are able to
manipulate the location, rotation, and scale of
all of our cylinders.
14. Adding Labels To Your Nodes: Over the next couple of videos, we’re just going to turn
our attention back to some house-cleaning tips
that can make reading. You will know trees much easier. First of all, it helps to name your no tree appropriately. Originally we just named our
two main trees, one and two. We can swap between these
two no trees and then use the parameters that
we created for these no trees to edit the
model however we see fit. But the names aren’t very
useful for each of these, so we’re going to rename them. This one could be
used to create, say, a low bodybuilding. I’m just going to take
my cylinder and I’m going to swap it out
with a traditional cube. Then I’m just going
to rename this as building base
and press Enter. That’s not how you spell building. I’m just
going to correct that. Now we have a no tree that
is labeled correctly. For the second node tree. This is used to create
multiple instances. So I’m going to name this something slightly
more appropriate. I’m going to label this as join mesh because we’re creating
our mesh various times. And then we’re joining
them together. That just describes exactly what this no tree is being used for. Now another thing that
we need to do is label individual nodes so that we can better tell what
they are used for. The moment we have no less
than seven transform nodes. The cylinder node is used
to create a cylinder. We don’t need to rename this, nor do we need to rename
the joint geometry node. That’s fairly self-explanatory. But when someone
looks at each of these nodes and sees
Transform, Transform, Transform, they’re going
to be asking the question, what are we transforming
with each node? This one, for example, represents this cylinder here. We’re going to relabel
this by going to the side panel and
selecting node. Here we have the ability to
label this transform node. I’m going to name
this left cylinder. This changes the label here. The second transform node here, which is used for the scale, I’m going to rename
as L C scale. Lc is just short
for left cylinder because I don’t want the
nine to get too long. We can see that we are using this transform node now to create the
cylinder on the left. And then LC scale is used to
manipulate its scale value. Let’s repeat this process for
the middle transform node, which is our middle cylinder. Then for the scale, we’re going to use MC cylinder. Finally, with the bottom set, we’re going to rename
it as whites cylinder. And then for the second
transform cylinder. Now you can see more clearly what each of these
nodes is supposed to do. If you don’t want to
use the shorthand, you could just name this as left cylinder Scale or
middle cylinder Scale. That’s up to you. But because I know what
these are used for, I can just use the shorthand. Joint geometry can
be kept as is. And this point will
transform node. We’re just going to
rename this as transform because we’re using
it to manipulate the whole of our geometry node
tree as a mini challenge. Before you move on
to the next video, I want you to go back to the
building base geometry tree. I want you to spend
a couple of minutes renaming each of these nodes to something that
you think would be more acceptable
for your setup. I want you to do that now. Then I will see you
in the next video.
15. Changing The Color Of The Nodes: Welcome back guys. You should have completed the mini challenge from
the previous video. Here you can see my results. So with the building
base I renamed my cube is building base. My first transform only manipulates the location
of my geometry, so I 90 as location. The second transform is the scale building node
used for the scale. The combine XYZ node, if I just zoom in as being
renamed to oscillate height from size because
that’s what it’s doing is isolating the height, which is DC value, form the sides, which
is the x and y. Then for my math node, I’ve relabeled it
as control points because it adds additional
control to the highest value. Wherever you name
your nodes is fine. So long as you understand exactly what each node
is being used for, I want you to maintain
this practice for all of the different
nodes setups that you will be creating in the future. Now we’re going to move on
to another thing that we can do to improve the
visual look of our setups. I’m gonna go back to
my join mesh no tree. This time I’m going
to introduce colors. At the moment, you can see that each of our
different nodes, they have these green headers. Along with the sort
of gray bodies. We use a different type of node, say an input node. You can see that we have a reddish header
and a gray body. The color of the headers. In the case the type of
node that is being used. Red indicates the use
of an input node. Green indicates the use
of a geometry node. But the body can have its color altered so that you can bet up, describe what each
node is being used for at each phase
of your no tree. For example, we’re going to take the left cylinder
unless cylinder Scale. And we’re going to give these
their own unique color. To do that, come over to the
Notes tab in the side panel. And left-click where
it says Color. For the left cylinder. You will see now that
because it was selected, the box has changed color. We’re going to open up this tab here and change the color
to something a bit darker. I’m going to change it
to a reddish color. Just lower down the brightness. Then I’m going to do, is I’m going to create a cinema, a similar color for the scale. I go back to my original left cylinder
note and go to the hex value. I can get the hex
value of this color. I can left-click and hold
down control and C to copy. Then I can select LLC
scale, enable color. Then perform my hex value. I can hit Control
and V and press Enter to use the exact
same color here, but a two notes. As a mini challenge, I want you to repeat
this process for the middle and light cylinders, but have a different
color for each. I’m just going to repeat
this process myself. I’m going to add a new color. Let’s go for something
slightly different. Make sure we copy the hex
value we’ve controlled. And C. Select the cylinder
for the scale. Make sure to use Control V. Press Enter. Then we’ll do the same
thing for the bottom. Add a new color. We will copy the hex value, select the scale, paste it in. Now we have the more
visual markers of having the different instances of our geometry represented
by these different colors. You can, if you wish, use colors on any nodes that you want to better indicate what
they are being used for.
16. Using Reroutes: Another tip for
helping to clean up your node setup’s is to use
what is known as a readout. We rounds can just tidy up the noodles that connect
the nodes to each other. To create a reroute hold Shift and I E to bring
up the Add menu. Then come down to
where it says layout. You have two options
here, frame and reroute. Frame is another
very useful option that we might
introduce later on. But for now, let’s
introduce reroute. Left-click. Then position your reroute node. Or you’ve wanted the
new doors for now, let’s position it here
for the middle cylinder. What we can do with this
is we can click and drag form this new socket or reroute that would allow
us to connect from here. This would allow
us to more easily identify exactly where
these noodles are going. We cannot as many as we want. So for example, I
could add another way routes up here and then press the G key to
reposition this reroute. Better tidy up the
noodle system. I can add one more
position for this noodle. Hit G. And we position here. Because we have
this rewound going in different directions
to other reroute sockets. We get these little
arrows that show up. This is handy
because it tells us the direction that
the data is flowing. So now you can see
that it’s a lot clearer where our new doors
aren’t being directed. And this is going
to come in handy when we reached a
point that we are using 203040 plus nodes
in our node setups.
17. Creating A Block System Exercise: At this point, we’ve
taken a look at some of the core principles of
using geometry nodes. Now it’s time for
a little bit of a challenge to test the
knowledge that we have acquired. In this challenge, I
want you to create a building block model where we can increase the geometry
in the form of blocks. And as we increase the geometry, we also increase the size. Now as an example, I’m just going to
unlink this data block. I’m going to select
New and we’re going to use a cube as our base mesh. Then going to ensure
that wireframe is on. So you mean the challenge
here is when we add vertices using this
value, we add geometry. The gold is going to be to increase the size
of our geometry so that the blocks will always be the same size on that axis. For example, if we have a
value of two for vertices x, that creates a single block and that block should
be one meter long. If we increase this to free, then we’re going to want
to have two blocks, because we have free vertices
that create two blocks. And each of those blocks
should be one meter long. The current setup
increases the geometry, but does not increase
the size on that axis. Is going to be to do both. We’re going to divide
this up into two steps. So the first step of
this challenge is to isolate the size of your model. For the height,
width, and depth. We’re going to want to isolate
each of the effects of values as their own values
that we can control. That is going to be the first
part of this challenge. I want you to complete that
now and then we’ll come back and we will look at the second part
of the challenge. So pause the video
and give that a god. Welcome back. What we’re going to do is
use the combine XYZ node, which we’ve used a
couple of times already, to isolate the free
factor values and then expose them as height,
width, and depth. Hit Shift and I then locates, you’ll combine XYZ
node position here, connect the effector
to the size. And now we’re going
to take the x-value, expose it as its own socket. Do the same with the y. And then the z. In the side panel, which you can open
up with the N key. We’re going to go
to the Group tab. For x. We’re going to rename
this as the width. The y-value is going to
represent the depth, and the Z value is going
to represent the height. Because we want to do this
by meter and meter blocks. We want to change the type of data used from float
to an integer. So we are using whole numbers, select float and
change it to integer. Do the same with the
depth and width above. Now if we were to increase these values in
our modifies tab, we can manipulate the size of our cube on all of these axes. So we can manipulate our
heights independently, depth, and our width. That is the first stage of
our building blocks model. The second stage is
going to be connecting the vertex count to our
height, width, and depth. Remember the goal here
is when we increase, say the height value, then the height will
increase by that amount. But it will also add
geometry on the z axis, allowing us to not only
increase the height, but also add blocks to act
as the parts of that mesh. Give that a go. Now, remember that
for this challenge, you will not need to
use any new notes. This may take a little
bit of trial and error out to foreign to
want combination, but spend as much time
as you can try to find the correct set of nodes or correct set of connections to create that building
block model. Free to pause and go. Let’s see how we would
go about doing this. We have our x, y, and z values located here. One thing that we can
do is we can directly connect the vertices
x value to the width. Now if we were to
change this value, you can see that
we are able to add vertices as well as
increase the width value. Because both of these are
connected to the width input. There is a problem with this. However. We press say one on a number
part in the 3D view port. We can enter front
over graphic view. If I set this one, then at the moment we only
get a flat line at the side. Increase it to two, and we get our block. We have two vertices, which is the quit behavior. If I increase this to free, we get two blocks
and free vertices. But have a look at
the grid behind it. You can use the grid to determine the actual
size of your model. If you pay close attention, you can see that we have these larger squares and
then the smoothest squares, the largest squares represent
singular Blender units, or in our case, blender meters. We have two blocks here. But if we take the
center point here, come over to this side. We will see that this block is much larger than a single meter. If we increase this to four, then we get free blocks. And they come
across 1234 meters. So the size of the
cube is correct, but the blocks are too big. The reason why is
we always seem to have one block fewer
than what we need. We want the number of
blocks to be the same as the number of meters that
we define the width by. This is our next step. How do we solve this issue? Well, if you think about
it, it’s very simple. All we need is to
increase the number of blocks by one each time. That involves the use
of the math node. Hit Shift M, I. Go to search or Utilities
and select math. I’m going to position it here. Then I’m going to click and drag vertices x and then connect the width here and increase
the bottom value to one. As soon as I do that, you will notice
that the number of blocks are added has changed. We would use the
width value to one. We get a single block. It comes five squares to the left and five
squares to the right, ten squares in total. That means it’s
the correct size. And also the correct
number of blocks. Increase it to two, and it goes two meters. Two blocks, increase the free, free meters, free blocks bore. You get the idea. This is exactly what we need to do for the depth
and height as well. Which is going to close this by clicking on the
little button here, since we don’t need to view it. And then we’re going to
duplicate this app mode. Hit Shift D position underneath and shift the
again one more time. Then its height, the depth. The second at nodes and
plug it into vertices war. Finally take the heights and plug it into vertices C. Now, if we were to
manipulate our values, you will see that we
are able to create, I will one-by-one meter blocks
by controlling the height, depth, and the
width of our model. If you are able to do
that, challenge yourself. Congratulations. If not, don’t worry, at least now you have a better understanding
of how you can manipulate these nodes together to form this type of geometry.
18. Growng Our Building Block From The Bottom: Hi guys, we’re coming back to our building blocks challenge because we have that same issue as we did with our buildings, where we can increase
the height value, but it increases in
both directions. If you wanted to use this as the model
for a building base, you’re going to want to
position the bottom of the model onto the surface of your grid or applying
if you create one. The problem here is we’ve got a more complicated setup
than what we did before. So it might require a
slightly different solution. Two ways have our building
sits on top of the plane. Let’s re-add the plane back
in if we still have it. If not, just add a new client. What’s the solution here? Well, I’m gonna give you the opportunity to try and
figure it out yourself. But once again, we are not going to be introducing
any new nodes here. This is still part of
the same challenge. Think about the nose
that you’ve used in the past and the way
that you’ve used them. And consider how you can set up this no tree so that whenever we increase
the height value, we can increase the
height value in the upwards direction
only and have our objects sat on top
of this plane ago now, and I’ll see you in
a couple of seconds. Okay, so if we recall when we
created the building base, we will be able to
view the setup that we had where we used a combined x, y, and z node and
also a math node. We plug that into the scale
of our scale building. We can do something
quite similar here. What I’m gonna do is I’m going
to add a transform node. We’re going to go search
transform and position here. I’m just going to
increase my width again since that has been
decreased for some reason. Now, I don’t really want to use the scale values here
for this transform. Instead, I want to use the
location for this transform to constantly move my modal up every time we
increase the scale, which is used by
the height value. What this means is we need
to add, first of all, our combine XYZ node
because remember, we’re looking to isolate
the z axis for the heights. It shift and I. And then we’re
going to go search, combine XYZ, position it here, and plug the vector
into the translation. Remember, we’re keeping
the scale as it is. We don’t want to edit the scale with the transform
at this point, because that’s actually going to change the size of a cube. And to an extent, make the values that we’ve
already created redundant. Remember, we want
these to be one meter by one meter by one meter cubes. Next, we’re going to
isolate the z value here. We’re going to do that
by adding a math node, hit Shift, and I add
in your math node. And we’ll position it
here, plug it into the Z. Then we’re going to change
the Add Node to divide. We’re going to plug the top
value into our heights. We’re going to set
the value to two. If we test this, by
reducing the height, we can see that it positions
itself on top of our plane. Why did we need to do this? Well, by dividing
this value by two, what we’re telling blender is
to have the highest value. Define the total
size of our model. That’s the same as before. But then with the
transform node, we want to move up our model
by half of this value. Remember that without this, we had half of the modal above the plane and
half of it below. We needed to increase
the value on the z-axis by half the
scale of the height, which is located here. That’s why we had to
isolate the z value, format translation and then divide it by two before
plugging it into the heights. Now we get the
higher value here, which is four, gets divided
by two by this node. The combined XYZ
node ensures that the value of two is only
used on the z-axis. That gives it the value
here in the transform node, moving the entire objects
up by a value of two. I hope that makes sense. If it doesn’t quite make sense, feel free to watch the video again or the last
couple of videos again. It’s very important
to understand exactly how each of these nodes are
being used in this process. And every single time you create a new node
setup like this, make sure to take a
couple of minutes, even after you’ve completed it, to label your nose, color them if required. That’s a little mini
challenge for you as well to label each
of these nodes. Also just ask the question, what is the purpose
of this node? What is the purpose
of this node? Makes sure that you
understand the long that each of your nodes plays
in your objects creation. As for this challenge, we’ve now completed
it successfully. All we need to do now
is just rename it. I’m going to call it building
block. And press enter. We double-check. We’ve got building base, building block, join mesh. And we’re just going to add the fake user that we
don’t lose our work. Congratulations guys, and I will see you in the next video.
19. What We Are Going To Create: Welcome to this section
of the course guys. This section is going to be a project based section where we are going to be
creating what you see here. This is a procedurally
generated Building where we can adjust the height, width, and length of our
building however we see fit. If I come out of this view, then come into our no tree, you’ll be able to see the node system that
we plan to create. As a brief overview. These purple boxes
here, these frames, they represent the
grid structure that is going to be the
base of our building. And then each of these
blue frames here, How’s all the different nodes required for each
individual wall? We’re going to join
them up together using join geometry nodes. And then when all the
walls are joined, we’re going to move on to
creating the roof and floor of our building before
finishing things off by determining its position
to the objects origin. All of this is going
to allow us to create our own
procedural building. And we’ll be able
to edit some of these parameters
in our modifier. So here we’ve got width,
length, and height. These are the main for it. We can also create
variations for the objects we are
using for the building. If I was to adjust the
width, for example, you can see we are
able to increase and decrease the number of
windows that are being used, as well as the total
width of the building. The same applies to our length, as well as the height. It’s truly procedural
in how it’s generated. The first thing that we need
to do is create the assets that are going to be used for this procedure.
Will building.
20. Introducing Data Flow And Fields: In this section of the course, we are going to be
taking a look at Dataflow and fields
which are used to help construct our
geometry nodes systems and allow us to determine exactly how our nodes interact
with each other. Let’s start by going
to our geometry nodes workspace and add a new node
tree for our base objects. Dataflow is when information is transferred form
left to right. The most basic example, we have the information stored
in our group input node, which by default is the geometry
of the original objects. We connect via this noodle, the group inputs to
the group output. The data from the group input node is transferred
to the group output, which is the result of the
geometry nodes modifier. In other words, if we were
to add an annotation, the flow of information
goes in this direction. We can add nodes and
these nodes will act as junctions where the
dataflow will stop. We calculate and then continue. For example, I’m going to add a set position node
and position it here. Now our data flow
goes from the group input node to the
set position node. It then we calculate
the information based on the parameters
of the set position node. Before continuing on
to the group output. With Dataflow, the
information will always try and find its way to
the group output node. If we manipulate the
offset value here, then we are taking the base information
from the geometry, which is the cube in
its original position. We are then changing that position by manipulating
the offset value. And then we are
transferring the data from this node to
the group output, which gives us our
result and allows us to view these changes in real time. In this example, the
data flow goes form. No one which is the group
inputs to the set position. We calculate that information, is then sent to
the group output. This principle
remains regardless of the nodes that we add in. So if I add another node, say transform node, manipulate the rotation
on the z axis. Now our Dataflow goes from the group input to
the set position, calculates the Z offset, which is the one change for
this set position node, sends that data to the transform where
it looks for changes. It finds one in the
rotation of the z-axis, then sends that data
to the group output. So to clarify, Dataflow is when information goes
from left to right, we go this direction. We’ll go D, F, which stands for Dataflow. If we go in the
opposite direction. In this way, we are traditionally
working with fields. Apologize for the
bad handwriting. I’m using a mouse
body annotations. So our Dataflow goes
from left to right. Fields go from white to left. These fields allow us to manipulate the parameters
that we have in our nodes. They also work in the
opposite direction, searching for
information or lose. That can be used to
define new parameters. They can also be used to expose those parameters for
our group input node, allowing us to make
changes two-hour, no tree in the form
of the modifier. Let’s take a look at an
example of fields in action. I’m going to add a node
for this offset value. I want to isolate my offset
vector into free floats. I can do this by adding
a combine XYZ node, then connect the
vector to the offset. If we take a look at
the set position node, you will see that each of our sockets is a different
color or a different shape. If a socket is circular, that indicates that
the information is part of the dataflow workflow. It goes from left to right. This is the case
for our geometry. The free properties underneath or the selection
position and offset. These all have diamond
shaped sockets. This indicates that
they can use fields, which is a form of
function used in Blender to manipulate values. You will also notice that for the selection and the offset, they have little
dots in the center. This indicates that
these properties can use E for fields. All they can use a
form of data flow. They are flexible in
how they can work. You’ll also notice
the different colors. This simply indicates
the type of data. So for example, this green
color represents our geometry, while the purple color
represents vector data. If we take a look at
our combined XYZ node, we can see that this
is a node that can handle both fields and floats. We can manipulate these
three axes independently. But what we can now do in
addition to this is we can manipulate these values
using other nodes. For example, let’s
say I wanted to expose the z value
to my group input. This creates the C
parameter for one modifier. I can manipulate it as such. Let’s do the same
thing with the y-axis. It connect it to the
exact same input. Now, this single C value will control the positioning of
my cube on the z and Y-axis. You will notice as well
that the connections, the noodles, are slightly different to the one
used for the geometry. The line for the
geometry input is solid, but these are dotted lines. And this is another
indication of when fields are effectively being
used or could be used. What we can do here is
add a math node and changed the way one of these two operations is
affected by the modifier. For example, if I plug it in to the y noodle and
use the add value, I can set this to say to. Now, whatever the
z value will be, the y-value will
be that plus two. The way this is working though, is we are still going from left to
right. For our Dataflow. We are going form our group
input to our set position, but we’re not going to our
transform straightaway. Instead, blender
is going through the different
properties and it’s finding one that
has a connection. In this case the offset. It then works in the
opposite direction. It goes from right to left
to find the nodes and find a pathway potentially
back to the group inputs. Although this is not
always the case. Here, the data is going
back to combine XYZ, where we know that we can
control the one c-axis. And then for the z-axis, it goes all the way back
to the Z parameter. For the y-axis, it actually goes back to this math
node of thirst. Then goes to the z parameter. Don’t think of it as the z value being
the starting point. It’s the control point. The starting point is still
this offset value here. Going into that
combine XYZ node here, we have the y-value
and the z-value, which are currently set to 0. We add one to the y-value
or two in this case, let’s double-check that yet, but value to make it to here. Then we manipulate the z value as the faunal control point. Then it sends that data
back to the set position node before it can move
on to the transform. That might sound
complicated at first, but as you continue to
create more node systems, it will become much
easier to understand how Dataflow works
and how we can use fields to edit our information.
21. Moving Around Our Nodes To Change The Flow Of The Data: Understanding the
terminology and exactly how our node systems can work is often more challenging than learning
about the nodes themselves. So we’re just going to go
through a second example of how Dataflow and fields operate
in our node system. I’m just going to erase the lines that I’ve created
here in the previous video. Then I’m going to delete
some of these nodes. So I’m going to delete the
combined XYZ and the AV node, as well as the transform
node that these two, I’m just going to delete
that for the transform node, I’m going to select it. Hold down Control
and press Delete. This will delete
the transform node, but also maintain the connection from one position to
the group output. This way I don’t have
to reconnect them. Now I’m going to demonstrate a second example with
a different node. I’m going to add a
sub-divided mesh node and plug it in here and
increase the levels to free. I’m going to display
the effects of my sub-divided mesh node
in the 3D viewport. By coming to my viewport, overlays menu and turning on
wireframe for my geometry. This way, we can see the
actual geometry of our model, even though we are
not in edit mode. At the moment, the
dataflow is fairly straightforward because we’re
not using any fields here. We’re going from the group input to the set position,
calculating the data. Then moving to the
sub-divided mesh, calculate the data, and
then the group output. It’s all relatively
straightforward at this point. But now I want to
introduce a field. I want to create a random value for the
positioning of my cube. To do that, I’m just going
to go search in my Add menu, type in random and
select random value. If we zoom in, we can see that the random value node
has a data type menu. We want this to match
up with whatever we are connecting it to before
we actually connect it. If you take a look, you’ll see the value output here is a solid diamond shape. This indicates that we’re
working with a field. The inputs for the random
value node can be connected to Eva field inputs or Dataflow. We’re going to change this
to vector so that it matches up with the offset.
Click and drag. Making sure that
you’ve got the method turned on and connect. Now the random value
node here has allowed us to randomize the
positioning of our points. However, how will this works is just as important
as what it’s doing. How it works is it’s taking our set position node before it’s
sub-touchpoints the mesh, it goes backwards
using this field. It finds the data for
the random value node. We calculates it and sends it back to the
set position node. Then it will go on to
the sub-divided mesh. We can see this more
clearly if we were to change the positioning
of our notes. This is the setup
that we get when we have the set position node
before the sub-divided mesh. But what happens if we place the sub-divided mesh over here? Well, I’m going to hold down
the Alt key, click and drag. And that’s going to disconnect
my sub-divided mesh node, but reconnect the
nude will behind it. You can see in the
3D view port that the general shape of our
cube has not changed, but the extra geometry
has been taken out. Let’s now plug in here
and left-click release. This seems to have completely
messed up our geometry. Something’s not quite why, but actually the
behavior is correct. What we’re doing here
is we are going for my glute input node and
subdividing the mesh. We’re creating that
extra geometry. With then sending that data
to the set position node. For the offset, we’re going
to randomize the values. The key difference this time is every single point
that we created with our sub-divided mesh is now being randomized in
terms of its position. This isn’t the same as when we were using the sub-divided
mesh over here. If I, it was store that
to its original position. You can see that as we
take it out and put it in, the shape of our cube
does not change at all. The newly subdivided geometry simply follows the
new shape because the random value only affected the original points
of this cube. It doesn’t affect the points created by the
sub-divided mesh node. This is an example of how fields can influence our data flow and how changing the positioning of our specific nodes can also
impact the final result.
22. Creating An Abstract Effect Using Data Flow And Fields: Now that we understand
a little bit about our Dataflow
and fields work, Let’s create something in
Blender using this process. I’m going to start
by literally just deleting this node setup
and adding a new one. Next, I’m going to add a
sub-divided mesh node. I’m going to increase
the amount of geometry for our base cube. Hit Shift. I, then go to Search and
type in sub-divided mesh. Eventually you’re
going to know where all the nodes are in the menus, so you won’t have
to search for them. But for now, I’m going to plot the sub-divided mesh in here, then increase my levels
to a bounce free. Next, I want to
take the data from my sub-divided mesh
node and I want to extrude the individual faces. To do that, I first of all
need an extrude type node. Again, shift and I to
bring up our menu. And it will be
located under Mesh, same as the
sub-divided mesh node. And she will find extrude
mesh in this menu. We’re going to plug
it in about here. That will extrude out our
faces form each side. If we just review our Dataflow, we’re going from
the group inputs to the sub-divided mesh
to the extra output. Next, I want to randomize the extrusion of each
individual face. First of all, I’m going to
zoom in on my Extrude mesh. There’s a box here
for individual. Let’s see what happens
if we untick this. At the moment. What it does is it sort
of curves everything together so it maintains
the shape better. Now for the effect that
I’m looking to create, I’m actually going to want
them to be separated. I’m going to want to avoid this almost curved
like appearance. I’m just going to
turn that back on. Here. We have things like
how offset scale, which determine exactly
how much we are extruding our geometry by. What I’m going to do here is I’m going to land on Wednesday. So I’m going to add a
random value as a field. If we zoom in on our
extrude mesh node, you can see that the
offset scale amongst the offset and the selection
or can use fields. The offset scale can also use
Dataflow as its connection. I’m going to do what we
did in the previous video, and I’m going to add
o random value node, IT company afloat value. So the type should
be set to float. And we’ll just click and drag to connect to
the offset scale. This creates the
randomized effects for our extrusion of every
individual face. I want an effect where
it’s either being extruded in or out
but only slightly. So I’m going to set the
Min value to negative 0.1 and the max value 2.1. That gives us this relatively
interesting effects where we have these minor
extrusions across our model. What we can do here is we can manipulate some of
these values, right? The C, for example. This will randomize which of our faces are being extruded. The various amounts. Here we have our data flow
going from the group input to the sub-divided mesh and then
to the extrude mesh node. But before it moves on
to the group output, it finds its offset scale. And it goes back to
following the field, which is the random value node. And uses the values
here to determine exactly how the offset scale is going to work
for the extrusion. Now we’re going to
go one step further. We’re going to create a
parameter using this field. I’m going to take the max
value and plug it in here. I’m also going to do the
same with the mean value. Plug it into the same socket. When you do this, the two values are gonna
be exactly the sign. So it’s going to extrude
the same as it did before. We actually added the
random value node in. What I’m going to do though, is. Improve my control by
adding in a math node. I’m going to plug it
into the Min value. Set this to multiply, and then multiply it by
a value of minus one. Then press Enter. Now, I’ve set this up so that whatever the max
value is going to be, the Min value is
going to be that. But in the negative axis, if the max is set to 0.1, then the minimum value is
going to be negative 0.1. If I increase this to 0.3 for the max value than
the Min value is going to be negative
0.3 and so on. We can also connect different attributes to
our actual group inputs. We can take the C, for
example and plug it in here. We can manipulate the seed
value in the modifier. As a result, I can control both the extrusion in both the positive
and negative axis. And I can also control which of my faces are being extruded
using this seed value. So to sum things up with regards to our
current setup here, our data flow goes from the glute input to
the sub-divided mesh. It then goes to
the extrude mesh. Then it works its way back. Trudy spilled functions to our glute input node where we have the parameters
that we exposed. And we can edit these
parameters to change the final result of our keep. It’s almost like a loop. We’re going back from the extrude mesh to
the group inputs. Then once it finds these values, it’s going to go and
continue on past the extrude mesh to
our group output node. That’s another example
of how we can use Dataflow and fields to create different types
of objects in Blender. If I want to add even
more control over this. So say if I only wanted these
to be subtle increases, then I could fervor
control with a Min and max values by adding
another multiply node. So I could, for
example, hit Shift D. Plot the Multiply node in here. At the moment it’s only
connected to the mean value. But I’m just going to change
this from negative one to 0.1 and press Enter. That reduces the influence
that the minimum value has. But I want this to also
affects the max value. I’m going to click
and drag and plug it in to the max value for
the random value node. Now, the max value, which is the parameter here, is going into this
multiply node. Then it’s either going into
a second multiply node, It’s going to become negative before going into either
the Min or max values. Of course, because we’re
working with builds, it actually goes in the
opposite direction first. So in this case, we have our mean value here
and our max value here. And we have the max
value is set to psi one. Then we multiply that by 0.1 to get 0.1 and
the mean value, we get the negative
version of that. Now, we have even more control over how our phases
of extruding.
23. Separating Our Geometry While Being Defined By A Field: As we continue to learn how nodes interact
with each other, we’ll be able to create
more complex shapes. To continue on with our practice with regards to understanding
data flow and fields. I’m going to go one
step further and create a sci-fi object
using these principles. I’m just going to rename
this as abstract extrude. This is an abstract
object where we have used a random value to just
extrude the various faces. I’m going to tick
on value icon here. That’s going to ensure that the carbon geometry node setup is maintained even
if we close Blender. Then going to press
the X button, then select New, we’re
going to start again. This time. We are going to actually create something a little
bit more complex, but we’re going to be
using the same systems. I’m going to start by turning
my cube into a diamond. Now, you might
think that they’re all going to be numerous
ways to do that. For example, you could use a transform node,
plug it in here, and then begin it just rotating your actual mesh and sue you get something
like a diamond shape. But I cube isn’t
necessarily a diamond, so we’re going to need to use something a little
bit more effective. Fortunately, there is a node
that allows us to do this. If we go to our Mesh menu, at the very top of the list, is node labeled as jewel mesh. Select it, and then connect
it to your node tree. This creates a diamond shape. What the jewel mesh point
self does is it basically converts any face into a vertex. Then what would
become the faces? If I was to add a
primitive node? For example, let’s add a column. Then use this as our geometry. The default behavior,
it’s just the account. But if we add our jewel mesh, it actually inverts that. The face of the bottom
now becomes the point. Then all of the faces around and the point at the top are
used to create the circle. So effectively inverts this. That’s what the jewel mesh does, inverts the vertices
with the faces. I’m just going to delete that and plug my juul mesh
into this setup. The next step is going to be
to increase much geometry. And we now know how
we can do that by just adding a
sub-divided mesh node. I’m going to increase the
levels to about four. To give us plenty of
geometry to work with. Now, I asked the question, what happens if we
were to reorder these? Well, in their common STI, if I was to just hit Alt, click and drag the
sub-divided mesh and plug it into my jewel mesh. We actually do get a
significant change because the sub-divided mesh is
adding the geometry first. And then the jewel mesh
node is converting that geometry from points
to faces and vice versa. So now we get
something that looks a lot more like a cube. In a way you could cite, this is low-level Bevel effect. If you’re clever enough, you can actually create bevels
using this type of setup. Now, I’m going to restore
the sub-divided mesh back to its original position because we want to
keep the shape. My next step is going
to be to create the same abstract look that we have for our cube objects here, with the ability to extrude the mesh using a random value. I’m going to restore this
and I’m just going to name it as sci-fi object for now. I’m going to add my
Extrude mesh node, then plug it in. At the moment, they’re
all being extruded out way too far and
by the same length. So I’m going to add
random value node. I’m going to plug it
in to my offset scale. This gives us a better look, but it’s still all too much. So I’m going to set the
Min value to negative 0.1, the max value 0.1. Now this is still
too much for me, so I’m going to reduce
it even further. But I might as well do that by exposing these parameters
to my modifier, just as I did before. I’m going to first of
all add a math node, set this to multiply. Then we’re going to connect both the Min and max
values to this model. Apply node. I’m going to
multiply it by a value of 0.1, which is going to be
the bottom node here. Then I’m going to
connect the top socket. So my input, I can rename this input by pressing
N on my keyboard. And I’m going to go to group. Left-click where it says value
and change this to scale. Now if I manipulate this value, I can control how much
the fight is extruded by. But the Min and the max
value is still the same. I’m going to add
another math node, position it over the min, set it to multiply, and set the value to
minus 0 minus one. So it doesn’t need to be 0.1. Just minus one is going
to be sufficient. Now I should have better control
over the extruder scale. So I’m going to just use
a low value of about 0.1. And that just gives us
this rugged sci-fi look for this diamond shape. So as a quick review, our data flow goes from
the group input and it’s going to go fruit juul mesh
to the sub-divided mesh, to the extrude mesh. Like this. Before it goes further, it then goes back from
the offset scale to the random value to
the Multiply node. In the case of the mean. The Multiply node for control. Then to the extrude scale. Whatever value is
positioned here is then going to control
the dataflow. Going forward, we’ll go
back to the extrude mesh, then to our group output node. That’s how the flow of data currently exists
for this setup. Let’s now add a few more nodes. The next thing I want to do is scale this up on the z axis. I want to elongate it
in terms of its height. We can do this just by
adding a transform node. I’m going to add a transform
and position here. Then I’m going to
increase the scale value. On the z-axis. I’m going to use a
value of about 1.4. I think that’s a pretty good
look for our diamond shape. The next thing that I
wanted to do here is I want to add another
field system setup. I can separate the top half of white diamonds
from the bottom half. The first thing I’m going
to need to do here is add the appropriate node
to separate my geometry. I’ve already given a hint as to what that node is
going to be cold. It’s going to be called
separate geometry, which you can find
here by typing in Sep and then connect to the end. But a separate geometry. It’s a little bit different to the previous nodes which only have a single mesh outputs,
will geometry output. In the case of the extrude mesh, it has a couple
of other options, but those are fields
specifically. In the case of the separate
geometry node die, we have to Dataflow outputs the selection and
the inverted selection. We’re going to want
to use both of these. For now. I’m going to add what is known
as a joint geometry node. Go to Search. Go to geometry, and
select join geometry. If we zoom in on our
joint geometry node, you will see that we again have a different socket type here. This is sort of
like an oval shape. This allows us to attach multiple noodles to
the same socket. On the input side. Now I’m going to connect the inverted socket
joint geometry node. Nothing changes because with
a separate geometry node, we needed to use a
field or even Dataflow, as we can see body or icon here. In order to get this
to actually work. Before I move on, I’m
actually going to change this from points to face because that’s
going to help us a little bit later on when
we define our selection. So how can we use a
field to the fine at the selection of the
separate geometry node. Well, we want to separate our geometry based
on the z axis. We also need to base it
on the object itself. To do this, we’re going
to need to define the position of each
face on our diamond. This requires the use
of an input node. Open up your Add
menu, go to input. And the node that we
want to use is position. Then we’re going to
attach the position node, which is actually a
vector to our selection. This does not change
anything with regards to the diamond shape. It is simply cooling the
position information and telling blender
that it plans to use this position data
to define the selection. But we still need
to use the nodes necessarily to actually
define what our selection is. In this example, because
we only want to focus on manipulating the separation
based on the z-axis. We’re going to use a
separate XYZ node. Go to Add menu and
search for separate XYZ. Then plug it in here. This is going to
separate our geometry. Now at the moment
is on the x-axis, I’m going to change it to the z. If we take a look at the 3D Viewport,
nothing has changed. But that’s because we
have actually connected both our selection and our inverted selection to
the joint geometry node. I’m going to hold down
Control, right-click and drag. Then hover over inverted noodle. And release. This deletes the
connection between the inverted output and
the geometry input. And it also deletes the bottom
half of our diamond shape. So to sum up what’s
going on here, we using the separate
geometry node to separate our geometry
into two parts. These parts are defined using the selection and
inverted outputs. To decide how these are divided. We use this selection field. For the selection field, we know that we want to
separate based on the x, y, and z-axis, and we only want to separate
based on the z. We then face this data off of the position
information for each of the faces used
on our diamonds. If I was to change the type of data or the mine
form face points, you’d see this
changes the effect slightly on our diamond shape. And it creates the sort of standalone edges where
we have our connections. It’s very important to
ensure that we choose the whites domain for the
separate geometry node. With this, we now know
how we can separate our geometry using
fields and data flow. But let’s take things
one step further.
24. Controlling Our Separation With Math Nodes: Now that we have a field used to define which of our faces are going to fall under the selected category and which are going to pool under
the inverted category. We can now begin to control each half of
our diamond shape. Let’s do that now by
actually bringing the top half of the
diamonds up on the z axis. To do this, I’m going to
create a bit of space between the joint geometry and
separate geometry nodes. Then I’m going to add a transform and plug
it into my selection. We’re going to move
at transform up here. Then we’re going to
change the z translation. You can see that the top half of our diamond
is being pushed up. I’m going to move it
to a value of 0.1. And then I’m going to connect the inverted socket to
the joint geometry node. If we zoom in, you can
now see that we have a gap between our top
and bottom halves. We have the ability to
influence the top half of our diamond shape without effecting the
bottom half at all. I’m going to actually
set this to 0.05. Then I’m going to create
another transform node. Position this for the
inverted selection. Set the z value to negative
0.05 and press Enter. Now, I can control both halves of my diamond
shape independently. If I want, I can create some cool animation
effects, for example, such as rotating the bottom
half in one direction, and perhaps rotating
the top half in the opposite direction. I can also manipulate the scale independently of the two halves. We have different example
of how Dataflow works. We can play this up
into a few sections. We have our data flow going
from one node to the next, up until we reach extrude mesh. Then we use fields to go
in the opposite direction, which we should now understand to control the offset
scale with the exclusion. We then go to the
transform node, which is just a single
node for our Dataflow. And that allows us
to adjust our scale. Then with a separate
geometry node, we use a field to define how the separate
geometry node works. Then we create two
flows of data. One for the top half
of our diamonds, and another flow for
the bottom half. We can add as many nodes in-between the separate
geometry and joint geometry nodes to change the way the
top and bottom halves behave. And we can do that completely independent of the other half. But at some point, we always
need to bring everything back together because we
only ever have this one. Geometry input for the
group output node. We use are joined
geometry node to bring those separate paths together
and join that information. This is another example of how Dataflow works in
Blender and how it can actually be separated
into different paths allowing you to control the different aspects
of your models. Now, I want to create a
little bit more control. With regards to exactly what is being defined
in white selection. We’re going to actually
go backwards a little bit to our separate G arbitrary
node and the field setup. I’m going to take this set of nodes and just bring it back. Now, I want to use a math node
to control the selection. We’re going to add
some more control to this field. Shift. I go search. We’re going to select math. Now let’s start
by connecting it. Here. We connect the add node
in-between the separate x, y, z and the selection. This changes where we break
down our diamond shape. As I increase this value
and zoom out a little bit, you can see that the gap goes
further and further down. And that’s because the
position value of each face is being offset by the
value of this node. If we set this to 0, then the middle phases
have that value of 0, which means that they will be effectively the
point of separation. As we increase this, then all of the values below
will also increase in value. So they’ll get closer
and closer to 0. And then once they hit 0, that becomes the
point of separation. We can use any functions
for this so far, use the subtract node. It does the opposite
calculation. So as we increase the value
for the subtract node, then this point of separation gets higher
up our diamond shape. With a value sets of point a, we can go back to our
Transform and then manipulate the z-axis the
same as we did before. Only this time we’re working
with less of the model. We can use math nodes
in our functions to forever changed the behavior
of our specific nodes. In this case, we’re using the Subtract node
to change the way the separate geometry
node divides up our mesh. Another example could
be a compare node. Let’s add a compare node. We have a value and
an Epsilon here. I’m just going to set
the Epsilon to 0. And while that’s set to 0, we actually get no
separation at all. I’m also going to
move our value by 0. What does y increase
this Epsilon value here? As I did that, we get a little bit of
separation at the bottom. Also some interesting
behavior at all. If we increase the value, you can see we
almost get sort of like almost like
extruded out look. So it looks a bit more
three-dimensional. We’ve got the top
half, the top quarter, the diamond and it’s sort
of being pushed into the larger pulled
directly underneath. But while we have this compare operator
for the math node, we could also use an
actual compare node, which works slightly
differently. I’m going to select my node. And because I’ve got
Node Wrangler enabled, which you can do so by going to the add-ons tab in the
preferences panel, typing in node and then ensuring that Node
Wrangler is ticked. You can then select
the node and press Shift and S and change
it to something else. I’m going to change it to a compare node found
under utilities. This is not the sign as the Compare up right
up at the math node. I’m going to select Compare. Then I’m going to
connect the z value to the value at the moment
is set to greater than. Anything greater than B, is going to be defined
as the selection. Anything that is
not greater than b is going to be The find is
the inverted selection. So if I increase this value, then less of my diamond is going to fall above
this threshold. And so less of it is going to be assigned that selection output. I can also change this
to other operations. For example, I could
set it to equal. I’m going to set back to 0 and then increase
this Epsilon value. So we’ve got this epsilon again. This is basically the range. If it falls within the range, then it’s going to fall
within a specific value. I’m just going to
temporarily take the inverted connection out. This is what we get. So, because so much of our diamond actually falls underneath the inverted output, we are not actually seeing
much about geometry at all. But if I increase
this Epsilon value, you can see we get more
and more diamonds, but it is actually being
generated in both directions. Because more and more
of a diamond shape is folding within
this Epsilon value. To clarify what’s going on here, we’re using a compare node
here to control our selection. We are defining it
based on the z-axis, which is then being
used as the a value. The b value is think of it as the center
point of the compare node. Then the epsilon is
the range either side of this B value that will fall under the
selection output. If I increase the B value, you can see this changes the way that the
diamond is generated.
25. Controlling Multiple Parts Of The Set Up With A Single Node: In this video, we’re going
to demonstrate how you can control multiple values
at the same time. What want to do is create a
setup where the z value for the top half is also influencing the c value of the bottom half
of our diamonds. I’m just going to get rid
of more equal node here. Because I don’t really
need it at this point. Then I’m going to connect more inverted node will inverted output to
my second transform. This gives us the
current setup of having two separate
halves of our diamonds. At the moment, we can edit the location
independently from each other. But I wanted to set
this up so that as I increase the highlights or the positioning on the
z-axis or the top half, I also decrease the
z-value, the bottom half. So I can increase and
decrease the space between. To do that, we have
a couple of methods. One method is to
use a value node. A value node is a type
of input node similar to the position node that holds
a single arbitrary value. We can then use that value in multiple areas of anode system. Work sample. I’m going to add
my value node in. You go to the Add menu, type in value and
select the value node. All this is, is a single flow
value because it’s a float. And we’re working with vectors, we need to convert this. I’m going to create a
little bit more space. And then I’m going to add
a combine x, y, z naught. I’m going to plug the vector
into the translation. I’m going to plug the z
value into the value node. Now if I manipulate
the value node, we manipulate the top half
of our diamond shape. What I can do here is duplicate my combined XYZ node and
connect it to my transform. Then I can connect the z-value
to the same value node. When I do this, both of our halves are going to be following
the same value. Always going to stay connected. What we want is to invert the behavior
for the bottom half. We can invert our translation, rotation or scale
directions by using a multiply node and setting
the value to minus one. I’m going to do this
by adding a math. Now, positioning it before
this combined XYZ node here, setting it to multiply. And then you’re using a
value of negative one. If I just close this to create more space and adjust
the value node. You can now see that as
we increase the value, the 12.5 of noises, while the bottom half lowers. This gives us control
over the ability to create the distance
between our two hops. For now, I’m going
to set this to 0.05. Now we have that little
bit of space again in-between the two
halves of our diamond, which at this point basically
look like two pyramids. An alternative way of doing
things is to actually use exposed parameter
rather than a value node. To do this, we just need to add in another group input node. I’m going to delete my value node by selecting it
and pressing the X key. Then I’m going to
search for my input. I’m going to add one here. I’m also going to create one
more with Shift D down here. I’m going to take my c value and connect it to an empty slot. We’re going to rename
this in our solar panel, which you can open
up by pressing the N key and go
into the group tab. We’re going to select it
and rename it as distance. Then we’re going to connect this multiply node for the
lower half, the same input. Now, if we adjust our distance
value in the motor file, we get the same behavior. To prevent this
from overlapping. One thing that I can do
is adjust the Min value, which if we set to minus, actually overlaps our geometry. So I’m going to set the Min
value for 0, the max value. We will set it to one finance. If I edit my distance, then I can control
the distance between 01 without going any
higher or any lower. This way, we are able to control multiple parts of our node
system using a single value. And we can do this using
either a value node or unexposed parameter
to our modifier.
26. Creating A Second Object And Using Materials With Nodes: In this video guys, we
are going to be adding a second object to
our node system. And we are also going to
be looking at introducing materials to geometry nodes. Let’s start off with adding a new object to our node system. We have access to primitive meshes as we
know by this point, we can add as many of these
preventive meshes as we wish. Then we can use transform
nodes, for example, to create multiple
instances of those meshes. As a quick example, I’m just going to
create a fake use with my sci-fi objects and delete it. Then we’re going to
create a new node setup. I’m going to create
some mesh primitives. So let’s start with a cone. And I’m going to create
a cone cylinder. Finally, an IPO sphere. Now at the moment
we can only connect one of these three nodes
to our group output. But if I was to use a
join geometry node, then I can connect all
three of these mesh objects to march geometry output by
using the join geometry node. Now at the moment they’ve
all in the same position. So the next step is going to
be to use Transform notes. Making sure that I’m
using the correct nodes. We’re going to create
one for each reposition. I’m just going to move
them along the y-axis. Now I have three objects here. These are all part of
the same node system. Not only that, but I can create multiple instances for
each of these objects. I could, for example, create a bit more room. For each of these. Then I could duplicate
transform node, connect one object to
the new transform. Connect this to the
joint geometry node. Then manipulate it
on the x-axis a bit to create another version
of that primitive objects. Again, I could do the
same for my cylinder. Create a transform which creates a new instance once
it’s attached to the joint geometry node and then move it
along the x-axis. It one more time
for our Ico sphere. Again, duplicate connects, connects to the
joint geometry node. Then we position on the x-axis. This is how Dataflow
can be used to create multiple instances
and multiple pathways. Or we will geometry node system. And each of these
pathways before they are connected using this
joint geometry node, which almost acts as a junction for all
with this information. Any nodes that you have added along these new doors
will be independent to that instance and to that path without directly affecting
any other part of the object. So let’s take this
principle now. Let’s use it to add a new
object to our sci-fi model. I’m going to create
some space between the joint geometry and
the group output nodes. So just click and drag. Then I’m going to duplicate
the joint geometry node. Hit Shift and D and position the duplicate just
in front of the group output. Next, I’m going to
add an ecosphere. I want a sphere to appear at the very center
of the diamond shape. We also add the positioning
in just a moment. Hit Shift and I go Mesh
Primitives and select Ico sphere, position it about here. Then connect the mesh
to join geometry node. The ICU sphere is too
low ways, but too big. We’re going to
decrease the radius to 0.1 and increase the number
of subdivisions to four. Now, I need to be able to
actually view my Ico sphere. So one kind of set this
distance value to c of 0.05. That gives us that
little bit of an opening in-between the two
halves of our diamond. Let’s make it a
little bit higher. Let us go 0.07, just so we can see
a little bit more clearly on the inside. Now we have two objects. We have the cube which was
converted into a diamond. Then we have the Ico
sphere inside it. The next step is going to
be to create materials. We want to create materials for the diamond structure as well as an emissive material
for our Ico sphere. So this is going
to become a light. The first step is to go
to your materials tab in the Properties panel and
create your materials. The first one, I’m going to
label as diamond structure, which is going to make
this a very dark gray. If I was to go into moments
here we will preview. You will see that the material is not being
applied to the model at all. The reason why is because
it’s not applied directly to any geometry created
using our geometry notes. It would work with
the base cube. However, if I just hide
geometry nodes modifier, you can see that we have our cube and it has
the correct material. However, when creating geometry using our geometry
nodes modifier, we need to apply the material within our
geometry node setup. To do this, I’m going
to hit shift and I, I’m going to search
For sets material. I’m going to position this
one before that final joins geometry node
placement is important. If I at position is
set material node after this one will
join geometry node, then wherever material I have for this set material
node is going to be used for both the
diamond structure and the Ico sphere inside. But I want them to have
separate materials. I position it in front of
the joint geometry node. Remember that at this point, these are two separate pathways before they are connected
using the join geometry node. With this first set material, I’m going to set it
to diamond structure. And as soon as I do that, the material on my
structure changes. Now I’m going to create
a second material. Come over to your
materials tab in the Properties panel
and press this Plus button to add a
new material slot. And select New to
add a new material. I’m going to name
it as red emission. So it’s going to be
a red light that it misses that lines
across our scene. I’m going to scroll
down to where we have our emission color, which should look
like a black bar. Left-click. Make it white. Then choose whatever
color you want. I’m going to make it a deep red. I’m then going to increase the strength for
the moment to free. But we could change this layer. Once again, this
emissive material has not been assigned
to the Ico sphere. I’m going to duplicate
a set material node. Then I’m going to change the assigned material
to read a machine. If I just turn off more
at wireframe overlay, we should now see that our cos phi has a different material to
our diamond structure. If I go into my rendered view, you can see that we have these materials setup and I’m counting using
the EV Linda engine. If I want this to have sort
of block a bloom effect, I can enable bloom form this. Lend up for parties tab
in the Properties panel. Left-click where it says Bloom. And we get a small bloom effect. So we can improve this by
increasing our intensity. Maybe adjusting some of
these other values as well. This is going to give us a nice little bloom effect
for our Ico sphere. Alternatively, we can use
the cycles Linda engine, which calculates the
light differently. As you can see now, we’re beginning to learn the inside of our
diamond structure. We could increase the
strength value here. To increase the
strength of the liar. Keep in mind that
because this is focused around real-world
lighting properties, increasing the emissive
strength to a certain point. We’ll eliminate the color
from the sphere itself. The light emitted, however, will be that emissive color. There we go. We’ve got our little sci-fi
model here using a diamond as the base structure separated
so that it opens up to View inside an
emissive oncosphere, which is all being generated
using this node system.
27. Bonus Video Animating Our Node Set Up: Hi guys, Welcome to this bonus lecture where
we are going to be animating one of the values for our geometry nodes system. The effect that I want to create is the dissolving effects of my geometry for my diamond form the top and the bottom
in towards the center. In other words, I want to
animate my epsilon value. So commonly if I set it to 1.4, which is the current
scale of my diamond, we see all of our geometry. As I decrease this value, the geometry dissolves
from both the top and the bottom until
it reaches the center. This is the value
that we’re going to animate to create our animation. Hover over an intersection, right-click and select
horizontal split. This is going to allow us to create another panel
at the bottom. I’m going to change this
panel to a dope sheet. At the moment, we haven’t
added any animations. Make sure that you are on
frame one to start with. And then hover your mouse cursor over the epsilon
value and press I. This will add a keyframe
to the epsilon value. Next, change your active frame. Currently it sets one. I’m not going to set it to 240. The epsilon value
appears green to indicate that the value
is using a keyframe, but no changes have been made. I’m going to change this Epsilon value to
0 and press Enter. The value now appears orange to indicate that a
change has been made, but a key frame has not been
created at this position. Press I to create that keyframe. Now if I go back to
frame one and press the spacebar to
apply my animation, eventually you will see that’s our geometry begins to
dissolve towards the center. Behavior isn’t quite right. It takes a while for it to
start a little bit too long. Then once it reaches the end, it almost stops before we delete the final
bit of geometry. This is because we
are using a form of interpolation that is not
suited to our animation. I’m going to reset it
back to the first frame. Then I’m going to go to the
key menu in my dope sheet, goes to the interpolation mode and change the interpolation
type to linear. It will probably be on bezier. So change it to linear. Then test your animation again
by pressing the space bar. Now the geometry dissolved
earlier in the animation. And if we wait for it to reach
the end of the animation, it should all fade out much more smoothly because we’ve changed
that Interpolation type. This is a basic example
of being able to animate values that we
create in geometry nodes. Anything here that you see has a value like the transforms. The sub-divided mesh node
for its levels can be animated because these
values can be changed.
28. Analysing Our Node Setup And Organizing With Frames: Hi guys. In this video, we’re going to be reviewing the object that we’ve created by using our
dataflow system with fields. To make this easier, we’re also going to demonstrate
how you can divide up. You will know Tree
intersections using frames. Frame is a box that you can use to store parts
of your setup in. What we’re going to
do is we’re going to divide up our node sets up into individual sections based on what they are being used for. And then we’re going to create
frames for each section. The first section is this section here from the
group input to the Transform. This is where we created our diamond shape and also created the
randomized extrusions, as well as scaling
it on the z-axis. So this here is the setup
for the general shape. I’m going to click and drag
to select all of these nodes. Then if we hit Shift and k, we can create a frame
around our selected nodes. With this frame created, go to the node tab in the
side panel, give it a label. We’re going to label
this as structure. You can choose to give
your frame a color, which will advise that you do. Then give it its own color, which in my case is
going to be dark red. You can open up
this Properties tab here and increase
your label size. So now we’re able
to review what’s going on in this part
of our nodes setup. We have our original
group input node. And we’re taking our base cube and turning it into
a diamond using the jewel mesh with then adding geometry using
the subdeltoid mesh. The next step is to
extrude that geometry. Using the extrude mesh node. We set it up so that we
extrude individually. And then we use a field
system to generate random values for the minimum and maximum
extrude amounts. We expose this field as a parameter and we
call it extrude scale. We then work our way back to the extrude mesh and move
on to the transform node, where we increase the scale of our diamond structure
by 1.4 on the z-axis. That is our setup for
creating the base structure. The next setup is
actually located here. So we have these nodes
used to separate our geometry and then join
them up together here. I’m going to take this
section and move it over. I’m gonna take this section, move it over slightly, hold down Shift and
press P. Here we have another frame which we are
going to label as separation. Let’s give it a color. So let’s go with purple this time and
increase the labels size. Then we’ve got the final setup, which is for the materials
and additional objects. Again, I’m going to
select all of these with the exception of
the group output node, which will be on it’s own. Hold down Shift and press pay. This we’re going to label
as finishing touches. We’re doing multiple
things here. We’re adding materials
and additional objects. So you could label
this as adding properties or anything
else that you think accurately describes what these nodes are being used for. Now we have three frames. That point itself makes the whole setup looks
so much cleaner. You could also create
frames within frames. For example, we can
take these three nodes, select them all, hold down, Shift and press P. This will create a new frame
for these three nodes. But it will detach them
from the separation frames. You can just click and
drag to connect them. This, I’m going to name
it as separate base. So these are the
bass notes use to determine where we’re going
to separate our geometry. Let’s give this greenish color and increase the labels size. While we’re at it. Let’s just do the
top and bottom, so the selection and
the inverted as well. We’ll select these nodes, create a frame and
just reposition. And then the four notes
at the bottom, shift pay. We attach. Just make sure each
of these has labels. So we could say this is the
top half and give it a color. Then this setup is going
to be the bottom half. And let’s give it
an opposite color. Now we have a very clear set up of our node system
by dividing up the node tree into
smaller groups of nodes that we can analyze to determine what they
are being used for. That wraps up our section
on data flow and using fields to generate objects using the geometry node system. Thanks guys, and I’ll see
you in the next video.
29. Building The Base Asset: Our first step for creating our procedural building is to create the individual assets, like the corners, the windows, and the roof tiles. I’m going to open
up a new project. And straightway, I’m going
to save the project. So I’m going to go File, Save As, and I’m going to save it as pro building dot blends. So I’ve created a test
one ahead of time. I’m just going to name it as pro building pro
short for procedural. And click Save As. Now we have baseline, Let’s start creating the assets before we worry about
the building itself. Now the assets all need to follow specific rules
if they’re going to be used properly with our
instancing of those objects. The main role is that
they all need to follow a one by one by one ratio. So we’re going to
start by creating a base assets that
we can model off of. I’m going to delete
my cube objects by pressing X and selecting Delete. Then I’m going to
hold Shift and I go mesh and add a plane objects. Open up the operator panel
in the bottom corner. I’m going to set the
size from two meters. One meter. It’s important
that we do this step as early as we can to avoid
complications later on. Then if I press one on my number palette to go
into front orthographic view, I want the plane, it’ll be facing this view. I can do this by
rotating on the x-axis. I’m going to rotate
on the x-axis by a value of 90 degrees. Then I’m going to go into edit mode for my plane
by pressing the Tab key. Let’s zoom in a bit. You’ll see that we
have these squares. We’re going to use
these squares to position our plane precisely. Hit G with all of your
geometry selected, and then hold down control
to enable snapping. I’m going to position my plane so that the
objects or June, we’ll fold at the bottom
left-hand corner. Left-click to confirm, then hit the Tab key to go
into object mode. Next, I’m going to press N
to open up the side panel. I can confirm the
scale and rotation. The rotation is
set to 90 degrees. The scale is set to
one on each axis. The sky was correct, but we need to make sure that the rotation is
going to be applied. Hold down Control and press a
to bring up the apply menu. Then select rotation and scale. This should reset the
rotation values back to 0. Because of that, the dimensions will change slightly as well. Now it reads one
meter on the x-axis, one meter on the Z, and 0 on the y because
it’s applying. Finally, we have
our base objects. We’re going to double
left-click on where it says plane and type in base. Press Enter. And we have the base objects.
30. Creating The Assets For Our Building: We’re going to be creating the various assets
for our building. With the base selected. Hold down Shift and press D
to create a duplicate hold down Control to snap it to the grid and move it
across to about here. You might find it difficult
to see on your screen. But we have smaller grids
inside of larger ones. We’re using the larger ones
to determine the distance. This is just for the sake
of good organization. With this second plane, we’re going to name
this as door lava, then modelling them one-by-one. I’m just going to
create the base for each model first
and just line them up. You can fast forward
this if you wish. But we’re going to
be creating a door. Ground window assets,
two more windows, a roof tile asset, and a corner assets to act as
the corner of the building. I’m going to do that now. So I’m going to again go
back to the base asset, shift D, control and position. One of them. I can go quicker by
creating another duplicate. Positioning, selecting
two of them, and then duplicating
them at the same time. Hold down control. And position. This is my door. This one is going to
be the round window. This is going to
be the window one. We’re going to have window too. This one is going to
be the roof tile. We’re going to have
one more added. So hit Shift D one more
time, bring it across. We’re just going to
make sure that it’s in the correct position
and name it as. Next, save your work. Now we need to model
each of these assets. Now you can spend as
much time as you want, but always keep in
mind the target, the mentions of these assets. So starting with our ball asset, which is this one here, I’m going to select and then press the period key
on my number part. Focus on this asset. Hit the Tab key to go
into edit mode for the store and hold down control and R to
create luke cuts, scroll up on my scroll wheel a couple of times and left-click, then right-click to
confirm the position. I’m going to hold
Control and Alt again to create a horizontal Luke car. Click. Bring it up to about here,
and left-click again. These two phases are
going to be the doors. Go into face, select, select these two faces, and hit the I key to inset. We don’t want anything
at the bottom here. So we’re going to press
B on our keyboard. And that’s going to
remove the boundary, allowing us to create
the door frame. Once you have the measurement, left-click to confirm, Alt, left-click to select the frame. And I’m just going
to orbit my view to make it easier to see. Then shift and move your cursor to create
a frame objects. Always make sure to bring it out so that the
frame is feasible. That is our first asset done. We’re just keeping things
as simple as possible. But you can go into as
much detail as you want, so long as the door asset
follows that one by one ratio. Up next we’ve got
the ground window. Again, we’re going to
focus on the asset. Press one on my number pad so I can go into fun
orthographic view, hit Tab, and now we’re going
to create a ground window. The way I’m going to do
this is I’m going to hit I and just bring it in slightly. Now at the moment, it doesn’t seem to be
working for me and that’s because I’ve got the
boundary switched off. I’m going to hit B to
turn the boundary back on and just bring it in
slightly to about here. Then I’m going to hit again. Bring it in a bit further. Select the inner loop. Just extrude it. Just a touch. That’s how what ground window. Let’s now move on
to the next one. Focus with the period key. Hit one to go into fund
orthographic view. This time we’re going to
do something similar, but we’re going to create
a slightly different shape for the window. Hit I to inset. That’s inset to about
here this time. Insert again. This time I want to create an additional frame about here using a couple
of luke cuts. So hold down control and are
going to create my loop cut. But rather than
repositioning it, what I’m going to do is I’m going to hit the
light mouse button to confirm that I can move it
and lock it to the z-axis. Then I’ll just bring
it up to about here and convert the position. Repeat that process
with a second loop cup, but this time, drag
it all the way up to the top so that it
straightens out. Hit G, then z, bring it down slightly to about. We’ll go. Now we’re going to
go back into face, select, hold Alt, and
click to select the loop. But then hold shift
and click to select this face here to extrude. And just bring it out. Just a tad. Click, confirm, and then tap
to come out of edit mode. We’re making good progress
here with our assets. The next one is going to be
our second window asset. Again, repeating the process of zooming into our selection, going into front
orthographic view. This time I’m going to
create a cross shape or sort of like plus sign
shape with our window. So again, we’re going to insert and I’ll
inset to about here. Then I’ll inset again so that
we have the outer frame. And now we want to
create the loop cuts to go vertically and horizontally to create the rest of the frame. Control and r, Let’s create
the third school first. To make this even, I’m going to left-click. Then I click, then
hit G, Then x. And I’m going to move
it along the x-axis. A value of, let’s go
0.05 and press Enter. Then we’re going
to hold Control R. Click. Just drag across so
that it snaps and left-click. Then hit G, then
x, then minus 0.1. Then press ends up. Next. We’re going to actually bring these in a tab because I think
there’ll be too far out. So let’s just hit G, then x, then 0 to five. Then we’ll do the same
with the other one, but in the reverse direction. So grab x minus 0.025. An answer. And I think that’s
so much better. So i’s for that
part of the frame. Now we’ll create the
horizontal loop G. Then, then see this time. And we want to move
it up just a tad. So probably 0.025 again. And then we’ll do one more time. We have a loop cut below G, then z, then minus 0.025. Let’s actually go with a
value of point C Five. Press Enter. That should be a good enough
shape for the cross pattern. Now, we’re going to select the frame by going back to face, select, holding Alt
and left clicking. Then hold down Shift. And select these faces here. Navigates have you hit E, hold Shift and just
bring it our TAT, that there is our second window. The next one is
gonna be the luteal. And this is where it’s
gonna get a little bit easier for our design. I’m going to press
the P key to zoom in, make sure I’m in front
of orthographic. And all I’m going to do for this asset is create
a single loop car. Hold down the Control key and bring it down to about here. Then select the top face, which should be the
larger of the two. I’m going to extrude this out. I’m going to extrude this
out by a value of 0.1. Then press Enter. It comes out by 0.1 meters
to create the shape. Now we can move on
to the final asset, which is going to be
the corner asset. Focus our attention on this corner asset and the construction here is gonna
be a little bit different. We’re actually going to turn
this into a cube of source, go into edit mode, and then grab this H here. So don’t grab this edge. The one that’s opposite. Hit G, and then Control. Move it in. I’m going to move in to about here for the moment. Then I’m going to grab
it using Face Select. I’m going to hit E to extrude. And we’re going to use a
value of 0.1 and press Enter. Now if we take a
look at this cube, It’s basically a one
by one by 0.1 keep, which will be perfect
as a corner asset. Also note that the
object origin is located at the back of
the bottom-left corner. This is very important for lining up the assets
together later on. Now we have all of the
assets that we plan to use for our procedural building. But before we move on
to the building itself, there are two things
that we need to do. The first of which is
to move these into their own collections based on what they’re going
to be used for. Starting with the window assets. If we just pop into object mode, these window assets
aren’t going to be used for the majority of our
procedural building. They can go in their
own collection. Select them both in
the outliner panel. Press M, select new collection. We’re going to call
the collection window. Then select, Okay. Next we’re going to create a collection for
the ground floor. Select the door and then
select the ground window. Press M, new collection. Ground floor. Select Okay. To create the new collection. While dilute tile and
the corner assets will basically be independent
assets used by themselves. For the sake of organization. I’m going to move them into their own individual
collections as well. So that the loop tile press M and create a new
collection for roof tile. Select Okay. Then do the same for corner. Select it. Press
M, new collection. Corner. Then select, Okay. Now all of the assets
that we plan to use for our procedural
building have been moved into their
own collections. The base is no longer required. You can either delete
it or hide it, which is what we’re going to
do with all of our assets. We’re going to hide the base, and then we’re going to hide the other assets by
their collections. So select the icon next
to each collection. Hide those assets. Finally, we’re going to
create one more asset, which is going to be
the building itself. Hit Shift a and add any
object that you want. It really doesn’t matter
what primitive you use. I’m just going to
use a cube for now. Then we’re going to
name this building. Now, we are ready
to get started with the node aspect of our projects.
31. The Base Structure Of The Grid: The time has now come
to begin working with nodes to create our
procedural building. Come up to the top
of the blender UI and go to the geometry
nodes workspace. From here, I’m just going to bring my no tree up slightly, or the editor up
and out just a bit. Just so I’ve got a little
bit more space to work with. I’m going to select new. The first node that I want to add is going to be a Greek node. Now you might ask the question, why not just use a cube node which will
have all of the sides, BLUF and floor built-in. Reason why is because
I want to have complete control over
individual walls. Not just in terms of how
wide or how long they are, but also in terms of the assets
being used on each side. We’re going to use
the grid method to construct our
procedural building. Hold down Shift and press. I. Then go to Mesh Primitives
and select grid. We’re going to plug it
in to anode system here, which is going to detach
it from the group input. Next, we need to
rotate our grid here. Press one to go into
funds orthographic view, which is where we’ll be working while we are constructing
first-world. We’re going to need to rotate this wall at a transform
node after your grid node. Position it here. The only change we’re going
to make is the rotation, which is going to be a value
of 90 degrees on the x-axis. Do not worry about
moving your grid. So far. We’re going to be waiting till the end of our project
to move it into position and have the
objects are rich in located at the front corner. Now, we need to set up the grid itself so that I can better
see what we’re doing. We’re going to go to
the overlays menu and turn on wireframe. If I zoom in, you can see that we have the various edges and vertices used to
construct our grid. We’re going to be
manipulating two properties. First of all, the
width, the height, the length is going to
become the third property, but we won’t be creating that until we have generated
the other walls. Now, we’re going to
take the vertices x value and plug it
into the glute input. Then take the y-value and also plug it in
to the group input. Press the N key on our keyboard to open
up the side panel. Goats where it says group. From here, select vertices x. We’re going to rename
this as width. I’m also going to set the
minimum value here to one and the default
value to two. But he vertices while option, I’m going to rename
this as height, again, set the default to two and the minimum
value to one. Now, we adjust the width
and height values. We are adjusting
the vertex count. But we are not yet
adjusting the size. We want to construct
the grid so that as we increase the
number of vertices, but the width, we also
increase the size, the width as well, and
the same for the height. We’re going to plug the x value for the
size into the width. Then we’re going
to do to sign for the size Y into the height. Now at the moment, it looks good because we have
squares and if we increase, decrease, we have R-squares. The problem here though, is in the way that
this is calculated. So at the moment, if we go down to a value of three for both the
width and height, you can actually see that
everything looks correct. So the height here
is half a square, square, square,
half a square free, and the same for the width. And then the vertices being
used for you on each side. This looks right. But actually when we
use our instances. It’s going to be incorrect because we
are going to want to have the size lower than the vertex count in
order for things to match up. Because with each points, each vertex that we create, that’s going to generate
an instance when we are working with a
free by free ratio here. With the instances,
we’re not going to have four phases here. We’re actually
going to have nine. And you’re going to
see that when we add in our instance objects. If you’re confused by that, consider the size of the
individual squares here. Remember our rule to use one-by-one meter squares
for each of our assets. Well, if those squares are
going to be one by one meter, then the squares used in the grid needs to be the
same dimensions as well. If the grid squares
are too large, then you’re going to get spaces in-between the
individual assets. For example, here, our
individual squares line up at approximately 1.5 meters
tall and 1.5 meters wide. There are basically
two big increase, the width and the
height for each. You can see that we
still get the same issue where the squares are just
too large individually. To solve this issue, we’re going to need to reduce the size of the square
on both the x and y-axis compared to the value
located in our modifier. We’re going to add a math
mode hold Shift and I search for math and just
plug it in to the size. If I change this to subtract, subtract it by a value of one. We’re going to close up this
subtract node, hit Shift D. Position this with the size. Why? Noodle? Now
if we take a look, the size of each
grid is one meter. By one meter. We increase this to
540 width and height. We can still see
that each grid or each square of the grid is
one meter by one meter. The size is correct, regardless of what
the values here are. So let’s review what
we’ve done so far. We’ve created our grid objects. We’ve rotated it by 90
degrees on the x-axis. We then created two parameters, the width, the height. For the vertex count. We’ve connected vertices x
to the width and the height. That whatever value
we have here, that’s the number of vertices or points that are being used. For our objects. We plugged the size x into the width and the size
Y into the height. In order for us to get out
one-by-one target ratio, we need to subtract by a value of one for both size parameters. This is what gives us the
perfect width to work with. Regardless of the number
that we choose to assign for either the
width or the heights.
32. Organizing Our Nodes Into A Frame: We’ve now completed
the first stage of our procedural building, setting up the grid system. To keep things organized. We’re going to store
all of these nodes inside of a frame and then
label that frame accordingly. This is going to include
the group input node. I’m going to click and drag so that all of these
nodes are selected. The only node that should not be selected is the
group output node. Then we’re going to use
the hotkey Shift and p. This is going to
add a frame that surrounds all of
our selected nodes. In the side panel. Go to where it says node. The label, your frame. I’m going to label this
as base and press Enter. The label is gonna change
later on when we create more walls because the purpose is going to change
slightly at that point. But for now, we can
keep it as the base. I’m going to change
the color as well. So make sure that this
option is ticked. And I’m going to
start by making this. Let’s give it the red color. Then open up the properties and increase the
label size to 64. Now we can click and drag this
entire base frame or ADS, rather than moving
the individual nodes.
33. Adding A Window Instance: The next step is
going to be to add the first instances
to our grid system. I’m going to zoom out and
I’m going to click and drag to move the group output
further away from the base. As we continue to
add more nodes, the group output will get further and further
away from the base, which means we have to
zoom out more than more. I will try to ensure
that shoe can always see what’s going on
as best as possible. The next step is going to be two instance the
window collection. We want to do this first because it’s
actually going to be the lowest priority collection
from all of our options. You understand what
I mean by that? A little bit later on, we’re going to add a
new node to this setup, shifting to bring
up the search menu. And we’re just going to search instance and select
instance on points. We’re going to drag and
drop and position it right in front of the group output. At the moment, all of
our points and all of our geometry
have disappeared. We need to define the collection that we
are going to instance. I’m going to click and drag
the window collection from the outliner panel
into my Node Editor. This gives us our
collection info node. I’m going to enable
separate children. We said children pick
instance on the instance on points node and then attach the geometry to the instance. You can now see that
we have instances, these points to our grid. You will also notice that we have a four-by-four
grid this time. If I select the instance on points node and press
the M key to mute it, you will see we have
a three by three grid based on the faces. But if we take a closer look
at our three-by-three grid, you can see that each phase requires two points
or two vertices. We have one to free. For. Each of these is the
bottom left-hand corner for that instance. So we’ll end up with one
face here or one instance. A second face that
this 0.3 face, that this 0.4 face
this point here. If we press M, we get
four instances across. Four instances up. Because we have our width and
height sets of four each. We would use this to two. Then we get two
instances or two points Going along the x-axis and
four along the z-axis. This is why in the
previous lecture, we decided to
subtract the size by a value of one to ensure that
when we use the instances, we would get our one-by-one
ratio for each instance. But also maintain the
correct number of instances in the Modifiers tab. If I was to mute these, you can see that we now have a gap form in-between
each of our instances. As we manipulate this value, we are able to create
the instances correctly. But we get that gap
in-between because the size of each square, if we again mutes the
instance on points node is larger than
that one by one ratio. We use the subtract nodes here to get the
white calculation. And then we add our
instance on points node here to map our instances
to each individual point.
34. Randomizing Our Window Instance: At this stage, we want
to begin randomizing which objects in our collection
appear at each instance. We can do this by manipulating this index
instance attribute. So I’m just going to close up the collection info node
because that’s fine as it is. Hit Shift and I am going to
search for a random value. Left-click and drag it in. Before I connect the
random value node to our instance index, I’m going to change the
type from float to integer. Then I’m going to change the
max value from 100 to two. Now, I can connect the value socket with
the instance index. As soon as I do that be instances that appear
at each point change. From here, I can manipulate
the seed value to randomize which objects
appears at which point. Now that we have
this random value connected to the instance index, we’re going to take these
three nodes and we’re going to hit shift and P to
add a frame around them. We’re going to name this window. We’re going to give this
frame greenish color. Then increase the label size. At this point, we
have a frame for our base loads and a frame
for our instance to Windows.
35. Separating The Geometry: The various assets
that we are going to be using for our building, the window asset is going to
have the lowest priority. That means that unless
we define otherwise, the window is going to be used. But we can define other
assets by separating the geometry and assigning those assets to that selection. What we’re going to do now is add in the corner collection. This is going to be the asset that has the highest priority. The reason why is
because with each wall, we want our corner assets to be positioned from the bottom
all the way to the top. We don’t want any
other assets to overwrite our corner asset
when we add the Min. Let’s do this now. We’re going to select
all of these nodes here. Click and drag to
create some space. Next, we need to
separate our geometry. We’re going to
start things off by adding a separate geometry node, IP and SAP in the search bar, select separate geometry
and position about here. We take a look. We can define at the selection, which is always going
to be our window. Then the inverted selection, which is actually going
to be the corner. We then go into the following,
the selection itself. Using this input. We’re going to add an
instance on points node, which is going to
be used to generate the corner at the
various points. Hit Shift I, search instance, and then instance on points. And position about. Here. Connect the
inverted socket from the separate geometry node
to the points socket. On the instance on points node. We’re going to drag
the instance on points node down to about here. Then we’re going to move
our group input back, hit Shift and I search, join, select join geometry. We’re going to take the
joint geometry node. We’re going to pop it behind the window node or
the window frame. I should cite the instance
on points node here, connected to the
joint geometry node. Before we go any further, you’ll notice that the
new door that connects these two nodes is passing
through the window frame. We want to keep things
nice and clean. We’re going to add a
reroute node or two to this setup shift in AI. And go to Layout
and select reroute. I’m going to position
the first one here. Then hit G. And just move it
down to about here. I’m going to add a second one. Position down to about here. And just move the
instance on points node up a little bit. Next, we need to define what
we are going to instance. So take the corner collection. You can also do the corner
objects if you’d like. But we’re going to go with
the corner collection here. Click and drag and pop
it in to our node tree. Make sure that these
boxes are ticked. So separate children,
reset children, and pick instance, and then connect to the
instance input. This sets things up ready
to define the selection, but nothing has changed as yet, because we’ve not plug anything
into the selection input. This is what is
going to be used to define what is apart
of the selection. Which points are going to be part of the inverted selection? We’re going to do that
in the next video.
36. Defining The Selection For Our Separartion: Even though we’ve told
blender that we want to instance two separate
collections. We haven’t told Blender where we want each collection
to be created. This is what we’re
going to do now using the selection input. Let’s take a look at our wall and determining exactly
how this needs to be done. Body end of the projects, we’re going to
create four wards. At the end of each wall. We’re going to need
our corner assets to act as the divider
for each wall. We don’t need the
corner asset to be on both ends
of the same wall. However, this is going
to create duplications. What we want is to replace these four windows here right at the end with
the corner asset. This is going to require the use of several
different notes. But the first thing we need
to do here is we need to define what attribute is going
to be used for selection. Since we want to select our instances based
on their positioning, we’re going to start by
adding the position node, hit Shift and I go to
input and select position. Then we’re going to plug the position up
to the selection. This doesn’t change anything, but it’s going to
allow us to use other node that we’ll refer to, the object position values. Now, we want to isolate this so that it only
works on the x-axis. We basically want to take
the points that have the highest x value and
convert them into our corners. To do this, we’re going to
add a separate XYZ node. So go search. Then separate XYZ. I’m going to position
it about here. At the moment it’s
set to the x-axis. It’s already created a change
with regard to our wall. But it’s not the
change that we want. What’s going on here is we are using the separate XYZ node. So that Blender will use the
windows whenever the value of those points on the
x-axis is greater than 0. If it is equal to 0 or less, then it will use
the corner points or the corner instances. As we have defined. We have our inverted
socket here. We need to change
this calculation, which we can do by
using math notes. I’m going to take these two nodes and create
a little bit of distance. Then we’re going to hit
shift and I search math. And we’re going to plug
this node in here. What we want to do is
we want to say that if the value of a specific point is less than the highest value, which is going to be
these points here. Then it’s going to be a window. If not, then it’s going
to be a corner object. We’re going to change this
math note here from AD. We’re going to choose less than. This seems to be working better
than what it was before, but it’s still not quite there. At the moment. Any point with a
value lower than 0.5 is going to be
assigned the selection, which is the window. Anything equal to or higher than this threshold is going to
be defined as the corner. We increase this threshold, eventually will reach the
point where we can get the corners to the final set
of points on the x-axis. Now initially this
looks perfect. It looks exactly what we want. But what happens if we
increase the width value? Even if we increase the
width value by one. You can see that
we are now adding more corner instances here. As we increase the
width further, we gradually increase the number of corner points
being used because all of these points have an x value greater
than this threshold. So obviously, it’s not
quite working as it is. I’m just going to
reset that back. Another way in which we
can tell that this isn’t working is by actually
moving the objects. So if we come over to the transform node and then
move it along the x-axis. You can see that each
of the points are being converted as we
move along the x-axis. What is the next step here? Well, the next step is to
tell blender that we want the final set of points to always be set to the
coolness instance, regardless of what the width
is going to be assigned, this means that we need
the threshold to be base to a degree on whatever
the width value is. Rather than taking
our group input and just plugging the
width in directly, what we can do is just
create the group inputs. Again. I’m going to hit
Shift and then I’m going to search for group
and select Group input. I’m going to position it
underneath the position node. Then I’m going to take the width and plug it
in to the threshold. Now, the threshold is going to be directly
impacted by the width. But because it’s a
direct connection, increasing or decreasing
the width will not change anything because all of the points are going to fall under the less
than a threshold. We need to use a couple of math nodes to correct
this behavior. First of all, we’re going
to use a divide node. The reason why is when
we are working with the scale or location
of our instances, we need to remember that we
are working in 3D space and each axis has a positive
and negative direction. So when we increase
the size of something, it’s going to move that
geometry in both directions. Because of this, we
need to first of all, divide the value here by two. Hit Shift and I add in your
math node and position here. Convert it to divide and
set the value to two. Again, this doesn’t change
anything by itself. We need to add another node
that will tell blender to convert the end
points to our corners. So have a little think. If all of our points here, company fall within
the threshold, what node can we use so that the endpoints for outside
for the threshold, the answer is the subtract. Note. If we take our divide
node and duplicate it, then converts this
divide node to subtract and set the value
to something like one. For example. We get in this instance, one set of windows and
one set of corners. If we increase our width value, you will notice
that we only ever have the n set the find
as the corner objects. The question is here is
exactly why this is the case. Well, let’s review the
nodes that we’ve used here. First of all, we used
our position node. This tells Blender that
when it comes to separate into geometry between these
two instance collections, we want to use the position
attribute of our points. We only want to influence
it based on the x-axis. So we use a separate
XYZ node to do this. The y and z-axis or not apart of this calculation,
only the x-axis. The key note here is
the less than node. With this node, we are telling blender that anything
that falls below a certain threshold
is going to be defined as the selection
output, which is the window. Anything that does
not fall below this threshold is going to
be given the inverted value, which is our corner instance. The threshold is defined
using the width. We then divide the width
value by two here. Because when we
increase that width, it increases in both the positive and
negative directions. But by using just
these two nodes, all of our points will still
fall within the threshold. In order for our endpoints to fall outside
of the threshold, we use the subtract node and we subtract by a value of one. Let’s take a look at this from a slightly
different perspective. Let us use an
actual calculation. I’m going to hit T to
bring up my tool shelf. And let’s create an annotation. I’m going to set my
width value here to six. So with the group inputs, the current value is six. If it was directly
connected to the threshold, the threshold value
would be six. That means that any points
that fall below this value on the x-axis would be assigned
the selection output, which is our windows collection. If we take a look at
the windows object itself would have
building objects. You can see that all of
these points for well, within this threshold,
using the grid, we can go 123456. This is the value of
six on the x-axis. This is where using the
divide node comes in. Because the value here
is a simple integer. We’re using the value of
six on the positive x-axis. But by using the divide node, we can cut this in half. By dividing it by two. We’re left with a value of free. Now the threshold
is set to free. But if I was to just
mute this subtract node, you will see that at the moment, all of our points still
fall within this threshold. If assuming just a
little bit closer, you will see that
here is point C 0, or a value of 0 on the x-axis. One is located here. Let’s make this easier
to p with annotation. So we have SEO, we have 123. The problem is that even the furthest
point on the x-axis, which is here, still falls
underneath this threshold. What we need to do is use
the subtract node so that this point falls underneath the calculation or false
underneath the threshold. By subtracting this
by a value of one. We then get a value of
two for our threshold. Which means that now we have a set of points that go beyond the threshold
that go higher than two. Each of these points has
an x value of about 2.5, which falls outside
of the threshold and therefore is given the
inverted selection. I hope that makes sense. And if you need any
more clarification, what we can do is
we can erase this. Then let’s do the
same thing again very quickly with another value. So let’s go higher.
Let’s go ten. If we have a value of
ten for the width, then we’ve got a value of ten. Divided by two is five
minus one is four. And if we take a
look at our points, it’s 012 free, then
this one, he is 0.4. But we get that last set of points that falls outside
of this threshold. Even though we’ve
changed the width, that last set of points
will always fall outside of the defined threshold
that we have created using these notes. And so we’ve created
the corner of our wall.
37. Creating The Ground Floor: Before we move on to the next
stage of our wall creation, we need to make sure we keep
things nice and organized. So click and drag
to select all of these nodes used to
create the corners. Then hold down Shift and
press P to create a frame. Label it as corner, and then choose your color. I’m going to go for a
slightly dirty yellow, then increase the label size. Our next step is to
create the ground floor. So we want to assign the
ground floor assets to all of the points at
the bottom of our wall, with the exception of
course, of the corner. This is where the
priority aspect comes in. We’re going to need
to create the nodes for our ground floor
after this corner frame. To ensure that the corner,
it maintains priority. We’re going to click
and drag all of these nodes to the side
to give us a bit of room. Then we’re going to begin creating our notes system
for the ground floor. Now before I show
you how to do this, I want you to try yourselves. So save your work
before attempting, just so you can come back
to a previous state, maybe even save it as a backup, and then attempt to
sexual notes up to use the ground floor collection as the incidences
for the bottom row. Before you do that, take a look at the
Cournot setup. Ask yourself, what is the responsibility of
each node in this setup? What changes are am I
going to need to make in order to not only use the ground floor
as my collection, but also to position
it on the bottom row. Do that challenge now and
come back to me in a few. Welcome back, guys. So we’re now going to begin the process of creating
our ground floor. And we’re going to
start by once again using the separate
geometry node. You shift and I go search and select your separate
geometry node from the list. Then we’re just going to
attach it about heat. Then we’re going to use an instance on points
node so that we can bring in and use our
ground floor collection. Again. Go to your Add Menu. Instance, instance on points. Connect the inverted
option to the points, then the instances output
to the joint geometry node. As you can see,
we’ve got the noodle passing through
our window frame. For the sake of organization, Let’s add a couple of reroute
nodes and position them accordingly so that it improves the visual
appearance of our node setup. Then we need to instance a specific collection
which is going to be our ground floor collection. Click and drag to create the node and tick
the relevant boxes. So the separate children, we set children and
pick instance options. Then connect the geometry
to the incidence input. As you can see, nothing
changes because we have yet to define our selection using
this selection input. Of course, this is
where it’s going to get a bit more complicated. Let’s use the corner
setup as our guide and run through the
purpose of each node. We have the position note here, which allows us to use the position attribute
of each point. We’re going to need to use
this again, of course. We also need to use
the separate XYZ node. However, with the
corner selection, we were focused on the x-axis. So we wanted to
select the points with the highest
value or the x-axis. This time, we’re
working on the z-axis. So we’re going to need
to use the C channel. And also lost time. We wanted the points that had the highest values to be
assigned our corner object. But this time for
our ground floor, it’s going to be the opposite. We want to use the lowest
values for our ground floor. That means that instead of
using a less than node, we might want to use
a greater than node, which does the opposite. Let’s replicate this first
half with our setup. From the separate geometry node. We’re going to add
an input position. And we’re going to connect
it up to the selection. Then we’re going to use
a separate XYZ node. Instead of using the x-axis, we’re going to use the z-axis. This looks pretty good so far. At the moment, we’re using the inverted instances for the bottom two rows
because they fall below a value of
0 on the z-axis, which is the default value. When we are combining our position and
separate x, y, z nodes. Let’s now add the control. By adding a math node. We’re going to
position it here and then change it to
be greater than, lower than, less than. Remember, we want it
so that any values greater than the threshold are going to be
assigned the selection. And anything that
is not greater than the threshold is going to be assigned the inverted
instance collection. Of course it just having
a single threshold value here is not going to work when we adjust
the height value. We know this from when
we created the corner. So we have to control
this threshold. Here. We have our group input, but it sets a width
because we’re working on the x-axis
for the corner. We’re going to use the
glute input again. But now what we’re
working on the z-axis, it’s going to need to be
influenced by the height value. The divider option here
is going to be necessary. Once again, the threshold is going to be a positive value. And simply use the positive axis in the 3D view port to calculate
where the threshold is. Divide option is going to help
mitigate that to a degree. We then have the
subtract node here. But again, because we’re working with the
greater than node, we may also want to invert
this math node as well. We may want to use
an app node instead. Let’s test this out with
our ground floor add-in. First and foremost,
our group input node. Then connect the heights
to our threshold. All of our instances now fall under the
inverted selection. Next, we’re going to
add our math node, which we’re going to set to
divide by a value of two. Then we’re going to
use an app node, duplicate the divine node, set it to add by a value of one. This doesn’t seem to
be working right now. All of our points are common sli sets to use the
inverted instance collection, which is the door
and ground windows. Maybe we didn’t need
to change it from add to subtract or vice versa. If we go back to subtract, it seems to look a
little bit better. We get our windows on top, but this isn’t
actually the issue. The add function is the correct ones you
use in this case. However, the problem that we have and we mentioned
this earlier, is the fact that we’re trying to calculate based on
positive values alone. We’re not taking into
account any points that fall below the value of
0 in this calculation. In order to fix that, we actually need to confer this calculation from
positive to negative. The easiest way to do this is
to just use a multiply node and then multiply the value by the negative version of one. If we just take our divide
node and duplicate it, then convert it to
be a multiply node. Set it to a value of minus one. Now we can see that we have
our ground floor assets. Then we have our window
assets on each row above. If we increase the height value, even if we go pretty
high and zoom out, you should be able to see that only the bottom row is assigned at the ground floor
collection and everything else is assigned
the window collection. Let’s review exactly
how this is working. Once again, I’m going to just
use my annotate tool here. In both my Node Editor
and the viewport. The height value here
this time is set to fall. Here. It has a value of four. We divide it by two to
get a value of two. Then we multiply it
by negative one, which two times minus
one equals minus two. Then we add one to
give us minus one. Because we have the
negative values, they actually go closer to 0 as we add positive
values to them. The greater than threshold here is actually set to negative one. If we take a look at the
building in our 3D viewport, this bottom value here on
the z-axis is negative 1.5. Then the next row
is negative 0.5. The next row is positive 0.5. In this case, the only row of points that fall
below the threshold. The bottom ones. This is going to
be true regardless of the height value
because we are using the height to influence
the final threshold. I hope that makes sense. It’s very, very similar
to the corner setup, but it’s important to understand the subtle changes
that you may need to make in order to assign the geometry to the correct
areas of your model. The last thing we’re
going to do here is just train the nodes
that we have created. So I’m going to just erase the annotations
that I’ve made here. And I’ll do so as well. In my 3D view port. Then we’re going to select
all of these nodes. We’re going to hold Shift
and P to frame them. And I’m going to just
move the frame across. We’re going to label
this as ground floor. For the color. I’m going
to set to a pinkish red, increase the label size. We are now one step closer
to finishing our wall. The next step is
going to be to create the roof tiles on
top of our wall.
38. Adding The Roof Tile To The Wall: Now that we have the ground floor collection located at the
bottom of our wall, we’re going to turn
our attention to the opposite side
on top of the wall. And we’re going to add
in our BLUF tile assets. I’m going to once again leave this as a challenge for you. See if you can create a node
setup for the roof tiles of your walls based on
what you have already done before with the ground
floor and corner assets. Make sure to review what each of these nodes
are responsible for. Which ones are you
going to need to use to create the roof tile? And what changes are you
going to need to make? Now I want you to attempt
to add the roof tile to the top row of
points on your wall. Welcome back, guys. We’re going to start things
off again by selecting the window frame and the final two nodes
in our node setup. And just move all of this across on the x-axis to create
some more space. Next, I’m going to add another reroute node to
this instance on points. And I’ll just so it
doesn’t get in the Y. Hit Shift, I go to
Layout and select, reroute, position it here, and just drag and drop. Next, we’re going to begin creating our nodes
for the roof tile. Once again, we know
we’re going to need a separate geometry node, an instance on points node, and a collection info
node so that we can instance our roof tile.
Let’s do that now. We’re going to hit
shift and I search for a separate geometry node
and plug it in here. Next, we’re going to
add our instance on points node and then connects the inverted socket. The points. Then take the instances output and plug it in to our
joint geometry node. I’m going to take this
reroute node here, Get Shift D to duplicate, and use this to
reposition the noodle. Duplicate again. Bring it down to about here. Next we need to take the loop tile collection,
order Mouton, object, drag and drop
into our node tree. Tick separate children,
reset children, and pick instance so that we get the quick behavior and connect
to the instance input. That’s the easy bit. Now for the slightly
trickier a bit, we want to create the loop
titles for the top row. Again, if we assess the
setup we have here, we know we’re going to
need our position node. And we know we’re going to
need a separate XYZ node. Once again, we’re going to
be working on the z axis. So that’s going to be the same. But for the greater than node, we might want to invert
this to the less than node. Because we’re going
to want all of the points below a certain
threshold to be a window. Love it Dan, being a
greater than value. In this case, we’re
going to want to swap this out with
a less than now. We’re going to add in
our position node, then connect it up to our
selection, same as before. Then we’re going to add
our separate XYZ node. And we’re going to
use the z value. The next step is going to be to add the less than node
to gain some control. We’re going to search for our math node and
plug it in here. And change this to be less
than comparison operation. Now if we manipulate
the threshold, we can control the loop
tiles for our wall. The next step is to control the threshold based
on the highest value. Again, let’s go back. And we can see we’ve
got our group inputs that choosing the heights, That’s going to be the sign. The divide node is
also going to be used. But the Multiply node
was used to invert it from a net positive
value to a negative value. Now in this scenario, that’s not going to be
required since we’re working the top of our
wall and not the bottom. So it’s pretty much
always going to be on the positive axis based
on our objects origin. Therefore not going to
require this multiply node. Finally, we have
the AV node here. But again, as ad worked
with greater than, subtract will probably be better suited for
the less than node. We’re going to go with a
group input using the height. Then we’re going to divide it. Then subtract the value
to get the threshold. Let’s see if that works. We’re going to search for our group input and connect
the height to the threshold. As expected based on
our previous frames, we no longer see any of our roof tiles because everything falls
within the threshold. But next, let’s
add our math mode. Plug it in here. Set to divide and divide
by a value of two. Again, nothing changes. I ****, We’re still working
purely on the positive axis. So we need to bring the target value for the
threshold down just a bit. Duplicate the divide node, and turn it to subtract. I’m going to use a value of one. Now, we get our blue tiles
on the top row of points. If I zoom out and then
increase the height value. You can see that the roof
tiles of fixed to the top row, just as the ground floor is
fixed to the bottom row. Despite the fact that
we’ve added in several. Let me just go back in there. Despite the fact
that we’ve added in several instances or several
instance collections, the priority is still going to be the corner
objects because that is the first in our hierarchy here from
the base to the corner, the ground floor and
now the roof tile. Because of that, because
of this hierarchy, if we reduce the height value
all the way down to one, which do you think will
remain the roof tile, the windows, or
the ground floor? Well, if I lower this value
all the way down to one, we get the ground floor. Because with the exception
of our corner assets, the ground floor takes
priority over the roof tile as well as the window
because they are both behind the ground
floor in our system. All that’s left now
is to click and drag to select all
of these notes. Hit Shift and P to
frame them altogether. Just going to reposition
the frame slightly. And we’re going to label
this one roof tile. Let’s give it a purplish color. Increase the labels size. We zoom out. We can see that we have numerous trainings
for our node setup. And each frame is responsible for a specific
aspect of our wall.
39. A Review Of What We Have Done So Far: Before we move on, let’s analyse
everything that we’ve done so far, frame by frame. We’re going to start with
our base frame here. We have our original
group input node. And attached to this node, we have the grid object, which is where we’re going
to map all of our instances, as well as the transform node. The grid is added to provide the mesh data with
the transform node. All we did here was
rotated by 90 degrees. On the x-axis. We created two parameters,
width and height. The vertices x value here
is used for the width. While both sees why is
used for the height. This is mainly because
we rotated after. We also wanted to calculate the size on the x and y-axis for both
the width and height. So that every time we
increased the width value, order highest value, we would maintain our grid or
one-by-one squares. To do this, we added
a subtract node to each of the size values to
minus them by a total or one. This allows us to keep all of our squares to the
same one-by-one ratio. After that, we move
to the back of this setup where we first
created our windows. So we use the instance
on points node so that we can
instance a collection. That collection was
our window collection. To ensure that everything
works properly. We enabled the
separate children, reset children and
pick instance options. To randomize our points. We added a random value node to the instance index by
manipulating the seed value. If we take a look here, we can randomize
the placement of each point and the instance
associated to that point. With the Windows done, we could then add the other collections
to our instance wall. So coming back to our
corner frame here, we had to first separate
aren’t geometry. This is because
we need to define where our corner objects
we’re going to go. We attached the selection
outputs to our windows, while the inverted option was connected to another
instance on points node. For our corner assets, again, all the boxes
are ticked here. This second instance on points node is then routed all the way to the back of our setup where we have
this joint geometry node. This is where we combined
all of our instance points. If we go back to our
Cournot once again, you will see that we needed to define the selection
specifically. We first of all added our position node to
our selection input. This tells the separate
geometry node that we are using the position data of
each point or vertex. Because we wanted to focus
on all of the points. That’s where at the far end
of the wall on the x-axis, we added a separate XYZ node
and use the x-value here. We wanted to create a
formula where anything less than a specific threshold would be assigned the windows. That would be the selection. Then anything that
does not fall within that threshold would be
given the inverted option, which would be our
corner assets. To define the threshold, we used the group input node and we defined the width value. This way. Whenever we increase
the width in the modifier, it would have a direct
influence on which points would be affected by
this separate geometry node. But to get the right formula, we first had to
divide by two because the original
calculation would only focus on the positive axis. Then we had to subtract
that value by one. So that’s the end points. Of our grids would fall under the inverted category and
not the selection category. This is what gives us
the ability to create the corner points regardless
of the width value. This process was pretty
much repeated for the other two collections
with some slight changes. For the ground floor. Again, we used our
separate geometry. The selection again is for
the window collection. The inverted output is for
our ground floor collection. Again, all points are ticked. We again used our
position node to focus on the positional data of
our individual points. But with these
separate XYZ node, we use the z value instead
because we were working on the z-axis and trying to convert all of the
points at the bottom. Because we were trying to convert the points
at the bottom. We used a greater than node
instead of a less than load. This way, any points
that had a value on the z-axis greater than the threshold would be
assigned the selection output. Anything that was
not greater than this threshold would be
assigned the inverted output, which would be the ground floor. Again, we use the group input
node to help define this. But this time we use that the height value
instead of the width. Again, we used our divide
nodes to divide by two. But this time we added
another math node, which was the Multiply node. The reason why is because
we needed the threshold for the lowest value to
be a negative value, not a positive one. Since our building is currently scaling on both the positive
and negative c-axis. We then added a value
of one to this total. So that’s our bottom points
would fall outside of this threshold and would
therefore be given the inverted output from
this separate geometry node. Moving on to our
roof tile finally, and again, it’s a
very similar setup. The separate geometry node
with a selection go into the windows and the
inverted output go into our roof tile. We define our position
on the z axis. This time we went back
to our less than node, because we want
everything less than a specific value on the z-axis to be
defined as the windows. If we take a look below,
we can see again, we’ve got our group
inputs are focused on the height divided by two. This time we just subtract
it by one because we’re working with values lower
than the threshold. We did not require a
multiply node here because the top points will be on
the positive axis anyway. So that’s a quick review of
everything we’ve done so far. Makes sure that you understand the role of each individual
node up to this point. Before we move on
to the next stage, which is going to be to create the individual walls
of our building. So far we’ve only
created a single wall. Now we need to figure
out the best method for creating all four
sides of our building.
40. Creating The Second Wall: The next step in our process is to create the second
wall of our building. There are several ways
that we can do this, but I’m going to
choose a method that is going to allow us to control the randomization of
the individual points on each wall independently. What we’re going to
do is we’re going to duplicate all of the frames. And the joint geometry node used to join all of our
instances together. We’re not going to duplicate our base frame at this point. I’m just going to move
it to the side slightly. And I’m also going to
move my group output, which is the very end node here, and just move it away. Then I’m going to click and drag and select all
of these nodes, all of the frames and
the joint geometry node, with the exception of the base
rain and our group output. Then I’m going to hit shift
and D to duplicate this. Lock it to the y-axis. Then left-click. Now we duplicated
most of this setup. I’m going to take the geometry output for
my base transform node. I’m going to plug it in to the separate geometry
node for the corner. Just click and drag until
it snaps into place. I’m going to add a
reroute node here. Just to better organize. The back. We have our joint geometry node
for the first set, and they’ll join geometry
node for the second set. What we want to do is add a third joint geometry node
to bring these together. I’m going to pop it here and
then connect the bottom one. This new joint geometry node. At the moment there
is no change, but that is only from
a visual perspective. We’ve actually now created two walls at the
exact same location. If I was to go to
my window frame, for example, and
adjust the seed. You will notice that we are still able
to adjust the seed, but the behavior is
a bit weird with these windows and that’s because they geometry overlapping. So our next step is going to be controlling the
positioning of each wall. We’re going to start off
by using a transform node. And we’re going to do
this with each wall, shifts in AI and
adding a transform. I’m going to pop the transform
of board the first wall. However, I’m not going to
change any values whatsoever. Then going to duplicate the transform node
and pop it in here. For our second wall. This I’m going to use a height
and width value of four. Just as a starting point. Then I’m going to
rotate this wall on the z-axis by a value
of 180 degrees. Next, I’m going to
move it on the y-axis. Let’s move it. If we press seven
on our number part. Let’s see if we move
it by a value of free. That might work for us. What we’ve done here is
we’ve duplicated our wall effectively and
then repositioned it with the transform node. The reason why I rotated it
is when we have four walls, each wall is going to
have that corner section. And we don’t want these
corners to overlap. When we create the
third four fours, we’re going to have a
corner section here. Then for the fourfold, a corner section here. Now to keep things organized, we’re going to add a
couple more frames. I’m going to have a frame for the first wall and then a
frame for the second wall. I’m just maneuvering
things about a bit. And you’ll notice
that I’ve moved the join geometry node here
away from the two sets. And I’ve moved the group
output fervor away. And that’s just in
preparation for the two walls that are
gonna come underneath. Then now I’m going to click and drag to select all
of these nodes here. I’m going to hold down
Shift and press P. We’re going to
label this as well. I’m going to give this
bluish green color. You’ll now see if we
increase the labels size that we have all of these frames located within
our larger frame here. The only thing that you
will notice is that when you create
that extra frame, it detaches all the nodes, form the smaller frames. Very quickly. See
if you can just select the appropriate frames. Just hit G and try and move them into
their original frames. Can be a little bit tricky. But if you just go
through that process, you should be able to reset everything to how it was before. While we’re doing that, we’re just going to sort at
the second wall as well. So let’s create a frame with the second set
of nodes with Shift P. Then we’re going
to label it as B. I’m going to set it a slightly
different blue color. There we go. So now we
increase that labeled size. We’ve got all of
the nodes for wall I and all of the
nodes for wool be. In the next video, we can focus on
creating wolves C and D. But the process is going
to be slightly different.
41. The Second Set Of Walls: We’ve created two walls. Now we’re going to create
the second pair with walls to create the four
shape of our building. Whereas in the previous video, we’d only duplicated at the nodes associated
to the instances. This time we’re going
to duplicate the base. And there’s a reason why. I’m going to click and drag and select
every single frame, except for the group output whenever it looks
like really far out. But that’s simply
because we need to zoom out to select everything. But if I zoom in,
you can see that the only node not selected is going to
be the group output. I’m then going to hit
Shift D to duplicate, locked to the y-axis
and position down here. Next, I’m going to use
the joint geometry node one more time to connect the first pair
with the second pair. I’m going to hit Shift D because this is our joint geometry node. Again, I know it’s really small, but because we’re working with a much larger set of nodes here, we have to zoom out a bit. Hit shift the position here. If I zoom in enough, Let’s just drag it so
it’s a bit closer. We can connect one joint
geometry node to the other. Just as with the previous video, nothing has changed because our walls are basically
in the same place. We need to change
these values here. For this one, I’m
going to rotate it by 90 degrees on the z-axis, then going to move it on the
x-axis by a value of 1.5. And I’m also going to move it on the y-axis by a value
of 1.5 as well. That will line the wall
up with the other two. Now we’re going to repeat the
process with the fourfold. At the moment it’s set to
a z value of 180 degrees. We’re going to want to
use a value of about. Let’s take that back to 0. And we’ll use a value of minus
90 for the rotation here. If you take a look, we’ve got our corner points
located on this side. Which means all we need
to do here is just set things up so that it lines up. At this point, we’ve used
the transform nodes for each set to create the shape of our building
on all four sides. With each wall, we have
that corner section, which allows us to
distinguish where one more lens and another begins making pretty
good progress. But there’s still a lot
that we need to do.
42. Adding The Length Parameter: We seem to be making good
progress with our building, but now there are a few issues that we’re
going to need to fix over the next few lectures
with regards to how the walls
are going to scale. If we take a look at our
width and height parameters, the height seems
to work just fine. They all work in the
same whiteboard, the height, the instances
are also applied correctly. However, if I was to go into
my top orthographic view, so we can see things from above then manipulate
the width value. You can see that we
are overlapping here. So the actual width attribute here is not working how we want. Now we’re going to
come back to this, but we also want to actually use two of these walls
for a Nava attribute, which is going to be our length. We want to be able to control the width and the
length independently. The width is going to be the size of our
building on the x-axis, while the length is going
to be using the y-axis. This is why we duplicated our base frame when we
created the second pair. I’m going to just move
across to the base frame. Make sure it’s the
base frame for the lower pair of frames
in your wall setup. Then we’re going to make
a couple of changes here, mainly with the width input. This connect vertices
x from the width and also disconnect the
size X from the width. Then take your vertices x input from the grid and
create a new socket. Come to the group tab
in the side panel, select vertices X, click
and rename as length. I’m going to set defaulted
to an amine value to one. Now I’m just going to
use this up our here. Move the length
above the heights. This will just make things
a little bit cleaner. Then I’m going to take my size x value and plug it in
to the length input. Now we have width,
length, and height. If I press seven and then
increase the values. You can see that as we test, we have a bit more control
over the different pairs, but they’re not quite
lining up correctly. And plus we also have an issue here with our corner section. As we increase the length. For example, you can see that our corner section is duplicating
on the various points. There are a couple
of things here that we’re going to need to fix. What we’re going to do is for the corner section
of wolves C and D, which reminds me I still
need to rename them as such. So I’m just going to go to
node named this as well. Rename this as d. For each of these, we’re going to go to
our corners section. You can see we’re coming to
you using the width value, but we need to be using
the length value instead because these walls are
now focused on the length. So plug the length into divide node and then
repeat that process. For wool. Wool C and D should
be edited so that we’re using the length
value instead of the width. If we increase our values here, we should be able to see
better behavior for the width. And if we were to do the
same with the length, we also get the
correct behavior. We still have this
issue where the walls are not moving if they’re not associated to that parameter. But at least now
we have ourselves a third parameter to control
the length parameter. So now we have width, length, and height, which we can control for our
procedural building.
43. Maintaining The Connection Between Each Wall: As we noted in the
previous lecture, we still have an issue where if the width is changed
order length, then the wolves will
disconnect from each other. What’s going to be our solution? Well, let’s think about this. When we increase the width, we increase the size
or to MR. walls, what do we want the
AVO2 wolves to do? Well, we’re going to
want these two walls to move outwards as the
width is increased, we don’t want them to scale, we just want them to move. That means we’re going to
need to be able to adjust or manipulate that translation
transform for these walls. And we’re going to need to
use the width to affect it. Let’s zoom in and for
now we’re going to focus on Wu’s C and D so that we can control the location of each wall
based on the width value. I’m going to just take
my Transform Note and create a little
bit of space. You can see here that we
initially used some hard values, 1.5 on the x and 1.5 on the y, which only works when we set our width and length to
specific values as well. In this case, four on each axis. What we need to do is gain
some control over this. We know at this point
that we want to use our width value to
control that translation. I’m just going to add
glute input node here. We have our glute input node. Now how are we going
to connect this up with our translation? Well, we’re going to want
to isolate these vectors. That means using a
combined XYZ node. This way, we can connect this
vector to the translation. But before we do that, just so there are no
immediate changes, we’re going to match
up the x and y values. Then we can connect the
vector to our translation. As it is, that should not make
any difference whatsoever. Next, let’s take
the x value here and connect it to the width
from the group input. Immediately, this moves
one of our walls. If we adjust the width, you can see that
this wall is now moving along with
the width value. We’re making progress,
but it’s far, too far away from the building. Which nodes do you think we can use to fit this to our building? It’s actually a very
similar process to when we created
the instances. If we use this in the
form of a calculation, you can see that the
current positioning of this wall is actually the
same as the width value. If we would use this
to free and zoom in, we can go 123 on the positive x-axis to
get the width value here. And the location of this wall. To help with this, we’re
going to add a map node, plug it in here, and set it to be divide
by a value of two. Now if we increase our width, it seems to be working, but it’s just a little
bit offset from the positioning of
the actual wall here. And I’m, uh, how much we
seem to increase the width. There’s always that
little bit of a gap. Since it seems to be a
little bit too far over y. Which node can we use to offset
the x value of this wall? The answer is a subtract node. We’re going to use
the math node here, set it to subtract. And with a value of 0.5, you can just about see that it locks in to the rest
of the building. If I increase the width now, you can see that the wall lines up with the other two walls that
are adjusted for the width. This is exactly the behavior
that we’re looking for. Let’s review exactly
how this setup works. We’ve taken the
transform node for wool see, bear in mind, we’re working with wool
see here to adjust the positioning of this wall
based on our width value. To do that, we plugged our group input into a
combined x1 x0 node, only focusing on the x-axis. Take a look here.
You can see that the y-value is
still a hard value, but this is perfectly fine. We also needed to math
nodes to position it. So we needed to use
the divide node and then subtract node. If we just mute each of these, then enable our annotations. You can see that the current
value of the width is for the value of this group
input node is also four. In order to get it into
the correct position, we needed to, first of
all, bring it closer, which we did with
the divide node, which gave us a value
of 212 on the x-axis. We then needed to
correct the offset. Here, we basically use a subtract node and
choose the value of 0.5 to minus 0.5 equals 1.5. That’s the value
that we get here. If we increase this
to a value of six, then what we get instead Is a value of six with
our group input, a value of three when
we divide it by two. And then a value of 2.5
when we subtract it by 0.5. And that puts it still
in the correct position. With this setup, we’ve achieved the correct behavior where
increasing the width of wolves I and B
allows us to alter the positioning of c so that
everything stays connected.
44. Connecting The Other Walls Challenge: Now that we’ll see
has been connected, I want you to repeat
this process for wolves day and be with each wall. You’re going to need slightly
different calculations. So as a little bit of a tip
ahead of time, for war, you might need to add in an extra node to this setup so that you can
invert the calculation. Remember Wave Warp see, we only need to work
on the positive axis, but for wool D, we
might need to work on the negative values
of the x-axis. Instead. Think about what nodes you
can use to correct that. With walls I and B, we’re also going to
need to consider whether or not we want
to use the width, the length, or the height trick question as our influence
for the translation. As don’t forget
what a and b will lie on a different
parameter towards C and D. I want you to see if you can link up all of
your walls so that the actual building
maintains its connections regardless of the
values used for the width, length, and height. Complete that challenge now. And then we’ll go through
how to create each wall.
45. Connecting Wall D: Welcome back guys. In this video, we
are going to work with so that we can fix the length value
or the width value, I should say, to the
translation value of D, which is this wall here. I’m just going to move down in my node tree till I
find my wool D setup, which I’m going to
need to label again. We’re just going to
bring out our transform node so that we can get enough
space to create our setup. Now the first thing
we’re going to want to add is our group input node. So I’m just going to
search for my group input. Then I’m going to want
to isolate the X, Y, and Z channels
with my combine XYZ. I’m going to match
up the values. So negative 1.5 on the x-axis, then 1.5 on the y-axis, just to keep everything
in place as we connect. And then we’re going to connect our wall or width
value to the x-axis. You can see straight away that the wall is now on
the wrong side. So we need to invert this so that the translation
value is negative. We’re going to do that
by adding a math node. Then set the math
node to multiply. Actually, I’m going
to use a multiply add node and you’re going
to see why in a minute, this is effectively going
to allow us to multiply it the value and then
add it after the fact. I’m going to use a value of
minus one for the multiplier. And for the moment, just keep
the add value set to 0.5. Then I’m going to hit Shift I, add in another math node, set it to the void, and then use a value of two. That looks like it
lines up correctly. So now we just need to
test with our width. We can see that as we
increase the width value, both of our walls, wall C and D line up perfectly as the
positions are readjusted. Thanks to the setup we have connected to
the transform nodes. To recap, we have
added the width. Use that as the primary value for the translation
on the x-axis, which we are isolated
with a combined XYZ node. The node is used as
ways to bring it closer towards our
building as we’re working on both the
positive and negative axis. And because the war was
on that negative axis, we needed to invert the
value here that we would get a negative value for our x axis as we
adjust the width. We did that by using
a multiply AV node, which not only allowed us
to invert the location, but it also allowed us to offset the location with the Add-Ins
option directly below. We’ve done two of
the four walls. Now, we need to go
back to walls and B. Because if we were to go into at 12 graphic view and
adjust our length, this is still an issue
that needs solving.
46. The Third Wall: The next wall we’re going to be correcting is going to be. So that should be the top
frame for your setup. Make sure you’ve got
enough space to work with. And also just to
make things easy, always revert back to the same values with each
wall for your parameters. So here I’m working
with a width of four and a length of four,
and a height of three. And that way I can always
use it as the base. I’m going to add a group input. Then I’m going to add a
combine XYZ, same as before. Now I don’t need to make any
changes here because all of the transform values for the original wall,
we’re left unedited. So I can connect the vector. Then I can connect the
length to the y value. You can see that this
moves our wall across, but it’s moved across
in the wrong direction. As we know from our
previous walls, if the location is moving
in the wrong direction, and we can confirm this
by increasing the length. Then we can correct
this by adding a multiply node and choosing
negative one as our value. I’m going to use the multiply
it at node this time. Because we might need to use
the Add feature as well. Then we’re going to add a second node which is going
to be add divide node. Always make sure you type
in math in the search bar. And then set it to divide
and divide this by two. Then multiply it by a
value of negative one. Now at the moment, that’s not quite
lining up correctly. And if we adjust the add value, the more we adjust it by, the closer it gets to
the quick position. So if we use a value of two, for example, that looks
like it lines up correctly. Now if we adjust the length, you can see that the behavior
of WALL-E is correct, so it’s now attached
towards C and D. As we adjust
our length value. At this point, free of the four walls are
behaving correctly. It’s left, is Warby.
47. The Fourth And Final Wall: The only war that we
have left is wool B, which if we take a look
is this wall right here. In our node editor, just move down toward B and create a bit of space
for the transform node. We’ll zoom in a bit. Then we will add our
group input node. Next, add our combine XYZ. This time we moved this wall on the y-axis
for a value of three. So we’re going to
replicate that here. Plug it in, and then plug
the length into why? That looks almost correct. So we might only need to
use a couple of notes. We’re going to use our divide
node again because that is always a requirement for getting it into the
right position. But the Divine node by itself
has brought wall into far. So we’re going to need to make
a slight adjustment here. If we use another math node
and adjust this value, we can see that
we’re going to need to add by a value of one. By adding our calculation
by a value of one, we are able to line
up the full form. The question is, does this work? Well, let’s increase
the width and decrease. That works. And if we increase the length, that also is now
working correctly. Congratulations, we’ve been able to fix out what building so that whenever our width is altered to if the walls are scaled
and the other two are moved. Vice versa. For
our length value. And of course, the highest value is much simpler in this case, because all four of our wars affect the
height the same way.
48. Random Instance Parameters: Congratulations
on making it this far in our procedural
building projects. The next step is
going to be to create a few more parameters for our windows and for
our ground floors. I’m going to be looking at
creating six a new parameters. Actually, I’m going to
create eight new parameters, two premises for each wall, one parameter per
wall for the Windows, and one parameter for
the ground floor. I’m going to show you how to
do that for the first wall. And then I’m going to
leave it to you to create the parameters
for the other free. Let’s start with wool. I’m just going to locate it in my 3D viewport by going into
font orthographic view. It’s going to be this one. And then let’s go to
our window frame here. I’m just going to ensure
that that is set in. What I want to do here is attach the seed value of my random value node
to the group input. I can do that by adding
the group input node. Popping it within
our window frame. I’m going to take the seed value here and plug it into
the group input. Then I’m going to go to Group in the side tab, select seed. And I’m going to
change this to no. Now if I adjust this seed value, you can see that we are able to adjust the randomization
of the wall. Just for that one wall
so far I navigate around my scene and adjust this value. It only affects the
windows on this one side. Now I’m going to
repeat this process to an extent with my ground floor. I’m going to come across
to the ground floor, which at the moment has
no random value at all. Just going to make sure that everything is
positioned within that ground floor frame and then just fix everything so that
it’s nicely positioned. Now we’re going to add
in our random value, adds that random value node. We’re going to plug it in to where do you think
we should plug it in? We’re going to plug it
into the instance index. And I’ve made a slight error here with a random value
node, what you want to do, ideally is you want to change
the float type to integer. Because we want this
seed to be an integer when we expose it
in our modifier. So turn it into
an integer first. Then connect the value
to the instance index. That will allow us to adjust the seed of
the ground floor. Then we’re going to add
a group input node. We could always
use this one here. And actually, that will
probably work nicely. Plug it into a new socket, which creates the socket here. We’re going to select
it in our side panel, rename it as wool ground floor. Now if we just expands the
Properties panel here, you can see that
we have our width, length, and height, and we
also have values for the wall, windows and wall,
a ground floor. In our modifier, we have
the ability to randomize the instances applied for both the Windows and also the doors and windows
on the ground floor. Before moving onto
the next video, I want you to repeat this process for the
other free walls. Before you start
your next lecture, you should have 11 parameters that you can control
from your modifier. Do that now and I will see
you in the next video.
49. Setting Up The Roof For Our Building: Welcome back, guys. And as you can see, I’ve made some minor
adjustments to, to setup form the
previous lecture. Actually, we’ve added frames to the positioning of each
and individual wall. So we have a frame now that
stores all of that data. And we’ve also attached all
of the nodes required to randomize our window and
ground floor instances for each individual wall. You can see that
we have named the first one a window so we can manipulate the windows of
our friend’s wall, like so. And then we can manipulate the ground floor for the
same wall independently. I could then go to
the back where we’ll be manipulate these values
independently as well. I’ve done that for all
four of our walls. The next step is going to
be to create our roof. If we take a look from
a bird’s-eye view, we can see straight through our building and it
just looks hollow because it is we need to
cover up the roof area. The first question
is going to be, where in our node setup
are we going to need to create the node that will allow us to
position our roof. The answer is going to be at
the very back of our setup. Because we want to
base our roofs size on the positioning and
scale of our four walls. In other words, we
want the size and positioning of the roof to
be based off of the width, length, and height values. What I’m going to do
is I’m going to zoom in to the back of
our node setup. I’m going to create
some space between this joint geometry node
and the group output. Then I’m going to duplicate
the joint geometry node. So hit Shift D and
position here. The reason why we’re doing
this is because we want to use this additional joint
geometry node to bring our roof with
our buildings. So we want to connect
them together using this extra
joint geometry node. If I just add my
annotation for a second. The idea here is to
add all the nodes for our roof here and
connect them in. Then in the next video, we’re going to create the
nodes for our buildings floor. These nodes are going to appear he and connect to the
same joint geometry node. That’s the idea in
terms of the setup. Now, which node do
we need to start off with in order to
create our roof objects? Well, all we’re doing is
just creating a simple roof that is going to scale and
position based on the width, length, and height
of the building. So we can keep things
nice and simple by going to Mesh Primitives
and adding a grid node, then plug it in. Making sure we have selection enabled to our joint
geometry node. If we just orbit our view, you can see the grid here. At the moment. It doesn’t have the correct
size or positioning. I’m just going to add a transform node
straight after the grid. This is going to be perhaps the most important
node in this part of the setup because it’s going to control the positioning of the
grid as well as its size. Now, I’m just going to line
up the z value that it gets to the top of our building based on
its current height, which is currently set to fall. Here you can see that we have our grid just positioned
on top of the building, but it’s not in the
correct position. Now, we need to manipulate some of these transform
values so that they are influenced by the width and height as well
as the length. Now we’re going to add ourselves our group input node that
we can use the width, length, and height values. We’re going to connect these
values up to the grid. Of course, there are different
ways that we can do this, but we’re going to
use the grid for now. And we’re going to take
the vertex x-value, connect it to the width. The vertex y connects
it to the length. If we just do a bird’s-eye view, you can see that we are kind of getting the shape
that we want and actually we’re getting exactly what
we want because we’re basing on the vertices
and not the faces. And then we’re going to
manipulate the size on each axis. And if we see him
out, you can see that even though it’s not
in the quick position, it’s fairly obvious that
the roof is too big. So we’re going to need to
make sure that the size is always lower than
the vertex counts. We can do that by
adding our math mode, just popping in to
size x and setting to subtract and setting
the value to one. The size x value will always be one less than the
vertex x value. And we can replicate
this with the y-axis. Now one question you
probably asking is why are we not
setting this up so that the number of squares on our grid is equal to that of
the width and length values. Well, the reason why is because when we are
creating the loop, we don’t want it to overlap the additional points
used with the corners. We want to keep it
within those bounds. Remember that with our
instance objects here, such as the roof tiles, we set it up with
this formula in mind. So if we were to change
the formula for our grid, we would end up
with a larger roof. Dan will our building requires now that we’ve got
our roof the correct size. And if we test the
width and the length, we can see that these
matching up quite nicely. We now need to ensure that it
always follows the heights. Before we do that though, I’m just going to manipulate the translation value here on the y-axis just to
see if it lines up. And it does so with
a y-value of 1.5. So now if I, again, I’m going to click the width and length behavior of
our roof is correct. However, if we
increase the height, you can see that the roof does not move
with the building. What we need to do is we
need to control this c value here in the transform node
based on the height value. To do that, we’re going to
add a combined XYZ node. We can separate the
free vector values. If I disconnect that and just replicate
these temporarily. So Y-value of 1.5, the z value of 2.5. Plug this in to the
translation and then take our height value and
connect it to the z axis. Now, you can see that the roof is too far above our building. So once again, we’re
going to need to introduce a couple
of math nodes, starting with our divide node, which we’ve used for pretty much every
calculation like this. Set that to a value of two. You can see here that
it actually brings it below where we need it to go, unless you actually want the roof to look
like this and then you’ve got a barrier overhead,
that’s perfectly fine. But if we were to
manipulate the height, we can see that that
behavior is correct. If that’s what you’re going for, but I want it so that the roof
is quite literally on top. I don’t want this barrier
effects you might do. That might be a
better look for you. But for now, I want to adjust the offset so that the roof
is sitting right on top. We can do that by
duplicating our divide node. Set. It’s an ad because we want
to bring the roof up. And then we’ll set
the value to 0.5. That should position
it comfortably on top of our building. Now if I just zoom out
and manipulate the width, we get the quip behavior
with the length. Now the heights. At this point, we’ve done all four walls as well
as to goof up next, we’re going to do
the ground floor. But before we do that, can you guess what we need to do based on what
we’ve done before. We need to just try and
organize this node setup. Select if we think here. Hit Shift and P, frame nine, the frying roof. Let’s give it a purplish color and increase the labeled size. That’s our roof setup. Now it’s time for
the ground floor.
50. Repeating The Process With The Ground Floor: In the previous video, we created the grid that
is going to be our roof. Now, we need to
create the floor, which is the opposite
end of the building. This is going to be a very
similar process to our roof. So I’m going to lead this initially as a
challenge for you. I want you to create
the ground floor, the actual floor
of this building. And it has to behave the
same way that the roof does. I want you to pause the video
now and give that a go to see if you can create
the building’s floor. Welcome back, guys. I’m
now going to create my setup for our
buildings floor. It’s gonna be quite
similar to this. And I could duplicate
and work from there. But I always like to do
things one node at a time. I’m going to start by adding another grid node and connecting it up to
the joint geometry. It should be located
probably only inside. There it is. I’m just going to
make things easier by bringing our width, length, and height down. Next, I’m going to add
my transform node. I’m going to add the transform
node after the grid node. For the moment. I’m going
to reposition it on the c-axis so that it
lines up with floor. I think we’re going to
use a value of negative 1.5 for the current
size of our building. Then the next step
is going to be to launch it up to the
width and length. We’re going to add our
glute input node again. Plug it in here. Take our vertex x-value
into the width, vertex, into the length. And then repeating the
process that we did before, connects up the size to
the width and length. And using math node
just to recalculate it. So it’s going to be the
correct size on both axes. We use subtract to
subtract by a value of one for both the x
and then duplicates. And position for the war. At this point, the grid on
the floor looks correct. We just need to reposition it, which we can do by
manipulating the y-value. And we’re going to set
it to a value of 1.5. And if we zoom in, we can see that it is indeed
in the correct position. Now at this point, if we manipulate the
width and length values, our floor should be
behaving as it should, increasing in scale on
the width and the length based on these values so that it is always connected
to the building. Now the next step is
going to be the height. Just as we had an
issue with the roof. If we increase our heights, you can see that our grid is not impacted
at all by this value. We can fix that by connecting the translation to
our height value. Add your combined XYZ
node and plug it in here. But before we do that, we’re just going to
ensure that at least the y-value is mimicking what we have with
our translation. Connect that to the
transform node, and then take our z value and
plug it in to the height. Here we can see that the
plane is way too high up. So it’s both on the long axis, is on the positive z-axis, as well as being too far up. We need to add two
nodes to correct this, starting with a master node, which we are going to set to multiply and then multiply it
by a value of negative one. Now it’s too long, so
we need to duplicate the Multiply node
and set this to divide by a value of two. That’s a lot closer. We need to offset this. We take a look at
its positioning. We can see that
it’s too low steel. We need to increase that
value and bring it up. To do this, I’m going to change my multiply node to a
multiplier Add Node. As soon as I do that it has
an automatic value of 0.5. And if I look under my building, I can see that the floor is connected to the ground floor. Now, if I increase
my height value, then the floor grids should line up perfectly with
the rest of the building, regardless of the
height value that is used in our modifier. Congratulations if you
were able to do all that. At this point, we now have a seemingly complete
procedural building with four walls that
can be adjusted based on the window and
ground floor instances, as well as our roof and
floor for the building. That’s can be adjusted based
on the same parameters. All that’s left here
is to select and grab all of these nodes
used to create the floor. And then hold down Shift
and press P to frame them. Label it as flow. I’m going to label
it as fluid grid. Then we’ll give it a color. So let’s give this one
a bit of a dry green. Then just increase
the labels size. Zoom out, and admire everything that we
have created so far. At this point, there’s
one more thing that we’re going to want
to do that is to reposition the
building so that it lies flat on the blender grid. Because if you want to use
this building in a city scene, then one thing you
don’t want to do is manipulate the heights and see part of your building fall underneath or wherever
ground plane you’re using. We’re going to be solving
that issue in the next video.
51. Positioning The Building: For our procedural building, only one thing remains, and that is to reposition the building on top
of this blender grid. What I’m going to
do is I’m going to add a plane objects to the same, scale it up by a
value of about 20. What we want is to fix
our building so that the ground floor is always going to be sitting
on top of his plan. Currently, you can see
on the bottom here, far below our ground plane. That’s because
with our building, we are scaling the
highest value in both the positive and
negative c directions. In this video, we’re
going to fix this so that the ground
floor is always on top. And when we increase the
height than the site of the building will only increase in the positive direction. As a bonus, we’re
also going to be positioning the building so that it sits at the very corner
of the objects origin. But first things first, let us say if we can
fix the heights, we’re going to come to the
very end of our node setup. We’re going to add a
transform node about here. Hit Shift, I, add
a transform node. And it needs to be at the very back of our node tree because we’re affecting the positioning
of our entire object. If we zoom in, we’ve got our transforms for translation,
rotation, and scale. For this, we want to focus
on the translation values. Specifically, starting
with the height. I’m going to add a group
input node. Position it here. We want to isolate all
three of these values. And we’re actually going
to use all three of these values for the
width, length, and height. Your combine XYZ node, which we’ve used many times to isolate our factor channels. Then plug the x value
into the width, the y-value into the length, and then the z value
into the higher. The moment. Our building is hovering
high in the air. As we adjust our values. You can see that we are also
influencing its positioning. Now all we need to
do with each of these is just make a couple of changes so that we can fix our positioning
for the height, length, and width, starting
off with the heights. So we can see that the
building is too high up. So if it’s going to go up, we’re going to need to
reduce that influence. And we can do so by
adding in a math nodes. For this math node, we’re going to set it to
divide by a value of two. Now if I press one on my number part and just
zoom in a little bit, you can see that the building
is core currently hovering about 0.5 off the
ground on the z-axis. The next node that
we need to use to adjust this offset is going
to be a subtract node. So add your math
node and set it to subtract and have the
value set to 0.5. Now if we test this
and increase value, you can see that we are
getting the correct behavior, where we are only
increasing the scale on the z-axis in the
positive direction, the ground floor sticking
to our ground plane. Let’s see if we can make sense
of what’s going on here. I’m going to reduce the
height value to four. Then we’re going to bring
back our annotations. For the group inputs. We have the height value which
is currently set to four. We then divide this by two
to get a value of two. So trapped by one to get 1.5. For this example, we’re
moving our building up by a value of
1.5 on the z-axis. If I was to select the
building and just zoom in, we need to remember that we are scaling up or moving up on the z-axis based on the mesh data and not necessarily the
instances themselves. So at the moment the size of our grid on the z-axis is 123. So if I enable annotations, this, if you’ll recall, is the highest
point on our grid. On the z-axis. Form that point, we generate
a roof tile instance. The grid is actually
only coming up to about here in terms of its size. Remember that before we
added these nodes in, typically we would see
half of the building above and half of the building
below the ground plane. But because the size
of the building itself is approximately
free on the z-axis, we need to move it
up by a value of 1.5 in order to position the ground floor on top
of the ground plane. I hope that makes sense. So as another quick example, if we just erase these, then we were to increase
our heights to six. This time. We can calculate the
point, so 1234567. But the last point is one below, so it’s a value of six. That means that as we have a height value of six
for our building, we need to divide that
by two to get two free. And then we need to subtract 0.5 to get to that
for final value. Again, the height value here is six divided by two
is going to be free. Subtract by 0.5 is
going to be 2.5. And that’s how much we
need to move our objects up on the z-axis in order to
fix it to the ground plane. This is how our formula
works for the positioning. And it’s very similar to
what we’ve been doing for the instances themselves
earlier on in this project. Now that we’ve done our heights, which is the main thing, the next thing we want to do is position the building
on the x and y-axis so that the
objects origin appears at the very corner. How would we go
about doing this? Well, the process is
actually fairly similar. We just need to recalculate
is positioning using math. I’m going to hit seven on my number pad to go into
top orthographic view. And let’s start with the x-axis. I’m going to duplicate
my divine nodes. We’ve shift and D and
position here for the width. That brings in a bit closer. But it still looks like
it’s slightly out. I’m going to see if I can
subtract this value by 0.5. That looks correct. Now it’s a bit difficult to see because of our plane object, so I’m going to hide it. Now we can see that our building lines up
perfectly on the x-axis. This is where we want it to be. Now we just need to do
the same with the y-axis. I’m going to minimize
these values. Then I’m going to
duplicate my divide node once we’ll
use it for the y. This time, a value of
minus 0.5 or a value of 0.5 for over 40
subtract calculation is not going to work. If we zoom in, we’ve got two whole squares here
that we need to move by. We’re going to use the
subtract mode again. But as you can see, it doesn’t do enough. So we’re going to manipulate
this value by two. And that’s going to position our building at the very corner
with the objects origin. Now what we’ll do is we’ll
just bring these together. And if we test our building
with regards to the heights, we can adjust the
height very easily. Even if we bring back our
plane and look underneath. You can see that the building does not fall below
the ground plane. Now if we adjust our length, we can see that it moves
in a single direction. The same will also
apply it to the width. So it’s scaling out on all three axes form this
corner points giving us a lot of control
with regards to both the size and positioning
of our procedural building. There we go. We have now created our procedural building
for this project. The only thing left here
is to just frame all of these n nodes and use this
as our building position. Hit Shift and p, name it
as building position. And for the color, we’ll give it a bit of a dark
gray dust time. Congratulations, you have completed the
procedural building projects. The number one thing that
I recommend here is going over what each of these nodes and each of
these trains represents. Make sure you fully
understand exactly how all this works and exactly how you can manipulate
these nodes for your parameters to create any procedural building
that you want.
52. A Review Of The Project: Hi guys. In this video, we
are just going to review our procedural
building setup. Now if you’ve done this in your own time and
you want to move on, feel free to do so. But if you need just
one more reminder of what we’ve done
in this project, then I highly recommend
that you just follow along with me as we go through our
procedure will building. Starting off, we have
our base structure. We used a grid node. Then we rotated the
grid 90 degrees on the x-axis to help
generate our first wall. We created two values or two parameters,
width and heights. Vertices x and vertices war made the width and
height respectively. To create our one-by-one grid, we use the size x value
and subtract it by one, attaching it to the width. The size y-value again
subtract it by one, attached to the height. This allowed us to create
our one-by-one meter grid. We then started creating the various instances
of our first wall. We started things off
creating our window. Creating an instance required us to use the instance
on points node. We then dragged and dropped our window collection and attached it to the
instance inputs. We ensured that all of the appropriate boxes are
ticked the separate children, we set geometry and
pick instance options. We then randomize this by
adding a random value node. This allowed us control the actual instances that were being projected onto our wall. Later on, we ended up creating
a parameter for this. So we’ll window allowing us to edit this randomization
in our modifier. When the window was completed, we then moved forward
to our corner objects. The corner asset is the one asset that has
the highest level of priority amongst all of the collections that we
used in our building. The reason why is
because we wanted to ensure that on the x-axis, the values or the points where the highest x value
will always be given that corner instance. To do this, we use a separate geometry node to
the void up our windows, which is the selection
output here, and also the corner posts, which is used with
the inverted output. We used an instance
endpoints node here, then dragged and dropped our corner collection and
plugged it into this node. We then defined where on our wall we wanted
to position it. We use the position node
to tell blender that we wanted to use the position attribute of our various points. We wanted to focus
on the x-axis only. So we connected the x
value to a less than node, telling blender that
we wanted anything less than the threshold to
be assigned the windows. And anything that was
not falling within this threshold would be
assigned the corner instance. We define the threshold
using the width value, dividing it by two as we were working with both positive
and negative axis. Then subtracting by one, which acts as the offset. But its calculation, this is what gave us our
corner instance. Similar setup was required for both the ground floor
and roof tiles. With the ground floor, changes made included the
use of the z-axis with the separate XYZ node and the use of the
greater than node. As with this case, we wanted
anything greater than the lowest value would
be assigned the windows, the corners as they
would have priority. The threshold. We needed to invert the subtract node so
that we were plus one. Well within subtract one because we were using
the greater than node. We also needed to invert the value that was being generated by the,
by the threshold. We did this by
multiplying that value by minus one to give us
the negative value and allow us to only have the bottom row of points assigned our ground
floor collection. We also later one, created a random value and
attached it to the modifier, which is labeled as
wool, a ground floor. With the luteal, the
process was fairly similar. Again, the only change here
was going back to the less than node reverting form, add to subtract and not
using the Multiply node. Because we were working
from the top down this time to create our roof tile. Other than that, this
setup was pretty much identical to the one for
used for the ground floor. All of these allowed us to create the instances
for our wall. We used the joint geometry node to join up all of
these instances. Next, we were going to duplicate the first wall into a
second step, which we did. So he would act as Warby. The first large frame
represents War I, and then the second
frame represents Warby. We then manipulated
the positioning by using these
transform nodes here. And here. For the second wall, we use a z value
of a 180 degrees. This way we could
rotate the wall so that the corner was
at the opposite side, which we would need to correctly connect the
various walls together. We join them together using
this joint geometry node. After that, we duplicated the entire setup and
positioned it below, which you can see here. These are for walls C and D. This required several changes. First of all, with
our transforms, we needed to manipulate the
rotation and positioning of each so that they would line up with the wall when set
to a specific value. Then we needed to define that, that positioning by creating
a length parameter. So the length parameter was
created by editing the base. We detached our width values for size x and a vertices x and connected them
to a new parameter, which is the length. When we did this, we had to make a couple of
changes to some of our nodes. In particular, with regards
to our corner setup, we were working with our width
value for the threshold. We needed to change this so
that we would use the length. Instead. We needed to do this
with both of our walls. With that done, we
were able to move on to the actual meat and bones
of the walls structure. We wanted to set it
up so that the width and length would be able to adjust the building without disconnecting with each wall. We set it up so that that wall would be based on the
opposite parameter. In the case of a, for example, which can be scaled
using the width, we need me to move it
based on the length. He in his position frame. We use the length value
from the input node, divided it by two. Then we needed to
multiply it by minus one so that we could invert
the change in location. The end option here was
used as the offset. We then plug this
in to the y-value, which represents the length. And then the vector
of the combined XYZ goes into the translation. Similar process was
done with each wall, but minor changes were made. We will be, for example, we did not need
the Multiply node, and we only needed to add by a value of one to
get our result. For wool C and D, we needed to base this
off of the width. So we use the width for
war c divided by two, then subtracted the
value by 0.5 as our offset to connect it up
to with the other walls. Then we needed to invert this. So we use the multiply add mode to multiply
it by minus one, and then use a value
of 0.5 as the offset. Again, using the void node
to help control using the width as our group
inputs and combine XYZ to isolate our
effector channels. With all of our walls setup, we use the joint geometry nodes
to combine them together. So we used 12 free
joint geometry node to pull everything together. Then in the next part
of our node tree, we had to create the roof, the floor grid using another
joint geometry node. For the roof. We created another grid. Then we manipulated the values based on the width and length. First sees X and Y for the grid match the width
and length directly. The size needed to
be subtracted by one so that we could maintain
our one-by-one meter sizing. We then use the transform
node as a means of controlling the position
with for the highest value. We connect the highest value towards this translation input. By isolating our C channel, we’ve combined XYZ and
using the two math nodes, divide to divide by two, and then add to act as our offset and
position it correctly. The process was very similar
with the floor grid, creating our grid node. And using a transform connecting the vertices x and y values
with the width and length and subtracting the grid for both the size x and size
one or a value of one. We didn’t use combined XYZ to control disease specifically. And the only change we really
made here was inverting our calculation for our height
by a value of minus one. As we were attempting
to position the grid on the bottom of our building
rather than the top. We then use the value of 0.5
as our chin will offset. By that point, we
had created all of the various parts
of our building and also gain control over
everything we needed to. The final bits was to
position our building so that it would not scale below a ground plane as
we adjust the height. We did this by adding
another transform node. Separating the effects of
values for the translation. Using the combined XYZ node. We plugged the z value
into the height, the y into the length, and x into the width. The highest value. We divided this by two and
then subtract it by 0.5. With this setup, we were able to ensure that as we increase
or decrease the height, the building would never
fall below the ground plane, which is where the object
origin is located. For this object. The setup for the other two
channels was very similar. The width proved
to be identical, divide by two, and
then subtract by C15. The length proved to be
slightly different based on the original positioning
of our first wall. We divide it by two, but to get the correct offset, we used a value of two. This setup allowed us to
position our building so that the objects origin is located at the very
corner of the building, giving us maximum
control over the width, length, and height values of
our procedure will objects. That is how we construct
our procedural building. Congratulations on
everything that we’ve achieved in this section. And we can now move
on to the next one.
53. Downloading The Right Version Of Blender: If you are one of the early adopters to this class, then you may come across an issue where you can’t find your geometry node editor in Blender. There’s normally one reason for this, and that reason would be that you are using an older version of Blender. If you are not using a version of Blender, That is, I have a 2.92 or newer. You will not have geometry nodes accessible. In order to get blender version 2.92, you need to click on the download blender button located a blender.org. As of the end of February. This will read as 2.92 and beyond. For now at the time of this recording, it’s 2.91.2, which will not have geometry notes. The question here is, how do you get access to 2.92 or 2.9? Free. To do that. Just scroll down to the bottom where it says go experimental and download blender experimental. This takes you to the download page where you can download IFR, the next versions beta or the alpha for the version after that. Now, for commercial work, it’s not recommended to use any versions like this. It’s always best to use the stable version. But for the sake of education, go ahead and download either of these options. I use 2.3 alpha at the start of this course. And then once you have that all set up, you’ll be able to begin using geometry nodes.
54. How To Activate The Node System: Geometry nodes are pretty much brand new to Blender, and they allow us to create procedural 3D models by only using nodes instead of the more traditional editing tools that you will find in objects mode and edit modes for your selected objects. In order for us to access our geometry node editor, we’re going to just bring up our timeline here. And then we’re going to come to the editor type menu. We’re going to open this up. And you should see the geometry node editor located under general. So left-click to change this panel to the geometry node editor. Now, as you would expect from any node system, there are come sleep no notes. To add nodes to this Geometry tree. Click on the new button located here. This add a new geometry tree with two nodes to start with. We have the group inputs and the outputs. Both of these are going to be required for any no truth to create. The output is the final result of the geometry no tree. So any nodes that you place in between these two nodes are going to be accumulated by the end in this group output node. The group input node, on the other hand, is where you can assign values that you can change in the Modifiers tab, which we will be doing in a few moments. You will always need the group inputs and output nodes for your no tree in order for it to function properly. Now, let’s take a very quick look at some of the nodes that we’re going to be learning about in this course. Now what you see in front of you is a list of all of the different nodes that are used with our geometry node system. This is the current selection of nodes available as of blended version 2.92 beta. As time progresses, you can be sure that more nodes are going to be added to the geometry node system. But for now, let’s just quickly introduce what we have available. So in the top corner, we have the main group nodes, the group inputs, and the output which we have already discussed. We also have what are known as attribute nodes. When we talk about attributes, which geometry nodes, we are effectively most of the time talking about things like the location, rotation, and scale of an object, along with other attributes as well, such as the color. Next we have the color nodes. So this is great for the application of materials potentially further down the line. And that in a moment we have the color ramp combined RGB and separate RGB notes. Next up we have the geometry nodes. Now, right now there are only two geometry nodes, but they are both very important and we’re going to be learning about these two in particular, very, very soon, we have the joint geometry node, which is going to be used to combine different instances of geometry together. And the Transform node, which as you might guess, will allow us to manipulate an object’s translation, rotation, and scale using nodes instead of the values in the 3D viewports. Up next, we then have our input nodes. So here we can input various data like the vector values, traditional values, and object information. Beyond that, we have what mesh nodes located here. This is going to be more fun stuff where we’re going to be actually using these nodes to procedurally model our 3D objects. For example, we have the boolean and subdivision surface nodes, which we will be making use of in this course. The next group of nodes are the nodes. Now this might be an unfamiliar terms to you, but point nodes are effectively used as a sort of means of using a particle system to instance objects onto a plane or specific area. You will actually find that this is the most progress parts of the geometry node setup as of version 2.92. So we’re going to be taking a look at the point nodes further along in the course. Then we have our utilities. These are effectively things like math nodes to allow us to, we calculate other nodes to gain better control. And then we have the vector nodes located here. Vector node influenced specific attributes that involve using the x, y, and z axes. For example, again, location, rotation and scale. That’s just a brief introduction into all of the present nodes for the geometry node system. In the coming lectures, we’re going to be introducing many of these nodes to you and how to use them to create 3D models and scenes by using procedural modelling techniques with the geometry node system. Before we add any nodes to our setup here, I want to take your attention to the Modifiers tab. So if we go to our modify our Properties tab, you can see that we in fact have a new Modifier labeled as geometry nodes. Below that you’ll see the node sets up that we can select. Now we can create multiple geometry nodes to attach to this modifier. But below that, we will soon be able to add various inputs depending on the nodes that we are using. The now, the one thing we are able to do is we name this node tree. So I’m just going to rename this from geometry nodes by left clicking on the line. And then let’s just type here in basic. Since we’re just going to start off by creating a basic objects using what geometry node system.
55. Adding Our First Node: So let’s get started by adding our very first node to our basic node tree. We’re going to start by adding the Transform node, since we’re going to recognize very quickly how would this node works in blender. To add a new node a to our setup, hold down shift and press on your keyboard to bring up the Add menu. You can either go to Search and type in what she wants to find. Or when it comes to the Transform node, you can go to the geometry section and select transform. So we’re going to left-click and that’s going to add our new node. But we need to attach it to the no tree. So I’m just going to hover the Transform node until the new door that connects the glute inputs and group output nodes is highlighted. Then I’m going to left-click to confirm and attach it to my setup. Now you will notice that it will automatically attached to the first inputs for the Transform node and be released on the first output that the Transform node, that is geometry outs and geometry in below that, we have our values afford the translation, rotation, and scale. As she would no doubt have recognized, this looks almost identical to what you see in the side panel here for the location, rotation, and scale. And it works in pretty much the exact same white. We can manipulate the transform values here to change our location on the x, on the y and the z axis. We can also manipulate the rotation on each axis as well. By the way, I’m right-clicking each time to cancel my change in location, rotation and scale just in case you weren’t sure. Finally, we have the scale value itself. Again, we can scale our object on each of these individual axes as touched upon in the previous lecture. You can add to what you see in the Modifiers tab. By adding more inputs to the input node, we can take any free input form, our Transform node, for example, we can click and drag and positioning into an empty socket that you will see at the bottom of the loop input node. It should snap into place. Once you get close enough, then release the left mouse button. And now the translation will disappear effectively from the Transform node and be added to the group input node. So you can see here that we are no longer able to manipulate the transform values for the location inside of our transform. Note, the reason why is because those same values are now positioned he in our geometry node for the Modifiers tab. We can do the same with our rotation. And also with our scale. We can do this with any free inputs that we have in our no true. So now instead of having to always come back to our code editor, we can just go to the Modifiers tab itself to manipulate these values.
56. Creating A Basic Shape: In this video, we are going to be creating a basic shape by using two different nodes, the Transform node and the joint geometry node. In the previous lecture, we introduced the Transform node and how it works. This time, we’re going to add a second node known as the joint geometry node. Again, we are going to hold down shift and press. I, go to geometry and select joint geometry. Left-click and we’re going to position this here. Now this doesn’t do anything straight away. But what we have with the joint geometry note is we have to geometry inputs. The way we’re going to use this is we are going to take this geometry output from the group input node, click and drag. And we’re going to connect it here. Now what we have is two outputs form this geometry node, one into the transform and one into joint geometry. That doesn’t look too changed anything here. But watch as I manipulate the translation on the x-axis. So I’m just going to manipulate this. And you can see we now have two cubes. So what exactly is happening here? Well, each time we create a noodle form, this geometry outputs and connect it to another node. What we’re effectively doing is we are creating a new instance of the base objects. So in this first geometry slot here, we have our cube objects that was influenced by the Transform node. But in this second slot, we have a second cube that has been generated but is not affected by this transform note, I hope that makes sense. So if I was to basically hit shift D, which allows me to duplicate a node and a position, this one down here. And manipulate the transform on the x-axis again. But in the opposite direction. You can see we now have control over each of these cubes. Now keep in mind that they are both still apart of the same objects. They are just different parts of that object. So what we’re going to do here is we’re going to be using the transport and joined geometry nodes to create what appear to be the shape of a basic chair. So the first instance of this cube is going to act as our seat. And the second instance is going to be one of the legs just to start us off. That means I’m just going to take this translation value back to 0. And let’s just reduce it on the z axis scale to a value of, let’s go with points one. And then with our second instance, let’s move it on the x-axis temporarily back to 0. We’re going to scale it on both the X and Y axis to a value of 0.1 on each axis. And then we’re going to just reposition it. So I’m going to move it along the x-axis to about here. Value of 0.8 looks good. And then a value of 0.8 on the y-axis as well. And finally it move it down on the z. So we have the seat of a chair and a leg. Next, we need to add more legs. So how do we go about adding more legs? Form here. Well, effectively all we need to do is repeat the process of adding more instances of our cube objects. So we’re going to take the joint geometry and transform nodes here, and we’re going to hit shift D to duplicate them. I’m then going to position this about here. Select and then just attach and detach again. Then we need to take this geometry node and attach it to our group inputs. Like so. Now if I take the translation values or list Transform node that we duplicated and begin to manipulate them. You can see that we have another leg. So I’m going to use the value of minus 0.8 on the x axis to create our second leg for armchair. Now we need to repeat the process a couple more times. In order to create the final two legs site, we’re going to again select these two nodes. It shift D to duplicate and position. Take the geometry outputs of this joint geometry node and plug it into here. And then plugged this joint geometry node into here. Then we need to connect this Transform node to the group inputs. Just click and drag and position. And this time, let’s manipulate the y value, 4.8 to minus 0.8. That’s legged number three. And finally, for the last leg, same thing again. Select them both. Shift D to duplicate, attach wherever required. So like so. My need to zoom out a bit now because the node tree is getting bigger and bigger by the second, make sure all the nodes are quickly attached. And this time, we’re going to manipulate the x value again, two positive 0.8 and press. And so at this point we’ve now got our seats and we’ve got four legs. But let’s go a little bit further. Let’s add a few more nodes and create the back of our chair. Now, let’s treat this as an exercise. This is why I want you to do. I want you to create two more instances of our cube. And just create two small cubes that will act sort of like methyl attachments. So about he and he. And then create another instance of the cube, which is going to be the actual back or vice chair. So you guys want to small cubes here and here roughly. And they’re going to attach to the seat or the back of the seat, which is going to be positioned here. So pause the video and see if you can finish creating a chair by adding a few more instances of our cube. Okay? Well, once again, we’re going to continue the process of taking a transform and joint geometry node, hissing, shifty and positioning, making sure that everything is in the correct place and connected correctly. And this time we’re going to need to do a little bit more manipulation when it comes to both the translation as well as the scale of our newly created cube at the moment, we can’t see it. So I’m just going to move it along my x-axis to about here. I’m going to start by reducing the z scale to 0.1. And that actually might be too big. So I’m going to make it even smaller than that, 0.05. Then I’m going to increase it on the X axis. So we’re going to create a little bit more length on the x-axis. Just a little bit more. So 0.2 looks fine. Then I need to position it in the correct place. So I want to position it about here. We’re going to move it up on the z-axis to evaluate CRO, just for the moment. And then move it on the X-axis to about more go about here. So a value of minus one on the x axis. So that’s one of our supports for the back of the chair. Now we need to create the second. And this should be a little bit easier because we’re only going to once again need to manipulate the one value, which is going to be the y value for the location, I believe. So. Again, select your two nodes shifty. And make sure everything is attached correctly. Click and drag, click and drag. And then click and drag. And will also keep them relatively scaled in terms of the distance between them. Sake this y value. And just move it to 0.8 on the y-axis. Kay, so we’re making good progress. Now. We have just the actual back of the chair to create and lava than this time selecting and duplicating this Transform node. I’m actually going to take this transform node and duplicate it. The reason why is because with this transform now this represents the actual seats. And the dimensions of the seat are almost exactly what I want for the back of the chair. The only change I am going to make is going to be the rotation. So I’m going to with the Transform node here selected, hit shift in D to create a duplicates. And making sure not to position it’s anywhere. I don’t want to, I’m just going to hit control Z to undo that. So select shift D and position back. He then create a duplicate of the joint geometry node and position. Then connect to here. And then connects the geometry outputs to this geometry inputs. Now interestingly enough, you will have noticed that when we created the duplicates of dish transform, it did not actually duplicate these values because they’re now located here outside of this transform node. So when we duplicate a node, when its inputs have already been connected, we end up just creating a default version of that node. In this case, we created another Transform node that has the default values on all three axes for all free transforms. But that’s fine. Because now what we can do is we can take the x value here and reduce it to a value of around 0.1 and press enter. Then we can reposition on the x and z axes. And long behold, we have finished our basic chair. So congratulations, if you were able to get food and create this basic shape of a chair using only a cube objects. Now, as the geometry node system progresses in blender, there are going to be much more effective ways of being able to create your shapes using geometry nodes. However, this was a great exercise to start off with as it covers the basics of how and where to attach some of the most basic nodes. From here onwards, we are going to be gradually increasing the number of nodes that we will be using. Were not that often going to end up with a tree that looks like this with a ton of transforms in joint geometry nodes setup in this way. In the coming lectures, we’re going to be looking at how we can’t manipulate the shape of our objects by using mesh nodes, such as the subdivision surface and also the Boolean nodes.
57. A Review Of The Basic Chair: In this video, we are just going to review each of the nodes that we have created for our basic Share. And just make sure that we are aware of exactly what the role is of each of the individual nodes. So we start off with an overview of what we have created. If we start form this side, working across, we have our group input node where we can position any free nodes into so that we can make them available in our Modifiers tab. The first transform Note that we see here represents the seeds part of our Chair. And the one directly below it represents one of the four legs. We combine these together by using the joint geometry note, making sure that the geometry inputs of each transform is connected to the group inputs. Note that if we do not do this, the geometry does not read and we end up missing a leg in this case. So make sure to attach the geometry note to the group inputs. From there on, it’s a process of winds and repeats, just varying the transformed values. So this second joint geometry node allows us to create a second leg where we just manipulates the values on the translation axes. So the x, y, and see, the main difference here is the change in the x axis. Again, this continues with the next two node, another joint geometry to add another leg. And then the transform to position that leg. Then one more joint geometry with another Transform node. Final leg. By this point, we have all four legs on our chair. Afterwards we have free more combinations of the joint geometry transform nodes, which allow us to create the supports that the back of the chair. That would be these two nodes here. And then the final transform would represent the very back of the chair, which is this part of our objects. So this is a very simplistic no tree to use just to get started with, it only really uses two different types of node, the Transform node and the joint geometry node. And uses them in a way where we can repeat each time to create a new instance of the base keep object, and then reshape and reposition that instance to create the basic shape that we have come up with. As we move through this course, we’re going to be adding to the complexity by adding new nodes. But as we add each node to our process, we’re also going to pay close attention to detail on how these nodes work and how we can combine different nodes combinations together.
58. Applying The Modifier: One of the most important things to remember about geometry nodes is that in order for them to be truly procedural, they have to be editable in real time. This means that h geometry node system is effectively always a modifier. We already know this because we can locate this geometry node sets up here in the Modifiers tab of the Properties panel. But what does that mean if we were to go into edit mode for our object? Well, let’s try it out now. So let’s go from objects mode to edit mode. You will see that we have the shape of the chair steel in our scene. But now what is also highlighted is the original cube in its original dimensions. If we edit, this cube was made using this geometry node system. But what does that mean for editing the actual objects? Well, let’s see what happens if we attempts to edit this cube. I’m going to select the top face. I’m going to hit the icky to insert. And then I’m going to hit the E key and extrude down. Do you see what’s happening with the actual chair model? It’s being manipulated in real-time as we added the basic shape. If we go back into objects mode, you can see that the change in the geometry has been applied to each individual instance of our key object. You can’t see in the legs because the inset and extrusion was actually made on the top face of each leg, but you can see it on the seat of the chair, as well as the back of the chair. It’s important to keep in mind that making changes to the base objects after you have created your no tree is going to create a profound impact, at least in this scenario on the final results. And this may or may not be what you intend. The main advice here is that if you are going to combine editing tools in edit mode with the procedural workflow of the geometry node system, it would probably be better to create the edits in the 3D view port first so that you know what you’re working with before you start adding in any notes. Now I’m just gonna hit control and C a few times to undo all of the changes that I made in edit mode. And the other thing that I want to show you is the fact that because this is a modifier, it can in fact be applied. Now once you apply a modifier, the procedural nature of those tools will disappear. So it will no longer become procedural, it will become permanent. And then any edits that you make, particularly in edit mode, will become basically destructive. They will permanently, permanently change your model. But if you want to apply your geometry node system, you do so the same way as you would any other modifier. You come over to this arrow here for your geometry nodes modifier, left-click and select, apply. As soon as I do this, the node sets up disappears from the node editor. If I left-click on this Browse to be Links menu, you can see we do still have the geometry nodes system available to use. It’s just no longer being applied to this chair object. Instead, if we hit tab to go into edit mode, you can see that we have a fully created chair with the geometry applied to each individual parts. Now what this means is that we can’t select these individual parts and then manipulate them. So for example, we could take the top face here. We could hit the icky to inset. And then we could perhaps hit the E key to extrude down. We’re able to do this now without affecting any of the other parts of our model. Alternatively, we can also select the different parts of our model. If I press the arrow key on my keyboard to select the back of the chair. I can then grab, rotate, and scale this piece independently. I can also do the same with any of the legs. So for example, select a leg and then manipulates, selects another leg and manipulate the transforms. So every single instance of the key created is effectively what is known as an island. It’s an individual set of vertices used to create a point of the model. But because of the way that we created our node system, all of these parts are independent and can be edited independently from each other.
59. Using Mesh Nodes: In this video, we’re going to be demonstrating how we can use mesh nodes to manipulate the shape of our objects. So why I am going to do here is rather than just straight up deleting all of the nodes that we have created. I’m instead going to create a new node tree for r cube objects. If we want to create a new node tree, all we have to do is press on the X button located here to unlink the data block. So when we do that, it appears as if we have deleted the node tree that we created. However, if we go here to browse our no trees, you can see that we have the no tree still available in blender. To make absolutely sure that a notary doesn’t disappear at any point. Click on the shield icon located here to create a fake user. This why, even if a specific node tree is not being used by an object, it will still be maintained when you exit blender and then re-enter it later on. There were important step if you want to keep your node setups. As for right now, we’re going to unlink the data block again and click on the new button. This will add a new sets of geometry nodes. So once again, we have the default setup of our group inputs and group outputs. Here, I’m just going to rename this no tree as mesh. Since the main focus of this node tree is going to be to test out some of the mesh nodes available with our system. The first thing that we’re going to do here is we’re going to turn our geometry nodes quantifier into a subdivision surface modifier. We’re going to use the subdivision surface node, which we can locate by holding Shift and I, locating our mesh nodes and then selecting subdivision surface. Then we’re going to position our subdivision surface node over this noodle and left-click. So if we zoom in, you’ll see that we have a couple of options that we can manipulate with the subdivision surface node. The main option here is going to be our level. So it’s commonly sets one. And you can see the effect in the free viewport. We can manipulate this value to increase the number of subdivisions on R cube. But a better thing here is to attach this option, this property into the group inputs so that we can use it in the Modifiers tab. To do that, as you remember, will be to click and drag and position in the empty slot. Release. And then you have your level located in your modifier, in the Modifiers tab. So from here, we can now again increase and decrease the level value for this subdivision surface node. Now, from here, I might want to do something CLI, transform my cube into a disc shape, which I can do so by increasing the number of levels for my subdivision surface node. And then it just adding a transform node. Which I can do so by typing in the search bar and positioning the Transform node He before my subdivision surface node. Then I can manipulate the scale value on the z-axis to a value such as 0.2, for example. And this creates what appears to be a disc shape in our free DVI ports. Now there are other mesh nodes that we can use, such as the boolean node. The Boolean node is located in the same place that the subdivision surface node is. So hit shift and I go to your mesh menu and select Boolean. Now we’re not going to attach it to anything just yet. We’re just going to position it about he. Now the way to brilliant node works is, as you might expect, it will take one object and it will either intersect, unionize, or defined the difference between the two objects that are attached. Now currently, we only have one objects here. And that is the object that is created like a desk. In the next video, we’re going to demonstrate how the Boolean node is going to work with this setup by combining it with another node known as the object info node, which is going to allow us to choose a nova mesh object to act as the boolean.
60. Combining Object Info And Boolean: In this video, we’re going to be using the object info note and combining it with the Boolean node that we have here in our node set up to create a hole in our disk. Now what we need to do here first of all is add our object info node. So hold Shift and press ie. We’ll go search, type in objects. And the only option we see here is objects info, left-click. And we’re going to position this one about here underneath our subdivision surface node. Now if we zoom in on the object info nodes, you can see that we have a variety of options. 40, location, rotation, and scale of a specific object or its actual geometry. We also have the option to go with either the original or relative transforms. For now, let’s just look at the main output that we’re going to be focusing on. And that’s this geometry output. So we’re going to take this geometry output and plug it into the second input here. We’re also going to take the output from the subdivision surface, plug it into here, and then take the boolean and pop it in here. Now, by default, this doesn’t do anything. The main reason why is this object info node has no object assigned to it. But of course we don’t even have a second object in our scene. So let’s do that now. We’re going to hold down shift and press i mesh. And let’s add a cylinder objects. I’m just going to go to my operator panel here. And let’s just reduce the number of vertices down to 16 to reduce the amount of geometry here. I’m then going to scale this down to here. Hold down control and I, and apply the scale for my cylinder objects. So next, I go back to my desk, go to this object’s option here, left-click. And I can choose from a variety of different objects in my sing. The one I’m going to pick is cylinder. Now that makes a change straightaway. So now it’s using the cylinder. And basically what’s happening here is we’re only being left with the geometry from the disk that takes up the same space as our cylinder, which is the opposite of what we want. We’re looking to create a whole. So that means we need to change this boolean type from intersect something else. If we go Union, we’re effectively going to be joining the two together. So we are going to be using the cylinder objects to create a cylinder shaped to our disk. Or we could go with difference. Now difference doesn’t look like anything in particular is being done. But actually what’s happening here is with the different setting. We’re punching a hole right through the center of our disk. Now if I was to just apply this, so go to Apply and then move my disk objects or in fact MOOC my cylinder objects. You can see. That we have been able to create a hole in our disk as a result of using the Boolean note. So I’m just going to hit Control Z a few times until we get our node tree back. And now I’m just going to make a couple of changes to the scale and location of our cylinder model. I’m going to select it and scale it on the xy-plane. So hold down shift and press Z to lock to the z plane and just scale it in a bits to about here. Then grab and move it on the Z plane again to about here. Now what you will have noticed straight away is that we still have our hull. Now, there’s a reason for that, and it’s not the fact that we previously applied the geometry nodes modifier because we did Undo that process we’ve controlled and see and still have the geometry nodes located here. So what’s going on here? Well, what’s happening is the cylinder is still being used to generate the hole in our model. However, we are using the original transforms of that objects. If we select our cylinder, you can see that the location is different. So it’s no longer 000. And the scale has also changed as well. What this means is that these changes that we have made have not been applied it to the object info note. But in order to do so, we can simply change our setting from original to relative. So if I left-click to go relative, you’ll see that the hole in the middle has disappeared. Because now Blender is using the scale, location, and location values of the cylinder in its current state rather than its original one. So what this means is we could perhaps take this cylinder, for example, and create a duplicate movie on the x axis. Go back to our cube. And what we can do here is something similar to what we did with our chair. We can take our Boolean node, hit shift and they create a new duplicates due to sign with our objects in 4-node. Plug it in here, and change the object to the second cylinder that we created. We can repeat this process two more times. So I’m just going to go shift D, shift D to create two more booleans. We can create the object info note a couple more times. Make sure to duplicate these two. So select them both. Its shift D, move on the y-axis and position about here. Then go back to our disk objects. Change the selection for each of these so that we’re using a different cylinder each time and connects to the correct nodes. Now again, while doing this, it doesn’t appear as if any changes have been made to our main model. But if we were to go and apply this and then move the model, you can see we created a four holes through our desk using this Boolean method. So this is just one example of being able to combine the boolean and objects in phone nodes to use other objects to create things like holes or basic changes to our geometry by using the geometry node system.
61. A Drinking Glass: In this video, we’re going to be creating the shape of a drinking glass. Now the one thing that’s going to differ here form our previous creations is the starting objects. Up to this point, we’ve been using the basic cube. But this time we’re going to start with an object that is more representative of what we want to create. I’m going to start by deleting the default cube, and I’m going to replace it with a cylinder objects. Now for now, I’m just going to keep all of these settings as they are. And we’re going to make our changes using the geometry node editor. We’re going to change the timeline to the geometry note editor and click on the new button with the cylinder selected to add our group inputs and glucose output nodes. Then we’re just going to drag up and zoom in so that we can see dynodes more clearly. The first thing I want to do is I want to scale this drinking glass up on the z axis. How do we do that? Well, we do that by using our trust the Transform node. Let’s bring the Transform node in to our scene by attaching it to the two nodes. And then let’s increase the scale by a factor of free. Press enter. And we have a tall drinking glass. Now I’m going to also scale it up on the x and y. So let’s just move it’s up to about 1.3 on the x and also 1.3 on the y. Now this is a very large drinking glass, but we’re not worried about the exact dimensions, which is worried about creating the general shape. Next, what we need to do is we need to basically create the Boolean body inside of the drinking glass. To do that, we’re going to add a second instance of our cylinder. So hit shifty and position down here. Then we’re going to add ourselves a billion node. So locates your Boolean node, which should be located in the mesh section. Position here. Connect the bottom Transform and also connect it to the group inputs. Sets the value for the Boolean to difference. And at this point the cylinder disappears. The reason why it’s disappeared is because the two transforms have exactly the same values. What we’re going to do is reduce the scale on the x and y. But rather than reduce the scale on the Z-axis, we’re going to just bring it up on the z-axis ever so slightly. So we’re going to manipulate this translation value on the Z just to touch. And that gives us a hole in the top. But it also allows us to keep the bottom of our cylinder. And there we go. Nice and simple. We use the first transform to create the basic shape of the cylinder by manipulating the scale. The second transform is combined with the Boolean node to create the actual glass itself or the Boolean within the glass that transforms it form a cylinder into a hollow objects. And we do this by making sure fats, the transformed values for the x and y scale are slightly smaller with our Boolean. And that we also move it up just slightly on the z axis. Very quick, very clean.
62. Modelling A Button: In this video, we’re going to be creating a simple object that has a button on it. The first thing we’re going to do is we’re going to set up our scene so that we have our geometry note editor. Click New, making sure to cube is selected to add our geometry node’s. Next we’re going to create the shape of the basic object. To do that, we’re just going to zoom in. We’ll drag this up a bit more so that we can get a good view of the node tree. And then we’re going to start by adding a transformed node to determine the general shape. Hit shift, I. Go to geometry and select a transform. We’re going to position it about here. And now let’s influenced the scale. So we’re going to lower the scale on the x-axis to about Queen free. And also increase on the y axis to a value free. So we have what looks like over modes or a control of sorts. And now what we’re going to do is we’re going to create a button for this remote. There are a few ways that we can do that. But the first method that we’re going to demonstrate in this video is to create a new instance of the cube objects and then used that as the button. So we’re going to hit shift and D to duplicate. We’re going to hit shift and I to bring up the Add menu and this time bring in a joint geometry node position. It’s about here. Take the bottom Transform and pop it into this input here. And then connect the geometry to the geometry. Now at the moment they’re both exactly the same scale. So we’re going to just bring that forward on the x-axis. Just a touch. Lower the value on the y axis to one. And let’s also low are the x-axis just a bit. Bring that forward and lower the z scale to about something like this. If we zoom in on our object, we’ve got the base objects and we’ve got a button. Now the buttons are a little bit too far out. So let’s just lower the transform value here to about 0.17. And I think that’s pretty good. Now the one problem that we have here is the fact that it’s still just looks like it’s one object. There’s no indentation here, which you would normally see on a remote or a controller. So what we’re going to need to do is we’re going to need to create the indentation. And we can actually do that by using this additional instance. Well, we have to do is change this form joint geometry to billion. So we’re going to temporarily get rid of the joint geometry node. And then we’re going to bring in a Boolean node position here and make the appropriate connections. Now at the moment we’ve got it, sets it intersect. We could either go Union, which joins them together or difference. And that difference creates the whole union, just joins them together, but that just looks exactly the same as the joint geometry node. What we’re going to do here is we’re actually going to define it by the difference. And then we’re going to add a new instance of this transform load. So we’re going to bring the group helped put back here. We’re going to bring back our joint geometry node and position it’s behind the boolean. Then we are going to take the Transform node here, hit shift dy position here. And plug this in. Connects the geometry from the group inputs into here. And while it looks as though we’ve just gone around in circles and ended up with the same cube in the same place. What we can now do is just manipulate the scale values for this transform node. So for example, if we manipulate hits on the y axis to a value of 0.95 and press Enter and just plan our view. You’ll see we now have that little bit of an indentation on each side. I actually think that’s a bit too much it. So let’s go with something like 0.98 and presenter. And then let’s do something similar on the z-axis. So a value of 0.18, press Enter. And there we go. So now we’ve got a button on a remote. But we also have the indentation that gives it just that little bit of extra detail. So let’s review what we have done here. We started off with the first transform node. And this node here represents the main object and its general scale. You can see that we’ve manipulated at the scale values board domain objects. We then wanted to create a hole in this objects, which we could do by combining a second Transform node to determine the scale of the whole. And then position each of these into a Boolean node. By setting the Boolean type to difference, we effectively use the bottom Transform to cut a hole in the first one. From there. We then needed to create the button, creating the bus and just involved adding a joint geometry node and a third transform node. This transform note here is very similar to this one. The only difference is that the scale values on the y and z axes are slightly lower. This is to ensure that we have the correct amount of indentation for the button form here we can change the values as we see fits for any of the transform nodes to change the overall look of the model. So main objects, indentation, creating it with the Boolean, creating the bustle, and joining the button with the main objects.
63. Modelling A Button Using Another Object: In this video, we’re going to be creating a remote objects with a button. Now you might think, oh, that’s exactly what we did in the previous lecture. But the difference with this lecture is going to be the use of a novel object to act as the boolean rather than just instancing the cube itself. To start off with, we’re going to set things up by bringing the geometry node at it’s our interplay. Click New. And then we’re going to add our Transform node by going to Geometry, select Transform and position here. Then we’re going to manipulate the scale. So let’s do something similar to what we did last time. 0.3 on the x-axis, free on the wire, and one on the Z. Next, we need to add to the objects that we are going to be using for the boolean itself. In the 3D viewport. I’m going to hit shift and I mesh and select cylinder. I’m going to bring up the optimizer panel located at the side. Just expand the view a bit for our work freely viewports. And I’m going to keep the number of vertices as they are. But I’m going to juice the radius to about 0.55, which is the depth, two points, 15. And then rotate on the y axis by a value of 90 degrees. Now at the moment, the cylinder is found inside of the remote. So we’re just going to move it along the x axis until it sticks out. So something like 0.25 would do nicely. Next, we need to select the Cube objects and create the Boolean. The next step is going to be to bring in an object in phones node, hit shift and I go to Input and select objects info. We’re going to position it here. Zoom in on our node, goes where it says objects and select cylinder. We’re also going to change it from original to relative. And let’s try creating a boolean for Miss, hit shift. And I go to Mesh and selects Boolean position about here, change to difference and connect the geometry of the cylinder to the second slot. If we were to hide the cylinder up form the viewport, you can see that the objects info node is indeed working because we are creating our Boolean for our remote control. The next step then is going to be to create the button itself. So what we’re going to do is we’re going to add ourselves a joint geometry node. This time. We’re going to duplicate the objects info node. We’ve shifted the position here and plug geometry into geometry. Now, this presents a similar problem to last time, where the scale is the same as the boolean. So what are the solutions here? Well, let’s try adding a transform node to this. Hit shift ie. Go to Geometry, select Transform and position here. Now we know we need to scale on the y and z axes. So let’s see if this works. We’re going to manipulate the Y-axis. And all of a sudden it’s actually going in the correct direction. And let’s also do the z-axis. And we have our button. It’s a little bit difficult to see because of the lighting. But if we zoom in, you should see that we have the button and we also have the boolean 40 indentation. If we want, we can also increase the scale on the x-axis for the button itself, just so it sticks out a little bit more. This is just one way of creating a setup that allows us to use other objects to create things like buttons and indentations on the main objects.
64. Introducing Our Procedural Table: Over the course of the next few lectures, we are going to be creating a procedural table. Now, while this may not seem like too much of an upgrade over our basic chair, this table is fully procedural. What we have here is a more complex looking no tree. Some of the nodes you will find familiar, such as the transform and joint geometry nodes to create a separate pieces. But we also have some additional nodes here that have different colors that we will be learning about in the next few lectures. And it’s these nodes that are going to allow us to make our object truly procedural. So we’re going to be looking at things like vector math knows which are the purple ones here. And we’re also going to be looking at combining and separating XYZ channels and why this would be useful for us. As well as introducing math nodes, which are a critical part in any procedure, will build that you create. By the time we’re finished creating this no tree, we’re going to be able to apply the appropriate attributes to our group inputs. And that’s going to give us all of these options here. Now, as you can see, these options have been named AT specific to their purpose. So for example, if we want to adjust the sizing of our leg thickness, we can manipulate this first value and that scales up all of the legs on the X and Y axes. We can also increase the height of the table by increasing the height of the leg size. We can, if I just zoom out, manipulate the overall table size on the X and Y axes. And with these in particular, you will see how we are able to increase the size of our table on an axis, but not distort the legs. So the legs move as we increase the size of the table on either axis, but they are not distorted. We can also manipulate the table thickness, which represents the table top by itself, and the overall scale of our table. So all of these things are easy enough to understand when we look at them in the Modifiers tab. But in order to get to this point, we need to understand how each of these are created. We’re going to be doing all of this in the coming lectures.
65. Using Vector Nodes To Build A Table: Once again, we’re going to be using the default cube as our base for this procedural objects. We’re going to start things off by selecting the cube itself and in naming it as table. Then we’re going to bring up our timeline and change it to the geometry node editor. Click on the new button to add our geometry nodes. If we go to the Modifiers tab, we can rename the geometry nodes set up to whatever we want. So I’m going to name it and as table, the same name as the object itself. Next, we need to add our first transform node, so we can’t manipulate the base of this table in terms of its location, rotation, and scale. So hit shift and I go to Search, type in transform, select and position. If we zoom in, we can see we’ve now got our Transform node where we can manipulate the location, rotation, and scale of our cube. If you weren’t sure about how this affects our objects, just take a look at the transform values in the side panel. If we adopt the change of scale in our no tree, you can see that we are able to adjust the dimensions here, but not the base scale. If we manipulate the location or rotation, you can see that this does not affect the transforms in objects mode in any way. The Transform node is effectively the same as manipulating these values on a 3D objects while it is in edit mode. The only difference here is that we are actually in objects mode while making these changes. For now, I’m just going to reset this back to one. And now comes the time when we introduce our newest node to the collection. So we’re going to add a factor math node, hold down shift and I go to Search and type in vector. Then choose the effects up math node at the bottom. I’m going to position here. And you can see that the outputs and inputs for defects or math node are colored purple, the same as the translation, rotation, and scale located on the Transform node. What we can do here is we can take this output form, our effects and half node and plug it into any of our transforms. So for example, I’m going to pop it into the scale value he. When I do that, the options for manipulating the scale disappear in the transform note. But what we could do here, we can now do here in the factor math node, you will notice that the cube has disappeared. And that’s because these values here are set to 0. We’re going to set each of these top values, 21. In order to restore our cube. So how does a fix a math node work? Well affects a math node has two factors. And effects are, is effectively dividing up the values based on either the free axes or the free basic colors. So either XYZ or RGB. In this case, we are using the first value here as our x value. The second is the Y, the third is the z. So what does that mean for the bottom free values? Well, width vector, math nodes, you can define the type of calculation that you want to use by clicking on this option here. So you can choose simple ones, such as add, subtract the vibe. Or you could use more complicated operations such as tangent, cosine, and sine. Using this node as an example, we set the base values on the x, y, and z axis for the scale. Each value below will allow us to add to the value above. So here we have a scale value of one on the x axis. If we want to use the vector math node to increase this value, we can increase this value here. So if I increase this by a value of one, it would be one plus one equals two. And now if you take a look at the dimensions of the cube, you can see that it’s set to four meters, which is double what it was before. So we basically doubled scale by increasing this vector value by one on the x axis. If we were to manipulate our effective value here, we can basically add to our wire scale. And the bottom one allows us to add it to our C scale. Now as we continue to generate more nodes, you’re going to see how useful affects a math node can be. For now, what I’m going to do is I’m going to set this back to 0. And let’s take a look at a couple of options. So subtraction. As we know what happens when we add to these top values, it should be fairly obvious what would happen if we were to begin subtracting. So if I take this top value here, which is currently set to 0 and set it to one. What do you think is going to happen? If I press the Enter key to confer? Well, what’s going to happen is that our cube is going to basically become a flat plane on the x axis because we’ve taken the base scale of one and we’ve subtracted a value of one at formats which equals 0, which means the dimension value is set to 0 here. Alternatively, if we go for a value less than 0 for subtraction, say 0.5, then we can effectively half the scale of our cube on the x axis. So what about multiplication? How does that work? Well, let’s change our vector math node from subtract to multiply. And you can see straight away that the cube has disappeared. So what’s happening here is we are times-ing or multiplying each individual axis by a value of 0, which in Blender is of course equal to 0 on the x, y, and z axis. So we’re going to need to increase these vector values of the bottom. I’m just going to click and drag down so that I can select all three values at the same time. And type 0. Now here we have one times one equals one. So this is the base setup for using the effects are math node when sets or multiply. From here, if we want to double the scale of our cube, we can just use the value two on any axis. If we want to half the scale, we can use a value between 01, in this case, 0.5. You can also invert the scale by using a negative value. So for example, if I use the value negative one, the dimension values actually look the same. But what we’ve effectively done here is we have inverted our entire shape. We’re actually going to be using this to solve an issue that we’re going to find later on when building the tables legs. Then now let’s just set this back to one and demonstrate the next option, which is divide. So in the same way that subtraction is effectively the opposite to adding, the vision is the opposite of multiplication. If we want to reduce the size on a specific axis by half, for example, say the z-axis, we simply double the specs of value here. So we use the value two. That basically means we use a value of one, divide it by two, and we get c of 0.5, which is half the original size of the cube. Alternatively, we can use division to increase our scale by using a value lower than the base. So if we use a value of 0.5, for example, one divided by 0.5 is the same as one times two, which gives us a value of four on the z axis because we’re doubling the size on the z-axis. The final one I’m going to show you here is going to be this scale option, since it would take too long to cover all of the straighter y. And we really don’t need to were just for now focusing on the ones that we’re most likely to use. So add, subtract, multiply, divide, and scale with the scale value. It looks a little bit different. We have our original free vector values, x, y, and z. If we set this to 0, for example, you can see it behaves as normal. But instead of an additional free vector values below, we have this single scale value. This is useful because what this effectively means is we can adjust this one value to adjust all free of the upper values at the same time. So this takes whatever we have said in the effectors. And we calculate it based on this value. If I set the scale, SO2, For example, it doubles the overall scale on all three axes. Alternatively, if we set this to one and then set each of these to two, we can effectively get the same results. So I’m just going to set those banks one. And the main reason why you would use the scale operation instead of multiplication is that you can plug this value directly into your group input. And that way you would be able to affect the overall scale of your model. Whereas the alternative to this, if I was to take this scale value here and just plug it directly into a free socket. You can see that we have the option to manipulate the free transforms or the free axes border scale transform independently. There are times when you want this to be able to independently or provide a each access. And there are times when you will want to manipulate this scale as a whole. Which at this point doesn’t actually work because this vector math node is currently no longer connected to our transform. So we just have to reconnect that. And then you’ll see that the main scale works. But these values don’t, because they’re no longer connected. So always make sure that you have the correct connections applied. For now, we’re going to just disconnect that. Keep the scale as is, keep the transform as is. And I’m just going to take the scale values that we have created here and just delete them for now.
66. Combine XYZ: So our next job is going to be to scale our cubed to the correct values and then add our first leg. What I’m going to do is I’m just going to set the z value here to 0.1 and press enter. This is a good starting point for the base of our table. Next, we need to add a joint geometry node and a Transform node to create our first leg. So I’m going to hold down shift and I search for transform and pop it about here. Then hit shift and I again search for joiner. Joint geometry, plugged this in here, and then plug Biche Transform node just below. Next, we’re going to connect this Transform node at the bottom to this geometry output, like so. So what we can see here is predominantly this transform, this instance. We need to adjust these values. So we’re going to set the x value to 0.1, the y-value. So 0.1 as well. What I want to do next is rather than manipulates the translation values form this Transform node directly, I want to use a Nawab vector math node. So I’m going to take our vector math note he hit shifting and position down here. I’m going to change this to subtract and plug it into our translates option. From here, I can manipulate values at the bottom to manipulate the positioning of this leg on the x, y, and c axes. Now, this is where things get a little bit tricky. What we basically want from our object here is the ability to scale the object, but keep the leg positioned in a specific area. So we want to position this leg, for example, in perhaps this corner or maybe this corner. And we want it to remain in that corner regardless of how we scale the objects. To do this, we need to link this scale Node with this subtracts node so that we effectively use the same values that each. We can do this by using a different node known as the combine XYZ node. I’m going to hold down Shift and then press I, go search and type, combine. And it gives us two options. Combine RGB and combine XYZ. We’re going to choose combined XYZ and position here. We’re going to take this vector outputs and plug it in here for the scale. And also plug it in here for subtracts. It’s important not to forget the basic rule that any node connections on this side of a node can be connected to multiple inputs. So if we thing that you see on this side of the node, like this point here, this is an output for this node. You can create multiple noodles for a single output. So for example, we’ve got two links here. We can add as many more as we want so I can plug it in here. And here, for example. However, inputs can only ever have one connection. So I can’t, for example, it’s Hague, this transition value here and attempts to plug it into anything else. If I attempt to take this vector and plug it into the transition, it simply replaces is. So keep that basic flaw in mind. Meanwhile, we have a cube that has once again disappeared. So we need to set these values to one on the x, one on the war, and 0.01. on the z. So now we’re making a bit of progress. But the positioning of the leg still isn’t quite right. Not worried. Oh, because we can manipulate that here. So I’m going to reduce the values for the subtract vector to 0.2 on the x will go to 0.2 on the y. And we’ll use a value of one for the z. And now if we take a look, we can see that we’ve got the base of our table as well as a single leg. Now, what does that mean for the objects at the moment? Just how procedural is this? Well, let’s find out by manipulating the combined XYZ node. So if we were to adjust the X value, you can see if I just navigate my view that we are able to increase the scale of our base. But as we increase the scale of the base, you’ll notice that the leg moves at the same, right? That the objects expands. What you will also notice as we increase the value on the x-axis is that even though the base of the table is being scaled, the actual dimensions of the leg we have created were mine, the sign, it’s just being moved. Compare this to the traditional scaling of the objects on the x axis. If we hit S, then x, the scale, you can see that we are still able to scale the base on the x axis. But now we are also scaling the leg as well. And this is the first time that we really see the procedural potential of geometry nodes. Because here with the combined XYZ node, we can use a single value to manipulate the scale of one piece and also manipulate the location of a second piece based on the exact same value.
67. Naming And Organising Your Nodes: As a beginner, using nodes can be pretty daunting. I noticed myself from when I began using nodes for the creation or procedural textures and materials several years ago. So there are a few things that you can do to make this setup just look more pleasing to the eye. If someone were to just look at this no tree with very little knowledge of what each node does, they wouldn’t really understand how it works. One thing that you can do is you can actually label individual nodes so that you can have them describe exactly what they’re used for. For example, take this first transform node. This allows us to create the base instance for our table, the actual base here. So it would make things a little bit simpler if it were named as such. If you don’t already have the side panel open, then your editor will look like this. Press the Enter key on your keyboard to bring up the side panel. Then go to the item tab. Here you will have information with regard to the selected node. We have the name here, it’s set to transform. This is the unique node identifier. We’re actually going to keep this transform name as it is. Instead, we’re going to give it a label. When we give a node a label, it replaces the name in the actual node editor. So here we’re going to give this transform a new name. We’re going to call it table face. And actually let’s give it a capital and press Enter. As soon as I do that you can see the name of our transform node has changed to table base. Alternatively, another thing that we can do is adjust the color of our nodes. For example, with our table paste no selected. We can click here, allowing us to manipulate the color. So I can open this up, left-click on this white bar, and choose a color for this node. So for example, I can set this to green. Now there are various reasons why you would want to cut out your nodes. You may want to give colors to your nodes to indicate the type of node that is being used. So for example, you might want to keep all of your transform nodes, the color green, especially if you have renamed all of your transform nodes into no tree. An alternative method of using color is two section of your no tree based on the specific roles. So for example, with this node tree, once it’s complete, we’re going to have several sections. The first section, which you can see he is focused on creating the bass and the first leg. Then we’re going to have a second section that focuses on creating the second leg. And the third section is going to be used to create the final two legs. So in this scenario, it might be ideal to color code based on each step of the process for creating this table. Well, I’m going to do is I’m just going to take each node and just set it to green. So by doing this, I can make it very obvious at what parts of the process these nodes are being implemented. In this case, the first stage of our process, creating the base and first leg. Alternatively, we can, as we’ve already touched upon, rename each of our individual nodes so that we can describe exactly what each node is being used for. So with the joint geometry node, for example, we could rename this by going to the label and using join by select. And that just makes it obvious what this node is being used for. So I’m just going to go through each of these nodes and rename them. So this here is our first leg. And then we now have the joined based elect node, table, base and first leg. Now how do we name these nodes? Well, you can of course named them any way you want, but it’s always best to give it an accurate enough description. So this node, for example, it tells us that it’s scaling something but we don’t know what. So we take look, we can see that it’s scaling our table base. So let’s label it as such. So scale base. And then that gives us just a little bit more of an idea of exactly what this B is being used for. Now, the one below is focused on defining the position of our first leg. If we manipulate it, we can see that we are able to manipulate the position of this leg of the table. So we need to name this as leg position. And then press enter. Then we have this combined XYZ node where we know that this combines the base table with the leg. So we’re going to name this combine base to leg. And there we go. If your name is too long, you can always resize your nodes by just coming over to the edge of a node, clicking and dragging to resize. So here we’ve got a setup that is a little bit more easy to understand. We’ve got the base instance of our table. We got our first leg. We’ve got the node that joins them together. We’ve got our vector math, no, use to scale with the base of the object. We’ve got the leg position node here, which is used to position this leg. And then we’ve got this combine, paste a leg node, which effectively allows us to manipulate the leg position while scaling the base value. We’re going to keep this as our method of organizing the rest of this object. As we continue to create more legs and add additional parameters that allow us to truly make this object procedural.
68. Finishing The Legs: In this video, we are going to create the final three legs for our table. Now, creating the nodes for this is fairly straight forward. We’ve done this sort of thing a couple of times already. So we are going to create a new instance for this node here. We can do so by duplicating it with shift and they and position here. And this is going to be to join seconds. So base, so this is going to be used to join it the second leg to the base of the objects. We also need to create another Transform node. So we’re going to take our first leg he shifting and position here and plug this in. Now, this is where things get a little bit different to what we’re used to. We could take this geometry output and plug it in here. The problem with this is that while we have created a new instance for our base object, in this case, our next leg which we need to rename here. This second leg is not actually connected to any of these nodes here. So the scale base, leg position and combine nodes. Because of that, if we work to begin manipulating these values, they would not affect this part of the object in any way because they’re in no way connected. So what we need to do instead is take our joint based select node located here. And we need to create the connection directly from here to the second leg. Now, that makes it look very weird at this time, but we will solve this issue in a couple of moments. What is effectively happening now though, is because we are linking the second leg to this point. We are now able to use these nodes to influence this one because they’re all apart of the same link. Now if we take a look at this leg, we can see that it’s positioned in the middle. And it’s actually using the correct c value, which is set to one, but it looks like it’s scaled far too small. Why is this the case? Well, when we plug this second leg from here to here, we are already using the values located here as our base values. So what we’re doing is when we set this value to 0.1 and this polytope 0.1, it’s basically 0.01. at times 0.01. which is if you do the maths, 0.01 on the x and y axes. So because of that, we need to set the x values back to one. And you can see that the value on the x axis has been corrected. And then the scale on the wire. But now that we’ve done that, the leg has disappeared. The reason why is because when we set all of these values back to one, the location and scale of this second leg is in fact identical to the first one. We positioned it in exactly the same place with no deviation to the scale. So the big question is, how do we move this second leg over here? Well, if we attempted to use the Rotate value here on the z axis, you can see that we are able to manipulate the positioning of that second leg. So if we use a value of 90, it looks pretty good, doesn’t it? However, this presents a new problem. If we manipulates our combined values again. So we manipulate this on the x-axis. You can see that we are now getting some unwanted behavior. The table is not being scaled in a manner that we would expect. To solve this. We are actually not going to use this rotation value at all. We’re going to set that back to 0. And instead, we’re going to use the scale value. Now you might be thinking, what’s the point of that? We’re just going to make the second leg smaller than the first again. But what we can do is we can actually invert the scale on a specific axis. Bear in mind that we are using the location for parties of the table base as well. So if I was to set this to minus one on the x-axis, so minus one. And then press answer. What effectively happens is we flip the positioning of the second leg. You’ve got to the other side. So what is a positive value on this side of the x-axis is a negative value on this side. And that allows us to alter the positioning of our second leg. If we were to test our combined node here. Remember what happened last time when we created this cross pattern? If we manipulate the X value, you can see that the behavior is much more in lines what we would expect when we want to increase the scale of our table on the x axis. If we manipulate the why, we get the same sort of result only this time scaling on the y axis. So this is the behavior that we are looking for, formed these parameters. That means we can now move on to creating the final two legs for our table. Before I do that, I want to take each of these two nodes and give them a different color. Since this is a different part of the process for creating a table. So we’ve might join node here selected. I’m going to change this to a yellowish color, something like that, may be a bit lighter. And then let’s make this node a similar color as well. So by changing the colors, we now know that the green nodes here are the first stage of the process. And these orange nodes here, or yellowish nodes in the case of the second part of the process, which is to create the second leg. Now, we just need to add one more join node here. So we’re going to just add this time joint geometry and position here. Then we’re going to create one will transform. And position about here. Makes sure the connections are correct. Don’t forget this time. We want to take this output and plug it in here. And that’s going to have the same sort of effect that’s plugging these two nodes together had. And this time what we want to do is instead of scaling on the x-axis, we want to scale on the y-axis. So we want to be able to invert both legs over to the other side of the y-axis. To do that is very easy because we’ve already done it on dx. Take this y value and change it to minus one, then press Enter. And there you go. You now have four legs created for your table. If we were to come back to our combined based elect node and manipulate the table on the x axis, we get correct scaling. And if we were to manipulate on the y axis, again, we get some correct scaling. If we manipulate on the z-axis. The behavior again is correct. The focus here though, is on increasing the thickness, the base of the table. So this value is going to have a different purpose to the two values above. But at this point, we’ve now created the base setup for our procedural table. From here, there are a couple of things we need to do. So we need to first of all, label the new nodes we’ve created. So join. Final two nodes or two legs, I should say, to represent this joint geometry note here. And then take this transform. And this represents our final legs. Like so. And then once again, we need to change the color. Let’s make this, perhaps a pinkish color, will make this roughly the sign. And there we go. A nice colorful setup here that’s relatively easy to understand in terms of the law for each individual node. To finish off, we want to create the functionality to be able to scale our entire model as we would just by manipulating the model with the S key in the Friday viewports. Now if we attempt to do that here with this open scale value, only our base of the table is going to be scaled because that’s the only node that is being influenced by this vector math node. What we need to do instead is create one more Transform node. So we can do so by going shift a and then just typing in transform search bar. And we can position here then to change it so that we can manipulate all free of these values at the same time. We’re going to take our scale bass note here, shifty, and position it here. That creates a duplicates of the same node, which is going to set this vector value back to one. Plugged effects are in here. And then we can use this scale value here to manipulates the entire objects in the same way that we can by pressing the S key in the 3D viewport. It’s left again is to rename the nodes, making sure that we have our NO treat nice and organized. So this is going to be our scale Node, our main scale. And this one, he is going to be scale control. So this is the node that allows us to scale the entire model. And this is the node that allows us to basically use a single value instead of the vector values to perform that scaling. All that’s left is to just give these final nodes their own color. I’m just going to make them a grayish color. Let’s make that a bit brighter. And there we go. So congratulations on completing the table up to this point. But it’s not very procedural still at this point because at the moment, we don’t have any values that have been exposed here in the Modifiers tab. And we need to find out which of these values can be used in order to manipulate our table in various ways. For example, we want to, being able to control the thickness of these legs on the X and Y axes. We also want another controlled for manipulating the length of the individual legs compared to the base of the object. So over the course of the next couple of lectures, we’re going to be looking at how we can expand on this by Setup and then expose some parameters into our group input node, which will allow us to manipulate our table in various ways. From the Modifier tab.
69. Assigning Parameters To The Modifier: In this video, we are going to begin exposing some of our parameters so that we can’t manipulate those parameters in our Modifiers tab without necessarily always coming back to our node tree. So often nodes that we’ve created so far. Which of these parameters do we want to expose so that we can control our table? Would have first one that sticks out is this scale value here. We know from the previous lectures that this scale value will increase the scale of our table as a whole on all three axes. So this looks like a good one to expose. If we take a look at the group input node back here, you can see that we have a transparent connection. This allows us to create new inputs for the group input node. So we’re going to do that now with the object scale. I’m going to take that bottom node. And because I have to scale out so far, I’m just going to have to temporarily move the base scale or the scale control, I should say. And then take this empty socket and plug it into here. This exposes the scale value, and we can now see it in the Modifiers tab. So we have is set to one. I’m just going to reposition the scale control back to here. Now, if we manipulate this value from the Modifiers tab, we can scale our object as a whole. So that’s the first parameter that we have been able to connect 2D Modifier tab. Now, the more nodes that you create, the more messy things are going to look. So right now I have an issue where we have this scale control node, where the scale is connected to the group input and it’s all functioning properly. But this scale noodle here looks like it’s connecting to the scale base. Then it looks like it’s connecting to the second leg. Then it looks like it’s connecting to the first two legs node. In fact, if I just reposition that, it looks like it’s going in to the inputs for all three of these nodes exactly. This doesn’t look very good and can make things more confusing than they need to be. We need a solution here. Fortunately, there is a solution known as rerouting. Well, I’m going to do is I’m going to take my free nodes back here and just move them back. So I’ve used box select, click and drag to select multiple nodes at the same time. Then you click on any of the nodes and drag it to reposition. Then what I can do with everything these selected is I can go shift and I and this time I’m going to go all the way down to the bottom where it says layouts. The second option here is the reroute option. I’m going to left-click. And then I’m going to hover my cursor over this noodle that connects to the scale control. I’m going to left-click once it’s highlighted. And what this allows me to do is if I press the G key, I can now reshape and reposition this noodle because of the reroute note that I have created. So here what I’m going to do is I’m actually going to take this and push it all the way up above the node setup. I’m then going to create a second reroute at the other ends. So I’m going to go shift and I again, layouts. We routes position about here. Left-click, Hit G, and move up above the notes. This just makes it a little bit easier for me to see what this scale output is being connected to. So I can now see that it comes up here all the way across to the end and down to my scale control. So that’s a handy little hint for organizing once you start to create more parameters for your node setups, because those parameters are going to be located in various parts of the node tree. Now that we’ve done that, we need to expose a few more parameters. So to free parameters that I am going to expose this time are the x, y, and z axes for our combined node here. I’m going to take the x-value first, plug in, say the y-value, plug it in, and then the z value, and plug it in. All of these are going to be useful for once our table is finally completed. So we need to rename each of these values. We’re going to select our combined based hillock node and go to the no tab in the side panel. From here, we can select the x, y, and c inputs, and we can’t change the name of each. So for the x inputs, I’m going to rename this to table width. For the y input, I’m going to rename it to table length. And for the z inputs, I’m going to rename it to table depth. So this last one is going to be the thickness of the table base. The second one is going to be its length and the first one is going to be the width. Let’s just test each of these so we can manipulate the scale, same as before. We can manipulate the width of the table. Like so. We can manipulate the length of the table. And we can manipulate the depth of the table base.
70. Adding Leg Thickness: In this video, we’re actually going to do a little bit of a mini challenge. So what I want you to do is I want you to see if you can create two new parameters for the leg thickness and leg size. Now when we talk about the leg thickness, we’re talking about the scale of the legs on the X and Y axes. When we’re talking about the size, we are talking about how tall the legs are. I want you to see if you can look at the nodes you have created so far. Determine where you can influence the leg size on the free axes. And if you need to add any additional nodes in order to connect them into our group inputs. I will be performing this task in a few moments. But right now, I just want you to pause the video and see if you can figure out how to create parameters that adjust the leg thickness and the leg size. A little hint, we have already used the nodes that might be required in this node tree. So 321. Pause and go. Okay guys, well I’m now going to create the parameters for the leg thickness and leg size. Well, I want to do is I want to bring out the values for the x, y, and z scale. For our first leg. Remember, these values determine the scale for all of Allix. So if we manipulate this on the x-axis, we’re manipulating each of the legs on the x axis. That means we need to basically isolate these into the free separate axes because we don’t want to plug them all in to a single slot. We can do this by using a combined XYZ node. So I’m going to go shift, I, go to search, combine, and then choose combine XYZ. I’m going to position this node about here and connect these two together. This way, we’re able to isolate the x, y, and z nodes. I’m just going to click and drag and set them to one. And you can see here that we basically have a big cube. So we need to make sure that we’re using the same values that we did before. That’s 0.1 on the x, 0.1 on the y, and one on the z. With the combined XYZ node, we’re actually now able to plug these in independently. But the task that we had was to create two parameters, not free. One for the leg thickness and one for the leg size. We’ll start with the tricky 1 first, the leg thickness. We’re going to plug the x value from the combined XYZ node into the group input. But what we’re also going to do is we’re going to plug the y value into the exact same input. So we take a look at our group input node. The node labeled as x actually comes out to the combine XYZ node for both the x and y inputs. This y. When we manipulate this x value in the Properties panel, we are able to manipulate our legs on both the X and Y axes at the same time. Now, the Z value is actually easier, or we need to do here is just plugging in by itself into an empty socket. And now if we manipulate that, we can manipulate the leg size for our table. Now this presents a different problem. You can see that as we increase the leg size, the legs actually pierce through the corners of the table. In a few lectures time, we’re going to be solving this issue. But for now this behavior is okay. While we sought out a view of the other issues that we have with our common setup. Now, one thing I want to address is the fact that we’ve got basically two neutrons coming out of a single output. In terms of the x value here. I just want to add a reroute node so that we can combine these two noodles into one certain point. So I’m going to go shift and I go down to the layouts and select reroute. I’m then going to position the reroute node about. He makes sure the x noodle is highlighted and left-click. I’m just going to hit the Z key and glad that over. And then I’m going to click and drag form this new node and position it into the y input. There we go. So that looks a little bit cleaner than what it did before. We basically have a single noodle coming out of this output. And then it splits into two, right before it’s joined with the combined XYZ node. From this point, we just have to do a little bit of housecleaning. So this x parameter here represents the leg thickness. Meanwhile, the z parameter is based on the leg size. Let’s also rename the combined XYZ node by going to the item tab will name this as leg control. And that’s also changed the color so that it matches the other green nodes to something like that. And there we go. So now we have our table set up so we can manipulate these scale. Table width, table length, table depth, leg thickness, and leg size in their current state. That each of these parameters is basically unlimited in how we can manipulate the individual values. So for example, we can take the table depth and increase it as much as we want. But it will eventually reach the point where the base of the table here becomes so big that it just engulfs our legs. Now, we don’t necessarily want these values to go too high, so we’re going to want to add a bit of additional control. We can do so by defining the minimum and maximum values of each parameter. To do so, go to the nano tab in the side panel, select the appropriate input. So for example, we have leg size here. And then you can define the default value, the minimum value, and a max value. I’m going to reset this to 0 for the minimum value. And I’m also going to set the max value to one just for the moment. So now we can both decrease and increase that leg size value between 01. We can do the same with the others. So the leg thickness between 01, table depth 01. And if we test that, you can see it only reaches the bottom of the legs and then stops. And then we table length and cyber width, we want a little bit more freedom. So we’re going to start with the minimum value of 0. But let’s bring it all the way up to ten as the max value. Let’s do the same with the width. Minimum, minimum at 0, max at ten. And now if we test these, we can increase the table width to a max value of ten and a table length by the same value. So now we just have a little bit more control over these parameters. I’m not going to adjust the scale value because I want to be able to scale it as much or as little as I’ve acquired. So we are going to lead the scale value as it is just for now.
71. How Math Nodes Work: In this video, we’re just going to be talking about a different type of node known as a math node. Math nodes are used to perform calculations for our node setups. They differ ever so slightly from vector math nodes in how they are used. What I have here is just a new file that I’ve created because I just want to demonstrate math nodes without too much clutter up from the other nodes for our procedural table. So I’m going to create a new geometry node set up. And I’m just going to add a single Transform node. So here we have our transform node with our translation, rotation, and scale values. If I was to add a vector math node by just going to search and just adding a fixer math node, I can position this into any of the free transforms. For example, I can position it in the scale transform. And now I can define the base scale of each axes with these top four effective values. So type in one. And then using this add operation, I can recalculate each individual axis by manipulating each of these values. So if I wanted to double the scale on my x axis, I would simply typing one key to double the length on the x-axis. I can use different operations, such as subtraction to change the way these values are affected by the ones below. That’s generally how a vector math node works. A math node is actually simpler than this. So what we’re going to do is we’re going to add a math node two, this setup shift and I were going to go search Chai P and at math and select the math node here. I’m just going to position here and plug it into my scale input. So let’s take a look at how the math node is constructed compared to the vector math node. I’m just going to set this back to add temporarily and just bring this up and zoom in. So these two nodes are very similar in their structure. Each has two separate inputs and a single output. Whereas a fetter MAF node deals with effectors, in this case, x, y, and z. A math node will deal wish great values. So in this example, we have the top value here, which is the initial scale that we assign to our cube. And then we add the value below. It’s pretty much the same as with the vector math nodes. So here we can define the vector scale on the x axis with this value. And then we can add to it using this value. The same approach is made for the maths node. The only difference is that this top value represents all three axes. And then the bottom value will allow us to add to each of these axes. As an example, if I just set this to one and the bottom value to 0, we’re telling blender that we want to set the scale value on the x, y, and z axes to one. So if we open up the side panel, we can see that the dimensions are at their default, two meters by two meters by two meters. Now, as you will have no doubt have seen by this point, manipulating these values, even in the scale itself, will manipulate the dimensions, but not the base scale. So from here, what we can do is we can take the base value which is assigned in the first slot, and then we can add to it using the value in the second. So if I want to double the size, I can type one and press Enter one plus one equals two. So we’re scaling it by two times on each axis. Hence, four meters on the x, y, and z. If I increase this bottom value to two, we’re effectively tripling the scale because we’re setting the overall scale value to free on each axis, three times two is six. So six on the x, y, and z axes. Again, this is very similar to the white defects or math node works. The only difference is that with the traditional math node scene here, we only manipulate a singular value for all three axes. So with that said, let’s very quickly take a look at some of the other options that we have. So we have subtraction where as we increase this value at the bottom, we can, we can decrease the scale. Then we have the multiply function. And when we use the multiply function, our cube disappears because the bottom value is now set to 0. So in this scenario it’s one times CuO, which in Blender is in fact 0. So the cube has no scale. In this case, we need to increase this value to increase the scale of our key. And then we have on Divide. Divide is effectively the opposites or multiplication. So if we were to set this to 0, once again, we can see that the cube is disappeared because you can’t divide the scale of something by nothing. But if we set this to 0.1, we get a joint cube. Because one divided by 0.1 is effectively the same as one multiplied by ten. It’s effectively inverted in the way it calculates the scale. So now that we have a pretty basic understanding in how a math node works and how it compares to a vector math node. Let’s go back into our procedural table and see how we can use a map node to enhance the amount of control we have over certain parameters.
72. Using The Math Nodes: So we are back here with our procedural table. And this time I want to introduce a math node at some points in this setup. Now, i Math note will be used to recalculate one of the existing values so that we can gain more control over that value. Because we’re using it to control values further down the line of our node tree. We’re going to need to create the math node before the node which defines that specific parameter. So for example, we have the table depth value, which we can increase at the moment between 01. Let’s say I wanted a bit more control over this. So I didn’t want my table dev to increase so much just by increasing the value by such a small a man. What I can do here is I can add a map node in-between the table depth output here and the C input for my combined based leg node. So let’s go in and hit shift, and I go search math and select Math. Then I’m going to hover the math node over the noodle, where we have the table DEF connected to the C input and left click. This instantly has an effect on our model. At the moment is set to ADD. So whatever value we have here, we’re going to add 0.5. to that value. So the final calculation is actually C of 0.6 because it’s 0.1 plus 0.5. But we don’t want to use the Add Node here. We want more control. So we’re going to use either the multiply or divide functions. But this, I’m going to choose divide. Now when I choose the void, it’s now 0.1 divided by 0.5, which is a face, effectively the same as 0.1 times two. So we need to push this value above one. I’m actually going to push it to a value of two and press Enter. And now if I was to increase or decrease more Table depth, you can see we’ve got a little bit more control. It won’t go down as far because we’re limited to a maximum value of one. Well, I’m going to do is I’m going to set this to a value of about ten. So here we can adjust the table deaf between 01. And if I ever want to have more control over the actual distance, I can always select the table depth from here and increase the max value. So if I increase this to five, for example, I can increase my table depth here all the way to five and just add the additional thickness. So that looks good. I’m just going to drag this out, create a bit of additional room. And this is going to be our depth control. So we’re going to rename it as such. Come to the item tab, left click, and press enter. Then we’re going to give it a bit of color. But for this node, I don’t want it to be visible. In fact, when we’re finished, we want a lot of these nodes to basically take up less space than what they come in the ER. So with this divide node, with the depth control node that we’ve created here, what we can do is we can press on this arrow here that’s going to minimize the node. In our view. It’s not going to do anything to how the depth control node operates, but it’s just going to minimize the values so that we can make the no tree as a how a little bit more pleasing on the I. I’m now going to add one more of these math nodes.
73. Fixing The Leg Size: In this video, we’re going to be addressing an issue that we highlighted a few lectures back with regards to the leg size parameter. So if I go back to the notes tab and select leg signs and just increase this max value to ten. When we increase this leg size past a certain point. You can see that even though we are able to scale the legs, they actually scale form the center of each leg. So today’s fail both up and down at the same time. This creates the issue where the legs on now piercing the base of the table. In this video, we’re going to learn how we can fix this issue. Now based on the behavior of the leg size parameter, we can pretty much tell that each cube has its origin point located in the center of that cube. So each leg, when scaled, is going to scale from the centre. Now, rather than this being an issue, we can actually use this to our advantage. What we know is that we can scale up and down. But at the same time, we can also move these legs if we wanted to. So why not put those two functions together? As we scaled the leg value for the leg size, we can move it down by the sign, right? This would allow us to increase the scale, but not have it peers through the base of the table. So how do we combine the scaling of our legs with their location? Well, that’s not possible without first being able to isolate the z value form the translation vector. So what we’re going to do here is we’re actually going to add two nodes in between our leg position node and the first leg node. First, we’re going to add a combined XYZ node. So shift I, go search, combine XYZ. And we’re going to position this just before the translation value. With them going to add a second note here. Wonder we haven’t used yet. We’re going to be adding a separate XYZ node. So again, shift and I search. So IP in separate, separate XYZ and position he. What we have here is the combined XYZ node, which will take the translation factor and split it into free separate values on the x, y, and z axes. The separate XYZ node. If we’re going from this way to this Y, actually does the inverted to what he says. So he, we’re taking our free factors and we’re going to join them together by connecting these nodes. So if I plug this in here. And this in here, it’s the exact same behavior as if these two nodes didn’t exist. So what’s the point? Well, the point is, we can now take the z value away from this equation and connect it to our leg control. Now if we connect this up directly, so we take the effective output and plug it into the C input. You can see that now the legs are positioned on the top of the table. And if we increase the leg size, it’s increasing the size of the individual legs, but it’s going in completely the wrong direction. What we’re going to do instead is we’re going to use a math node. And we’re going to connect the combined XYZ and the leg control using that math node. And then we’re going to, we calculate the legs so that they scale on the bottom and not the top. I’m going to add my math note first of all. And then I’m going to position the math node here. So we have the math node first, then we have it going into our leg control. I’m actually going to bring this math mode down to about here. And then connect the C value to the value output. Now at this point it’s done something very similar to what we did before. The only difference is we are now adding to this scale value. I’m going to change this form, add some Multiply. Then I’m going to set it to one. When I do that, you can see we’ve got the same result as we did when we directly connected the leg control to the combined XYZ node. However, what we can now do with this multiplier operation is similar to what we did earlier when we created the additional legs. If you remember, we inverted the scale on a specific axis to mirror the positioning of the legs. We’re going to do this to once again, mirror the positioning of the legs, but this time on the z-axis lava than the x and y. To do that, just take this bottom value and set it to minus one. Then press Enter. And the legs are now back in the proper position. The only different style this time is when we manipulate the leg size. The behavior is exactly what we want. We’re now able to increase the leg size by as much we want to without it piercing the top of the table. Why? Because now as we are increasing the scale, we’re also move into legs down in terms of their location values on the z axis. This is what is allowing us to increase the leg size without having the legs pierce the base of the table. So all that’s left now is to just rename these nodes and give them appropriate colors. So the combined XYZ node first, let’s set that to green. Separates XYZ to green and multiply to green as well because there was still a part of the first stage of the process. We’re where we’re just calculating how we want the bass and the legs to be created. Now we’re just going to name this Multiply node as size control. And this combine XYZ node. Both the main purpose of it is to isolate the z value. So we’re going to isolate C. And the separate XYZ note actually does exactly what it’s supposed to. It separates the effective values into the X, Y, and Z channels. So we can just leave that as is. Finally, I’m just going to minimize my math node, which I like to do just to clean up my overall look. Fourth, no tree. And there we go. So now at this point, we now have 123456 different parameters that are all working exactly how we want them to. We can manipulate the scale of the overall object’s type of width, length, depth, leg thickness, and leg size. So congratulations for making it this far, and I’ll see you in the next video.
74. Finishing Touches: In this video, we’re going to just add a couple more parameters to our procedural table. What we want to do is we want to add the ability to move the positioning of the individual legs on the X and Y axes. Now, before we actually do this, can you estimate exactly where in our no tree, we’re going to need to add nodes in order to control the X and Y positioning for the legs. Just take a minute and look at what each of the nodes are responsible for. And then decide where you’re going to position any potential nodes, what those nodes might be, and how they’re going to work. Ok. Well, we’re going to be manipulating the location on the x and y axis. If we take a look at our nose setup, we can see that we can already control this using this leg position node. So if I manipulate these values, we can manipulate the location on the x, y, and z. But as you can see here, we can’t actually manipulate the z-axis as a result of this node. Over here, the isolates see node which we used to take our c value for the translation and plug it into this math node Dan here. So to see, value is not connected to our leg position at all, which makes this value completely worthless. So what we want to do is we want to isolate the top two values. We can do that by adding, you guessed it, a combine XYZ node. I’m going to hit shift and I search. Combine XYZ. I’m going to position it here, plug the vector into the vector. Then we’re just going to temporarily reset these back to the way they were before. So point to 0.2. We don’t really need to manipulate the c value. Again, it’s not connected to anything. But what we can now do here is we can connect these two x and y values to our group inputs independently. So I can take this X value position here. Take the y-value position here. Go to node, scroll down and just rename these. So here we are naming as leg x, and this will be Leg y. So now if we manipulate these values, we can control the positioning of our legs on the X and Y axes. We’re going to finish just by tidying this up. Take the combined XYZ. And we’re going to rename this by going to the items tab. And let’s just rename this as position x, y. And that tells us that this node is being used to define the positioning of the X and Y axes for the legs. Then let’s take that color. Make it green, as we always do. Zoom out and admire the no truth that you’ve created, which has resulted in a truly procedural table object in Blender.
75. A Review Of The Table: So in this video we’re just going speed. We’re viewing the node tree that we have created for our procedural table and the responsibilities of the individual nodes. So at this point, we already know that the primary function of the glue inputs is to expose parameters that we can manipulate. The group output, which is located at the upper end, is effectively the final result based on the parameters that are manipulated here, and also any parameters that are located here with the individual nodes. The table base note here is a transform node that creates the first instance of the cube. This is the node that we used to create the base of the table. If we zoom out, we can see that we have a first leg node, which is the second instance of R cube. This was used to create the first leg. We then join these two together using this joint geometry now so that we have the leg attached to the base. If we go to the next section of our no tree, we have a second Transform node, the legs. So this allowed us to create a second leg by mirroring the location using the x scale value. We then join this up with the bass objects using this node here. Then we repeated the process one more time by adding another Transform node, which allowed us to mirror the two existing legs over on the Y axis using a negative value widget. We then join up this instance using a novel joint geometry node located here. Then as a means of controlling the overall scale of our object, we added a final Transform node right at the end. This note is specifically for being able to scale our 3D objects. We used a fixer math node for this soda, we could combine all three axes on the scale transform as a single value. We then take this node up here using a reroute. Just for the sake of making our overall node sets up a little bit less messy than what it needs to be. And we plug this into the scale inputs, which is actually our first parameter. So this is how we can manipulate the overall scale of our table. From this point, we created the structure of our table. Now let’s take a look at the parameters we created to make this table truly procedural. Starting with the first free, we have the table width, table length, and stable depth. We can use the combined based elect note here to isolate each of the free individual axes and manipulate the width on the X axis, the length on the war, and the depth on the z. With a table depth, we even added a math node so that we can change the way that the table depth value is recalculating the depth of the base of the table. If we take a closer look, we can see that the values for this node R, using the values of the scale base vector and the leg position factor. This means that as we are able to increase the scale of our object, we will move positioning of the legs at the same rights. This allows each of these free nodes to be able to scale the table without losing the positioning of the individual legs of the table itself. If we take a look, once again, our group input node, we then have the leg thickness and leg size options. So we can see down here that we have our thickness control board, the leg control. And by connecting the x and y values from this leg control node, which is a combined XYZ notes together using a reroute. Plugging into this fitness control math node, we are able to control the leg thickness on the X and Y axes. So we adjust the leg thickness. We can scale the legs on the X and Y axes, but not the z. The z value here separated into this size control node. It’s also connected to this oscillates. See node located here, where we effectively isolate the z value of the legs location from the x and y. This way, we’re able to take the location of the legs and move the legs on the z-axis while scaling them. This gives us the behavior and ability to adjust the scale of the individual legs without them piercing through the top of the table as they did when we initially created this parameter. The combination of these two nodes here is what allows us to separate the z value form the translation of the first leg. So that’s a overview of exactly what we have created and what each of these nodes are used for. I hope at this point you have a decent enough understanding on the properties of each of these different types of nodes that transforms joint geometries, combine and separate XYZ vector math node, traditional math nodes, et cetera. Before moving on to the next section, I am going to give you a little bit of a challenge. I want you to see if you can create a different objects. One that is completely different from this base table. See if you can make it truly procedural using the parameters for the group input. And also make sure that you organize your node setup. So here, because we’ve been able to color code our node setup, we can sell that anything relating to the color green represents the first part of creating our table. In this case, we’re taking the table base, adding the first leg to it. And we’re creating all of the different calculations that are going to make our objects procedural, even with the additional instances added later on in the node tree. So wherever objects you choose to create is entirely up to you. You could, if you wanted to create a different table or even create a chair by using this procedural workflow. So complete that challenge now guys, and I will see you in the next video.
76. Making Our Drinking Glass Procedural : In this video, we’re going to make our drinking glass objects that we created in the previous section of the course. A bit more procedural by exposing some of the key parameters. The parameters that we want to expose are going to be the x and y scale board Boolean, as well as the c translation. We’re going to want the x and y scale to represent the thickness of our drinking glass going around its radius. And we also want to determine the height of its base, which we can do so by manipulating the c translation value. We are also going to want to control the overall scale. Let’s do that last bit first. We know that we can control the scale of our entire object by just adding a transform node at the very end of the node tree. Let’s add that Transform node by going to geometry and select Transform. And then what we can do is we can isolate the scale values specifically. Now we need to turn these form a vector into a float value. So as a reminder, a vector value is basically split into free the x, y, and z axes. But we want to use a singular value, which is otherwise known as a float. If he will remember from when we created our procedural table, we can isolate this scale as a float value by adding a FETS HeartMath node. So go to theta and select vector math, position and connects to the scale. Then change the function from add to scale. And you can see here, we have the choice of exposing the scale as a vector or as a float. We’re going to take that float value and plug it into the group inputs. So take drag and connects. We’re going to keep this as scale because it represents the overall scale. And now if we go to our modifier Properties tab, you can see that we can manipulate the scale value. The reason why the objects has now disappeared is because the effects of value itself has been reset to 0. So we need to set all of these three values back to one to restore the base shape of the object. Now, we can manipulate the float value in the Modifiers tab to increase the scale. If we wanted to, we could also isolate these vector values using something like a separate XYZ node to manipulate the overall scale of the drinking glass on any specific axis. So let’s do that now actually. So let’s add another node, shift I. And let’s go with combined XYZ. Plug the vector into the scale. Take the x value. Plug it in here, and they’re designed with the Y value in the same socket. Let’s rename this as gloss outer width. So that represents the Alto width. And if we set this value to one, at the moment, it has it. So day looks like a disk and that’s because of the Z value. Let’s just increase the Z value to one. And now if we manipulate this gloss outer width parameter, you can see we are able to adjust the size of the drinking glass on both the X and Y axes. So, so far we have the scale, which is all free axes at the same time, and the outer width, which is just the x and y. We can also manipulate the C value, plug it into his own slots. And if we adjust that, we adjust the height of the drinking glass. So let’s just rename that as glass heights. And there we go. So now we have free parameters, but the overall scale, the outer width, and the glass heights. Let’s just manipulates the positioning of one or two of these nodes just to clean things up just a little bit. Move this up here. Just so we can get a bit of a clearer picture on what is connected to what. And now I want to do is I want to control the thickness of the glass on the inside. So we’re going to isolate the x and y scale down here. Let’s add ourselves. You guessed it’s combine XYZ node connected a scale. And then we’re going to set the z value to free. And we’re also going to just drag this out a bit more. Connects the x and y to the same group inputs. And we’re going to manipulate these values to 1.2 and press enter. And that gives us exactly what we had before. So now we can manipulate this value here to manipulate the thickness of our drinking glass. Be careful not to go beyond a certain value. Because then the Boolean overlaps the object as a whole and you end up with a disk at the bottom. So you could easily go in and clamp this value using math nodes or just a basic value in here. For right now, we’re just going to finish things off by isolating the z-value body location. And that is going to determine how high the basis. So what we’re going to do is we’re going to duplicate the XYZ node we have created here. Connects to the translation. Set that 2.1. And then connect this to the bottom slop. Makes sure that it’s actually the correct one. And now if we manipulate this value, you see at the moment we just got a hole at the bottom. If we increase it to 0.01, we get the base. And then as we increase this value, that base comes further and further up until it reaches the top. So let’s set that to 0.01. And let’s just finish by renaming these values. So this one is going to be our class thickness. And then the one below is going to be the base heights. So from here, what you can do is you can add some math nodes to get further control over your parameters. We’re going to leave it at that. Thanks guys, and I will see you in the next video.
77. Preview Of The Forest: In this section of the course, we’re going to be learning how to create this a forest of different types of trees that are scattered across a single applying. We’re going to be doing this by learning about points, nodes. Point nodes are used to distribute a specific object or collection of objects across another object using a point system. We’re going to be taking a look at different types of nodes in this section. In addition, subpoint nodes, we’re also going to be taking a look at attribute diodes, as well as being able to use the math nodes to control certain attributes from these new nodes. We’re not actually going to be using that many nodes to create this effect. And that’s the beauty of this node system, is that you don’t actually need something to be super complicated to get its work the way you want. So over the coming lectures, we’re going to take things step-by-step in how you can achieve this result in very little time with very little effort using geometry nodes.
78. Using Point Nodes: In this video, we’re going to be introducing the two most important nodes for scattering and object instance across the surface of another object. At the moment we have a single cube. Well, I’m going to do is I’m going to add a second object to this scene. I’m going to add a plane object. So I’m going to go shift and I mesh and then select Plain. And then going to scale this up by a value of about 20 and press enter, then hold down control and I and select scale. That way. If we go to the side panel, we can see that the scale 4D plane object is set to one on each axis. With the plane is selected, bring up your timeline and then switch it to the geometry node editor. Click on new to create a node system for our plane. And we’re just going to rename this geometry nodes system as scatter because we’re going to be using it to scatter object instances around the plane. Next, we’re going to introduce a new node. So hold down shift and I. Then go to search or go to the point menu here. And the first one we’re going to add is the point distribute node. So left-click and position over your no tree like so. And left-click against confirm. As soon as we do that, you can see that our plane object has been transformed into a series of particles that have been randomly distributed across the area where the plane was once positioned. If we zoom in on the point distribute node itself, you can see that we’ve got a few options that we can play with. The only two to unfocused on at the moment are the density and the seed. The seed is effectively a random generator that changes how the Pascal’s are created by the point distribute node and where they are each positioned. So you can change the seed to randomly change the positioning of all of the individual particles. The density option represents the number of paths calls that are visible. At the moment it’s sets one. If I reduce this value to something like 0.1, for example, this significantly reduces the total number of paths calls on our plane object. If I increase it to a value of ten, it’s going to do the opposite. It’s going to significantly increase the number of particles scattered around the plane area. For now, I’m just going to set this back to one. What we want to do now is take our cube object that we have here and use this as our particle. So each of these little dots that you see, there are particles that have been scattered across the plane and we want to turn all of these into cube objects. I’m just going to make sure that the plane is selected. Bring my points distributed node over here. And then I’m going to add our second node, which this time is going to be the point instance. Left-click position after the point distribute node. Like so. Now as soon as we do that, the particles disappear, but the plane doesn’t exactly reappear. The reason why is because we don’t have a defined objects. So if we left click here where it says objects, you can choose whatever objects in your scene that you want to use as your point instance. In this case, the cube objects. As soon as I do that, you can see that we have many, many cubes now in our scene or scattered around the area of the plane. Now, there are several ways in which we can edit how these cubes are being generated. But for now, I just want to reduce the overall size of each individual cube. And the easiest way to do that is to just select the main QB objects, hit the Tab key to go into edit mode, and then just hit S and scale down. As we scale down at the Main cube, the instances will be scaled down as well. But this will only really work in edit mode. If I was to go into objects mode and change the scale, you can see it doesn’t actually affect the point instance. What we can do here though, is we can scale down, hit control a, and apply the scale. But my preferred method is to simply go into edit mode and scale from there. So I’m going to scale down to about here and left-click. So now you can see that across the area of our plane, we have hundreds of little cubes for our sing. As a little bit of a mini challenge. I want you to see if you can figure out how you can keep all the cubes that you have generated, but also bring the plane back into view. So if you think about it, whenever we use our point distribute node, the plane objects disappears from our sin and is replaced by the particles. If you remember from our projects on creating the basic chair and also the procedural table, do you remember how we could create separate instances of the same objects? Think about the specific node that we used, and if you can figure it out, try and apply that node to this node sets up to bring our plane back into view. I’ll just give you a couple of seconds. Okay? Well, if you remember, when we created the basic chair, every time we wanted to create a new leg or the back of the chair, we used the joint geometry node to create a new instance along with the Transform node. But in this case, we don’t want to manipulate the transform with the plane itself. We just want it to be visible. So we’re going to use the joint geometry node position here. And then we’re going to take the geometry outputs and plug it into the second input here. As soon as we do that, we bring our plying back into view. So the first slot represents the actual point distribution of our cube. The second slot here represents the plane itself unedited from any notes.
79. Attribute Nodes: Not only are we learning about points nodes, in this section, we’re also learning about attribute nodes, which can be used to control the transforms of our points instances. So what I’m going to do here is I’m going to add our first attribute node to this set-up. Bring up your Add Menu with shift. And I. Then go to attributes and you’ll see we have numerous attribute nodes that we can add. The first one we’re going to demonstrate is attribute field, where you position the attribute node is very important. For example, we’re going to position the attribute fill node in between point distribute and point instance. Now at the moment nothing has happened to the instance cubes. We have with our attribute fill node, a geometry inputs and attribute inputs and a value inputs. We can actually change the type of this form, float, subvector, color or Boolean. But a moment, let’s just keep it at floats. Now an attribute is something like a transform, for example, so to location, location, and scale, it could also be something else like a UV map or the color or vertex colors. We’re going to keep things simple. We’re just going to use the attribute fill node to control the scale. To do that, we’re going to type scale in this little box here. This is case sensitive, so do not start with a capital S. We want it to be lower case for all of our attributes. I’m going to press the Enter key. And as soon as I do that, all the cubes disappear. The reason why is because the value is set to 0. If I begin to increase this value, we begin to increase the scale of the individual particles. The attribute fill node is a very simplistic version of some of the other attribute nodes, such as the scale and randomize options. Because with this value, it does so uniformly. So they are all scaled the sign. If I was to change this to the vector value, then we end up with free vectors x, y, and z. By changing attribute fill from floats to Effexor, we can then control the individual axes, 40 scale or the keys. So if I could set this to one, then one again, then four. You can see that we have the cubes instances of add arsine, same as before, but they’re now all scaled up on the z axis, even though the original cube objects, which if we just bring up here, you can see that’s not being scaled on the z-axis at all. So this attribute fill node is only focused on the particles themselves. And that brings us to another important point. You will notice that we positioned the attribute fill node before we defined the objects that we would be using for the points instance. So this is in fact controlling the particle itself and not dependent on whatever objects we select that comes after. Let’s test what happens if we were to change the positions around. So I’m going to take one attribute, fill node, and position it after the point instance. Here you can see that nothing happens if we manipulate the values on the x, y, and z. The attribute fill node has no effect because we’ve already determined what’s the object instance is going to be and also how it’s going to be generated. Now while you cannot position the attribute fill node after the point instance node, you could position it before the point distribute. Note, since these are values that are being defined for the particles that are generated. So in this example, you can control the attribute fill four to scale before you distribute the points. I like to set this up after. So I like a workflow where I distribute my points first and then control things like the density and seed values. And then use things like the attribute note to control attributes like this, scale and rotation. We could also add other node types such as math modes to this set-up to gain more control over our scale. While I’m going to do is I’m just going to set this to a float value. Then I’m going to add a math node. So go down to utilities and select Math or search from the search bar. I’m not going to position it in between the two geometry nodes. I’m just going to position. He creates a little bit of additional space so I can position and then connect the value to the value. Then I’m going to set this to multiply. And let’s just set this to one as the top value and one for the bottom value. So this gives us what we basically had before with a base value of one. Then we could expose this top input, for example, into here. Go to the Modify tab. And if we set this second value dance of 0.1, we can get a bit more control over the scaling of the individual instances. If you wanted to, you could also use a Fetzer math node to adjust the individual factors. Or even a combine XYZ node to isolate certain values, such as the free individual axes of the scale attribute.
80. Per Vertex Instancing: In this video, I’m actually going to take a step back and we’re going to perform a little bit of an experiment. We now know how to combine the point distribute node with the point instance node to create the effect of scattered particles around a selected objects. But what happens when we mute one of these nodes? For example, what happens if we work to move the point distribute note so that it would have no effect on our scene. Well, let’s select the point distribute node and find out. If I press the key on my keyboard to mute the point distributed node, the cubes disappear. Or do that. Because if you take a look at the corners of our plane, you can see that we have an instance of the cube at each corner. The reason why is because the point distribute node is used to randomly generate the instance object on our plane. When it’s not being used. The instance objects will be positioned on all available verticies of the main objects, which in this case is the plane. So the main object is applying and the instance object is the cube. If we hit the Tab key to go into edit mode, you can see that this plane only has four vertices, one on each corner. Let’s see what happens if we increase the number of first vertices for our plying. Right-click to bring up your third Texts Contexts menu, and then select subdivide. As soon as we do that, we can see that along with the additional edges and vertices that we have created, we have also new cubes positioned at those new vertex points. If I open up the operator panel and begins increased the number of cats. Not only do we increase our geometry, we also increase the number of cubes that are generated. So now if I hit the Tab key to go back into objects mode, you can see that we have all of these cubes generated, but they are locked to the location of the individual vertices. Now when it comes to our point instance node, we’ve already seen what happens when we don’t have a point instance node in effect. I’m just going to demonstrate this again. Basically, if we mute our points instance node, I’m just going to zoom out here. By pressing the mkay. Then the cubes are replaced with particles. These particles basically look like sort of diamonds, but they don’t represent any object in particular. So this is the effect of using both the point distributes and point instance notes. And what would happen if you were to choose not to use either of the nodes in question.
81. Instancing With Collections: Up to this point, we have been using a single object as our point instance. However, if we zoom in on the point instance node, you can see that we have two options, object and collection. This time, let’s create a new collection in Blender and use the collection as our point instance system. To start with, I’m going to add a new objects shift I mesh Ico sphere. Then I’m going to set the radius to something like 0.2. Press enter. By doing this in the operator panel when the object is created, were not altering the scale. So we don’t need to apply it the scale by going control, ie, if we manipulate the values here in the operator panel. Next, I’m going to add a new collection by right-clicking in the outline a panel, select new collection. And just rename this new collection as instance o b, j. Then I’m going to position where Ico sphere inside my instance OBJ collection. And do the same with the cube objects. Then select the plane. Once again, choose collection from our point instance node. And when we do that, you will see that all of the scattered points have disappeared because we don’t have anything defined here. Left-click and select instance OBJ. So as soon as we do this and zoom in, you can see that we are creating instances of both the cube and the ecosphere. There is just one issue, and that’s the fact that the instance is being created at the same location. So even though we have multiple objects, both objects are being created each time in the same point. If we select one of these objects, such as our Ico sphere and hit g to move that object, you can see that it impacts all of the individual particles. So if I look this to the x-axis for example, or maybe the Y. And we position. You can see the effect that this has on each individual particle has been scattered around our plane. However, this is not really the sorts of behavior that you want. If you’re trying to randomly generates your parts calls, this doesn’t look as random with a cube and an ecosphere sat next to each other at every generated instance. Fortunately, the solution is much simpler than you might think. In the point instance node, we have a tick box that says Whole Collection. When this is ticked, it basically applies the entire collection of objects to each generated instance using their transform values such that the location. However, by untaken This box, like so and zooming out, you’ll be able to see that now each instance holds only a single object format that collection. If I was to add a third object to my collection. So I’m going to select instance OBJ, hit shift, I, then go. Monkey would use the size to about 0.2. Reposition on the y axis to about here. And then select my plane objects. What I can do is I can just increase my value. And you will see that we are generating the cube, Ico sphere and Suzanne objects, but always in different locations to each other. This in comparison to setting, it’s a whole collection which uses the transform values of the entire collection for each particle that’s generated. That’s a very important point to consider whenever you are using collections, bought your point instancing.
82. Attribute Randomize For Scale: In this video, we’re going to be taking a look at our second attribute node. We’re going to be taking a look at the attribute randomized node. Well, I’m going to do with my current set up is I’m going to replace my attribute fill node with an attribute randomized node. I’m going to start by deleting the attribute fill note, hit shift. I go to attribute and select attribute, randomize. I’m going to position here. And then take the geometry, in-situ geometry. And again over here. Then I’m going to set my attribute. So with each of these attribute nodes, you have to set a attribute to be effected. Again, we’re going to choose a scale and press Enter. You can see what this does by looking at the scattered objects around our plying. The attribute randomize node will allow us to scale each of our particles. But it randomizes how much they are scaled by. This compared with the attribute fill node, which was used for uniform scaling. We can use the seed value for the attribute randomized node to change how much each of our individual objects are being scaled. And it also changes the overall look of our model. As a result, we have the minimum and maximum values that we can set here. So the closer these two values are, the closer the scale is going to be between the incidence objects. So if I set the max to one and the min to 0.8, the scale of each of our instance parts calls is going to appear very similar. The greater the difference between the minimum value and the maximum value, the greater the potential difference between the scale of each individual particle. We can also use our Multiply node here as well to manipulate the control of each. So I’m going to take this Multiply node and set it up to the max. Then I’m just going to close this, duplicate it. And position with the min. Then take the top slot, which is going to be this one here. Let’s position into this new group input. We’re just going to take the bottom one. Popular on top. Name it as min for minimum. Max for maximum. And now we can’t manipulate the values form the Modifiers tab. Don’t forget that much likely attribute fill node, the attribute randomized node can be changed in terms of the type of data used. This time we have free options, float, vector and Boolean. So we could change it to the Fetzer value, for example. And then we could begin isolating the scale on the x, y, and z axes. For now, I’m just gonna sit that backs afloat. And let’s move on to the next video, where we’re going to be using the same attribute randomized node, but for a different attribute altogether.
83. Attribute Randomize For Rotation: In this video, we’re going to be changing the wider we use the attribute randomized node by changing the attribute. Now in this example, I’m going to keep my current attribute randomized node. Because what we were about to do is affect a different attribute altogether. So we don’t need to replace this. Instead, we’re going to select it and hit Shift the two duplicates, then position straight off that the original node. Now you can see the effect that this has on our Quinn instancing. But that’s because we once again have the attributes set to scale. We’re going to left-click here and we’re going to give it a new attributes. We’re going to use rotation. I’m going to select rotation and press enter. Now all of our particles appear small again. And if we zoom in, you will notice that some of the parts calls have been affected by a change of rotation. Well, I’m going to do is I’m just going to increase the min and max values for the scale just so we can see a bit more clearly what’s going on. Do something like that. And you can see how some of these objects instances have been affected by the attribute randomized node by setting it to rotation. What you can do here is you can change from float to something like factor. And then you can begin manipulating the individual axes. For example, say if I only wanted to manipulate the rotation on the z axis, when I could do is keep the minimum values set to 0. This indicates 0 rotation. And the bottom values here they’re set to one. And that basically means that it’s rotated once around a specific axes. So 360 degrees. We’re going to set the x value to 0 and the y value to 0 as well. What this does is it now allows the attribute randomized known to only affect the rotation of the instance particles on the z axis.
84. Create A Forest Exercise Geometry: Now that we have a good idea of how to combine point nodes with attributes and math nodes. We’re now going to have a little bit of a challenge for you. In this challenge, I want you to create the following scene. I want you to create a forest using two different types of trees. Now, the models that you use to create your trees can be as simple as you want so long as they resemble trees. I’m actually going to keep objects very simple. But what we’re going to do is we’re going to create those objects, position them in a collection, and then use that collection to spread the trees around a large plane, much like you see here. We’re going to be using the attribute randomized nodes to randomize both the scale and rotation of the trees that we create. So what I want you to do now is pause the video for a couple of minutes and see if you can create a scene that looks like a forest with at least two different types of trees scattered around a large plane. Free to one. Pause and go. Ok guys, I’m now going to perform this challenge myself, but I’m going to do so in a new file. I’m just going to save what I’ve done so far. Go file new general. The first thing I want to do is create the objects that I’m going to use for the points instancing, which are going to be two separate trees. With the cube that we have in our scene. We’re going to go straight into edit mode. We’re going to use face select and select that top face. Then it just grab it and drag it up on the z axis. We’re going to scale this down to about here. Then select the bottom face and scale it down, but not as much as the top face. So this is the base of our thirst tree. Now without going into objects mode, we’re going to add a novel objects or another mesh objects, which is going to be a part of this tree. Hit shift i. And I’m going to select cone. I’m going to open up the operator panel and drag it up on the z-axis to about he. Then I’m going to duplicate this cone with shift and day. Bring it down on the z-axis to about here. And hit S and scalar. I’m going to do that one more time with shift day. See to look at to the z-axis dance whereby he and S to scalar. So this is the first of the two trees that we’re going to be creating. Let’s rename it as tree one. Now, I’m going to create my second tree. So let’s move this over on the x-axis. Shift I, create a new cube. The start of the process is going to be designed. Just select the top, bring it up on the z-axis, and scaling. Do the same with the bottom face, but not as much. And now I’m just going to add an ecosphere to act as the leaves of the tree shift. And I select Ico sphere, increase the radius to two meters, and then bring it up on the Z axis to the top. Then we’re going to go into objects mode and rename this one as two. And there we have two different trees that we can use with our collection. Before we go any further, we need to address an issue that we have not highlighted yet. And that regards the objects or virgin. I’m very quickly going to just save what I’ve done so far. I’m going to save it as forest dot blend and click Save as. Then I’m just going to go back to my previous file. And if we take a look at our scattered objects underneath applying, you can see that what’s happening each time we create an instance of these objects. Half of the object is positioned above the plane and half of it is below. And that’s because the objects origin of each of these objects is located in its center. If we go back to our what forest file, what we want is for the objects or gene to be located at the bottom of the tree. To do this, we’re going to go tab to go into edit mode for one of the trees. We can select the bottom face, hit shift and S to bring up the snapping menu. And we’re going to position the cursor to selected this bottom option here. Then go back into object mode. Objects, sets origin, and then origin to free the cursor. Alternatively, what we can do is if we select this first tree here, I’m just going to hit the period key on one number parts of zoom in on it. We can go to options. Choose to affect only the objects origin. In April snapping by clicking on this button here and then selecting face. What I can do now is I can hit G, snap it to the face, and lock it to the z-axis by pressing Z. Then press left mouse. To confirm the new positioning of my objects origin. Go back to options and turn this off and also turn it snapping off. So those are two quick ways of positioning your objects origin at the bottom of your tree. Next, we’re just going to open up the side panel and position both objects on the top of the blender grid. So I’m going to select this one, set the z value to 0. And now what we can do is we can add these to a new collection. I’m going to right-click Add New Collection, rename it as trees. Then position both trees inside of this collection. We’ve now set everything up so that we can begin using geometry nodes. The only thing missing is the plane itself. Hold down shift and I go mesh and create a plane. Then we’re going to scale it up by a value of 20 on both axes. And because we’ve moved the 3D cursor, we’ve moved where the plane is created. Let’s just change the location back to 0. Then we’re going to select each of our objects and just move them off to the side. Bring up our timeline, change it to our geometry node editor, select the plane object, and then select New. Now we finally reached a point where we can begin adding our trees to our ground plane.
85. Create A Forest Exercise The Nodes: In this video, we’re going to be taking the tree objects that we created in the last lecture. And we are going to be scattering them around this plane object to create our forest. In the geometry nodes editor, we need to start by creating a point distribute node. Hit shift, and I go to the points menu and select points distributes. Then position about here. You can see the change made to our plane object in the 3D viewport. Next, hit shift and I again go to the point menu and this time select points instance. We’re going to place the points instance node He just in front of the group output. We will create a bit of distance between the first two nodes and the second two nodes. And then change the type from object to collection. At the moment the plane has completely disappeared. We’re going to turn off whole collection, go to this collection option and select our trees collection. At this point, we are now generating both types of trees. It doesn’t look that great. Oh, we need to make a few adjustments. The first one I’m going to do is I’m going to add a attribute node. So I’m going to add attribute randomize and position he. Then I’m going to hit shift these duplicates and position another one straight off with this first one is going to be for the scale. So I’m going to take type scale where it says attribute, and then press enter. With the second one. I’m going to set this to rotation. Go to where it says float and change it to vector. Then I’m going to take my max value and set it to 0. And then this second max value to 0 as well, because I only want to rotate these on the z axis, which is the one at the bottom. I can adjust the seed at any point to change the effects of that node. So for example, I can take this seed value and adjust where my point distribution is being applied. I also need to reduce this density. So I’m going to reduce it to a value of 0.1 just for the moment. And the variation between the different trees in terms of their size is too great. I’m going to take the minimum value and set this to 0.8 and press enter. One thing that we’re missing here is the plane itself. What we need to do is select these nodes that we have created and drag them up. Move the group output node back here, hit shift, I, go to geometry and select joint geometry node by plugging it in at the end of our node tree. And then taking this geometry output. And plugging it into the second slot of the joint geometry node. We can bring our plane object back into view. At this point, I think the trees are still generally too large and there aren’t quite enough of them for our forest. I’m going to make a couple of changes. The first is going to be to add more control to the min and max values. For this attribute randomized node. We’re going to do that by adding a math node, shift I to bring up your ad menu. Then go to utilities and select math. I’m going to position the first math mode here and plug the value into the minimum. Then I’m going to set the first value to one. Changed the math function from AD, multiply. And let’s reduce this second value to 0.2 and press enter. You may have gotten the idea of plugging this value output into the max input as well. But this isn’t going to give us the effect that we desire. When we do this, we’re going to get much smaller trees, but they’re all going to be the same size. If you take a look from this view here, you can pretty much see that they are the same size as each other. The reason why is because we’re using the exact same value for both the minimum and maximum here. What we need to do instead is just duplicate this node. I’m going to drag it up slightly, hit shift a, and bring it down. Be careful not to connect it to any other nodes like I have here. I’m just going to fix this issue very quickly. And I’m going to plug this bottom Multiply node into the max. Now that’s going to do the same thing as what happened just a moment ago, where we have all of our different trees at the same level of the same scale. But now we can at least manipulate the values in each of these multiply notes. For example, I can take this top value and I can bring it down by a couple of points. To bring down the minimum scale of why trees. I’m going to set this to a value of about 0.7. And so the minimum value for this scale is going to be 0.7 times 0.2, while the maximum possible value is going to be one times 0.2. That why we get some good scaling for our individual instances. Next, I’m just going to close each of these. And finally increased the density. So I’m going to increase this to 0.6 and press enter to see what we get. And I think we can go a little bit higher. Let’s go 0.7. And there we have our forests now, you can go as high or as low as you want. But be warned, in this configuration, you are going to get particle instances that are going to overlap. So for example, you can see we have two trees here. They’re not in the exact same space. But because we’re using the geometry of parts cool objects like these, that geometry is going to be overlapping at certain points if you set the density to high. So think about what density value is suitable for you. That will conclude this challenge on creating a voiced by using particle nodes. Thanks guys, and I will see you in the next lecture.
86. Materials For The Forest: To follow up on the previous two videos where we created our little forest. We’re going to assign some materials and rendering an image. Now we’re not going to be using nodes at all for this, which is going to be assigning some base materials to the plain objects as well as the instance trees. So let’s start with the plain objects. Let’s go to the materials tab and add a new material. I’m just going to set this to Brown’s, press Enter and just set it to a sort of muddy color. So something like, something like that. By the way, you can’t view your materials by going to your material preview for few ports shading located up here, and you can see the color of your separate objects. Next, we need to assign materials to our trees. Now this is much easier than it looks, because all we need to do is assign materials to the original objects. With this first tree, we already have a material created. I’m going to name this as tree and press enter. And I’m going to set this to a similar color, perhaps slightly lighter than our ground plane. So something like this. Then I need to add a second material for the leaves. I’m going to come back up here. Click on the plus button, select New. And then we’re going to name this as leaf. Set the color to, let’s go with a darkish green. And it doesn’t apply to our object straight away. I’m just going to zoom in on the object itself. What we need to do here is we need to go into edit mode for the selected object and select the geometry that we want to assign a material to, which we can do by pressing the elk on the separate islands that we created when we made the object in the first place. Make sure that the tree bark itself is not selected, which is not here because it’s not highlighted. And click assign. This gives that nice green color to the leaves of our tree. Let’s repeat this process with our second tree. We’re going to set the base color to the tree material. Then we’re going to hop into edit mode. And with the ecosphere selected, which you can do so by pressing the arrow key. We’re going to go. This plus button here to add a new material slot. And then we’re going to select, leaf, click assign, and job done. Now if we take a look at the forest itself, you can see that the materials have also carried over to the instance objects. So now we have what looks a little bit more like a forest. I think that ground plane is a little bit to reflexive. So that’s just with its selected come down here and adjust this roughness value. So I want to increase this to about 0.75 and press enter. If you know how to. You can, of course, create much more complex materials that look much more realistic than this. But considering the shapes that we used for the trees in the first place, this is a very low poly scene. So I think the material was on much suited to the geometry that’s been used. When you’re ready, you can take a render of your finished Creation. So if you select your camera and press 0 on your number pad, or press on this button here to toggle the camera view. You can preview what will be rendered when you go to this render button at the top and select when the image. Now at the moment that’s not quite enough of our forest. Because we’re taking a picture of what would appear to be a landscape. One thing that I suggest is to play about with the focal length, which you can find in the object data properties tab with the camera selected. So the lower this value, the further out the shot, so you get more of your forest inside of the render border. The greater the focal length, the more you focus on a specific parts of your forest or objects. So play about with the focal length. See what works best for you. And then when you’re ready, See if you can position your camera by going to this View tab in the side panel. So if you’re here, you can go to view under few lock. You can choose cameras, review. And then as you navigate, you can reposition your camera and change what you’re going to render. So I might want to go down to a bat’s. Here, for example, select my plane and perhaps increase my density just a bit. And then perhaps I’m ready to render. So at this point, I can go to my output properties. The fine that the resolution which you can do here. And you can also come up to your render Properties. Choose your render engine. So between EV or cycles, EV is the much faster but less realistic version, which is probably more suitable for arsine. And you can define certain parameters, such as the render samples, whether or not you’ve got ambient occlusion. So if I just turn off camera view and zoom in a bit, you can see the effects of ambient occlusion underneath the cones here. What I’m gonna do is I’m just going to increase the distance so that it’s much easier for you to see. So you can see we’ve got shadows being created as a result of enabling ambient occlusion. This compared to it being turned off. You can see it’s a much better result. You can also manipulate things here, such as the bloom, which isn’t going to affect the current scene. Or even screen space reflections. Which creates a little bit more of a reflexive property on the surface of our separate trees.
87. Changing The Point Distribute Method: In this video, we are going to be tackling one of the most common issues when we are using point density nodes will I’m going to do here is create a very basic setup using point density. I’m going to add a plane object to this basic seen scaling up by a value of about ten and then hit control a and apply my scale for the plane objects. Then with applying objects selected, I’m going to just set things up in the geometry node editor. And I’m going to add a point density node to the setup. His shift, I go to points and select point distributes position here to create our points density. As we know, we can increase this value. But what we want to do right now is we want to use the cube objects, which we can do by adding a point instance and selecting the cube. Now at the moment it’s too big. I’m just going to select the Cube, go into edit mode and hit the AES key to scale down. Then we’re going to select the plane to make the node setup visible. And we’re just going to use a joint geometry node located here. Connect the outputs to the geometry and purchases so we can see the plane. Now, a problem that we have when using point distribute and point instance is that some of our instance objects will actually overlap each other. If you go back to the scene you created for the forest, you will see this as well with the trees. So there are several instances here where we have two 60ths partly occupying the same space. The question is, how do we solve this issue? Well, at the moment there is one solution to this. And that is to change the random method for the point distribute node. If we take a look at the point distribute node, you will see it is set to random. We want to change the way we scatter the points. So if we open this up, we will see that we have to distribution methods. The second one is Poisson disc. If we were to select a Poisson disk, we get an additional parameter, which is the distance. This represents the minimum distance between our scattered particles. If we increase the distance value even by a little bit, you will begin to see that some of our parts calls will begin disappearing. The reason why is Blender is making sure that certain particles do not overlap each other. Now by going up to a value of 0.4, can you now see any key? That’s our overlapping. I don’t think I can. So let’s see what happens if we increase the density value. Let’s increase it to a value of ten. Even by increasing the value of the density to ten, which is much higher than what it was before. We’re still not getting any overlapping of our instance cubes. If we go even higher to a value of say, a 100, we still don’t have any overlapping. So this method is a great way of making sure that your instance objects do not overlap the same space. Let’s now apply this to the forest that we created in the previous videos. Here, I have my forest with some material supplied and a little bit of editing with regards to the lighting. So I’ve just enabled things like ambient occlusion, bloom and screen space reflections, just to make the overall scene look a little bit nicer. What I want to do here is I want to make sure that none of these trees on goings be overlapping. So you can see why here we have three trees that are effectively overlapping in a similar space. What we’re going to do is select our plain objects. You can see we’ve got a really high density here. So we’re going to go up to the distribution method and change it to Poisson disk, then increase our distance value. Now, this plane is much smaller than the one we had in the example. So with the density sets of 0.01. we’ve dramatically reduced the number of trees in our forest. That means we’re going to need to use a smaller value for our distance. Let’s use point c11 and press enter. That looks a lot better. But if we go so low, you can see we end up with the same issue. So we wanna make sure that we don’t go so low with the distance value that it doesn’t really affect our particle instances because if the instances are too large, 40 distance than it won’t make a difference. Let’s increase this value 2 COO free. That’s making good progress almost there. Let’s go 0.06. And then let’s increase the density form here. And as we increase the density, we get more and more trees. But with our distance value, we are able to continually sleep create our trees, bought a forest without them overlapping each other. I think I’m going to just bring this down just a tiny bit to 0.05. citadel were a bit closer together and increase that density a bit more. So something like 4 thousand. And now we’ve got ourselves a forest where the trees were all have their own space.
88. Using Vertex Groups For Density: The goal of this video is going to be to create our vertex groups to define exactly where we’re going to position our trees on the plane. At this point, all of our trees are being evenly scattered across the entire surface. But what if we wanted to create areas where we didn’t want any trees to appear. There are a couple of ways in which we can do this. And these revolve around the creation of vertex groups. So we create a vertex group in a specific area. Then we define the vertex group here where we have the density attribute. The first step here is going to be to create vertex group itself. We’re going to make sure the plane is selected and hit tab to go into edit mode. At the moment, we don’t really have an awful lot of geometry for the plane objects. So we need to add some geometry. Hit the right mouse button, subdivide and set the value to something relatively high. So 50 cards, for example. That should give us plenty of geometry to work with. Then we need to create the vertex group itself. What I’m going to do just for the moment is go to my modifies tab and I’m going to hide the geometry nodes modifier. Just so we can see the plane itself. Then we’re going to go into top orthographic view by pressing seven on our number pad, or by manipulating the interactive access that you see up here. And then I’m going to go into third text selects, select a vertex. And all I’m gonna do here is I’m just going to hold down Control and press the plus button to expand my view once you expand the selection. So I’ve selected all of these vertices and I’m going to assign them to a vertex group. To do that, go to the Properties panel and go to where it says objects, data properties. The first option you have will be to create vertex groups. We’re going to click on the plus button to add a new vertex group. And we’re just going to rename this as clearing. So it’s a clearing in our forest. We then go into click assign, and this is going to assign all of these selected vertices to this vertex group. So left-click and all of these should now be assigned. Next we’re going to go back into objects mode, go back to our modifier and make it visible. And now we’re going to go to our points, distribute node. Left click where it says density attribute. And we’re going to type in the name of our vertex group. So if you’ll remember, it was labeled as clearing with a capital C, we need to remember that this is going to be case sensitive. So we’re going to use capital seeing for clearing and press enter. Now you can see here that we have been able to position all of the trees or at least as many as possible into this specific area. But that’s not exactly what we wanted to do. We wanted to do the opposite. So how do we reverse this? So that we have all of our trees on the outside of this vertex blue. Well, the fastest way is to simply invert this. And we can do that several different ways. But the way I’m going to show you is to actually go to white paint mode. So here you can see with our clearing vertex group selected, that any region that is colored red or is basically not blue is going to have the trees scattered in that region. What we can do is we can go to the whites menu and then come down to where it says inverts. We’re going to invert the active vertex group. As soon as we do that, the area that was previously read is now blue. And what was blue is now wed. And in real-time, the trees had been repositioned on the outside of this clearing.
89. Using Weight Painting For Vertex Groups: Considering the importance of being able to accurately create vertex groups. And the facts that we have already moved into the weight pain mode anyway, we might as well just demonstrates the second method of creating a vertex group. And that is to use the white paint tool. What we’re going to do is we’re going to add a new vertex group. And I’m going to name this as river. So what I’m going to do in my talk orthographic view is I’m just going to paint a river going down at this side of the forest. You can define things such as your weight value, which is good when sets one, radius is going to be the size of your brush. So we increase this to 100. The radius of the curve increases, but we want this to be around about 40. And we also have the strength. So how powerful is the Brush itself going to be? So these are the values that I’m going to use, 141. Then I’m just going to click and just move my cursor down to the bottom. If I was to hide my geometry nodes, you can see the white painting on the surface of the object. So I’m just going to increase the size of my river, going all the way down. And this is probably easier if you have a pen and graphics tablet. So I’m going to go to about here. And that would do me bring my forced back into view. And then what we can do is we can define this new vertex group which is weaver in our points density node. So from here, I’m going to, instead of using the density attribute for clearing, I’m instead going to use it for river. As you can see, we get the same issue again where it’s basically positioned on the river itself, but we can just go weights and select inverts to reverse that affects. And that’s how we can use white painting to create customized shapes on our textures or planes to define the location of our points, instances.
90. Using Empties For Control Overview: So each scene creation is all about being able to make adjustments in real time and having complete control over your scene. So in the next couple of lectures, I’m going to be demonstrating to you how you can use a different object altogether to control the scaling of your particles or your point instances by determining the location and scale of that specific objects. So what we’re going to do is we’re going to create an object. We’re going to base it in the center of our map that we have here. And as we reposition that object, we can scale up any of the points that are located in the same area. We can increase that objects influence by increasing its size using scaling. The object in question is going to be an empty object. So let’s see how we can connect an empty object to the scaling of the individual points for our forest.
91. Creating New Attributes: To start things off, I’m going to be making a couple of changes to the setup that I already have. I’m going to keep the attribute randomized node, but I’m actually going to change the attribute of this is going to use, I’m going to switch it from scale to rotation. Now, as you can see, this makes a very notable difference with regards to our set up. But what we’re going to do is we’re just going to disconnect these math nodes, select them, and delete them. Then we’re going to change the attribute type form floats to vector. We’re going to position the max value on the x-axis to 0 and also on the y. And for now we keep the value on the z-axis to one. You can adjust the seed if you want as well. Then we’re going to add our next node in the setup. This is also going to be an attribute randomized node. So hit Shift D position and select. With this randomized node, we’re actually going to be turning this back into a float. And we’re going to be setting this to a brand new attributes. The attribute in question is going speed labeled as size. I am going to press Enter to confirm. And this is going to represent the minimum scale of my tree objects. So I’m going to reduce the max value to 0.6, increase the min to 0.4. Now, at this point, the size attribute is one that we have just generated and we created a values for it. He, because of that Blender, does not know what to do with this attribute. So our next step is going to be to tell it what to do with said attribute. Of course, we’re also going to need a second one of these attribute nodes to represent the maximum scaling of the trees. So we’re going to hit Shift D to duplicate and position here, rename this as size B. Set the Min value to 0.7 and the max value to one. Our next step is going to be to mix these values together. We can do this by adding an attribute mixed node located here. We can position is of that the second of these attribute randomized nodes. And actually there are three of them. If you include rotation. And we’re going to position this one. He well, we’re going to do is we’re going to take one of our new attributes and mix it with the other to create the new results, which is going to be our scale. So what you can do is you can hover over an attribute, hold down Control and C, and that will copy it. You don’t get any indicator to tell you that it has been successfully copied. But if you come over to the blank space next to the a input, if you go Control and V, you can see that it pastes in exactly what you copied. We’re going to do the same with size be Control, and C to copy control, V to paste. Then we’re going to set the results to scale, which is an attribute that exists. So press Enter and you can see a small change occurs with regards to our point system located in the free DVI ports. If we adjust this factor value, we are effectively adjusting which of these two randomized nodes is given more priority. So if we set it to 0, then we’re focused purely on the size attributes. If we set it to size be ors, or a factor or one, then we are setting it to size B. For now, I’m just going to set it back to 0.5.
92. Your Trees Are Too Tall: In this video, we’re just going to be covering a very important topic with regards to your point, instances relating to the actual plane that we are projecting them on. And that is the topic of applying your transforms. Now when using geometry nodes the same as using specific tours in the 3D view ports. The behavior of these generated points is dependent on the transform values of the objects that they are applied to. So if I was to go into object mode for my plane objects, then go to the Item tab in the side panel. You can see that the scale is set to 20 times on all three axes. And this is what’s causing the issue with our trees because they are also being scaled up to 20 times their original size. So you think, Oh, okay, The solution here is to just apply the scale. But be very careful if you choose to do that. If you don’t double-check your settings. For example, with my setup, I have a max density of 4 thousand. The problem he is that if I applied a scale, it’s going to give all of my trees the correct scaling. But as a result of that, it’s going to significantly increase the amount of trees on my plane and that could potentially crash blender. So if you’re ever looking at this situation where you’re about to do something like apply the scale. Make sure to double-check your settings before you do so. For example, I’m going to set my density to 10. Just for the moment. Then what I can do is I can come back into my 3D viewport, hit Control and I, and select scale. And I can do so safely with that lower density. Left-click, zoom in. And you can see even with the density value set to 10, we have a lot of trees on our plane. Can you imagine what would have happened if I had attempted to apply the scale for 1000. Even this seems too much. So I’m going to reduce this to five and increase the minimum distance. Remember, we’re using the Poisson disk method. So if we increase this, then it will gradually decrease the number of trees on our playing. Until we reached a point where we have a little bit of space in-between our trees. I’m just going to reduce this value so that we can generate just a few more trees. And that looks perfect.
93. End Of Class Challenge: Congratulations on completing this class. It is now time to finish on our end of class challenge, where we’re going to be assessing the skills that we have been developing throughout this class on using geometry nodes for procedural modelling. Borders challenge. You must complete the following projects. Creates an exam hall with tables and chairs positioned accordingly. Things to consider. Create all objects, including the hole itself, using geometry nodes to some extent, position your objects across your scene using point nodes. Ensure the objects that you creates can be edited correctly in the Modifiers tab for that object. Add materials and lighting to your scene. Both are very important for creating that final result. At other objects, such as a clock on the wall or pencils on the desk to add more detail. And choose modular pieces to create the exam hall. Remember, larger objects can be divided up into modular parts that you can create procedurally using geometry nodes. Complete this challenge by using all of the skills that you have learned in this class. Thank you very much for joining me and I hope to see you next time.