Transcripts
1. Introduction Trailer: My name is ibas Fin. I am a three D
environment artist and I will be your
instructor for this course. In this course, you
will learn how to create procedural art tools in blender and integrate them in unreal engine to
optimize your workflows. These art tools are created
using blended eo entry nodes. This course we teach
you how to create three different tools going
from simple to complex. We will first create a trash
scatter tool allowing you to quickly scatter
various amounts and types of trash
in your scene. Next, we will create a row
tool which allows you to drag and drop ready rods that you can place with help of splines. And finally, we will create an in depth building
generator that you can use to quickly place buildings and customize
them to your liking. Next to this, we will be
using a plugin called Ultims which allows us to use our blended geometry note
inside Unreal Engine. And as a little bonus, we will also showcase
to you how to build environment quickly
using these tools. The general takeaway is at
the end of this course, you will have the know
how on how to create both simple and
complex tools using blended geometry
nodes and on how to use these tools
inside Unreal Engine. This course will not include any asset creation as it is
focused on creating tools. However, we will provide
you with our source files. The geometry node Netix will
be done in Blender 3.5, and at the end scenes
will be done in Unreal 5.2 using Ultims as a bridge
between the two softwares. With a total of 11.5
hours of video content, I feel confident that at
the end of this course, you will understand the logic
and workflows needed to start creating art tools for
your three d environments. This course will also come with auto generated subtitles in English, Chinese, and Spanish. I hope that you will
enjoy this course and that it will have a
positive impact on your life.
2. Part01 Intro To Trash Scatter Creation: Welcome to Fast Track tutorials. My name is Cubs den, and for this course,
I'll be your mentor. In this course, we're
going to create some tools in blender that we can then transfer to unreal. We'll be creating these
tools using geometry nodes, and a basic understanding
of blender is needed. The geometry nodes will
be explained completely. We'll be creating a
trash cater tool. This will allow us
to scatter trash on roads on surfaces and so on. We'll also then using a
tool to create the roads. This will be a procedural tool that will create a
road along a curve, as well as a building tool, which will then be a
bit more advanced, which will extrude
a building from a custom shape you've made and give the floors
amounts and so on. But we'll start simple by
doing the trash cater tool. This will just be
a tool that will be used and seen somewhat
similar to this. We'll have a car, a person,
just for some scale. And what we're going to do is we're going to use some objects, which will be included
in the source files, and we're going to
scatter them across. So we'll have these
small objects, which are cans and
boxes and so on. We'll also then have
some medium objects, which will then be
some clothes and so just to add some variation, and we'll have
these large objects to break the silhouette
a little bit here. I'm just going to increase
this density a bit. We can do this in two ways
we can either subdivide this mesh or we can just
increase the scattered density. We can also then use a
set to move these around. Then some extra nice
features we just want to include in the case
of this sphere, we don't particularly want the
trash to be underneath it, or we don't want it
to be this far over. So we'll be making a Z contrast that you
can just play with. This will just make
sure that the Z amount needs to be high enough for
the trash not to fall off. This will also apply for
something like these gutters. If we just move the Z amount up, you'll see that it
cuts out here as well. You'll still have
some overlapping because we're using
larger meshes. For this, you can just play with a seed just to get that right. Or we're also including a noise, which you can then
just move around. This will just cut some holes in the actual trash just
to add some variation. We'll also then be
looking at solving a problem like this where
the meshes intersect. We'll do this by using
an exclusion distance. This will mean that no trash
can be close to the car, no matter how much we add of it. So if we do that, increase
it by quite a bit, you'll see that that
distance stays similar. And if we move this mesh, it'll then also just remove. So with all that explained, let's get into it and start
with the trash creation.
3. Part02 Trash Scatter: So in this first
part, I'm going to show how to create the
trash scatter tool, but I'm also going to be explaining the concept
a lot clearer, just to make sure that
all nodes understood, all inputs and outputs
are understood, and just to make sure that when we build on for the
road and for the building, you can create any tool, not just the tools
I'll show you. For this first one,
I've just created a scene with three collections, just the small trash, medium trash, and
the large trash. These collections
will be used later, as well as these
two scale objects. But for now, we'll use a cube. I just want to showcase how geometry nodes works for
anyone that's new to it. So in geometrinds, if
we select this cube, we'll just call
this trash scatter, as this will be
the actual object that holds our geometrinoid. It doesn't necessarily need
to be the object we use, but this is just
what we use for now. So in this sra scatter, we'll then say new. This will create a
geometry node for us that will just
look like this. Here we have two things. We have input and output. As well as if you open
this dropbox to the right, there is a group here, which then shows our
input and output as well. So because we've
only got this cube, we've got a cube here
and a cube here. It's just rendering the same
cube that comes in again. So you can think
of this as render. But if we then do a cube here, you can just buy clicking, pressing tab, span object, or if we do a sphere, so if we do UV sphere here, you'll see the same
settings you get with your meshes from the base,
just in here as well. So on this block, there are a few
things to notice. There is mesh, which has
a green round socket. This means single
value geometry socket. These diamond shaped sockets
means multiple values. So it could be something
like one, two, three, four, and five, or it could
be position one, two, three, and so on. Just know that
there are multiple and circles of singular objects. They can't be put into the same one because it doesn't know which one to reference unless you have something
that tells it to. But we'll explain that later. Then for these round ones
here, these mean values. So there are some different
colors here as well. This just means integer, which is a solid number, which is green or float, which is a non round
number, which is white. But we'll worry about those. Now for the start, we're going to just show
what this output does. If I then drag this
mesh by clicking left here and strag it over
to the output geometry, you'll see that now we have
a sphere, but not the cube. This is just because the input here is not doing
anything anymore. If we would want to
get that cube back, we can do a join here and
just join these together. The cube will then be in the sphere because
it is smaller. But if we then say that the sphere's radius
needs to be smaller, you can see how that adjusts. This is just generally how
we work with geometry nodes. It's just a input and
follow the graph on. We'll always read them
from left to right. And there are some things
we can do to clean this up because these
do get quite chaotic. So we could also do a group by selecting both
and doing Control G, which then makes a little group here and just makes
a Na block here, which then transfers
this input into the group through here into the join and out
and combines the sphere. Just a basic run now on groups and just some
things to know. Something else that we'd also encounter is something
like this switch, which on this switch, you'll see that there is
a true and false. And this switch here just
means it's a boolean. So this is false or true. And on these conditions, we can just apply what
happens to the cube. So if we say that
this must be true, click this switch,
once it's true, we'll then show this, and we bring back that sphere again, if it is false,
it'll be a sphere. This is just called
control output, where we can say that this block needs to control
what comes out of here. Yeah, now that we just have a little basic rundown
on how everything works, let's get started with creating
the actual trash cutter. So for this, we'll
just start with the file provided
that'll already have these collections
with the textures applied. Just to make it a bit easier. I'll also provide the
models with the textures. You can assign them yourself, but I don't see a
big need to do that. So we're just going to put this in the geometry
node collection. And call it trash scatter. This will currently do nothing, but we're going to
make that do now. So hide the collections,
and then we can start. So for the input, what we can also do
is if you do object info or create a
let's add mesh plane, and then go back to
the trash scatter. If you drag this plane in, you'll see it makes
an object info node. This is currently
set to be the plane. But if we do geometry out,
it'll just stay the same. But if we hide this plane,
you'll see that one there. But you'll see it's bigger.
Geometry nodes are very upset about object transforms. We have to always just
to apply all transforms just to make sure that it does show correctly in
the geometry nodes. Now that that's the case, we can show how to
do any input here. So what you can do
is left lick on this white box here and
transfer it over to the plane. That'll make a new
block called object. This node or this color here
is just object instance. It's the object without
anything split off. So here you can see we can
get the scale rotation and location from this object
as well as the geometry. But what having it in this
input box provides us is if we then go to the trash scatter into the modifiers
panel over here, you can now see that we have a new box in this geometry
nodes panel over here. If we do an ad mesh sphere, well then go back to
the trash scatter and say that that sphere
must be the object. Within height the sphere, you'll see that
this trash scatter has now become the sphere. This just allows us
to create inputs for everything and have it
be seen by the end user. These blocks will also be
able to be seen in unreal. This is how you communicate your controls to the
person using your tool in the end because we're doing this as if it's used
in a studio environment. You're giving this
to the level artist. He's just putting it down, making some trash
scatter and going on. So we want to make
the inputs as clear as possible and just
think about what we need. So now that that's explained, we'll just go back
to this plane. Make sure that that's
on the trash scatter. And now we'll just think
of how we want to do this. So we've already
got this Geometry. We can make this geometry, this base geometry go
away because we don't necessarily want to use the
trash scatter geometry. We want to always control this. We then just want to call
this ground geometry, just to make sure
it's a bit leaner. So what do we want
here? We want to distribute small assets on this. We want to do medium assets and we want to do large assets. So how do we get
points from this? We could do a points
let's see on points. So you can see points
instances on points. That I'll take the plane away, but we can then put a
cube on the points. So that'll mean that
this plane comes in. We grab the points
from this plane, which will then be
its four corners, and we put a cube
on every corner. We can increase this
naturally by doing a subdivide we
subdivide the mesh, we get all the other
points as well. Point in this case
is also vertices, but we can't really
call them that because there is a way to distribute points on the face that are not vertices as well. But for now, we'll just
do this subdivide, throw an input into there. Call this subdivide. I'll just allow us to
subdivide the base plane. And then we're going to also just go to
small trash cutter. Okay, let's start the
small trash cutter. So if we don't want the
points on the faces, we want to do distribute
points on face. This will mean
that we distribute points randomly on the face rather than on all the points. So we'll take the
subdivided mesh, and we'll push that through. So now you'll see that we get a random assortment of points. This won't have any
objects on them. This will just be the
actual points distribution. We'll move this
just further away. We'll also then do a
control in No control N. So I just say Control J. We'll just do Control J
and make that a new group, right on the group
and rename it. Scall this small trash scatter. We're going to use the similar
node over and over again. But for now, we
just want to have a way of knowing what
we're busy with. So then we go back
to the points, but we now go see the base mesh. A symbol for the solution
for this is just do a switch let's drag these up. So we'll do a switch and say, reveal, let's call
this reveal base mesh. So this will just mean
that if we tick this true, it should just show
us the base mesh. Make sure so we're on a drag so true on a
drag this geometry through to tell it to reveal this plane
once we trigger true. So now you'll see on the
object right to layout. Reveal. So this
needs to be a sorry, this needs to go
into the switch, not into the actual here and
make sure it's a boolean. Because we just want to
input a true or false from the actual base mesh here, and we just want to
go back to layout. And you can see we have a reveal base mesh
that we can just toggle the problem of that
is once we toggle this, it does not allow us
to show both of these. So we'd rather just want
to do a join over here, and we want to drag the
points through to here. So we're then only
toggling the base mesh. We're not toggling
the points as well. So looking at that again, if we then reveal true, we still have the points
and the base mesh. Now we can start our scatter and make sure we can
see the object as well. You can just keep
these a bit more orderly just by doing
this, Control J, rename this just call
this reveal base mesh, and we can just move
this block over here. You want to keep
this a bit leaner, you can also then just, you can move this group output, but it won't be
necessary in this case. So once we've done the
distribute points on face, we'll then do a instance on points and just make sure that stays
on the same frame. For the instance on points, we're then going to want
to do a collection. Collection will mean
that we can take this whole collection and we can actually pick an object out of this collection
to distribute. So we'll just do a
collection info. This will give us
a block similar to the object block that
output instance. So it was our input
instance there, and we'll then also
just create an input dragging that into
the collection block over here and call this small trash collection. We'll then say that
that has to be the small trash collection over here and immediately
of freak out. This is because it's
trying to distribute a small trash piece that's the same on every single
point on this face. We'll drop the density down
just for tasting purposes. And we'll just make
sure that this is on original so that if you scale the plane, it doesn't scale. If we do wanted to pick a different instance
for every point, we'll just to make sure
to separate children, reset children, and we
want to do pick instance. Reset children will
also just mean that if you see in
the small group, these are not all on center, but that's just for
demonstration purposes. Reset will just
mean that it takes their actual origin point and just uses that
as the scatter. So here you can see we've
already got a scatter. It works. It'll have a density. This is a very basic scatter, and it won't do much
else than just do that. So we'll also have to check
if there are any objects that clip so there doesn't seem to be any
objects that clip here. But what we can do just
to make very sure. So we can just do a set
position node here. Set position will
just mean that we can offset all the geometry
on a certain point. Let's height the selection. We'll just do that
at 0.03, a very, very small amount that you
won't really see. It's 0.02. It's just small enough, but I just make sure that we don't have any clipping
with the floor. So how do we make
this not as uniform? Well, what we can do is
we can just do a Eula. This will just kind of
randomize its faces. So we'll do a rotate Eula. We'll then say it's
base rotation is the base rotation of
the points on the face. And then we'll do a
random value over here. Well, then input that
random value into rotate B. This will mean that for
every point it goes 0-1. Actually, we don't
want to use that one. We just want to do random, random value set to vector. This will allow us to just have more control over the
actual values you change. Because the problem is
if we put rotate by that much in here and we do 360, which is what we want to
rotate into all three points, it'll mean that all of
the objects go crazy. We then want to just
move these over to the side and just input
the rotation in here. This will tell every instance on the face how it
must be rotated. So here you can see
the chaos I mentioned, where it doesn't
stay on the floor as we plan the actual assets. We to make sure that the X
and Y axis are both zero. This will mean that only
the Z axis is rotated from a random value of
zero to 360 degrees. We can set this down and you can see how it randomizes
all those objects. The scale is also a
little bit uniform. This is a preference where you would have these objects
scaled correctly, but a nice thing
to do is just to input a random value into
the scale on all three axes. And I like to do just 0.9. It just causes the assets
to not be as uniform. You can see that there's a
very, very slight difference, but it is quite a
nice difference just to make it
look a bit cleaner. So that's pretty much what we want from this
for the moment. So we're just going
to drag that up. Just confirm we've
got everything? So we want two more values here. We want the exclusion
zone one in here still, and we want to be able to
control this density because if we now just go density full, we'll literally just get a
pile that has no meaning. And if we just drag
this plane over. So if you then now edit the
base mesh of this plane, it'll do just that same
distribution on everywhere. So to just make
that a bit better, we'll then start with
the exclusion zone. The thing we just
want to do first is we just want to select this whole small
trash scatter group. We want to do a Control
G. Now you'll see it's in a group and we can then sort
this on its own cleanly. Pressing escape gets
out of the group. We'll then just call this group, naming it here to
small trash scatter. And you'll see that we have a collection input
and a mesh input. These aren't very clearly named. So in the collection itself, we can just call this
small trash collection, and we can just call
this base ground mesh. This will just tell us what
these values need to be. And you can also see
these values from here, small trash goes in here. Base mesh goes in here. And then the reveal base mesh, we can just move to
a nice location. Just move it over
there. Just trying to keep things as
clean as possible. What we can also do is
we can do a reroot. It just gives us one node. If you press that on a block
and you move that anywhere, that'll give you a node
that you can name. So we'll just call this
small trash collection and just put one
over here as well. Making sure they're
lined up. I just makes that we don't have
as many crossed wires, which just looks a bit cleaner. One more thing we can also
just add in here that will be nice is just the
density control. We can just add that in here. To do that, you'll just
click on this input here, not out the group
on this input here. If you go to group,
when you click Add, you can call this small
density make this a float. And just drag this into
density over here. This will be automatically zero because it is a new value. If you want it to just be the
amount you had it set as, you can take that away, drag that through to this density, and just call this
small density. So what we did before is on
the input, we did it here, but if you do this on the group, it still has a value on the
base gomgenes over here. So what you'll
need to do is just drag this line through to
small density over here. That'll then add it to the actual layout to the actual gomgenoes
over here as well, and give the end user
control over this density. What we're going to do next
is we want some breakup here. We have some slight
breakup already, but we still want
to do this with maybe a noise that
just goes through. So to start that we're
going to do a new group, and we're just going to
use a mus grave texture. And we're just going to add this into a group
we're using Control J, and we'll just call
this noise breakup. Just like that. Then we're going to we're going to
use a color ramp. This will allow us
to just control how the color is clamped here. So we just want some darker spots where it's actually dark. We just want it to
be dark. And then we just want to take this color. And we just want
to do a multiply. So just using a math
node, make this multiply. And we want to take
the color in here. You'll see that the line
is not the same color, but the value still carries across. So this is still fine. And then what we
want to do with this is we want to put this into the density factor of the actual noise of the
actual small scatter here. If you go in here, we want to put this into
the value is not here. We just want to change
this to ***** and disc. Because what we want to do is we want a minimum and
maximum over here, and we want to make
the minimum 0.1. The maximum, we want to
make this small density, and then the small factor, we want to call
the noise density. This will then be
controlled by the noise if we then go out of this group, we take this noise value
and throw it in here. Just playing around with this multiply just
to see what we get. This like 100. So we're getting just pretty
much a cut off here. So we're just going to
have to play around with this noise. So in the values, what we're going to do is we're going to make it scale 50, these are nine, one and one. Just play around
with these values. You'll see what you
kind of like over here. Play with a scale, you'll see that this just cuts
into the mesh. What also could
be the problem is that we're not subdividing
this mesh enough. So if we just subdivide two, you'll see that we get a
bit of a smoother breakup. But we're still just getting
this nice breakup that's just not as just uniform
as the other one is. But what we can do just to make this a little bit cleaner, you can add a position here. This will just make
sure that we stay aligned to the faces and that we just get a
noise that's aligned. That's just not as stripy
as the other one was. For this, we're also
then going to do a multiply so math again, we're going to go multiplying. And we just wanted to
add these two values together because we're
just going to be able to add to that position so
that we can offset the noise. So if you then do
this, you add a value. So now they're added together, now you can see we have a offset to make the user be
able to control it. This just moves
the noise around. Stays alged. It's
nice. It works. You can also use a
vector math maybe Yeah. Okay, let's roll through this. Let's use a vector earth. We can input that
value here then, and we can make the user be able to put in a
value on top here. So we can say that
value goes in here. We can call this noise offset. This will allow us to then just multiply whatever value we
put in by how much ever. We'll make this a smaller
value that we don't need 100 times I'll go to 1,000
in the actual node. We can just go to a small
value and it'll be fine. So we're going back to layout. Now you can see we have this
new noise offset node here, or group here, and
we can just do an offset just to make the
noise a bit better to control. Now you can just pick how
you want it to be done. Maybe do one more subdivide if you want to smooth the noise. So something like
this should be good. So you can see we can carve
into the mesh by this now and we'll just clean that up before we
move to the next step. We'll just take this,
make it a group, call this input
vector noise offset. Just do it like that. And the output we'll
just call noise breakup. Just like that, and we'll just call this
group noise break. So now we've got that group. But one thing we
are still missing, and we can just see
that by just going to the plane into Edit mode. And as I do it like this, this is a dirtier way to do it. What we're going to do is change out this object
info over here. We're going to make a
collection with this plate. So let's go new collection
of the plane and call this distribute object. Distribute objects like that so that we can add
objects we want to distribute on rather than
having just a single mesh because otherwise we
would have to go into Edit mode and add
meshes the whole time. We can change this by just
going to collection info, replacing this mesh over here, and then just changing
this ground geometry to a collection and putting that in here and doing instance to mesh realize instances. There we go. Actually, it's just because we haven't defined the
actual collection. So what we're going to do is
you see we don't see it now. We're just then going to have
to go to the modifier panel over here and just set this
to distribution objects. Now you'll see we have
it back on the plane. But if we then go to this
group and add a sphere, add mesh UV sphere, you'll now see that if we
add anything to this group, it'll just be
distributed on as well. You shouldn't move
in object mode. You'll see that the
trash doesn't come with because it
transforms toplid. So we're just going
to scale this sphere up I just move it
out of the way, just to see if we are looks on a non
straight plane as well. So we're just going
to shape this smooth. And we can see we
have some issues. So how we're going to solve
these is we're going to do a Z offset first so that obviously trash won't be at the
bottom of the sphere, it'll only be on the top. We also have some
alignment issues where it rotates over here. So we want to distribute
all this perfectly. What we also want to
do is we want to get the small trash to
scatter correctly first because we can just duplicate this group
over and over again as well. So for the Z offset, what we're going
to do is we want a value how we're
going to do a normal. This will get us all
the face normals, we're going to do
a separate XYZ, plug that into the value. This will allow us
just to take one of them and put that in. We're then going to do
a map range as well. This will allow us
to just control the range better of
what we want to do. Let's say we want a max
of 50, this minimum 2.1. This will just be
the offset we get. Make this 02.4. So I'll go 0-2 0.4
and 2.1 to 50. We then with this value, we can add a new Z
normal contrast. This will just allow
us to define how much of the Z contrast we want or how upward
facing the Z must be. To get these together, we'll just use a Power
dmthnde copower. So the expedent will
be the map range, and the base will
be the Z normal. Move this up to keep
it a bit cleaner. From this power, we're then
going to want a clamped node. So we'll do a math, just multiply that by one
and just clamp it. This will just clamp the value down just to make it
not go too crazy. So this will just
give us the range. Let's see if that works.
So we'll do a math node. This needs to go to the same
place as the noise breakup. So we're going to add
the math node in. We're then going to change
this to a multiply, and we're going to put
the Z influence in here. So now you'll see that we
only get it on top here. And if we then go to here and
just adjust the Z contrast, you'll see that when
we set it down, we can only get upwards facing. Because we clamped the range, the lowest we can get is 90
degrees sideways facing, and we can then specify to be pretty much 90
degrees upwards facing. So just like that.
And now we have nothing on the bottom
of the sphere. And we'll work on clamping these values as a bit
cleaner later as well. Then on that group, we can just group everything
except this last one. We can call this Z normal
contrast, the input. And the output we can
just call Z influence. So just like that. We'll drag this group here. As they multiply together, we just want to
keep them together. To call this group Z influence. Let's get them a cleaner. Let's remove these from frame so that we don't make them
link to the top one. We can call all these into
a frame and just call this breakup So something
like that will work. And now let's see
how we can solve this issue with the alignment. So I think it's because we're aligning the Elet
to object currently. We want to align this to
local. So there we go. Now we have the trash scattered with local so
they're all laying flat, and we can adjust the density. So now if we adjust
the small density, you'll see that starts going
up and it stays the face. If we then adjust
the Z contrast, you can see that that
also starts going less of upwards facing and
more towards just the top. So we're making good progress. We've got this noise. We've got the Z contrast, and we've got the
revealed base mesh. The revealed base
mesh for some reason doesn't work. See why. So on false, it
shouldn't show anything, it's because we have the distribute objects
group revealed. So what will happen is when you're working
in engine or so, you'll assign a plane to it and you'll distribute
on the plane, maybe like this, you'll drag
it onto your road or so, reveal these objects again. So it'll be on your
road. Come on. Select the right
plane. It's quite confusing with
geomogene sometimes. So you'll select it. You'll put this next to your
alleyway or something. Let's extrude this up. And you'll see here we also get that Z control and
you'll do it like that, and then once it's in the
place you want it to be, you can then just
on your geomgnoe just hide the base mesh, and you'll get it and you can replace this
with any models. So that's just kind
of how you'll use it. The next thing we want to work on is the exclusion object. To see that, let's just modify this plane
a little bit more. I'm going to hide the reveal
base mesh for the rest of this just so I can see what
I'm editing on the plane. For this plane, I'm
just going to drag it out only with these
small objects, we're going to test
the exclusion. We're going to use this
car mesh included in the file and we're going to put that right
in the middle here. So here you can
see we're getting a lot of clipping on the car. This could be what you want, but for this exercise, it's
not exactly what we want. So the next thing
we need to do is we need to set up the
exclusion object here. So we're going back to
the geometry notes. For the breakup zone, we want two things ideally. We want a exclusion zone
that's clean around the car, and we want a zone that has this noise breakup in
between it as well. What to start off with, we're going to do
a collection info. Strike that over. We're going to make a new group that will include new collection that will include this car into. We'll call this
exclusion objects. And we'll go back to the
trash scatter and make sure that exclusion
objects is in this collection, which
we should have named. This is called this
exclusion objects. So this will be anything that we don't want
any trash near. So this will be trash cans or whatever in the
road that I fall over, you don't particularly
want things under them. How we're going to do this is
we ideal want to have a ray casting from the normal of the plane and say that if
it hits anything above it, it should not generate a point
under it to distribute on. There is a function
called ray cast, which we'll use for this
that'll just do that. What we're going to do is we're
going to use the ray cast node and we're going to drag this target
geometry in here. So on this is hit, we can output that as
when it hits the car, it needs to do something.
Where do we go with this? This is a Boolean node here. This will tell us
what needs to be selected or what needs
to not be selected. On the instance
distribute points on faces or on the
instance on points, we've got a selection here. So on the instance on points, we're going to input a value into the selection
box over here. Which will then be
the exclusion zone. We'll just call this
exclusion zone. And we'll just do a re root just to make sure
it's a bit cleaner. Just track it over
there. Let's call this exclusion. Exclusion zone. So we've got an input for
this exclusion over here. So this is hit from
the cast we'll take up here into the exclusion zone. Let's not doing
anything just yet because if we think about logically what's
happening, we'll see. So this is an instance
we need to realize this instance that it
counts as actual geometry. Otherwise, instance and
geometry are different things, but still we are casting
this array to the minus Z. We want to cast
this to the plus Z. So now you can see we get a oddly the opposite of what we want because
we're telling it that on this geometry, when it is hit, make
a point over here. So it's instancing where
this geometry is hit. This could be a useful effect, but for this, we're
looking for the opposite. What we can do for that is
we can use a Boolean math. This will be math with
the true or false value. We can just say
that if it is hit, do not place
anything over there. So this is nice. The only problem is we are now just getting it removed from
exactly where the car is. What we want to do is we want to make this car's faces bigger. So we want to extrude it in
all directions so that we can exclude more
things around it. How we're going to
do that is we're going to do the normal. This will be the normal
of this collection info. We're then going
to do a multiply. So use a math node. We're going to use
a vector math node because we're doing
three different values. We're going to
multiply the normal by let's just drag a new
one from the input. We'll just call this input
exclusion zone size. Yes. So you'll see
that it's a vector. We have all three values, but we ideally
don't want that for modifying this in
the actual node. We're just going to
make this an integer. This will allow us
only one value, and we're just going to
say the minimum to zero. So here we're just going to say the exclusion
zone needs to be two, just for testing purposes. And we're just going to.
So we're going to multiply these together so that that two gets multiplied by the normal We're then going to drag
that into the offset. So we need a set position here. So we're going to
set the position of all the normal faces here. Drag that in geometry
to geometry. Just line this up
better. Then this vector will go into the offset. So now you'll see that there
is a ring around the car. So this value is a
little aggressive. What we can do to
just slow that down a little bit is we can add a vector math, multiply by 0.3. This will be only 30% of the
value the person puts in. So we'll just do it like
that. Drag it a bit cleaner. We'll do this multiply, not add. So now, you'll see that
that value is smaller. You will then go back
if we set it to three, you'll see there's a much
smoother ramp up around it now. It's very clean. So if you look at it from
the top, it's exactly the car's outline,
but just wider. So how do we change this? We can use another ring around it by doing another
set position. Not that one, just to get the actual base
geometry back again. We'll take this geometry over here and we're going to
do another ray cast. Just copy this top ray cast, set the target geometry
to be this position again and this ring we
want the full value. Before we multiply it
by the smaller number, we're going to use this
normal vector over here. This will be the larger one
than this as an outside ring. But we don't want just two rings because it'll just
defeat the purpose. So what we're going to
do is we're going to use a muskrave texture, just
like we did before. And we're just going
to set this to five. Let's leave this as default. We're then going to
math these together. So let's add this together,
multiply them together. So this is now when this
plus a noise is hit, then let's do this. So this knot must be away, so we can then do a math here to say that if it
is hit and it is noise, the noise must be subtracted
from the hit over here, so we get a calf into
this shape over here. That should be good. We can then throw this
value into the knot. And then also just
make sure that we let's say this realize
instances from here as well. So let's see what
that looks like now. So if we change this
exclusion object, you'll see that there
is an outside ring, but it is very large. We want to tim the ring
down a little bit. So what we can do is we
can either make that one smaller or we can
make this one bigger. But we'll just take this to the outside ring
and make this 0.5. So just like that, just to make this ring 20% bigger than
the one on the inside. So now you'll see that
there is a breakup, but there's also a
secondary breakup away from the inner
ring as well. That's pretty much
exactly what we wanted. So let's just make sure that
we order this correctly, and we organize it correctly. We'll take this. We'll
group everything in here up to this knot at the
end. We'll select everything. We'll do a Control G.
Now that it's grouped, we can rename these objects. So this normal we called here
was extrusion zone size. So we'll call it that
Extrusion zone size, and the bottom one is called extrusion objects to have
all our objects correct, and the output is
exclusion zone. So now that we have
that, we can just lean this group up a bit
better to understand. We can do a re root on
these two geometries. One going to the bottom. Let's call this bottom
node just outer ring. So we call this outer ring, just so that we know
which is which over here. And we'll just duplicate
that to keep it align. Just relink this. You can also scale these as you do normally
just to align them. And then for the top one, we're going to call
this inner ring. So just like that. Just making sure
that we can follow these graphs correctly. So that looks a good. And we can just put this over here and call this group
just exclusion group. It sounds like
that'll work. Now we have the noise density from
here in the exclusion zone. To make them not look like
they come from the same place, I'm just going to put
them a reroot in here. Just to clean these
up a bit better. This goes up here,
this goes in here. Now we've got a cleaner group. We've got a small density
with the exclusion. At this point, we're pretty
much done with one object. We're just going to do this but three times with some
additional settings. For the medium and large assets, what we want to do is we can actually duplicate the
small trash asset here. But let's just move
these out the way. And this selection needs
to be in this group because we want to ideally stack these on top
of each other. So when we do small,
medium, and large. So you'll see that these all stay the small group
if you click on them. These are all the small group. This obviously not what we want. But if you click on this here, which means there are
three of this node here. If you click on it, it
makes a unique one. You'll see it's now
trash cater 001. We'll call this
medium trash scatter, and we'll call this
large trash cutter. O. So then we also just
want to make sure that we have the same
node for all of these. So the exclusion
zone in all of them. I also just want to
go ahead and just join them together so we
can see what's happening. No, we don't want
to do that yet. Let's
4. Part03 Road Creation Tool Start: In this next spot,
we're going to be creating the road creation tool. What we're going to do
with this is we want a curve that we can edit. So if we edit this curve, you'll see that the road
creates the lines are the same. We have these lamp
posts on the side, some greenery in the middle
and some trees over here. We can also, then this
edit the road width. I'll then modify the lines
and the sidewalks over here. We can modify the
sidewalk width. We can modify how
many trees there are. This is a more complicated
node than the first, so we're going to be adding
quite a lot more over here. We're going to do things like being able to
increase the green zone width. We're looking to create a
mostly feature complete road. So we're going to be diving into a bit
more complex things. We're going to be diving
into how to array along a curve and how to get all of these surfaces
to work together. We're also then going
to working at how to orient the poles and the
benches to the road. You can see that they are
currently intersecting, but we'll also add a
modifier to pull them in so that that offset is also controller bell from
the middle of the road. Jump into it. So to get
started with the road one, I've opened the road
generator base scene, which will give some assets. This will include
the scale asset, the street light, the bush, the tree, the car,
and the bench. Some of these are
placehold assets that we'll replace later in unreal when we do the
production texturing and so on. But these will serve as good proxies for
what we want to do. I'm going to hide these assets, as we're just going to
have to discuss what needs to be done to make
this generator. So what we have is we
have a curve over here. How we're going to do this road is we're going
to take this curve. We're then going
to create a line here and assign this
profile to this curve. So that'll give it some width to then create anything
else but this road, we're going to make a wider one, and then we're going to detract this width from the sidewalk, which will then make the bricks, and we'll just keep doing
that until the end. So we'll then make the
sidewalk on the side of that, as well, minus this distance
giving us just this. This will be a repeated
pattern as we go. As even for the street lights, we're going to then make a
curve that's offset over here, and then we're going to
instance objects on that curve. So there is going to be a lot of repeating of
how to do things. But I'll go through each node and we'll create all
of them separately just to get the way of doing
them kind of ingrained. So to start off with, we need to get the road width. I just erase my lines, so let's get started with it. We're going to not use this
curve as the geometry of the object as we want to give the end user the chance
to replace that. We're rather going
to add a cube. It doesn't matter
what object this is. We're going to
disconnect it anyway. We're going to go
into geometry nodes, call this new, call
this road generator. And then we're just going to go to the same input
we had the first time. We're then going to drag the
road curve object in here, and then just disconnect
this geometry, link this to the
road curve instance, and then just take
this geometry away. This will give us the road
curve as an input here, and we can just drag that
through to output as well. So we just need to say for
a smaller curve here now. So we just want to make sure
that all transforms are applied on the curve to make sure that we get
the same size curve. Not applying
transforms immediately makes jummey nodes break, so we also just want to make sure that that's always applied. So we're going to start off by splitting
the curve in two. We're going to do that
by resampling the curve, which is just something
we always want to do. We're going to make an
input for the resample, and we're just going to
call this resample curve. Okay. That can just be a value
of let's say 32 for now. This will just smooth out the curve, as you can see there. So 32 is just a good number
just to keep for testing. The other node we're
going to use is called curve to mesh. This will make a curve with
a profile into a mesh. This is how we're going
to split the curve into because we're going to
create a straight profile, and we're going to then
profile the curve to that. To do this, we're obviously
going to need a road width. We're going to make
this an integer, and we're just going to
call this road width. Just like that. So how are
we going to draw this curve? We're going to do a curve line. And if I do this, you can see that it creates, I also need to join
so we can see it. So we'll do a joint
geometry over here and we'll join this curve line into it so we can see what the process is. So on this curve line, you can see that if
I increase the Z, it just makes a straight line. So what we want to
do is we want to have a road width over here, and we just want to say
that this road width is a combined maybe
not a combine. Let's see if we can get
away with not a combine. We'll then do the start as the road curve and the end,
see that zero for now. We want to on the y axis, increase it a little bit. So here you can see we're
getting this curve over here. The problem with
that is the start is currently exactly on this width. So if you increase
this road width a bit, it'll offset it. This is because we
didn't separate. So if we just do we can zero them out as well
by just going multiply. So we'll add a vector
math node over here. We're then just going
to say that we are multiplying the width by
one and zero and zero. This will mean that these two bottom values always stay zero, and this value is the
only one that increases. For the other side,
to get the end, we want the road width to affect both sides
at the same time. I'm going to take this
multiplier over here, just duplicate that
and we're going to make this one minus one to get the inverse of this road width to get the
curve on both sides. If we now do a started end, we should have seen a
curve that creates both, but it should still
work on profile. So if we do that on a profile, it'll just create a profile. It'll be broken for now
because it is quite intense. So the value is just too high. So we just want to see to
not make this an integer, we want to make this a float. We want to be able to more finely control this
value over here. And we just want to then
disconnect the curve line from the output as well. Doing that. We also then want to just
bring our base curve in here. So we're just going to add
a re root and just take this base resampled curve as an example curve just so we can see what's
happening over there. What's called this re
root base geometry. So now you can see we have the road curve with a
thickness of the road. This will then apply to
anywhere we move the road. So if I then reveal the road curve and I
move this vertex around, you can see that it just
profiles this curve. If we then extrude it, it'll just take it the same way. So we also just want to make sure if we
need to flip faces, we just want to do
face orientation here. As you can see,
sometimes it doesn't flip correctly because
we are inverting. So in that case, if it does not face
the right way, we can just do a flip faces just to flip that
faces back over here. That'll be it for pretty
much the road width. So we're going to have to keep this node very clean
because we're going to have about 14 of these groups. So to clean up, we'll just
do it after every group. We'll join this a new frame. We'll call this road width. We're then going to do
Control G. Not on that. We're just going to select
everything in here. We're going to do a Control G. We're just going
to name these inputs. So we're going to call
this one base curve. We call this resample curve. And this Vctor is
Roadwith. That looks good. Then we're going to disconnect
this curve over here. There's the base
curve still outside. But then you going to remove
this curve over here. This mesh is then just called road surface because that's the output we'll be
getting from this group. And we just exit the group. We can then just bring our
base curve. Let me see. The base curve, we can then
just do an object info, throw into the object info. Resample curve,
throw that in here, put that into base geometry because we just want
to be able to see what our base curve looks
like as well just to make sure that we're
staying intact with it. And we can just throw the
resample in there as well. We can now just
see the base curve as well as the road surface. We're also just going to call this node group road surface. What we're going to do is we'll duplicate
this group input. This doesn't mean that there
is a different group input. I'll just keep the same
values as the inputs. What we're going to
do is we can then move the road surface down and we can throw's
name the space curve. Reconnect the values over here, and that'll still
keep the group, but it'll keep it a lot better intact than having both
of them over each other. So we'll make a new
frame over here. We'll just call this base curve. We'll group these together, and we'll call
this road surface. Now that we have
the road surface, we can start going
to the next ones. If you want to an optional
thing is you can also reorder these nodes by clicking on these arrows
to bring them up or down. And if you do that, you can
then get something that's a lot more pleasing
just straight lines, which is just a bit
leaner than having the jagged lines as
we did previously, and then just add a
reroot over here just to separate these just so we can
see where everything goes. So just something
like that'll be good. And we can add a reroot over here and call this road surface. Just something like that.
I just keeps it cleaner. For the next one, we're then going to duplicate
this group input as well, separate that from the group. What will be next at our road? The next order of operations here will be to add
these sidewalks. These sidewalks are going to be the road plus a little
bit minus the road. We're then just going to do
the same we did on the road. We're going to do
an object info, just to bring this curve
through to do a resample, Then after the resample, we want to do a curve to mesh. There'll be a uniqueness here where we don't
want just one side, but we want both sides. We're going to have two
curve tomses over here. We're then going to do a
re root in the middle. Link that in here, and we're
just going to pull this up. Duplicate this re root. Let's just call it resample
curve before we do that. We'll call it resampled curve, duplicate that over here
and to the bottom as well. This will allow us to follow
the base curve a lot better. We're then also
going to just give ourselves some space over here. Just by moving this down
from the road surface. We don't want to get too
tangled in the nodes here. So for this width, we're going to need a new input. We're going to make that
under the road width. We're going to call this
sidewalk brick width. This will be because it's just the bricks between
the road and the sidewalk. I just a bit clearer named. We're then going to calculate this width by doing
a combined XYZ. Let's just make this is a float. The combined XYZ
also just allows us to separate the one
value out of better. It's super relevant
for the road. I just works better for
the sidewalk over here. We're also going to have to make an output
for this group. Let's join just so we can
see what we're doing. We'll join both
curve to measures, and we'll just take
that into the top join. The output can't be duplicated
the same as the input, so we always have to go back
to the source for that. Back to this. Combine XYZ. We're going to take the
sidewalk brickwidth. We only want to
do this on the X. And then we're going to need to have the road width as well. So add that same math
multiply up here. Let's do a vector math. So vector math, and we'll do road width in the
positive direction. So the bottom curve will be positive and the top
curve will be negative. We're then going to
add these together. So we'll use a vector math. So we're getting an
output vector here, which is just the X is the value of the
sidewalk brick width, which will just push
up a little bit. So here if you hover
over the node, you can see that
that's 1.39 null, which is the value
of acidity and 00, whereas the road width
is the same in all, but it outputs then just
the same in one on the top. So we're then going to
take the road width in the top and we're going to take the sidewalk
width in the bottom. And then we're going to do a curve line on the curve line, we want to make it start
where the road width ends and we want to make it go as thick as we've set
the side rock brickwidth. So we can say start at
what the road width is and end at what the
added values together is. This just gives us the width
of this plus a little bit. We're then going to
take this curve line into the profile
curve over here. So that offsets it
by quite a bit. Let's see if that's the sidewalk brickwidth we've got set here. This needs to be a
multiplier. That's the issue. So now you can see what's
happening over here. Again, you can't
see it very well because it's linking
to the road. We just to make sure that we
can't go negative with this, we'll just make the minimum negative zero here
on the group input. You can see that the
road is increasing, so it's increasing the road
width on the one side. But we want to obviously
have this extruded. So what we're going to
do is we're going to add a new input called the
sidewalk brick height. And then on the sidewalk
brick height on this mesh, we can just do an extrude
mesh on the bottom curve. And we can bring this sidewalk
brick height all the way through and say that that needs to be a
little bit higher. Set this to not be individual because we don't want
that to be individual. Use a re root just to pull this brick height away so
we can see where it is. Call that sidewalk brick
height, duplicate it over here. Let's pull that through. Now we've got a bit
of a raised sidewalk. Its shading is a little strange. So what we can do is we
can do set shading smooth. We can just say, don't
smooth the sidewalk. It's about unticking
shades smooth. That just means that
do not do this. So that gives us
the one direction, so we can adjust the height. We can adjust the width. Sometimes when you adjust
the width too high, you'll see that it
does actually just cramp the road here and
it does make a line here. It's not super
visible. It's just with the face orientation
that you can see that, but it is also a
point of if the road gets to go negative across
each other, it will intercept. So it's something we
just want to avoid. Then for the top part, we're going to do
this but invert it. So we'll duplicate this
curve line over here. We're then just going to
duplicate this operation. Let's create the
operation from base. So we want to do
as we want to do a negative of these values. So the width will go
into a combined X Y Z. But we want the negative. So we want to do a math. A multiply, multiply by minus one to get
the negative of this value. Then we're going to grab
the road width over here, grab this math node, put road width into it, change the multiplier
to minus one. We'll then do the add
at the bottom here. Duplicating the vector math notes from the bottom.
It's easier that way. So we want this to go from add I'll add the road curve together along
with the negative of this. Again, we're just saying
that its end point should be the rot curve plus whatever
the extra is over here. We then just want
to say that end is from this ad and the start
is from the top multiply. Clean this up a little bit and we're just going to move
this to a better place. And then just say that that
profile curve is this minus. So you can now see
that we're getting the same thing we do the
other side, but inverted. Because we're inverted, we're also having the issue
with flipped faces. That's the reason
we want to have the face orientation
on the whole time. It's just a lot easier to troubleshoot with it on rather
than doing it at the end. We'll then duplicate
this extrude. We don't necessarily want to extrude both measured
at the same time. We just do them individually. It's just cleaner that way. We'll do a re root on this. So it'll be the
sidewalk brick height that we'll just
transfer to the top. So you can just make
a re root there, duplicate that re root, link them together,
link them over. So now we have the same
height on both sides. We're also having the same
smoothing issue on the top. We'll just duplicate
this node and just shade smooth no
on the top as well. And we'll always
just make sure that we're not on individual faces. So now we can do the
sidewalk brick width, and you can see
that that increases the sidewalk brickwidth. So the sidewalk brick height, you can adjust that as well. And that's pretty good. We'll then just move
this out of the way. We'll do some cleanup
operations here as well. So I think the sidewalk
brickwidth is quite clear. But we'll call this just so we'll join this
in a new frame. We'll just call this
positive sidewalk and call this negative sidewalk. And then these will just
be the sidewalk mesh. So we'll just select
all of these. Join a new frame. We'll just call
the sidewalk mesh. And these two here. Join a new group. We'll
just call this base curve. So our inputs are all
correct over here. Our output will be one thing, which will just
be the sidewalks. We can then select all these, do a control G, just to
group them together. It doesn't keep these names
from the input group, so we'll just have to
rename them again. So just name the
object one base curve, name the count just
resample curve. The vector will be road width. And then for input and X inputs, just confirm what they are. I figure out the group, you can just see what they are. So the X will be
sidewalk brick width. And then obviously the top one will be sidewalk brick height. So the order is
wrong here as well. So we'll just reorder that a
bit just to keep it cleaner. We're going to do
this at the end again just because
we're going to sort the whole group out just to make it
a bit more legible. It just helps to see. But for now, we just want
to keep these notes clean. So we just want to do
something like that. And then the height needs
to be at the bottom. So we have straight
lines here as well. We then want to
expand this group, just call this sidewalk bricks and just name its output
sidewalk bricks as well. And just join it in a new
frame called sidewalk bricks. So we'll add that to the
stack on top as well. To avoid confusion,
which you can do here as well as
these input nodes, we can change their color. If you go to node, tick color. You can only do one at a time, but we'll just say that the input here is
always dark blue. I'll color dark blue and just do the same for
this one, color dark blue. So the other thing
you'll see here is even on the road surface where
we've connected these on top, but we have extras here at
the bottom now as well. We'll have to reset
it for most times. Every time we add one,
it'll add a new one. But we can do a Control
H or in my case, control shift H because
I'm an industry standard. This will hide any
unused nodes over here. So to collapse these cleaner, we'll just do a
collapse like that, and now we can just
see only the values relevant to these
nodes themselves. We'll then just make sure that we have a join for all three. Moving them into place. I'll duplicate this re root, and we're going to just call
this one sidewalk bricks, just so we know what goes
into the end product. We'll do a scale by X
and zero just to line these Then we can move on to the actual sidewalks on the side of the
road here as well. We can then add
for the sidewalks, we're going to add the road plus the sidewalk bricks
equals whatever it is, as the start point, then the end point is the value we add as
how thick they'll be. I make this curve a bit
nicer just by moving, having a bit more of
a straight over here. So we'll do an
extrude, just by Y, just to have a
straight leading into a straight because we're going to have to confirm that things are the same heights
and stuff as well here, just keeps it a bit cleaner. So we're going to then move on to the sidewalks themselves. You're again just going to
duplicate this group node. We're going to do a remove from frame we'll start
with an object info. We'll link the base curve
to the object info. We'll add a resample, drag this resample
curve in here. We're also going to
do curve to measures here because we're going to do a negative and
a positive curve. We'll just keep that the
same for all of them. We're then going to
do a reroot again. We'll call this
resample to base curve. This is going to be
a lot of this of just recreating kind of
the same node over again. We're copying it
just to get it a bit more ingrained and just
to repeat the operation. So we have the positive or
negative curve over here. Well, then just drag this away to give ourselves more space. So what do we want here? We want a flat curve that's road width plus sidewalk width
equals whatever this is. So we want to do an add so we want to do
a math operation. I want to say that
the road width plus the sidewalk brick width, as we're just
dealing with width, not height at this
point just yet, is then victimth multiplied by one, zero, zero. We then want to add a new
input called sidewalk width. Sidewalk width needs
to be combine XYZ. So if we go to combine XYZ, the sidewalk width
goes into the X. We then want to do a curve
line and distract these away. So the curve line will then be the sidewalk
width on its own, will be the end and
the start will be. We can do a vector math
just to add these together. So we'll do a vector
at the bottom, and then just add the road with that as well just
to get a better value, just to keep it consistent
with the previous one. If we then increase
the sidewalk width, we won't see anything. We're not linking this in yet. We'll just apply this
to profile curve, and we'll do a join geometry. We want to join in the
groups just so we have one output as well just to
keep things a bit cleaner. And then we want to drag
this join all the way up as well this join into the output. So now you can see we have
a sidewalk width over here. Let's just do the
go into view grain, and then just show
cavity for both. This will allow us to see
the sidewalk a bit better. With the sidewalk width, you'll then see we increase
the sidewalk width over here, and that line starts and
ends where the road is. So we have a gap in
the middle here, but it starts where
the sidewalk and road ends and goes out as far as we wanted to go
out over this side. We'll then just duplicate
this to the other side, put that into profile
curve over here, but we'll make the math
over here minus one, and we'll have to re
input these values, road width on top, sidewalk
brickwidth at the bottom. Then for this combined XYZ, we're going to do
a sidewalk width. But we're going to add a math
on the sidewalk width line, and this will be
multiplied by minus one. So multiplied by minus
one to invert that value, and we'll just drag them away to not intercept the other line. So now we have the same we
had with the sidewalk bricks, where we have a positive
and a negative line. We'll then just join
these in a new frame, call this negative sidewalk, and the other one we'll
call positive sidewalk. So join in frame,
positive sidewalk. And we'll just call these
two nodes, the base curve. That's out. Okay sorted. Now the next problem
we're going to have is obviously the flip. So we'll do a flip
faces on the negative one to make sure that that's
the correct facing way. We don't want to
do an extrude over here because it's not necessary. But what we do want to do is we want to not have this
at the road surface because the bricks will raise and the sidewalk width
will be up over here. We're going to give
the user control over how high this tiles
width is here. While tiles height is over here. So we're going to input and call this sidewalk tiles height. And we're then going
to do a set position. A set position will allow us
to control how high this is, and we'll just do this
on both sides as well. What do we want this
position to be? We want this position
to be a math node, not a set material, a math node. This math node, let's duplicate the group
input we do that in a group. We'll have the
sidewalk tiles height. Plus. So at the
bottom of the ad, and at the top of the ad, we're going to have this
sidewalk brick height. So we're going to have the brick height and then a custom value
input here as well. We'll move this ad over
to the side a bit, join it in a new frame, call this height, calculate this will just calculate the height of the sidewalks that
they need to be. We're going to add a re
root, join that in here. We'll call this sidewalk
height in the re root. And we'll just do a combine XYZ to have this only in the Z because we don't want to offset
it somewhere else, we just want to go
into the Z vector. Then this vector
we can link into both offsets in the
set position node. Let's do a re root over here. We just call the
sidewalk height as well. Sidewalk height Y Z because it's just the Z vector
of the sidewalk height. And we'll just clean
that up a little bit. So now, you'll see that the sidewalks are the
exact amount here. And if we adjust the
sidewalk brick height, you'll see that they just
go with the sidewalk. But if we adjust the
sidewalk tiles height, you'll see that they then go down as the
sidewalks go down. So what we're going to
do as well is then in the main group output by
selecting the group input node, going to group, we're
going to make sure that this sidewalk tiles
height cannot be positive. So we're going to make
the maximum zero. That'll make sure that if
we go all the way through, the maxim is only going to
be on top of the sidewalk. And then if we go down, the negative will be
down the sidewalk. We're then just going to group all these together in a frame. We'll do a right leg
joint end frame. We're just going to call
this sidewalk mesh. And this node here can also just go into
the height calculate. So we're aware of what that
whole operation over here is. Just straighten out some
lines here to keep it clean. So that does it
for the sidewalks, we're then going to
take everything, create a group, make sure that these inputs
are named correctly. So base curve, resample curve. But and then we just want to pull these closer to each
other so we know what their names are and
what the inputs are. So we have road width
at the top, road width, then we have sidewalk brickwidth Then we have sidewalk width. We then have for the bottom two, we have sidewalk brick height
and sidewalks tiles height. And then we just want
to make sure that the nodes are sorted
correctly again. So we want to do
the base curve on top with the
resample below that. Then the sidewalk brick
height needs to move up one. Then we have straightened
lines over here again, and we're going to call
this output side walks. We want to join these two in a group, call this sidewalks. We just want to remove or rename this node
group here as well. Name this sidewalks. Let's make sure
that these line up just for some cleanliness. We're then going to add
a re root here as well, and we're going to
call this sidewalks. Just like that and make sure that all
these nodes line up. So just double checking
on both sides. So now, as a test, we always need to do is if
we adjust the road width, the sidewalks go with, if we adjust the
sidewalk brick width, the sidewalks go with, and if we adjust
the sidewalk width, nothing comes with because the sidewalks are the
last node we've done. If you adjust the height,
the tiles height, it goes down on the sidewalks. If we adjust the
sidewalks brick height, the sidewalks themselves
come with as well. So we're making good progress, and we can start moving to doing some of the arrays
down the middle and so on. But for that, we're just going to do a simple array. We'll
start with the trees. We're not worried too crazy about the
scale at the moment, but we can just
make this curve a little wider and we can add
some cars at the moment. So here you'll see
we're just getting a intercept over here where the sidewalk width is going in and the curve resample
looks a bit dicey. So change the resample to 64. And we're then
just going to move this note over here at the end, just a bit further away. So isolating the road curve, going two points, and just
widening this turn over here. We can move one away
and keep one as the corner rotate it a bit
and just make that wider, just so we have some more
room to extrude and so on with because I think the road might be a bit
thin at this point. So I just want to make sure it straightens out towards
the end, as well. So something like that,
and just straightens out. Now we've just got a
more gentle curve. We'll then select the cars group and then just add some cars
into the road for reference. I'll just add one
on either side. This is not to look good. It's just to give us
reference on scale. We'll also then reveal
the scale object and just make sure that
that's also on the road. Reveal its body. Using the unreal engine
character here as well, just because then we know
what the scale and Unreal is also tuned to makes
life a bit easier. The sidewalk brick height, we're then just
going to drop down a bit because it's quite
high at the moment. So something like
that will be perfect. And then for the next one, we're going to start putting
trees in the middle of the road because we'll have a green zone down the middle
of the road here as well. 30 start trees. We're just going to
duplicate this group input, remove that from frame again. Then going to do an object info. Track this space curve in here. So this is going
to be the same as we did the trash,
but just on a curve. Resample here as well. Strike this resample in here. To we're going to do
an instance on point. So instance on points over here. So what we can do
is this resample. Let's change this out for
a control over the tree. Let's add a integer called
tree amount over here. So tree amount needs to be an integer because you
want round numbers. We don't want any
decimals afterwards. We're then just going
to add that into the count over here. Let's give ourselves some
more space over here. We're then going to have a
collection for the trees. So we're going to have to go
here at a collection info, add these instances into
instances on points, and then we're going
to make a new group here called tree collection. Currently, I just have one
tree in the tree collection. This doesn't matter too much. It just allows for more
trees to be added. If you just add one
tree, it'll just be one, but if you add more trees, it'll cycle between the
different types of trees. It just gives some more
flexibility to the end user. We're then going to put these points into the
points over here. So we're instancing on these points the trees
that come from here. We're then also going
drag this instance the output over here to the joint geometry output
we have over here. Let's see, our tree collection
is currently blank. We want to change that to trees. We then want to change
the tree amount to how manver we want. As you can see, if you
adjust this tree amount now, you'll get more or
less trees as you go. Now you can have final
control over those trees. We can then do a random
value over here, and we can just use
this for 023 60. We can do a rotate Eula
so we can do a rotator B, but we need to do a combine
XYZ so that we can separate this into one value and we
want to rotate this on the Z. Then that'll be rotator
B and we'll do local. So if we plug this
into rotation, let's see if that worked. So I'll change this a bit. So it's rotating around
a different axis. Let's check the tree's
axis over here. And this tree axis
is in the middle. Let's try a normal into
the rotation over here. That would work. Just make
sure that the tree is applied. So we'll just do object apply
all transforms on the tree. So it is off center. So we just want to put that back in the center and do it object, apply all transforms, its rotation is
directly in the middle. So if we adjust the
rotate, it'll work. So just delete this normal node. Well then group all
of these together in frame and just call
this random rotation. And this can just be tree mesh. Let's call this tree array. And then we'll see
what this looks like. So we'll hide the original tree. So now we have some random
rotation in these trees. That just rotates on the Z, and we'll just keep that to 360. We also then just want
to make a random value from 0.9 to one and just
put this into scale. This will just make sure
that all the trees are on the exact same height just to make them look like
different measures. And we'll just join this in a new frame called
this random scale. And that's all we'll
need on the tree group. So we'll then group all
of this, Control G. In object, we'll call
this base curve, call the count tree amount. We didn't put this
random value in. Let me just select that as well. Just make sure we
select everything. So count is tree amount. Object is base curve and the collection will then be called the tree collection. The output for this group
is then called trees. We just want to confirm that
that's all correctly linked. The base curve can
move one up and we can do a Control H here
just to hide this group. Now that we've done
that, we can name this node group trees and we can just join this in a new
frame and just rename the two trees and slot
that into our stack. I'd like to make sure
that these frames line up to keep things secure. Clean, sorry. I'll add a reroot we'll
call this re root trees, and that links all the way up. Well, then just zero all
these re roots as well. And now we have
trees on our road. So if we then increase
the road curve, you'll see that the amount
of trees stay the same, and we'll need to increase with how much longer the road gets. But they are working they are not affected by
the width of the road. So we can just confirm that. If you resample the curve,
they aren't affected. So it just gives us a right
amount of the trees we want. For the next one we
want to do is we want to make the street lamps. These are a little
bit different than the trees because to have the trees in
the middle is very easy as we can just
use this base curve. For these street lamps, we have a bit of a
different problem. For these street lamps, this
curve needs to be offset to the side and make a new curve
over here and over here. So what we'll have
to do is we'll have to split this curve in two, but we can't do it
the same as we did the sides over here because
this gives us a mesh, and this mesh would
have a point over in this corner and
in this corner. On the curve, we're looking
for a scentered point. So we're going to have to
find a different method to separate the curve into two different curves
rather than into a mesh. So how we're going to do this is by using a bit of a
different function, so we're going to just duplicate this group input,
remove from frame. We'll then do a Control Shift H or a control H in your case. We're going to need
two object infos for this because we're going
to need the base curve, and we're going to need
a collection info, not an object info, and we'll call this street
light collection. So I just call this
street light collection. And here we can just assign
this to the street light. We again just have one
street light currently, but if there's a need to do broken street
lights and so on, we'll just give the opportunity for the user to do that as well. So for first, we're
going to try to find out what this street
lights position needs to be. So the street lights
position is the road plus the sidewalk bricks
and a half of the sidewalk. And then we want an
offset over here. So we're going to
start by having a math with the road width.
5. Part04 Road Creation Tool Finish: So we're just going to
for the white lines, we're just going to first just collapse this
benches group. So how are we going to
do the white lines? So the white lines is essentially
what we have over here. We have a line that we can either make this line and then
boolean into it, which is a smart way to do this. The problem with that is
the Boolean operation takes a lot of processing power. So let's think of the
inverse of the lines. These lines are flat
squares on this surface. So if we distribute these poles this way and
the benches this way, then we can just also do the lines the same way as
the poles and the benches. So let's grab this bench
a group over here. I'll duplicate all
three of these. Make sure to click on
this two over here. We're then going to
call this white lines. And what we're going
to do is we're going to disconnect this
bench collection. We're going to control shift H, and then we're going to make
two new ones over here. So it's going to be right let's just make sure
bench offset needs to be roadr what's called
it white line offset. And the bottom one
we can then just call white line in
between distance. So we'll do that. Now we've got a white line
group over here. We'll name the
group white lines. We'll go into it and name
its output white lines. Go out of the group,
create a re root, name this re root white lines. It's solid, make
sure it goes all the way to the top into this join. Then what we're going
to do is we're going to rename this selection. We actually want to
remove this selection over here, the selection one. We then also want to remove the sidewalk
height over here, as well as the street
light collection. I want to take the street light collection
completely out of here. And then just take the sidewalk height out of the end here. Remove this combine, link the joint geometry
just to the end, delete this height offset. Actually, let's keep the
set position just for now, but we're going to
set it to 0.01. This is just so that the
road lines don't clip. You'll see why that's
relevant later. We also want to
keep these aligns. Here, what we're going
to do is we just want to have these dual curves, but we're going to
instance cubes on them rather than the
selection we had before. We're then just going to
call this line amount. We're not going to play with
the selection too much. We're going to just
delete these selections. For these parameters is
going to do a endpoint not. So for the selection, that's just endpoint selection,
Boolean math, Boolean math is not, selection into Boolean math, and then the selection to the selection of the
instance on points node. So just something like that. This just means that we
don't have the endpoints. You can join this new frame. Just call this selection. Okay, so then what do we want to instance on these points? We want to have a cube, so we'll create a cube by just
doing tab and go to cube. This mesh goes into instance. So now it says this
mesh is not instance. We'll just confirm
what the instance is. Realize geometry is not used when picked
instances is true. So what we can do is we can
do mesh to instance. No. Seeing it could also be freaking out because
we picked instance Titia. Oh, yeah, we'll just
take instance off. So you'll see our distance here is also quite weird
at the moment. Our distance is now the same as the benches because we
took the benches group. So we'll go into the
benches offset by distance, and we want to recalculate
this distance. So we'll delete all of
the math we've done here, or then call this
white line distance. And this white line distance
would be, let's see. If we take the road width
and divide that by two, we should essentially have
the lines in the middle here. So what we'll do is we'll
add a math in this group. We'll then take the road width, we'll divide that by two, and let's just put that
into the Z over here. We're having the same problem we did with these street lights where this value seems
to be not big enough. Let's just try a math,
multiply not lamp. Let's multiply by 28 as we
did with the other one. Not sure why that's an
issue with this road width, but 28 seems to be a correct value. We'll
just keep it there. That seems correct.
Now you'll see the lines are in the middle
of the road on this side. We're not generating
both curves. That's because this mesh
is not currently on both, so we'll add a re root. I was going to call
this re root line. We're going to
duplicate this up, remove it from the bottom frame, and then just instance that
on the top curve as well. So you'll see, we have these lines in the
middle of both roads. And we're just going to add a math here in the
front as well, move this value to
the bottom line, and we're going to input
this offset distance. White line offset distance
into the top of this ad. So now when this
distance is at zero, it is in the middle of the road, and it should increase as
we increase this value. So let's see, white line offset. So that then offsets it
to positive and negative, although we would want
this one to go negative. So in the group, let's just see if this white line
offset is negative, we should just make
this, be able to go negative, how many ever. Now the white line offset
can go inwards or outwards. What we're also having is
these lines are extruded up to change that, we can just make these
lines look a bit better. When they need to be longer, we can make the X let's make a give X one.
Let's make the Y two. So see they're a bit longer. Let's make the X a bit less, and the Zs will be zero. This will just give
us a base flat curve or base flat cube, but this will still be a cube. So to avoid that,
we're just going to do a merge by distance. This will just merge all
of that geometry into a single point or a
single flat plane, and the faces are flipped. So we're just going to add a
flip faces in here as well. So something like
that looks correct. You'll see them very slightly,
but you will see them. If we select it, you'll be
able to see them the best. So this is currently on
the resample curve amount, which is good, but we don't
want to use that to increase. So what we're going to do
is we're just going to add a math on this base
curves resample. We're going to do an ad with the but we didn't rename these. Let me just rename these to white line offset
at the top here. And the white line
in between distance. So that'll be fine.
We'll just remove this benches collection.
The rest is correct. So this white line
in between distance, we're then going to
put into this ad, and this will resample to
have more or less lines. We're then going to make this
able to go negative 100. Now if you go negative lines. We can't add a negative here, but we can have more lines here. So now we can change the
spacing on these lines to be closer away or
closer to each other. We'll make the default to be a bit smaller lines so
you can change them. So something like
that looks fine, let's just compare
that to the cars. They might still
be a little thick. We're just going to
scale them down a bit. You could add controls
to scale these as well, but I don't find
that very necessary. We're then aim to join
this in a new frame and just call this white lines. And the output is already
called white lines. So that's pretty
much this group out. Now we've got white lines
that we just need to texture, but we'll do the texture on
everything at a later stage. We just want to get the
nodes working for now. We also want to confirm that they're running
parallel with the road and they're not
curving in wear directions. We also want to see if we change the road width, if
they change width, which they do, make sure if
we change the other values, they don't change, which it
doesn't seem that they do. The resample will affect them, but that's just because the road lines get closer
to each other. So now we can move on
to the yellow lines. We'll just collapse
this white lines group, just to have everything only relevant to the white
lines in that group. For the yellow lines,
we can then just do, essentially what we
did for the sidewalks. We just want to have that
inset into the road over here. So we're just going to
duplicate this group input, remove that from
frame, expand it. We're then going to do an
object info for the base. We'll just throw the
base curve into there, or then do a resample. Just link that over
there. We're then going to just create a re root. Just take that all
the way through. Then going to create a positive and negative curve to mesh. Curve to mesh, and you get one at the
bottom and one at the top. We then just going to call
this resampled baseline. Resampled base curve just
to keep it consistent. Duplicate this. Do both sides. And then just link
that to the curve. Then we just need to
work on the profile. But first, we're
just going to do a join just so we can see what
we're working on as well. So we're just going
to do that join. Now that we have that,
we're just going to move it a bit further away. What do we want to happen here? We want a white yellow line
thickness that we can apply, as well as a distance
from the pavement. To do that, we're just
going to do a math stack. So we're going to
do a math node. We're going to add the Let's
just see how this works. This is going to be the yellow lines distance from pavement. So we're going to then
let's get the width first. We'll do a subtract math node. The distance of this will be the road width minus the
yellow line thickness. So we're aiming to add a
new node on the input here, we're going to call this new
node yellow line thickness. This will be as wide as the rod minus whatever
this value is. There's going to
leave a default 0.5. We're then just going to do
a Let's do and a math add, and we're going to add the
distance from pavement. This is going to be the distance that we need to be
away from this point. So we're just going
to do an add. And this new value we created, which is going to call yellow line distance from pavement. And then we're just
going to split this curve as we've done before. So let's start with the
positive line at the bottom. So we're going to do a math, to a vector math in
the vector math, we're going to drag this yellow line position
which this will give us because this is just where the yellow line
will be placed at the end. So we're just going
to grab that in the top because this
depositive line, we're just going to
multiply that by one, multiply the middle by zero. We're then also going
to do a combine XYZ. This is to define the
thickness of the line. We're going to use the
yellow line thickness in the X over here. We'll re root that
yellow line thickness over here is to keep it cleaner. Y a line thickness in there? We're then going to do a math. I need to do a vector math. And we're just going to
add these values together. So this will give us the
end point of the line, and the top line will
give us the start. So we're then going to do a
curve line to get a profile. So just move all of
this bath up over here. So the end line will be after the add because we've added
the thickness here as well, and the start will be where
we want the curve to start, which will be the top line. This profile curve
will then go in here. And then let's just make sure
we have set a thickness. We've currently set
a thickness of 0.5. So for testing purposes, I'm going to do a set position, and I'm just going to push
this up in the Z by one. Well, then add the
join geometry in here and we'll carry this geometry
all the way to the top. So just like that. So
let's see what happened. So we're quite a bit off here. Let's see if this
is the distance from pavement that's causing you that or if it is the thickness. So let's set the
thickness to zero. Let's make a small value. The distance from pavement
will set to zero. So this broke the line. So let's just troubleshoot this. So the road width and the
yellow line thickness, let's just input the
road width straight. That then still just
gives us a curve that is offset to the wrong side. Where's it seeing. It seems to be because this
is on AD and not multiplier. There we go. That
was by mistake. So we can set the
thickness up again, and the distance from
pavement should then be where this offset
on the pavement, so that will drag the line
forwards and backwards, and the thickness will control
how thick this line is. Let's see. Ideally, the
distance from pavement, if it is at zero, we want it to be in line with the pavement. Let's just increase
this offset over here and we'll just go into wire frame just to
see this line a bit better. That doesn't help
much. It's fine. We'll just do this. We'll
actually offset it to negative. Let's just do this. And we'll just here we can see the line. At zero distance from pavement, it is on the side
and at positive, it goes away from the distance. That's not what we want. We want the distance from pavement
to be if it is positive, it is further away
if it is negative, it can't go negative because
that's against the pavement. If we're going to do a math after the distance
from pavement, we're going to do a
multiply by minus one. So now if we do positive
distance from pavement, we go further away
from the pavement. And we're then just
going to go to the group input and make this yellow lines
distance from pavement, not capable of
going to negative. So the positive will
take it further away and the negative
will not go into that pavement. That
seems correct. And the thickness
then adjusts to the inside of the road,
not to the outside. As we did with the white lines, we're going to make
this offset 0.0 102, just to not get that clipping
on the actual mesh as well. I was going to go just into its skeleton view so we
can see this line clearer. So this distance from
Pavin is going to increase a little bit, just
to give a better look. The thickness, we're going
to change a slight bit. Then we need to do the
negative side as well. So for the negative side, we're just going to copy
this math over here. So we'll copy this multiply. We'll drag this value
after this ad in here and we'll just make
this a negative one value. We will then take
this combine XYZ to the top and we'll input the yellow line
thickness in here into the X. We'll do a re root here as
well, just to make it cleaner. Let's just duplicate
this reroot. So this is yellow line
thickness that we carried over. We'll just do it like this, and then this will be
yellow line position. It's called this
yellow line start. So we'll just do that. We then also need to do a math on
this yellow line thickness. I want to make this a minus one and a multiply
with minus one. This will just invert
that distance. But then want to take
the curve line as well, and remove these up a slight bit just to
get some more space. So we want to do the same vector math
at the bottom as well, not that one. Vector math. We want to do an add and add the top to the bottom
value over here. So the end will be
the bottom value and the start will
be the top value. And then this curve line becomes the profile
curve for the top curve, and we'll just move that up until those
lines are straight. So now we have a curve
on the other side, and it'll have flip faces. So we'll just do a flip
faces after that node, and now you can see the
the same way around. So if we do offset
distance from pavement, both lines will go inwards and
stop at the outside curve. If we do the thickness, both lines will thicken to
the inside of the road. So let's do our normal
tests as we do every time. We're going to increase
the road width, the lines go width. If we increase this
to a massive value, the lines don't get thicker. If we then increase
everything else, these values should not carry. They should have no impact
on those, and that works. The white lines still
stay in the middle, the yellow lines
stay on the outside. So that confirms
everything is correct. So then we can start lasing
up this group as well. So we're then going to slate all the nodes we've just made. We're going to do a control
G to make this a node group. We're then going to call this
node group yellow lines. We're going to go
into the node group. We're going to name the
output yellow lines. Then we're going to
drag this group input closer. We're going
to collapse it. We're then going to just switch these two bottom values so that they're all lined up
and easier to read. We're going to
call these inputs. Why's already yellow line group. Just call that yellow line.
Not sure why added a 01. We're then call it and
call this base curve. We're going to call
this resample curve. Then these values are road
width, yellow line thickness. And then yellow line
distance from pavement. And now our inputs and
outputs are named. We can select both
join a new frame. We can then call this frame yellow lines and drag
that to our stack. Just make sure it doesn't
combine with the frame above and then just reorder it so it stays in
the same size of stack. You can then do a re root. We'll call this re
root yellow lines. And we'll just make sure
that all of these line up. So at this point, we've essentially
created the road. Everything is there
that we want. We've got some trees. Okay, we haven't
created the whole road. We're still missing the
green zone on the inside. So that's what we're
going to tackle next, but for everything else,
we've done most of the road. So what we're going to
do next is we're just going to create this
green zone in the middle. And then we need to create a cube a plane as a
intersection over here. So let's tackle the
green zone first. So just before we start
with the green zone, there's just a slight
bug I'd like to fix. So if we just do an
ad curve and bezier, why we have that 28
value that we had to put in is because this
curve was scaled. So we shouldn't actually
scale the curve. We should just use the
handles to pull it apart. So just going to
do that. This is going to pull this
curve straight. We're going to scale the
points to zero like this. Just to get the
handles in place. I'm just going to
extrude this along the line and then just create
the same corner over here. But we shouldn't scale the curve object because
it seems like even with the actual
transforms applied, it still just keeps that
transform for some reason. So I'm just going to
make a new curve. Going to get it on the
same place as the old one. Let's make sure we've
got something similar. And then just scale this in to make it more straight,
and the same at the top. Then if we use this is
called this road curve Nu, and we go to our generator, well then add this road
curve new into this field. So you see what happened
now is the road is very thin and these
lines are all set. This is because we've
multiplied this value by 28. So now if we increase the road width to let's say something like 14 we increase the sidewalk width
by quite a bit and we increase
the sidewalk brick width by quite a bit as well. You'll now see that the benches, the street lights, and
the lines are wrong. This is a very easy fix. If we then just go
into the trees. So the trees are correct. If we go into the street lights, you'll see that we did
this multiply by 28, bypass this node, then it'll
be in the right place. We'll just do the
same for the benches. Bypass and we'll do the
same for the road lines. This is just a fix to do because this gets really
annoying later on, and I just don't want to
keep using this value. That's the end up with
this yellow line. Here, we didn't actually do it. Make sure the yellow lines are still in the correct place. This why going to Xray again, so the yellow lines are
not in the correct place. Let me just confirm. So the
thickness is just very low. So I was going up the yellow
line thickness as well. And there we go. It's
just a better curve to use because it just
doesn't have that bug. It's going to make
this turn a bit bigger and just bring
these in over here. So if you didn't have to add
that 28 at the beginning, it's just because your curve didn't have the
scaling bug minded. I'll also include I
would have probably included a bit of that in the
start of the video as well. But if you got to this point and you kept that same value, then this is just
how you fix it. It's also good to just confirm that you don't have that bug, just to make sure
your curve will work in any kind of
production environments. So just getting this
to a good shape again, did that original curve. And then just making
sure that we're scaled correctly in the
Z value as well. Just to make sure we have a flat curve and our scale objects are still in the right
place, something like that. The next thing we're
then going to do is I just want to make
sure this is zero. We're going to set where
this green zone needs to be. So there'll be a
zone in the middle where there will be some plants and where the trees
and so on will be. So we're just going
to do that now. So to start that,
we're just going to do a duplicate on this
input node again. We're going to remove
that from frame. So this one, we're going to
need quite a lot of space because there's a few things you want to add on this green zone. The green zone is technically
just a road on its own, but to get started with this, we're going to add
an object info. Going to grab that base curve. You're going to add a resample. You're going to add the
resampled curve in here and just link this geometry
to the curve on top. So we then want to create a
inset in the middle here, which just creates this kind of middle sidewalk or
this middle road. Then we're going to have
sidewalks on the side, and we'll have some bushes on the inside of this
face over here. So we've done this before.
We've done the road. We've done the
sidewalks. We just need to kind of repeat
that on the inside. So what's going to be
the thickness of this? So we're going to have
a green zone width. So we're just going to expand this and we're just going
to add a green zone width, but we'll just add a math node and then drag this into the math node to
create a new value. We're then gonna call this
value green zone width. And we're just going to
multiply this by four. Sometimes this value
is a little small, but we can play with
this value if need be. We're then also going to do a vector math on the multiply. So we're going to
have a positive and a negative value over here. So the top one is one and
the bottom one is minus one. Just like that. We're then
going to do a curve line that's just going to have the positive as the start and
the negative as the end. This is the same we've
done the others, but because we're doing this in the center, we're
just doing it like this. We're going then to
do a curve to mesh. So curve to mesh. Curve this. The base
curve here is a re root. It is this resampled curve. So we're just going to call
this re root resampled curve, and we're going to plug
that into the curve up top. Let's do a duplicate
on this re root. That goes into the curve. The resampled curve goes
in the top over here. Let's line those up. And then the profile curve will then be this curve line over here
that we've just created. So obviously, we won't
see this curve to mesh yet because we haven't
dragged this mesh out here. So we need to drag
this all the way up to the joint geometry so that
we can actually see it. Now you can see we have a zone
on the inside of the road. We're going to do
a set position, and we're just
going to do a 0.02 just to avoid the Z fighting. We're then also going to do a flip faces seeing as this
is the wrong way around. So a flip face over there. Now it's harder to
see but you can still see it is in the
middle over here. So we're just going to group these top ones,
not the base curve. We're just going to
join a new frame, and we're going to call
this the green zone. Now that we have
this green zone, let's see if we
can side its width with the actual modifier. The green zone width adjusts the road width
does nothing to that. Now that we have
that, we're going to want to work on
these sidewalks. We're going to do this the
same as we did for the road, so we're going to need
to split this in two. At the bottom here, we're going
to create a combined XYZ. To drag a new value
into the X over here. We're going to call
this new value we created green zone
sidewalk width. Just like that. So for the
green zone, sidewalk width, we're going to then strag that to the bottom just
to have some more space. And then we're going to do a curve line where the end will be how
wide the sidewalk is, and the side the start will need to be where
this green zone width is. So we'll just go to the top and we're going to grab this
green zone width from here. So we'll do a re root. This will be the positive line, so we'll grab the
positive over here. We're just going to call this
re root green zone width. The bottom one will just be
greens and width inverted. Duplicate this, make
the bottom one greens and width inverted. But for now, we just want
this screen zone width. We're going to
duplicate this reroot, remove it from frame,
bring that down over here. The start is then going to be
just the screen zone width, and the end is going to
be this combined XYZ. We're then going to
just do a join geometry at the end just so we can
see what we're busy with. You're going to connect
this curve line. Won't see anything on that yet. We're then going to
do a vector math, where the start the top will be a add of the
green zone width. This needs to be before.
So this will go before. So the green zone width plus the green zone
sidewalk width will be the start No, the green zone width will be the start and an
add of these two. So the bottom line needs to be the green zone sidewalk
width multiplied Sorry, the slide on top confuson but
let's just delete this add. So, the bottom line is the sidewalk width,
that is the end. The top one is then
the green zone width, but we need to do an
add at the bottom here. So we'll do a vector math, where the bottom is
this combined XYZ, that is the green zone width, plus or the green
zone sidewalk width, plus the green zone width. And then the start will just be the green zone
width on its own. We'll add a reroot here as well. Just to be able to
see this clara. Well then just name this re root green zone width as well. I'm just going to
line these lines up just to make
it a bit cleaner. Now, the bottom is
the sidewalk width plus the green zone width, and the top is just the
green zone width on its own. It's going to drag it like that. So that creates our curve. We're then going
to do a curve to mesh over here where the profile will be this
curve line at the bottom. And the top curve will
be this resampled curve. So we'll pull down
this resampled curve, and that becomes the
curve over here. Then this mesh can be output, and we should be able to see it. So we should just
increase the sidewalk width Just confirm
that becomes that. Just adding this in because it seems like a
piece went missing. So I just wanted to
show how to finish off the green zone
sidewalk pieces here. So now that we've
created this part of the sidewalk where it
brings in the sidewalk width. I then goes into an add, makes a curve line,
makes a curve to mesh. Well, I have this piece on the side here, which
is a flat piece. After that, what we want to do is we want to add
an extrude, as well. From this ex rot, we're going
to disabled individual. We want to make a new piece called Green Zone
sidewalk height. Yes, so green zone
sidewalk height. We're going to pull this
here into a re root. Just to pull this all the way
around, rename the re root. The green zone sidewalk height, we're just going to bring
this all the way to the end. And we want to put this
into the offset scale. So this will allow us
to control how high the sidewalk width is here,
the sidewalks are here. We they want to do a
set shade smooth over here and say don't set shade smooth so that we
have a full mesh here. So currently, we're just
getting the one side. So what we want to
do is we want to duplicate this
entire piece here. Sorry, we're going to
put this in a frame, so let's say join a new frame. So we're going to call this
green zone sidewalk positive. And then we're just
going to duplicate this. And we're gonna call
this green zone sidewalk negative on the bottom piece. So what we want to do
is we want to then grab the sidewalk width put that
into the combined XYZ. We'll also then just
grab the height from the top re root, so
a sidewalk height. We want to then
grab this and just take it into the joint
geometry at the end. But it's now still
generating at the same site. So what we're going to
do is we want to do a MTNade we want
to do a multiply. We want to multiply the
sidewalk width width minus one. Minus one and that value
output into the X. And I just want to make sure
that the green zone width comes from the top as well
to input into this line. Waiting for that to process. And the resampled curve also needs to input
into this again. Now we're getting
it generated here. That's because we're using
the green zone width here. And we don't. Let's
just unlink that. So it's generating
where this one is. So we actually
want the inverted. I think we so let's do
green zone width down here. We'll do a vector math. No not vector curves. So vector math. We'll do a multiply by
minus one and all of these. Now it generates
on the other side. But we're having the
issue of it being under the road
now. So let's see. We can do a flip faces
before the extrude so that it's normal shows
upwards. So there you go. Now you have the two sides here. Now that we know that
sidewalk height here, another piece, I'm not sure
if we show it is after this. So this is the green zone width and generating this
green zone in the middle. We want to offset this to also be equivalent to the sidewalk
height on the sides. So here we just add
a set position. Throw in the geometry
into the set position, and we want to offset it
to where this sidewalk is. So if we set the sidewalk high, we want the middle to go higher. So we're going to
do that, going to combine XYZ because you just
wanted to move in the Z. So there's going to
input this into offset. We're going to add a
math node in front here, output this value to Z, we
want to output it to Z. And then we're going to
sidewalk height so let's see, we're going to do sidewalk
height in the top, and we're going to do green
zone offset on the bottom. And we're gonna change
this to subtract. So now you have a sidewalk that goes up and down with
your sidewalks here. So green zone sidewalk. We will now raise the
sidewalk up and down. And if you change the width, it'll change the width with
the sidewalks on the sides. I hope that helps,
and then we can just continue in the rest of
part four from there. Now what we want to
do is we want to get some bushes on this
middle part here. We're just going to
do an instance on points but we also want to do a distribute points on faces. So the faces we want here
is the green zone up here. So let's move this all
down and work at the top. It's going to be
easier that way? So the green zone is
a line over here. So we want to grab
this mesh over here. We want to distribute
points on that face. Let's move this joint
ometer out a bit. Let's just preview these points. So here you'll see
that'll make points on the green zone and only in the middle because we haven't
included the sidewalks. We then want to use these points and then just go through, have this instance to points. We're going to need some
bushes for this as well. So we'll do a collection info, link that into the instances. We'll then create a
new value over here, drag all the way through to the collection
info, do a re root. We're just going to call this
reroot Bush's collection. Duplicate that all the way just so that we know what
value comes in here. We also on the
input gain to name this Bush's collection,
so just like that. And in the collection
of the modifier, we're then also just
going to input pushes. And immediately, we have
pushes in the middle. Don't worry about
their faces too much. It's just not necessary to have them all
facing the right way. These are planes anyway, so
they'll work at the end. What we're also going to
do is we're going to do the random rotation
and value again. So we're going to do
a random value 0-360. We're going to do a combine XYZ. We're going to put
this value into the Z. This vector will then
go into rotation. This again, just
randomizes their value 0-360 on the rotation. We're then going to
do a random value We're going to make this one to two because we don't
want bushes too small, but we want some larger ones. We're then going to
do a combined XYZ. We're just going to
do this on all three. This will just mean a random
is the same value for all three of these points. I'm going to drag
that vector to scale. That makes these
bushes nice and large. We can maybe just
do 0.5 and to 1.5. We also want to say
that this mesh has to be original and
reset to children. So you can even do 0.2 if you find the bush
is still too big. This just adds some nice
greenery down the middle. So let's confirm that this works with everything
we've done. So the green zone width will
make that green zone wider. The sidewalk width
will not affect it. The green zone offset
will bring them with. The green zone sidewalk
height will increase them, and that seems to be correct. So let's just take all of
this, join a new frame. We're then going to call
this green zone bushes. So that is everything we need
to do for the green zone. We're then just going
to make a group. Control G again on all of these. We can call this output
just green zone. It has everything to
do with a green zones green zone output here. Then we'll reconfigure the inputs again like
we've done before. So just to control H
to hide everything. We'll then reorder everything. Makes it easier to rename. So just like that. So
the top is base curve. The second one is
resample curve. Then we have greens in width. We have Green so sidewalk width. We have green zone height. Green Zone sidewalk height. We have green zone offset
and bush escalation. One thing I do feel we're
lacking in this group, though, is control
over the density. So we're just going to
add a new value here. So on the input, just drag
that all the way through to the density on the
distribute points on face. We're going to add a re
root to drag that up here. We're going to call
this bush density. To make sure it's
in line over here. Duplicate this over to do what
we're inputting over here. On the input, just make
sure that it's also named push density. There we go. And then on this large input, we're just going
to track that into the push density and it'll uo name name the node
group green zone. Make a frame, drain a new
frame, name this green zone. No idea why I have a tendency to make the over
capital as well. We're going to take this green zone and add it to our stack. And we're just going
to line this up. We're then going to add a re root on this
geometry output as well, and we're just going to
name this green zone. Just like that. Make sure
all of them are lined up. Make sure that this join is just more centered
just cleanliness. So now we've got
this green zone. The one thing we haven't
tested is the bush density. So we're going to lower
this bush density by a bit. Now you'll see that it'll start randomly growing less
and more in the center. That's pretty much what we
want. So for the next part, we're going to be moving into
creating the intersection. So the intersection
is going to be a bit of a different
thing because we're going to have to create a plane over here that's going to be
the width of the road. So to start the intersession, what we're going to do is
we're just going to do planning quickly just to explain the concept we're
going to be dealing with. So we would want a square here that is the width of
the road on all four sides. So we're just going to
make a square over here. This square then will
have road markings on the insides that are a bit
thinner than the road width. So it'll look
something like this. We will then also instance corners on all four
corners over here. It'll just be rounded corners it will be the width
of the sidewalk. And then a corner
on the outside, that is the sidewalk
bricks over here. And for the center, what
we're going to do is we're going to make a full rounding of this middle piece and a rounding on the outside of that for
the green zone as we
6. Part05 Building Tool Start: In this deck spot,
we're going to be creating a building generator
from a custom shape. So what we'll do is we'll start with a custom
shape like this. We'll then say that it
needs to generate a floor. If we want this
building to be taller, we can then add floors. We can give the end user
some controls over this, so we can have this
spacing in between, go wider or thinner. We can have the upper floors, a different thing than
the lower floors. We can also then have more or less air cons at the bottom. We can do the same
with the top as well. We can also just create a random seat for the awnings or for the
cons in this case. The entrance gaps can also
be controlled as a test, what we're going to do is
we're going to be using these proxy objects
in this tutorial, where we'll be having
only one window and everything that we
can see the facing. What we'll then later
do is we'll use these collections in unreal to define our style of building. There will be specific
building styles or measurements given for all of these
pieces that you'll then need to abide by to create
your own custom building. In unreal, we'll then import these models to create a custom
building deft our style, and then we'll generate these buildings from custom shapes. For building the tool,
it's a bit easier to just use proxy objects and then
just to replace them later. So let's get into so in the building
generator base C now, you'll see that there's a shape and the custom shaped objects, that'll be all the
objects you'll need, the lower awning and the upper awnings that we'll
use later as well. We're starting with a
shape that's not a cube because a cube is
quite an easy thing to do for the
building generator. There are still some assumptions we're going to make
on this shape, but we assume that this shape will always be custom generated. The assumptions we're going
to make is that we're going to divide this into blocks
of one by one meters. So this is just because working in a size that will be
accurate to the building, which will be floors
of three by 3 meters or at least 3 meters high, and then the windows
as wide as possible. That makes a problem
with a lot of the math that is
included with this. A simple solution
we're then going to do at the end for that is just to scale the actual object we're working with
to a scale of three. Don't apply the object
transforms after this. We want to increase
the one meters that are comfortable to work with
to a scale of 3 meters. Why I say the 1 meter is much easier is because in
the case of where we're going to start is we need to
start with a floor counter. We need to make a line
that has links on it. These points will
signify every floor. This is not accurate, but these will all be 1 meter apart. It then makes it
easy to have a value that just says
floors equals seven. Easy solution, just add
a meters after this. That's quite easy. Working in threes makes this a
bit more complicated. From this point on, we're working in a grid of one by one. The other challenges
we're going to face is, this is a custom shape. We have no idea where
the corners are. We have no idea if there
is a cut in the middle. This is not a strictly
needed piece, but we can't ignore it
because we're going to expect the end user to
clean up a mesh to use. So to figure out
what we need to do, we're going to need to figure
out where these corners are pointing this will be relevant for placing
corner objects, knowing in which direction
these need to face. We're going to have to calculate this direction and
this direction. We're going to have to do
this for all the corners. The other thing
we're also going to have to do is we're going to have to split all the
faces away from the corners. So we're going to have one
group, as for the corners. This technically does not
count as a corner because it's inner and its line
is just square. Anyways, for the faces, we're going to have to separate
those from the corners. If we then draw an
X on every corner, what we're going to be left with is we essentially
just want the faces. We'll have a group that
controls the corners. We'll then boolean
these corners away. That'll separate
these faces out. I'm drawing them offset, but obviously they
won't be offset. They'll just be the faces, but just as a curve. Having these faces as a
curve also means that we're getting rid of all of this
geometry on the inside. So that leaves us
with another problem. That problem is we can
have no face orientation. This is also a plane. So this plane has zero
normal face orientations. So just to show that
in a practical manner, what I'm going to do is I'm
just going to go to here. I won't be there. It's because
if we enter Edit mode, then under here, you'll see
these normals at the bottom. We'll tick all three
of these boxes. So there'll be little hairs off the mesh that'll
show us the normals. Here you can see that we're just having these little hairs
pointing straight up. This is good for having
the upwards orientation, but the problem is we
already have that. It's Z. This solution to that is
essentially extruding this mesh. This mesh extruded gives us
this direction over here. You can now see that we
have a haze pointing in the direction of
the arrows I drew. This means that we need
to say anything placed on this outer face needs
to face this direction. That's easy where we can just
say we extrude the mesh. The problem with that is we need those normals on the
flat plane as well. We have the same issue with the corners that in the corner, we don't have a
actual vector here. We only have that
when we extrude. We then have this cross product, we have the cross, and then in the middle, we
have the cross product. So to set this up, we're going to need to do some
housekeeping first. So the first thing
we're going to do is we're just going to create this flaws line here. We're then going
to move onto just calculating these
corner normals, and we're also going to just
work on getting the roof. The roof is quite easy. The roof is just this plane but higher, and then we're not going
to have a floor for it. So let's get started with
the flaws in the roof first, and then we'll worry
about the rest. This is just station of what
kind of thing do we need to think about and just how
we're kind of going to do it. Another thing that might
help think about this is think of the flaws
as just a scale. So for every floor, we're just going to move
this mesh up to that point. And then the curves we drew on the sides
will then be a floor. The objects will
then distribute on the faces and on these orders. So let's get started with the flows, and then
we'll go from there. So for the first thing
we do with everything, we're just going to
add a mesh cube. It doesn't matter
what the cube is. We're going to call
this cube just new. We're going to call this
building generator. And we're going to give it
space to make a custom mesh. So we're going to put that in the collection and
make sure that the plane itself has no
geometry notes or anything. We then just go to bring
that object info in, remove this geometry input because we don't want to use
the geometry of the nodes, we just want to use this
custom shape over here. Make sure this is set to object and the geometry
outputs to output. So we'll then select the
custom shape geometry nodes. We're going to have to scale
this cube to a scatter of three by three
by three as well, and just make sure
that this object has object apply
rotation and scale. No object apply's
to the location. So now that it's
wear the same glass. We don't want to
apply the scale, we want to keep this at three. To make it easier to
just measure for now, we'll bring the
cube down to one. So we'll bring it down
to one in all axes. So now we have a shape
that the user drew. This shape is flat and
it can be modified. We're going to set the
other one to one as well just to make the modification
of the shape easier. So in the new geometrinodes, what we're going to do
is we're just going to create a line on this edge. So we're going to
do a curve line. And we're going to
need a new input. To use a combined XYZ. We're going to drag
this into the Z. We'll call this input
the floor amount. The floor bound will then
be the end of this as the curve line merely says
that the start is the floor, the end is the combined XYZ. We'll then create a joint
geometry at the end here. It is also very important
to keep this node group clean because this
will be a big one. In the curve line, we can then output that to the
geometry over here, and we can increase
the floor amount. Assuming we don't
want 4.2 floors, we'll change this to an integer. So now we have an amount of flaws or a round
amount of flows. So changing the
floor amount now. If we change this to eight, you can see that it'll
go up eight squares. That just means that we
are going up 1 meter per square or per
floor amount here. We're then going to
do a resample curve, and to get points on this curve, we're going to do a resample
by length of 1 meter. This means that we
get eight points on the curve or rather we get the amount of
floor amount we put in. We're then going to
do a set position. This will need to be 0.5 meters
up because the thing is, if we have a block that is so let's create a
cube at mesh cube, this cube is not one
meters from the bottom. It is one meters
from the middle. That means even here
where it is at zero, it is 0.5 under the floor. So we'll need to up or move the curve line we've just
created up by 0.5 meters. That'll mean that
its middle point is at a point where the
cube will lay flat. We then you use this
height curve line to also influence another field
we'll need for the roof. So we're going to create
an instance on points. And for this, we'll just
need this curve line. So we'll do a re root. And we'll call this re
root height curve line. We'll duplicate this re root to the top and we'll use this for the points
of our instance. So what do we want to
instance on this top point. What we want to instance
is the base geometry. So we'll take this geometry over here and insert
that into instance. We're going to create
a reroot to see that clear We will call this
reroot base geometry. From here, we can then
take this instance on points and put that into the
join geometry at the end. Now you'll see it's perfectly
aligned with the top. The problem with this again is that it'll be in the
middle of the top cube. So what we want to do is we
want to do a set position. It needs to be 1 meter
above the top over here. Not sure why that duplicated. We need to say that it
should not be on the ground. So what we're going to
do for that is we're just going to do a
end point selection. We're going to pump
that into selection, and we're going to make
the start size zero. This just means
do not show flow. So now if we offset it, you can see we only
have the roof. So that is the two points of the actual geometry we're
going to be working with. As a showcase,
we're just going to do an instance on points. We're then going to take
the set position geometry here as the points and the base, we're going to use
this base geometry. This is just an example
just to help think clearer. If we then plug that
into the join geometry, you'll now see that
we've duplicated the mesh that was put
into multiple floors. These flaws then correlate with the meters and we can
increase the flaws we want. So keeping that as a showcase, we'll then start moving on to how we're going to
calculate the corners. So one thing we said is
we're going to separate the corners away. So how
are we going to do that? We're going to use
an instance on points We're then
going to use a cube. This cube is going to go into instances and these base points are going to be
the base geometry. We'll pull this all the
way down in this reroot. We'll use the re root
to go all the way here, or then move this
instance of points to the right and we'll use the base geometry
as the instances. This will mean that on
every point there will be a cube so we're just going to input this into the join geometry and just
center this joined dometry. We're going to make
a new join geometry for the top piece here as well, just to keep this easier
to group at the end. I remove this top cube or the top mesh and
just push that through. We're then just going to do
a joined dometry at the end, just so we can keep
this group contained. So now these cubes
are on every corner. We want these cubes
to be 1.1 meters because we don't
want anything to be too close to the edges, 1.1. These are going to be the
booleans on these corners. To make the boolean
a little bit easier, what we're going to
do is we're going to increase the Z to
quite a high amount. It doesn't need to be crazy, but you can go
something like 90. This will ensure that we cut through all of these corners. Because we're planning to
use it as a boolean later, we're going to do realized
instances as well. This will just make it actual
geometry that we can work with rather than the
cubes we have here. What we're going to
do then is we're going to rename all
of these groups. You're going to join
this new frame, we're going to call this flaws. We're going to call
this top one roof. And this bottom one, we're
going to call corner Boolean. We're just going to do a join
on all of these objects. So in the group, we
want two outputs. We want all the objects
and this corner Boolean, which we actually don't
want to see it at the end. This is just an example. So we're going to
remove that from here. We'll use this again. It's
just not relevant for now. So in the group, the
bottom one is called corner Boolean and the
top one is called roof. We're also just going to
take the roof and output that directly because we
need a value here as well. We need this value here. We're going to call
this value flow points. So this is kind of
our admin node. It does a lot of things that we just don't
want to repeat a lot. These values will be called
in almost every group we use. So we just want to
keep this as first. We're going to call these
inputs flaws and base geometry. We're going to call this node
group, roofs and corners. So we're just going to move
our base geometry over here. We can remove this join. We can just pull
the base geometry. Let's leave the
join. It's cleaner. So we'll leave that in
there. We're then going to just do a duplicate of this. Let's also take this base
geometry out of here. We're just going to make
the node group cleaner. We'll do the geometry into base geometry and the
floor amount into flows. We're then obviously
going to have to change the base geometry to object and create object info. And the geometry is then just going to go into
the base geometry, re root, we have a top here. This seems redundant to have an object info in
every node group. It just means that
we don't end up with spaghetti of going all the
way down with one node. We can keep the stop
one clean and we can just select these ones
and join them in new frame. We're going to call
this global modifiers. The other modifier we
want as a global modifier is the corner
calculation as well. We're then going to do the same thing we did
with other group. We're just going to
color this node as a dark blue signifying input. We're going to start with
the easiest corners here. We'll duplicate
this group input. We'll create a collection info. We'll just make sure
that our middle corner is in a collection. Let's call this middle
corners then pull that collection in so that collision can go here and just be defined
as middle corners. We can then do an instance on points and we can just separate children
and reset children. So this instances go in here. We can then do a join
geometry at the end of here, and we can just
output these corners. So the points we'll use for
this will be the object Info. So we'll input the base mesh and the geometry
into the points. We'll make some space here just to show how this
workflow is going to work. Here you see, I have
quite a few corners, but they're on places
that are not the corners, and they are definitely not
facing where we want them to. We'll need two more
values for this. But first, we're just
going to do the instance on points again and we'll do the instances to be
these instances and the points we're going to bring all the way from here,
these floor points. This will allow us to do A, let's call this
join a new frame. Let's call this
horizontal floor. This means it's one level. We'll then call the next
one vertical floor. So now we can output this into the joint geometry rather
than the base corners. And now here you'll see that we have the corners up to the top. If we then increase the floors, these corners will
go up and down. These are called middle corners. So from that we can deduce that we don't want
the top or bottom. So we'll do an
endpoint selection like that into the selection, and we're just going to
invert that by doing a Boolean math and
setting this to not. So now we have the corners,
they go up and down. But we have two problems. We have them not being
on corners necessarily, and we have them not
pointing in the direction. For now, what we're
going to do is we're just going to leave
this one to the side. We'll move that level
modifiers over because we're going to need quite a lot
of space for the next part. So what do we want to do? For these? We want to
select just the corners, which will then become these points instead
of the base geometry. We also then want to have
a vector in this rotation. We can try and align
ult to vector, and we can just do this with the normal and the vector over here. This will seem to work
for some corners but not for all because this will
just one align for each. We're going to have
to do a bit more of a complex operation here. We're just going to make a
new node here or duplicate this group input and just
remove this from frame. We're then going to
extrude the mesh. This will allow us to find the actual faces
pointing and so on. We're going to put
in an object info. This geometry goes
through to mesh. We'll extrude this by
something like 14. We'll then do a mesh to curve. After the mesh to curve, we'll then do a resample curve. This will just be count of one. This means that we're
splitting off all of the edges of this geometry and just
making them into curves. On these curves, we'll then simplify them with
a count of one. We'll then use a new node
we haven't seen before. We'll use a capture attribute. This will just mean that
we can either input an attribute or capture attribute from the
curve with this node. So what we're going to capture
here is we're going to capture the Boolean and a point. The geometry will be
this resampled curve. And what we want is we want the endpoints
of these curves. We're just going to do
an endpoint selection, and we're just going to
input that into the value. This will give us just the end. We'll then do a curve to points. So this will just convert our curve points
into normal points. So we can just preview this. We're going to drag this all
the way to the top viewer. Now you can see we have a single point on where these are. It's very small, but we've just essentially done what
we've done previously. But we've done it to just be
a single point on the mesh. We need to do a
calculation that will also tell us what
we're selecting. We have this selection on
this mesh to curve over here. So we need to put a
corner selection in here. So what we're going
to do is we're just going to add a edge vertices This will give us the position of all
the edge vertices. We're also then going
to do a vector math. We're going to subtract
position one from position two in subtract. We're then going to do a
vector math as absolute. This will just tell us that
it is at a corner or not, I just rounds the value
to not be a float but to be an integer, just absolute. We'll then going to use a compade we need to set this to vector
direction and equal. We're looking for
if the absolute of the edge vertices is equal to one in the Z direction with an angle of five
and an F slot of 0.75, which just means the
angle that they could be so we can still have a
slight corner selected. Then we're going to go
edge angle over here. We're then going
to do a compare. We're going to compare that if the signed angle is
greater than zero, this means that if
the combined angle of both points is
greater than zero, we're then going
to do we want to select something that
is here and here. We'll then do a Boolean math. We'll input both of these
into an and modifier. Think of this as a bad
English sentence where it is just we want something that
is equal to this and this. These get rough if
you make ten or 12 of them because
it just becomes this and this and this and this. So this is all we want. This then becomes our
corner selection. So we're just going to
join this new frame, and I'm just going to call
this corner selection. On the corner selection, this will then be into
this mesh to curves. We're saying that
the only mesh we want to convert to
curves is the corners. So we can't see
that very clearly because these points
are very small. The one thing we can
do to this is we don't want this geometry in
this horizontal flow. What we actually want is we want these points to go through. These are called
our corner points. So we'll select
these uptp and we'll just call this join a new
frame corners to points. This just tells us that this is the points of our corners. Now you can see it's
selecting the bottom part, but it shouldn't be
selecting the top part. We're using the base geometry.
Then going over here. Let's just do a quick check by importing the horizontal
flaws in here. Let's just for now disconnect
this vertical floor. Let's just confirm with the
horizontal flaws for now. We're then going to drag
these horizontal flaws up. So now you can see we only
have these on the corners. But when we array these
curves vertically, so we'll disconnect
the horizontal. We'll then go to the vertical. We'll input these
instances into instances, and then the vertical flow will output into the joint geometry. The other thing we're also
going to have to do is these corner points We
don't want them up top, so let's try to find
out why that happens. So the reason why this happens is because in this extrude mesh, if individual is ticked, we'll have a face that
cuts through the middle. So if we untick individual, we'll just get the corners. So now we can do a
quick sanity check. We can extrude a side over here, and now you'll see we've
created new corners, and it keeps the corners. So our corner selection
is now correct. So that's the
selecting the corner, but how do we align
to the corner? This is a bit of a
complex calculation. It is finding the 45 degree of the corner and then finding out which way these
corners need to face. To start with how I showed in the beginning
of extruding the mesh, and then we get the vectors, we're going to take
this extruded mesh over here that we've created. We can capture attribute
from this extruded geometry. What we want to
capture is vector of the face facing in the
direction of the normal. So we'll input the normal here. These red blocks are just
kind of global modifiers. This will take the normal of any object that's in
this geometry field. So we'll just want to say we
want to sample this normal. So we're going to make a reroot and we're going to go into here. We're going to call
this root face normals. Well, then duplicate
this down here. We're going to need quite a lot of space for this calculation. I was going to remove
this from frame. And then we're going to
start by just adding a vector math cross product. So for these, just follow
them very carefully, input the same values. I'll try Hover over things a bit longer just so you
can see easier. There's going to
be quite a lot of calculations here that
won't make a lot of sense, but this just does calculate
the corner normals. So just follow these as
is for the cross product, we're going to make
the third slot one. We're then going to add
another vector math, set this to normalize. We're then going to
add a cross product. Vector math, cross product. We're going to
duplicate this twice. We're going to put the
first cross product into the top of both of these. For the top one, the Y
needs to be minus one. For the bottom one, the
X needs to be minus one. Then from here, we're going
to do a vector math again. We're going to make some
more space over here. The top vector ore
going to set to seal. This normalize will
go into the seal. This normalized smooths out the value that it just
inputs into the seal. We then going to do a
separate XYZ twice. So from the top crossbrte
into the top separate, the bottom crossbrt into
the bottom separate. Well then recombine these or combine these Z to X
out of the top one, and Z to Y out of
the bottom one. We're then going to
do a separate XY Z on the top row as well. From that separate, we're
going to do a Boolean math, and we're going to make this. We don't need a boolean math. We need a compare note. I want to say that
if it is equal to X not equal to
the X and Y here, then it must do
this calculation. So we're going to do an integer, not equal, and we're going
to input the X and the Y. Then from the bottom,
we're going to do another vector math. Thi sum we're going
to use dot product. We're then going to input the
combine into the top slot, and then the Y needs
to be positive one. From this dot product, we can do two combined XYZ's we can split out the X and the Y out
of this dot product. We're then going to use the top boolean to trigger a switch. We're going to make
this switch a vector. The result of the not
equal will be the switch. The false will be the
top combined XYZ, and the true will be the
bottom combined XYZ. So this will calculate what the actual
cross products and so on are of the corners. We'll then need to input
the face values as well. So we're going to do for
that is we're going to do a line Eula to vector. We're going to grab
a node from up here, so we'll use a re
root from tangent. I was going to call
this face normals. And we'll drag that over here. So for this align, we want to align
the face normals, so we'll use that in the vector. We'll then align this to Z and
just drag that down a bit. We're then going to
do a vector rotate. For this vector rotate, we want the vector to be the corners and we
want the rotation. So we want a rotation here, we're going to do this by a. From this ula, we're going
to input that into rotation. The center here then needs
to be positive one in Z. So there'll be the X lined up. This will be the Z lined up. We're then going to
do another align unity vector to light up the Y. The vector will then
be the vector rotate. For the rotation,
we have an output of the capture attribute
on top as well. We're going to add a re root. We're going to grab
this rotation, call this node face rotation. I was going to take that
through all the way to the end. This phase rotation
will go into rotation. We're then also going
to set the pivot to Z and the axis to Y. This will give us the alignment of the corners as
they should be. From here, we can
take this rotation, the last rotation, and into the rotation of
the horizontal floor. So let's see what that did. The corners are not
rotated correctly. This is mostly because the
model we're using doesn't rotate very well or doesn't rotate in the
way we want it to. You'll see that the corners are actually correctly aligned, but they're all off by a
90 degree right hand turn. So here you can see, they're
all turned this way. So to fix that. We can just
rotate the Eula itself. We can rotate this
by -90 degrees, and that'll ensure that all our corners are now facing outwards of
all the corners. This is one of the two big calculations
we're going to have to do, but we're going to reuse
this group multiple times. For every corner, we
want to use this group, so we want to clean this
up as much as possible. We'll then just select
this first group, join a new frame, and
we'll call this a line X. We'll then select these
two middle pieces and call this a line Z. We'll select these last
piece and just call this a line X. Sorry, a line of Y. And the last bit
we're just going to call rotation correction. That should be good. We have the corner
selection over here and we're just
going to reorder these nodes a tiny bit better.
What do we want to group? We want these corner
points that are output from here as an output, and we want this
corner normals output. We're just going to disconnect this corner points and reconnect it because we don't
want it in that top join, and it is usually just easier
to disconnect from here. So from here, we can move
this input out the way. We can create a in this group, we have one input. This input will just
be base geometry, and the outputs will be corner
points and corner vector. Just like that. Just moving these into place. So now we have one
small group over here. Let's just move that letter. We'll then call this group
corner vector calculation or let's call it corner vectors. We'll then join these in a new frame and just call
the frame corner vectors. From here, we're just
going to have to do some organization
before we continue. These two that we did
far away from here, we can just consolidate into
this top group over here. If we were to have
it a bit leaner, we'll just grab the
top group output and put that into
the base geometry. This corner vector
will remove from this frame and just add
to the lobal frame. It is easier to have that
as the lobal modifier. Then for these
roofs and corners, we had this corner
Boolean, as well. This corner Boolean
is currently game of the base geometry and just
instancing on all points. Ideally, we'd want the
corner points to be in here. So we're going to drag a
new input into this group. We're going to call this
new input corner points. This will show us well, this will just put the corner Booleans on the corners rather
than on all the points. We're then going to
rename this node to corner points and just move
that over to the right. Then in this input, we're just going to input these corner points and
flip these outputs around. That keeps that a bit cleaner. Then for these middle corners, we're going to rename
this selection, join the new group, rename
that to remove roof and floor. And then we're going to
group this all together. We're going to name the
output middle corners. We're then just going to move that to a better
sorted spot over here. These points can go to the top just because that
value is coming from the top and then keep
this group input close. You name the group
middle corners. You can then start
naming the inputs, so the top one will
be floor points. The middle one will
be corner points. The rotation will
be corner vector, and the collation will
be middle corner vector. Just like that. We're then going to join
this in a new frame, and we're just going to
call this middle corners. We're then going
to add a re root and we're going to
call this output or this re root node
middle corners. So from here our base geometry. This is just showing us
what our plane looks like. We've then got the
global modifiers, which outputs the roof, which we can just
add a re root for. It's called this
roof. We're then also creating our
middle corners and outputting that most crucially, we've created this
corner vector group. This corner vector group will be used for all the corners. What we're going to do for the
ground in the roof corners is we're going to duplicate
this corner vector, remove from frame, bring over the group input,
remove from frame. Then you're going to
input the base geometry from the group input. And we might as well just duplicate this middle
corners group. Make sure to tear off the instance by clicking
on this number. And we're going to call
this ground corners. We're then going to link a collection to this
middle corners collection. We're going to rename
this new collection to ground corners collation Now, do you see that we didn't
name the other one? I called this middle
quarter collection. Well, then make sure that the ground corner is
in a collection. So ground floor corner, make a new collection
called ground corners. We'll just name the input of the group here ground corners. And then in the group, we'll assign the new
collection to ground corners. We'll also then link
the corner points, the corner vectors, and we're also going to have to continuously link this
floor points because what we do is we continuously do a horizontal
layer and then a vertical. So we'll just create
a re root spine for the floor points. So let's do a re root. Make sure it lines up
there. Rename this re root to floor points. Duplicate that,
remove it from frame. I'll just line these
up better as well. Let's just do a so now the floor points
has a place to go here. Ring that from the
top. And we'll just input that into
the floor points. For this bottom collection, we're also going
to add a re root. We're going to rename this re root ground corner collection. And we're just going to
make sure that that's legible as to what we're
inputting in here. So something like
that looks correct. So for the ground corners, we're then going to inputting the ground
corners over here. We're instancing
removing roof and floor. So what we want to do is we want to see what
we're doing by just creating a re root
called middle corners. Ground corners and rename this
output to ground corners. So now we've got an output. We can take this all the way
to the joint at the end. This will just allow us to
see better what we're doing. So in this group,
we want to remove this knot because we want to
instant them on the ground. Now you can see that
we've now distributed these bottom corners with
just a little lip over here, but it's also doing
that at the top. What we want to
do in that group, then is we want to change
the in size to zero. This will mean that
the only point is referencing is the
start one point. We just want to call this
removed middle and roof. That'll just be the selection. So we're doing a
horizontal layout and then a layout
on the vertical, but there's no vertical,
it's just the first point. We'll just keep it like
this for consistency. So all of the groups are
going to look like this, the horizontal,
then the vertical. We're also going to
confirm that these are exactly on the
floor, which they are. The roof corners will
be the same thing. So we're going to duplicate
this entire group and duplicate the
output root as well. We'll rename the output
root to roof corners. We'll take that all the way
through to the end join. We'll then go into the group. We'll rename the output
to roof corners. And we'll make a new collection. So we'll disconnect the
ground corners collection. Input a new one. I'll just do that into the first re root. We'll call this new
input Roof corners. Roof corner collection. And we'll just copy that name to all of the re roots as well. And then for the collection,
we're going to do the same. We're just going to call
this roof corner collection. So that'll input the collection, and we want to do the
inverse of the ground. So we want to make the size
one, the start size zero. And then this is called
remove middle and floor. We're also then going to
need these floor points. As I see that we didn't split the instance. So we're
just going to do that. Just make a instance
out of this one, not that we don't add
the ground corners one. We're just going to call
this roof corners group. So the roof corners are correct, but the floor corners the
ground corners are now wrong. We'll just rename this input to ground corners collection. And just flip these around
that groups now correct. The roof corners are correct. We'll then confirm
that by seeing that the ground corners are
in the correct place. We then have middle corners, but we don't have
this roof corner. That's because we didn't define the roof corner collection. So we'll just decide that
two roof corners over here. Checking if my roof
transforms are all applied. There we go. That's
correct. So now we have this roof
corner over here. From the roof corners group, we have the ground corners from the ground
corners collection,
7. Part06 Building Tool Finish: So in this part, what
we're going to do is we're going to add some
interest to the walls. So things like we want a ring that goes all the way
around as a blank wall. We want some pillars on
the in betweens over here, and we want to add some interest
to every window as well. The thing is we just have to do a quick check to see if we have a issue with
intersections in between here. Here you can see,
we have a bit of a problem with a
cut through here. So we're going to have to do
a pillar on this as well. But that's something that
we're going to get to later. We're just going to
add the rings first. So we're going to duplicate
this roof walls one. We're going to remove it
from the green frame. We're going to duplicate its group away by
licking this number. We're going to call
it output ring. The node here, we're
going to call ring. We're going to call
the group itself ring. We're going to
reveal all of these, input a new collection. We're going to call this new
collection ring collection. We're then going to copy this
to both re roots over here. We're then going to reconnect the floor point and
the corner Booleans. And we're going to take this ring all the way to
the top to the last join. We're then going to
make sure our ring is in the actual NAA
group on its own. We're just going to
call this ring walls. We're then going to put these ring walls into
the ring collection. So where would we
want these to be? We ideally don't want these
rings on the upper walls. We just want them in
the middle walls, but we also want them
to be spaced apart. What we're going to do for that is we're going to go in here, and where we do this
upper floor selection is going to group
that and just call this upper floor selection. We're going to do
a Boolean math, and we're going to say that it should not be where
the upper floor is. We're then going to
add a Boolean math. We're going to say
that it should not be where the upper floor is and it should not be
on the roof or floor. So now we have it where
the middle walls are. The problem with this is they're trying to generate the
same in the middle walls. What we're going to do to make our lives easier is we're
going to add a re root, we're going to call
this rerootK ring. This not ring value, we're going to take and we're going to put
this as an output. And move this over here. Oh, this would be so
this will be ring. This won't be? Not
ring. Sorry about that. We're just going to
call this ring because we want this to be
the ring position. So we're going to output that we want to call
this output ring. Then what we want
to do is we want to take this ring value.
We want to reroute it. And we want to take
this all the way to the top where the
middle walls are. So we're going to
copy this re root. And we're going to go
to these middle walls. We want the ring input to come into the middle walls
group over here. So we're just going to root
it all the way around to get the Then in these middle walls, we want to do a new input. We want to do a Boolean math. We want to add a new input into this Boolean math and make
the Boolean math a knot. Then this ring input
we can put into this Boolean and we can call in the group the
Boolean we can call Ring. We can then group this
new node as Kot ring. So just like that, we
can then do a re root. You can call this
reroot not ring. Then we can do an here as well. So from this, we can input this into the and
put not ring into the. So how does this read now? The middle walls must
be where they are, not the start or end point, the middle floors must not be
where the upper walls are. Their middle walls
must not be where the ring is. We're
going to input this. This will just mean that we are completely removing
our middle walls. Because the ring is
all of these walls, it states that the middle
walls must not generate here. So what we want to do then is we want to break up our ring. We just want to call this
group ring to not get lost. Just position everything
a bit cleaner. So, how are we going to do that? We're going to not
change the horizontal. What we call this horizontal
so in the horizontal, it doesn't need
to change because there's nothing that
will cut through it. We just want the vertical
to be different. So what we're going to do for
that is we're going to add an index and we're going
to add a new value. We're just going to do a math. In this math, the index
will go on the top, and we're going to
add a new value. So we're going to
pull from the input. We're going to add a re
root to this new input. This new input we're going
to call ring spacing. And we'll just name the re
root to ring spacing as well. Then on the big groups input, we're going to input that
into the ring spacing. We're going to add a reroot we call the reroot ring spacing. We're then going to
on the big group, just call the new spacing or
we're going to make it an integer and make it
minimum zero, minimum two. Then what we're
going to do is we're going to use the modulo function again because we're
going to tell it to be if it is divisible
by the modulo, it must be a ring. So what we can tell it
now is if it is here, if it is not the roof and
it is not the upper floor, we can do a Boolean
myth and say, if it is not those and
it is on the modulo, we're going to need a
compare here as well. So we're going to need
to compare because we're not outputting a Boolean. We're just telling it
what the modular is. So on this compare, we're going to say if
the modulo is positive, so if the modular equals one, then the result will be true. So it'll mean that if this wall is on the modular
value equals one, so equals true, and it
is not a roof or floor, and it is not an upper floor, then it must make it a ring. Well the input that
into selection. And we'll also update
this re root over here because the ring position now becomes this
position over here. We're then going to
change this ring spacing. Now you can see what happens. This ring spacing is now
controlled by the module and we're deleting
the middle walls everywhere where a ring is. We're just going to make
the rings spacings minimum, we're just going
to make that zero because maybe you
don't want any rings. But if you then up the rings, you'll get some rings and this will also
just keep generating. If you generate more floors, these rings will just
keep generating. From here on in we're probably
just going to use a bit of a taller building just because
it's easier to work with. It's easier to see. If you add upper floors, it
removes these rings. Is something like
that, t's good. Then going to move this
group into a better space. So the next thing
I want to approach is I want to do the entrances. So for this one,
we're going to grab this ground walls because the entrances will be on the ground. We're then going to
duplicate this entrance one, remove from frame, and we're going to call
this one entrances. We'll then make sure we break off the group by duplicating it. We call this entrances. We're going to link down these floor points again and link down the
corner Boolean. We're then going to
call this output re root here entrances. And we're going to
take the entrances at the end all the way to the top We're then going to make sure our
entrance mesh is in group. So entrances, we're
then going to link a new collection to this
ground walls collection reroot and we're just going to call this
entrance collection. And we're going to
copy this day and rename both re roots with
this entrance collection. There we go. Everything else is
correct, we're going to need a new value, so
we'll add a math. This new value we're going
to call entrance spacing. So we'll input that from
the big input at a re root. We'll call this re
root entrance spacing. And also call the input
value entrance spacing. We're going to make
this an integer. We're going to copy this name, and the group's input is also
called entrance spacing. We're then in this
ad is going to move this value down
and add the index. We'll than this up
by adding a reroot, calling this re root
entrance spacing. This index will
then go into value, and we're going to
do a modulo again. So we're just going
to say the entrances need to be this amount. We then going to do a compare. This will compare
if the module is equal to an integer of one. So it'll be integer
equal and B must be one. So for the entrances, we're saying that
this collection, rename this horizontal must be here horizontal
and this many flaws. Now, this was a bit different
than the other one we did. The floors will always stay one. The entrances will always
only be on the bottom floor. We need to break this one up in the horizontal, not
in the vertical. So this result goes into the
selection of the horizontal. We'll also then need to apply our entrance collection
into this group. And when we increase
the modular, you'll start seeing
some entrances. These entrances are although cutting into the ground floor. So what we're going
to do is we're just going to rename this. We're going to join
this in a new frame, rename this to entrances. We're then going to
copy this whole frame. We're going to go all the
way to the ground walls. Going to paste this
in the ground walls. It didn't paste correctly. We'll just copy this entrances again and in the ground
walls, we'll paste them. So we need this entrance
spacing value from here. So we'll drag it from the input. We'll call this input
entrance spacing. We'll then go to our big input and we'll grab the entrance
spacing from the input. We'll add re roots
to clean these up. Call these roots
entrance spacing. Then in the group, now it'll do the same operation as we did for the entrances
to get them. But this will obviously
the invert because the walls should not
be where those are. So we're going to
do a Boolean math. We're going to do a knot. So it should not be
where the entrances are. We're going to call this
group, remove entrances. We're going then
move this knot up a bit and this should also
go into the horizontal. So that should now
remove the entrances. Confirm what our entrance
mesh looks like. Let's see, we seem
to have a big here. Let's just see if
we bypass this not. They only generate here,
but it does feel like the ground walls duplicate
twice for some reason. So let's do some
troubleshooting, middle walls, it's not that. Ground walls is one
of those there. The roof walls, it's not that. So it is the upper floors that
are putting through here. So let's see, there's a miscalculation in
our upper walls. So here where we said
roof roof and floor. The start size needs to be. So that's the start size at the bottom here for the boy
selection needs to be zero. So we had the start size at one. That means that this
did include the floor. This needs to be set to zero. Now you'll see that we have
the entrances separated from the lower walls and however many entrances we have the lower walls
will be removed here. So that's that for
the entrances. We're also getting up close
to each other on top here. Just want to collapse
these groups again. So the next one we're going
to do is vertical gaps. So we want to do what
we did with the ring, but we just want to make a
vertical gap down the middle. So we're going to
move this group. We're going to call this V gap. We're going to duplicate
this group out, call this V gaps, call this node output V gaps. We're going to need a new input, which we input into this
entrance spacing re roots. We're going to call
this V gap spacing. We're going to duplicate
this and rename the re roots as well as the
input for the group. We're then going to change
out the collection as well. We'll input that into
the collection re roots. We'll call this V
gap collection. We'll then copy this, redrag the re roots in the
group will do the same. V gap collection. We'll then make sure our
V gap is in a collection. What's called the V gaps. So these V gaps, we want them to cut through
pretty much everything. We want them to go all the
way up except for the roof. We'll start by just relinking these floor points through
just on both sides, the corner bod in as well, and take the V gaps all
the way to the end. So for the V gaps,
we're going to add our V gaps to
the collection here. So we're going to do the
same selection we did for the middle walls
or for the entrances. So this staying
the same is fine. We're just going to
call this V gaps. So see if you add
some V gap spacing, it's adding it at the bottom. But this spacing
should be removed from quite a few groups. It should not be where
the entrances are, so we should make the entrances zero and both of
these need to be one, the endpoint selections with a Boolean math set to naught. We'll call these to
join a new group. We'll call these remove
ground and roof. So now the V Gap spacing will be everywhere that's not
the ground end roof. So we'll leave these in. What we're then going
to do is we're going to name this re root
to V Gap spacing. We're then going to take
this V gap group as a whole, or it's going to copy that. And we want to start by removing this from
the middle wall. So we'll go to middle walls or paste in this VGAp spacing. This one is called
entrances, but we'll just rename it VAs. It still
has our old copy. We're going to call
this one not V gaps. It's going to call
this V gap spacing. We're going to drag an input for this group into
the V Gap spacing. We're going to call
it not VGA or V gaps. Gap spacing we're then going
to add a boolean math, which we're going
to set to knot. We're going to throw this
into this group because we're going to duplicate the knot
Vaps quite a few times. This knot then needs to be
added to the whole stack, but we want to remove this from the horizontal,
not from the vertical. So this is too far over. We're going to move this
one back over here. We want to go into
the horizontal, which will be the
first node we did. This knot V gaps
needs to be removed from the horizontal,
not from the vertical. It doesn't do that. Let's see if it is
on the vertical. It's because the output
doesn't come from the outside. This VGA spacing
here is set to zero. We need to draw
the V gap spacing all the way from the
input of the group. Now we'll do a re root. We'll call this
reroot V gap spacing. And we'll input that into the
V gap spacing of the group. So now the middle walls are also not where there is V gaps. Just move these closer to
save ourselves some space. So now we're removing
these middle walls. If I adjust the V gaps, the middle walls will stay gone. The other place
we want to remove these V gaps from
is from the ring. We'll copy this
not V gaps again. We'll then go all the
way down to the ring. In the ring, we're
then going to paste it here because we want to remove
it from the horizontal, so we want it before these. We'll also just call
this at the bottom here, just a ring ring select, just a thing that I
see we didn't mark. So we're going to want a
new input for this group. So we're going to pull the
end group to V gap spacing. We're going to call this
new input V gap spacing. We're going to use the
output as the selection for the horizontal of
the rings so that we say that it should not
be where the V gaps are. We're again not getting anything because this V gap
here is set to zero, so we'll pull the V Gap
spacing from outside. So we'll reroute that. We'll call this V gap spacing. Okay. And we'll just put that into the VGAp
spacing node over here. Then just move the
other two back so we don't get a
straight line up. They're always
very hard to read. So here, now we're
subtracting the V gap from the horizontal ring and
from the middle walls. So if I move this V gap around, you can now see that it kind
of does a scanned through, but it's still scanning
where the upper floors are. We don't want that
for the V Gap. The V gap should be excluded
from the upper floors. So if we go back to
our upper floors, Upper floors, this
group is named wrong, so we'll just name
this upper floors. We're going to go into it, and this is the upper
floor selection. We're going to just
join a new group, rename upper floor selection. We're going to copy
this whole group. We're going to go
down to the V gaps. We're going to paste this in. This should be removed from the vertical because it
is a vertical floor. Then you're going to
do a Boolean math. You're going to set this
boolean math to naught. Here's EPA the selection. We need to then combine that with the removed
ground and roof. So we'll do a Boolean math. This Boolean math will be set, so it should not be the roof or ground and it should not
be the upper floors. Then to put this in.
These upper floors are currently not marked because we don't have a value for them. So what we're going
to do is we're going to add a re root, we're going to call this
re root upper floors. And to remove that
from this frame, we want to just put it
past those frames there. We just want to do
something like this. This value is then
going to come from a new input that we're
going to call upper floors, this upper floors
input comes from the upper floors input
from the main group. We're going to do a re root. We're going to call this
reroot upper floors. And we're going to input
that into the upper floors. So now you'll see if we
increase the upper floors, the ring will go away, the middle floors will go away, and the V gap will go away. If we move the V
gap spacing around, the upper floors don't move, but we cut into the middle floors and we cut into the ring. So now that we've done the ring, we've
done the entrances, and we've done the V gap, we can select all
three of these. You can do a join and new frame. This new frame we can call wall differences
Wall differences will then make an orange color. This just differentiates
what we're looking at, if we look at the whole group. So what we're going
to do next then is we're going to
do the pillars. The pillars will then be
where we have an intersect. So if we do something like this, we add a node here
on this point here, we would ideally want a pillar. We also want the pillars
on these corners. So currently we
have windows that are obstructed by these edges. We want to remove these and we want to just put
a pillar in here. So that's what we're
going to do next. So for the pillars,
first want to do is we want to remove everything
that's in our way here. So we can't do that in the group because we have these lines all the way through. One thing we can try and let's just try that
with the middle walls. Then we go to the middle
walls, and as a test, we'll add an endpoint selection, and we'll do the endpoint
selection this way. Well, then include an, so a Boolean math. And we'll change this to not. Once we do this, you'll see now that the pillars
are removed. This is because the endpoint and the start point of
the separated curves will be on the link
of all the geometry. So we're going to have to
add this endpoint selection, not to all the horizontals. So we're going to do that
by just leasing this, going back to the
original selection, we're then going to add an endpoint selection at
the bottom, a Boolean math. We're going to change
this boolean math to not. You're going to link
these together. We're going to call
this selection, so join a new frame. We're going to
call this pillars. So remove pillars. We're then going to link this
to the not V gaps as well. So we're going to add a
Boolean math in between here. We're going to do not V
gaps and not pillars. We're going to then put
this into the selection. So that'll then remove
wherever this vertex is. So if we look at this vertex, wherever this vertex is, there'll now be a gap if
there's a middle wall. So we're then going to do the same for the upper
walls as well. So we're going back
to the middle walls. We'll copy this remove
pillar selection. We're then going to the, let's see we're going to do the
ground walls as well. We place this in here. So we want to remove
the entrances, and we also want to
remove the pillars. So we want to do that, and the pillars I'm going
to add those together. I'm going to move that
body into the selection. Dill then make sure that this is not where
the pillars are. And we want to go
to the next one. So roof walls, we
want to do the same. The roof walls we might
want to keep like this. Let's leave the
roof walls as is. The upper floors, we want
to take these away as well. The upper floors don't have a different selection
in the horizontal, so that's just a
straight plug in. On the ring, we also want
to remove these pillars. So in the ring, we'll post
the remove pillars in here. We'll then do a Boolean math and we'll add these together. So that should be almost it. We want to remove an entrance
if it is there as well. So the entrances.
So here we want to do a place of the
removed pillar as well. We want to do a Boolean math. And we want to say not
where the pillars are. No, we want to do N and so it has to be where the engines and not
where the pillars are. That's the easiest
way to think of that. Let's see what else. So the V gap. We're going to remove the V gap when it gets the pillar as well. So on the V gap, we want to
place in the remove pillars. We want to remove
these two back. We want to add a Boolean
math to add these together. So now, wherever there's a vertex in the middle of
a face, it'll make a hole. This hole will then
fill with a pillar. These holes were also
getting on the edges. So we're getting them straight
on these edges over here. This is exactly what
we want. So we're going to start working on
creating these pillars. How we're going to do this
is we're going to grab the middle wall selection. So we'll grab this whole
middle wall section over here. We're going to duplicate
bottom, remove it from frame. We're then going to call
this group pillars. Let's call this pillar middle. We're then also just
going to make sure that our pillar is in a group
called pillar middle. Let's do the same thing
we do with all of them. Expand this group,
make a new collection. This new collection will be called middle Pillar collection. We'll copy this to all
the other does as well. So these re roots, we'll just rename to the middle
pillar collection as well. We'll then just split off this middle walls group over here and call this
middle pillars. We'll rename the output re
root to middle pillars. We'll then bring
down the floor point and the corner Booleans
to this group as well. It's shifted a slight pizza, we'll just move
it to be in line. We'll then take
these middle pillars all the way up to
the final join. You want to clean up this
final join a little, but what we can do is we just
literally just move it to the middle. So it
just cleans it up. It's just nice to see
where all the outputs go. So for the pillars, we're going to remove
this ring input then. It's not necessary. And we're just going
to delete this one. We're going to call
the collection in the group middle
pillar collection. So we're just going to do that. And then we're going to
bypass this remove pillars. We're just going to call this pillars because it has
to be where the pillars are. And we're just going to delete these V gaps because it
overwrites the V gaps. And this pillars
selection will just go straight into the
selection over here. We also want to
make sure that we select our middle
pillars selection here. So now you can see we have this blank wall where these gaps are. It's still removing
the upper floors, which is something
we don't want. So we're going to remove this remove upper floor
section and the knot ring. The only thing we
want to keep here is the remove roof and floor. So it just has to be not
where the roof and floor are, but everywhere else, and
it has to be on the ends. It should also not
actually be on the roof. So yeah, it is fine. It should
just be one, one and not. And the horizontal, it should just be
where the pillars are. So unneeded values is
these upper floors and V spacing because we copied
the middle floors one, so it's easier to remove those two just to
keep it cleaner. We're also then just going to condense this group
a little bit more. So that's how we're
going to do the pillars. We're then going
to just duplicate this group because we need to do a roof and a
ground for these pillars. So we'll duplicate it twice. We're going to call the
middle one pillar ground. And the bottom one we're
going to call Pilar roof. We're going to connect the
floor points to both of them. And we're going to connect the Corner Booleans to
both of them as well. We'll then also
rename their outputs. So we're going to duplicate
these groups first, so we'll split this one off, call this pillar ground. We'll then call
this pillar roof. We'll name their re
root outputs as well. And we'll take them all
the way to the end. So just like this. We're also then just
going to clean up the upper floors and V spacing
we have in these groups. We should have done that
in the previous group, but we'll just
clean them up here. They're not necessary for this, so we'll just delete them. So starting with
the pilar ground, we're going to make
sure our pilar ground is in its own collection. And our polar roof is its
own collection as well. We're then going to re inport
both of these collections. So the Pilar ground will
make a new collection. This new collection will be called Ground Pilar collection. We're going to
copy this name and we're going to put this
into the re roots as well. So that'll be good. And we're going to do the same for
the roof pillar as well. So the new input will be
called Roof pillar collection. And we'll copy this name and put that on both
re roots as well. We're also then going to put
that into the groups input. We'll do this for the roof
and for the ground pillar. We're then going to in the
actual modifier panel, we're going to assign
the ground pillars, so pille ground and pile roof
to these two collections. So here you can see now if
we go to the pile ground, we're going to have to
change just one thing. We're going to remove this knot. We're going to make
the end size zero because it shouldn't be roof
and the start size one. Just seeing. So that's the pillar
roof doing this. So the pillar ground should
then only be the bottom. If we remove it from
just this output and we put it back
into the input, you can see it's
just the ground one. For the roof, we want to
do the inverse of that. So we want to bypass this knot. The enside should be one, and the start size
should be zero. It should put a pillar on top, but I do think this roof
window is interrupting us. So what we're going
to have to do is we're actually going to have to remove
those roof walls. So if we go to roof walls, in the roof walls, we can then
do an endpoint selection. So in this roof walls group, we're then going to
do a Body and math. This is just to remove the pillows from the
roof walls as well. We're going to join
these in a new frame. We're going to call
these remove pillar. We're going to link
them together. We're then going to put
this into the selection of the horizontal That should work. You see? Pull a roof so
then just take this away. If we just disconnect
roof walls here. We should put them see, we remove the selection here. So it'll just remove
the pillar at the top. So it just has to
be in size one. It has to start in size
one. Is that horizontal? So now, these pillars
have a cap on top. Test if we take roof walls out. So the issue we're having is actually
with the roof walls, it's with the upper walls. So we'll just do a
coration the upper floors. The upper floors, they need to be I think that
they're interrupting. So if we disconnect
the upper floors, you'll see that it makes a
mesh go away up top here. So we're having one too
many floors over here. And it's because this roof
and floor are not connected. So we'll just do a Boolean math, and we'll just add an and Now if we disconnect
the upper floors, it should do nothing to
the roof, there we go. That just means that
the upper floors don't interfere with the roof
selection anymore. Back to the roof walls, if we now disconnect them, you'll see that the pillar is actually creating a pillar roof, but just looks like this. It doesn't look different. Let me just go to
the pillar roof and just confirm what this
model looks like. For the pillar roof,
maybe we just want a bit of a flatter face here. So just for visual interest, I'm just going to
make this flat here. I'm just going to take this face and just delete the rest. Extrude this through on
the Y. Take that snapping. I just mark the shop. You'll
have this final model. It's just me needing to
adjust this quickly. It's just for better
visual interest. So here now you can see
the pillar is working. I thought it wasn't
working because the upper floor looked the same. So we just changed that pillar to match the style
better of our pillars. So now you'll see that we have these pillars that
have a roof cap, and they have a floor cap. If we then go and we edit the
vertices of the base mesh, you'll see that this
pillar moves along. So you'll see it kind of scans. And we also have these pillars
on all the corners now. So you'll see it
looks like this. So we'll also just
do our sanity check and extrude the mesh by the X. And you'll see that
it still moves along. It creates everything as we go. If we then adjust
the floor amount, it still just the floors. The upper floors adjust. So that's it for the building
generation part of this. The next thing we're going
to do is we're going to make objects that can be
distributed on the windows. So we're going to add some cons that can
be distributed on top of these cons on
top of these windows. So let's do that. We'll just
hide these meshes over here, and we'll just do a cleanup
for the pillars here quickly. So we're going to select
all these join a new frame. We can call this new frame
pillars and we'll make this a pink something like that. Another thing I'd like
to do just before we move to that is
we're struggling a bit to switch between
our normal geometry and our kind of
generated geometry. So we'll just do a
switch at the end here. We have a group input here that this is the base and
this is the generated. So on the true, we're going to show
the base geometry. So we're going to call this
switch show base geometry. And then on the false, we can bring through this
joint geometry over here. We're going to reveal
the group input and add a Boolean in here. Not in there, we're going to
have to put that in the top. And we're going to
call this Boolean. We're going to call
this reveal base mesh. So it's a simple thing that'll just make
life a bit easier. But all it'll do is if
we flip the switch, if it's true, the output has to get to the
end that works. If it is false, we see
the whole building. If it is true, we only
see the base mesh. To clean this up, we'll
just add a re root. We'll call this re
root reveal base mesh. And we'll just input
that to the top switch. Well then also join this group. We'll call this whole
group base mesh, and we'll call this switch
just join a new group. We'll call this
switch base mesh. Obviously we want to
keep that all for now. It's easier to at the end if we want to create quick
geometry or we want to say, we just want to edit
this geometry now. We can just go to the geometry
and edit it rather than having to look under the
body in the whole time. So for the awnings, what we're
going to do is we're going to put some of the awnings
on the middle floors and some on the upper floors. So this should be
pretty easy to do. We already have those
both kind of specked. So we're going to go
to the middle walls, and we're just
going to duplicate the whole ring the whole thing with this ring on
the side as well. So we'll make a copy of that, remove that from frame. We're then also going to take the upper floors,
duplicate that. We're then going to
remove that from frame. Just to delete this green frame. We're then going
to make a copy of this middle walls and we'll
call this lower awnings. We call them awnings, but we do mean just anything that
goes on the windows. For the upper floors, we'll
duplicate this group. We then call this upper awnings. I'll just stack these together. We'll then connect the corner
Booleans at the start. Well then also connect the
flow points in the middle. We'll rename these
two output re roots. We'll name this
one lower awnings and we'll name the
other one top awnings. We'll name it upper awnings. Just make sure you
select the right one. Sometimes plan
doesn't understand what you want to select. So now we've got the lower
and the upper awnings. Select the wrong one again. So like that. So in the group will rename
their outputs as well. So this one will
be a lower awning, and the bottom one
will be upper awning. So for these models, we just have a I'll
show a middle wall. We go to the middle wall model. So this is are the
middle wall looks. The awnings on that then are
just an con to the side. So we have three variations. We have an offset con. We have a con in
the right place, and we have just some
flower proxy here as well. So these are modeled by
just centering them to the middle and making sure that they're offset
away from the window. So you can just move these on your window where
you want them to be. So just a quick
explanation of how you would create a custom model for this piece specifically. Then for the middle walls, the external thing we
need is this ring. We're going to grab this ring all the way from
the ring up top. It's going to go down, put that into this ring
at the bottom. We're also then going to need a new collection to
reveal all inputs. We're going to make
a new collection. We're going to call this new
connection lower awnings. And then we're just
going to copy this and rename the two
reroots this as well. We need to call this
lower awning collection, just to be more clear. And just make sure that the
re roots are named the same. In the group's input, we're going to name
it the same as well. Instead of middle
wall collection, it should be lower
awning collection. And then we'll just
collapse the inputs. We'll then also go
to the lower awnings and just select the
lower awning group. We're also then
going to take both of these and connect
them to the final join. You can see we're already
seeing the lower awnings. And the upper ones won't show yet because
we have no group. So we'll define the upper
awning group as well. So we'll input a new collection. We'll rename this collection. Upper awning collection. I just define that in the stack. We'll copy this name and rename
the two reroots as well. Okay. So now the upper awnings
are showing up as well. This is fine if we wanted
an con on every group. But assuming we want some interest, that's
not really what we want. So what we're going to
do is we're going to do two random values here. So we're going to
do a random value. We're going to do this
random value in Boolean. We're then going to add a new input into this whole group. We're going to drag this
through into the probability. This new input we're going to
call lower awning density. And this will just control
what the probability is here. The seed doesn't
matter too much, but what we can do
is we can just add an input as a integers
for the seed and just call this lower awning seed just to give the end user a more clean way
to use the tool. We're then going to make
two new inputs for these, lower awning density and
for lower awning seed. We're then going to add two
re roots for this node. We're going to call the top
one lower awning density. And the bottom one we're going to call lower ordering seed. So now we should
have these here. In the group, I'm
just going to move the upper awning
down a little bit, just so we have the collection, whatever affected, and then the next as we do for all the rest. Then for this density
here, it's fine. We can just leave it afloat.
For the upper awnings, we're then going to do the same. We're going to add
a random value. Just move this group
input away a bit. We're going to add
make this a boolean. The probability will be
upper awning density. And the lower one will
b
8. Part07 Road Texture Generation: In this part, we're
going to start finishing up the nodes for
going to unreil. The trash nodes should be fine. There's no changes
we want to do there, so we'll move on
to the next one. The road generator,
when we stopped on it, we had created all the models, we had placed all the things, and we had done some
shading in the front here. When we go to unreal, blender won't generate UVs for these. We're going to need
to have to generate UVs for this entire node, and we're going to have to
transfer that over on real. There are some other changes
we want to make as well, so we'll start with those, and then we'll move on to the texas. One of these changes will
just be on the benches. But to start off with, let's just delete this vertex and let's work on a straight
road for this part. From here on in, we're going to be working with
a straight road. It's just easier to test,
it's easier to see, and at this moment, everything should work
around the curve. So now on the road, if you make it shorter and
you delete that last line, there are a few things
that'll change. One of the things
that'll change is the street lights
will become more, so we're just going
to increase that, and we're going to
increase the benches. The white line in
between distance will also then get less. So for that, we're just going to make this line
a little longer. So when you are curve,
just make that longer. And then just go to the white line in between
distance and just lower that. We also then we set this white line in between
distance to have a clamp. So we just want to remove that because we want to
go a bit lower. So we sort of make this
to negative 1,000. So if we then go to white
light in between distance, just make sure that it's
not clamped on either side. Just make sure you said in the group and in the
main note as well. So if we then increase this
in between distance Sn, you can see we have these
lines like we want them to. And then shorten the
curve a little bit again, just to get back
to where we were. Now that we have that, one issue that I saw could become an issue is with
the street lights. If you want to put these street lights this
side of the benches, these benches become
horrifically uncomfortable. What we can do for this is
we can just create a switch that allows the end user to just switch this bench facing
this way or the other way. For this, we're just going
to go to the benches group. And in the Benches group, we're going to duplicate
the group input. We'll color this blue just to make sure we know
where we're going. So we'll color this
blue as an input node. We then want to create a switch. So we're already doing this
for one side of the benches. So we're doing it for
this side, I think. So if we make the zero, we're doing it for
the other side. So here you can see we're
rotating on the Z by 180. So what we want to do is
we want to duplicate this. And in the rotate instances, we just want to bring
that instance through. We want one that is zero and
we want one that is 180. We also then want to make
ourselves some space over here. We want to put the switch and we are going to keep
it on geometry. We want to add the 180 on top as false and
the zero on true. False would be facing the road and true would be
facing away from the road. It doesn't matter either way, we'll just call the
node flip benches, it doesn't matter which
is true or false. In the group input then
we're going to drag this through to become a new
input to the group. We're then going to
call this flip benches. We're going to then go
out of this node group and make this for a
main input as well. Here we call this
flip benches as well. It is named already. I'll put it in a bit
of a weird place because we're doing
this out of order. So we're going to move this to under the benches collection. This will give us a flip here, which will then, if we
tick it, flip the bench. It won't do it yet because this output is still
not connected. We'll disconnect the output from the bottom part and we'll reconnect this new
input from the switch. We'll then just move this over a tiny now we can just
taste our switch. So flip bench, and now
it flips back and forth. That's exactly what we wanted. We'll then add a reroot. We'll call this re
root flip benches. We want to just duplicate
this and have it in line with the switch
up top here as well. We're going to branch of this one for the top
benches, obviously, we want both benches to
flip at the same time. I don't see much of a reason to do one side
and not the other. So with this switch
duplicated to the top, we can then duplicate
this reroute, go all the way up
and into the switch. So the false has to
be its default value, and this one is not rotated. So what we can do here is there's no need to add a
rotate to the top instance. We're just going
to grab the rote by 180 from the bottom instance. We then going to plug
the instances from its instance on points
into the instances here, and the instances will go
into the true over here. We can then also just remove these rotate instances
from this bottom group, and we can just select
everything over here, join in new frame,
and we can call this flip benches.
Something like that. So now, both sides of
benches are facing inwards, and when flip is ticked, that one's facing outwards, and that one's facing outwards. That's one of the changes
we wanted to make just to make sure that
everything there stays correct. Now that we've made that change, the other change that
might become a problem in unreal blender and unreal read this a little
bit differently, so we have to play this by ear. But we're just going to go to
the white lines over here. So this white lines, we've done a set position
towards the end that is 0.01. I'm actually just going
to make this 0.005. This won't clip, but we don't want this to
cast a shadow and unreal. This is technically
going to be like decals, so we just want them to be
on the road as a texture, not really as a line. So just lower them
down a little bit. Just while I see
it, I'm just going to pull the flip
benches up here. And then we're going to go to the intersection
markings, as well. Under the intersection markings. Let's see if we've
offset these as well. These should be good. Now, we actually did offset
them over here. So on the lines to curve, we have 0.02 here. We're going to make that 0.05. 0.005, just to keep them in line with the
white lines over here. 0.005. We just want to
do this for all four of them. So that works. One of the other issues we've also been constantly seeing is these Booleans
freaking out a little bit and also one of them
is freaking out here. So what we're going
to do is we're going to solidify these
intersection markings. These intersection sidewalks
a little bit better. So if you go to intersection
sidewalks here, we have these
values that we set. But you can see
if these go over, they tend to break quite badly. So we're just going to make sure all our angles are correct. So see why this one
over here freaked out. This is to be 70 and a sweep
angle of 91. That's correct. We just want to change that
in the bricks, as well. This might not be a
bug on your side. This might just be something
that's happening on my side. So just checking so 270. I know it a bit of a bug. So over there. So that's kind of the
issue we're having is this boolean isn't working
all the time. It's because the sidewalk sometimes just leaves a one
pixel line on this edge. So what we're going
to do for that is on this after this
instance on points, we're going to do
a set position. And then we're just
going to add it into the frame and just
see where these are. So this one is over here. So if we do -0.01, it'll offset it a little
bit to the inside, but it'll be just smoother
to actually work over here. Let's do -0.1, not
0.01. So -0.1. Then in the sidewalk
width on the front here, we're going to just add
the 0.1 in here as well. So where it comes in
before the re root, let's do a math node. And we're just going to
add this 0.1 over here. This will just allow that the
curves here still light up, but that it still cuts 100%. It doesn't need to
line up exactly here. It can go over. This
is just ensuring our booleans will actually
look fine and not break. Unreal does tend to read
these values wrong sometimes, so we just want
to give ourselves all the chances we can
to make this work. So for this top one, just going to see if we
can get minus one as well, so here we want to go 0.1, and -0.1 is fine over here. You just want to offset it it's closer to that it
kind of overlaps the corner rather than what we did where it's exactly
on the corner for both, which is causing
the Boolean issues. Then we're going to
go to the next one. So see where this one is, minus one is open, one there, and -0.1 will
be correct over here. This one needs to be
zero point -0.1 -0.1, yes. So that one's correct? They want to duplicate
it for the last one. Just being careful not to
drag it over all the lines. Let's just see if
this one's correct. So one minus one. So this one needs
to be h one, h one. No, that's incorrect. Et's see say, 0.1, and so it has
to be open one, 0.1. The thing I think
we're also having an issue with is just let's make these arc points
at the start all 64. So those are correct. Then we're going to go to
the intersection bricks. And the one thing I want
to say here is we want to just do on the Boolean, let's do this hole tolerant. We're just going to go and set the whole tolerance over here. So that makes that a bit
smoother and doesn't just create a separate
mesh going from there. Then here as well, we just
want to make this Z minus two. The pixel is too close. So in the remove
sidewalk inner corner, the group we did that brings in the sidewalk and then
sets the position, we want to make this
Z just minus two. I'll just smooth out
this process even more. So minus two on all. And now we should
have a much more solid node group over here. So one of these seems wrong in the
intersection sidewalks, just find which one this is. It's sidewalk corner two
that's wrong over here. We want to make this -0.1
rather than the plus 0.1, and we want to make
the second 10.1. Something like that
looks correct. We just want to then check
all the other sidewalks. And we just want to see if this intersection stays a lot more solid now, which it does. It is now a lot more
solid on all the edges, and now we done get that
pop out we got earlier. So the last thing we want to
do just before we move on to the texturing is if we go to
the intersection sidewalks, we did the shade smooth to get these lines smoother
on the side. But now what we're going to
do is we're actually going to untick the shade smooth in
the intersection sidewalks. So that we have this solid over here and just for the
sidewalk bricks as well. So it was just fine. So there shades smooth
here at the end. We just want to remove
the shades smooth. And we're still getting
some segments here. So what we want
to do is let's do 64 on all these as well
on the sidewalk bricks, not on the sidewalks
as we did earlier. So 64 on all of these. This gives us more resolution that it feels a lot more solid. The intersection currently
feels a bit high. This is personal preference, but I'm just going to lower
my brick height a little bit. I'm just going to do
something like this. So sidewalk. Brick height increased
a little bit. So just somewhere like
that There we go. Then what we're
going to do next is we're going to move
to the texture. We're going to create
a checker texture. Let's just go to the
any material really. We add a material here. You can call this checker test. What we're going to do
is we're just going to apply the checker
test to everything so we can make sure that all the textile density stays the same, just to make sure the road is more or less
the same UV space. In this checker test, we're
going to go to shading. We're going to add
a checker texture. So checker texture,
that into base color. We're then going to
add a mapping node. The mapping node is going to
go straight into the vector, and we're going to do a
texture coordinate over here, and we're going to
take that from UV. So now if we go back
to the generator, let's start with
the road surface. The road surface is
the most simple one, if we're going to
figure that out, the rest is pretty
much the same. On the road surface
in the set material, we're then just going to
make this the checker taste. Make sure you have the
show texture on here, the viewpot shading, and now you can see that
nothing happened. This is because there's
no UV on this road. So this is going to be one of the first things that ultimas is going to have
to take into account. To pass something to AltimH, we want to capture an attribute. So capture attribute
is just this can capture anything
that's a vector, a float, a boolean, anything
we can get in this. But we have nowhere to
capture this UV from. So what we're going
to do is we're going to add a set attribute. So we're going to
put in a store named attribute over here.
Store named attribute. The one thing you
absolutely have to make sure of is we have vector, we have face corner, and the name of this
is called UV map. The capitals here are important, so make very sure of this note we're still not
getting anything over here. So let's do a test by
doing a UV unwrapped. And plug that into the value. And still, we get nothing. So this is because
we're not reading this. If we go to the shading,
we're reading it from the texture
coordinate of the road. But in the shading editor, we can add an attribute. The name of our attribute
is called UV map, the capitals here do matter. We can then plug this
into the vector. Now you see that there's
something happening on the road. Let's make this scale of
the checker texture 90. Let's make it 45. We want small obloxs
we want to taste. Let's do 120. It doesn't matter
too much what size it is. It's just that we can
see clearer to taste. So that's texture. Technically. We have these
lines running across the road. And if we do a extrude
on the end here, we'll grab this note, we do an extrude, and we'll create a curve again. Just a slight curve
to test with. Here you can see
what's happening is all of the UV space are going across the road or
they're going this way. The curve is also not straight. Let's make sure that
we don't mess that up. Just make sure the
curve is straight and flat, just to test. So this is going to
cause us problems. The other thing that
this doesn't really do is stay fine when we
make the road longer. So how do we do this? So this is going to be a little complicated
on the first one. But all you need to know
is that we're going to repeat the same thing
quite a few times. It's going to be
what we're doing here, but a couple of times. And we're going to do
this step by step. So where do we get
this UV attribute? If we get it from angle based, from a UV unwrap, it's just trying
to make the road flat and throw it somewhere
on the texture for us. But essentially, what we
want to do is we want to grab it from these lines. We want to grab the space
between these two lines. So to start with, let's do a
set spline type. To nerves. This is not necessarily
to do with the texture. It just makes the whole
curve a whole lot smoother, and it holds UVs a bit better. So to get this attribute, we're then going to do
a capture attribute, and we're going
to do this twice. The attribute we're looking to capture here is float and point. This point we're going to capture needs to come
from the spline. So just move this out the way. And then just reshuffle
this so it's a bit cleaner. Then in between these
two capture nodes, the parameter we're looking for. So if you go spline parameter, you get this red box. The red box means that this is reading from
the spline itself. So from the spline, we can then input the factor. The factor is telling
it how long and how wide both of these are and
where they are as well. So that's our one value
we're looking to get. We will get a float
point from this factor. We also then want
the curve length so just as a quick
demonstration, if we think of UV, so a UV is a sphere
like this with V and U, these might be the
other way around. But what we're technically
calculating with the spline parameter is we're calculating how wide is this? What's this value? So with that, we get this. Then with the V,
we're calculating the length of the
road over here. So for this, we can
use curve length. So curve length will
take the total amount of the curve over here
and give us a value. That value we can
then use to drive the V along with this factor. So we'll grab this from where
we convert the main curve. So this is base curve. The base curve then
goes into curve length. We just erase my grease pencil. Then from that curve link, we want to do a math. We want to be able to edit this F to make the
blocks look the same. Let's do a divide and
we'll do a math over here. And we're going to multiply the spline parameter through
the attribute to capture. That is being multiplied by this divide from the
curve length over here. We then want a combined XYZ. This will specify that
this line is So let's join all these and we'll call this calculate I'm just going to color this to
make sure it looks better. And this vector can
then go into the value. Delete this UV nra. Now you'll see that we have a UV that doesn't really
understand what's going on. And if we adjust
the other values, nothing really happens
because they're fields. So remember, with the
fields, it's per node. So we want to get the same sort of calculation
from the other side. For this one, however, if you
think of our example again, where we have the
U and V U and V. I did the other way around
the previous subsets to V and So we've calculated
this one now. But to get the across, we're going to need the road
width over here as well. So we'll duplicate this
input node over here. Then from this input node, we're going to do a math. We're going to set
this to a divide. This is the same as the top. We just want to be
able to calculate what value we're
looking for over here. The road width needs to then
be divided by something, and we need a math
that multiplies the divided value by the
bottom attribute over here. Join this in a group and call this calculate V.
Something like that, and this goes into Y. The Z is completely irrelevant here as we're working
on a two D plane, so we're just sliding
it over from there. So now let's see what that did. So we're still getting the
same error we did previously. Let's just check. Let's divide
these by, let's say four. Let's pick a random value. Let's try something
more extreme. Let's try 40 on
both. So here we go. Now you can see that this
road is starting to come in. We're using these
blocks to see if we're stretching the texture or
kind of clamping it down, so if it's too wide or not. If you increase the stop divide, let's say we make
the stop divide 70. Now you can see that
these are a lot more closer to cubes. 80 could even get us
more of the way there. So let's do 80. Now
you can also see that these cubes or these
squares are going around the curve and
following the curve as well. We have some pinching
over here where we're kind of coming around the corner because this
corner is just too sharp. But here you can
see it's pinching on the corner and it's
stretching on the outside. So what we want to do then is if we make this road
longer, what happens? So select the curve, and let's make the road longer. As we then make the road longer, you'll see that these
UV still stay intact. That's exactly what we're
looking for over here. So we'll just delete
this curve at the back. And then if we make
the road wider, go into a modifier puddle. If we make the road wider, these cubes stay consistent. These squares, sorry. Road width. So now we have a consistent
texture on the road. From this consistent texture, we can start doing
everything else. So the sidewalks would
be a similar thing. So moving to the sidewalks, we start by adding a
set material node. So test checker or checker test. This is sidewalk bricks,
not sidewalks yet. Let's go to not sidewalk bricks. Let's go to sidewalks first. It's flat, so it's the
same thing as the road. So we'll just do a set material. We'll call this check a test. And we're also going to do store named attribute over here. Now this is something that
will carry for all the nodes. If you name this one UV map and set it to
vector face corner, it'll read as its own UV. This attribute is per
node, not per name. You don't need to name
this something else. You can just call
this UV map and it'll pull the same
as the previous one. This one, we have a bit of
a more interesting problem. So let's think about
how we did the road. So on the road, we
have one curve. However, we're doing it
from the profile curve, and we're doing it from
the resample curve up top. If we go to these sidewalks, we technically have two roads. These roads come from here. So if we look at this
middle node over here, the resample curve comes
in and becomes the curve up top and the profile curve comes from both sides over here. We want to do the
capture attribute on both of these nodes. So let's move this entire
second section up by a bit. Let's make ourselves
a nice bit of space. We'll then do four
capture attributes, not two as previous. So we'll do two on the profile
curves on the outside, and we'll do two on the
resampled curve on the inside. Also, then make sure to do a set spline type on the resampled curve and
set this to nerves. We can do the same for
the curve lines as well. Just copy and paste
this set spline node. So we can then ungroup
these in the middle. Remove these from frame. These four capture attributes then need to be in
their own frame. Join a new frame. And we can just call those
capture attributes. And we can call these setSplins. We can just call
this setSpline type. Just line them up. So it just
something simple like that. Now, we want to do the same
thing we did on the road. So we want to do a
spline parameter. I'll do this twice so we can separate these
by what we need. So we'll do one uptop,
one at the bottom. We'll then do factor into
value for all of them. So factor, value,
factor, and value. We're then also going to
need to apply the UV twice. So we don't want to apply
the store named over here. We'll bypass this. We want to move this last bit up just before the join,
so move this up. We then here want to do
a store named attribute. Make two vector, face corner, vector, face corner,
call these UV map. We then want to do
two combine XYZ's. This will be our UV inputs. We can then remove
these from frame. Join a new frame
called this UV map. Everything that has
to do with texturing, I'm just going to make white. So from here, we can start doing the same calculations we
did for the previous one. So we're going to
do a curve length. So for this one,
make sure you grab the base curve going
down the middle, this resampled base
curve to curve length. We then want to do a math and
we want to do a multiply. So math multiply. So we then want to multiply
this divided value, set this to divide by the attribute coming out
of capture attribute one. So join this in a new frame, call this calculate And this value will go into
the X right at the end. We'll add a re root, and we're just
going to call this pose U because it's
the positive U value. So just something like that
and then line them up. Then it's Y value. It's Y value. We calculate
their width. Let's see. So the sidewalk width is Let's just do a
multiply after this. So let's do a math.
Take this attribute from the second node on the profile curve
of the first line. Do a math to multiply. Join a new frame
called this calculate V. Take this value at a reroot We're going to call this pase V. The re root not the node. Then just plug this into the
Y of the top combined XYZ. That then becomes a UV map. So let's play around
with this valley. So let's start at
like a seven here. And then for the top one, let's start increasing this value. Let's say 200. Not enough. Let's keep going until we kind of reach the same
thickness as the road. Et's do 2000. It's
nice round number. This bottom node does
not need to be subtract. It needs to be multiplying. It's most licked.
So there you go. We can make them be the same size as the road by just playing with
these two values. So let's go three.
And let's go 4,000. Let's go, 4,000 should be
fine. Something like that. Those blocks are a similar size. So that then does sidewalk one. As you might have guessed, sidewalk two is the same. So we're then going to grab this attribute over here
and the multiplier for calculate V. We're then going to grab the pase V
and call this neg V. We're doing the Y here first. So it's going to go up
here into the Y value. And it forgot which
way it's going. Now here you can actually
see a nice example of just the Y value. We're getting an infinitely
stretching UV in the Y value. Then to calculate the X, we can grab this whole
calculation over here, duplicate that down, make both blocks white so
we can track this easier, grab the resampled base
curve into curve length, and this is going
to be called Ng U. So, NU, is this
positive or negative. It just looks weird
if you write up the whole thing for
this small thing. Then we're gonna plug
this in over here. And is going to check that
all our bath is correct. It's not because
this bottom node needs to go into this
second multiply over here. So now we've got the
same on both sides. We've got a captured attribute for normal curve and
for profile curve. The normal curve goes into
multiply to calculate the V and the resampled curve
goes into the curve length, divides, multiplies and becomes the That text is both sidewalks, so let's do some tests. So sidewalk width. So here we see the sidewalk width does affect
it quite a bit. So is this our U or V? Let's see. This was our
view that it does that. There you increase
the sidewalk width. Let's bring the input over here. So we're going to duplicate
this group input. I'll color led polute and
make it easier to see. Then we're going to
do a math multiply. We're going to pull in
the sidewalk width. We're going to add another
multiply at the end over here and we're going to multiply that with
the sidewalk width. Let's do it by one. Let's set the initial value
to 2000, to higher or lower. Let's keep this at 4,000. Let's 6,000 maybe. Let's just test of the
sidewalk width works down. There we go. Let's do 12,000. 18,000 maybe. We're getting there, 20,000
is a nice round number. Let's keep it at 20,000. So now if we increase
the sidewalk width, the map doesn't stretch. Now we're just getting the
sidewalk to just work. So we'll duplicate this
to the other side. We're just going
to put all both of these nodes into the
calculate group. We're going to duplicate
this to the top. We're going to do a
math at the end here, math after the multiply
with the factor value, and we're going to make this
a multiply to be multiplied by one of the sidewalk width, and we're going to
do 20,000 over here. This math node isn't
strictly necessary, but it could be nice if
you want to change it. So we're just going to keep
this value at one just to add a way for you to test or to add things
you would like to add. So just a test, sidewalk
width increase, the UV map does not so that's pretty much the
basis of what we're doing. We're just going to
do that, but a lot. So what's next? Let's see. We're going to ignore
the three D one for now. It should be a bit easier to do, but we're not going
to worry about the sidewalk bricks just yet. The trees don't
have a U V value, the street lights
don't have a U value. The bench is only value. The next one, let's
approach the white lines. We're going to o to
the white line group. Then for this UV, we're not
going to do this the same as the others because this UV is not distributed the
same as the other ones. What we actually want to do
with this UV is we want to just texture this
cube over here. So remember this node, we're merging this
cube by distance, flipping the faces, then
we're instancing it on this. What we want to do
here is we want to do an vector math We want then
to do another vectormth. So what do we want to add? We want to grab this
UV map over here, plug that into the
top of this ad. This will be so that we
can move it left or right. For this one, we are looking at UV something a
bit more specific. What we're looking at UV
is this line over here. So for this one, we're
going to do a new material. So let's just do a set material. We want to then create
the material as well, and just call this
material white line. In shading, we want then to go attribute UV map,
spalling here matters. We then want to do a mapping
node, vector into vector. We then want to drag the white
line texture you provided, vector into vector
of that white line, and then color into base color. Now if we go to the lines, so back to geometry nodes, set the material as white line. So here, you'll see, we don't
have a texture on it yet, but now we can see what we
need to do when we have one. So what we need to do is we need to store named attribute. I just want to pull
that in line over here. Maybe let's pull
everything back here so we can add a re
root over here. So add a re root
and we just call this line just so we know
where the line is coming from. So the star named attribute, What want to store is, again, the vector, face corner, and UV map spelling
here matters. So then we want to do this add, and we want to do a multiply over here so that we
can adjust the scale. And we apply the into value. Let's set all of these
multiplies to one. So now let's see what
we're working with. So we're grabbing this UV map and we're plugging it
into this multiplier. Let's play around
with the values. So now you can see we
see this line over here. This line is extremely thin, but to make it wider, let's do this top one
if we push this up. Let's do something like 0.2, and then just reset this. I can see the lines a lot wider. This is just making
the UV tile more. We then want to do maybe a two over here to push this light in. Let's keep it at one. Let's keep it at
one. One looks good. So let's see if we
minus a bit more. I then minus 287
is fine over here. So something like
that looks good. Now you can see the line is
on both sides because we UV this line once and we just carry it
over to both sides. Then the other
white lines we have is we have these
intersection lines. So we'll just jump to those next just as a logical
or point of order. So in intersection markings, here we're doing the
same calculation, but we're doing it four times. We have this cube, merge, flip, but we
have it four times. So let's go back to
the white line group. Let's grab this whole up
to store named attribute, and we'll just grab this
line over here, this reroot. Then in intersection markings, we can paste this entire group, line this reroot up with
where we want it to go, and we can delete all four of these cubes we're
inputting over here. So I like that. And then we can re instance this new line we're bringing
in that is Uvied. So duplicate this
instance four times, keep it on the Y, remove
it from the bottom frames. And then we can just bring
this node up from the bottom. Just bring that
to all the lines. And then into the instances. So now we have smaller lines
than we used to have over here because the initial
cube is a bit smaller. It feels like we're missing one. Just seeing instances over here and the top instance. Which one? We're missing the instance over on
this left hand side. So see, it should
be the first one. I was going to disconnect
this line and just replug it. I want to see if I drag it directly from the
cube over here. I just experimenting. So I think what might
actually be happening is, we're offsetting it
incorrectly over here. So if we play with this Z on the set position,
it's not that one. We go to the top the
top one is wrong. We want to go positive
0.005 over here. There we go. Now it's correct. We then want to at
the end over here. After the join, we want
to do a set material. We want to make this the white line But these lines
are very skinny. So we just need to
go to the base cube, and we just need to play around with its
values for a bit. So it's length and width. Let's make them
just a bit beefier. There we go. Something like
that looks quite good. So next, let's texture
the intersection. We're also going to let's
just make this box white, just to call it texture, and we'll do the same
in the white lines. It's just a visual aid, but it is just nice to know where everything
is coming from. So for the intersection road, we can pretty much
just use a calculation because it's a square
UV in the first place. So we're going to its material, and we're going to
apply the checker test. We're then going to
make a duplicate of the group input over here. We'll make this blue so that
it's clear for us to see. We'll then add a math node. So we're adding the road width. Adding the sidewalk brick width. But we're also then adding
the sidewalk width. So we're adding this first add with sidewalk width
as the second add. We're then going to
do a math divide so that we can control how much this distance needs
to affect it. We're then also going
to do a UV unwrap that we want to multiply. So we want to do a vector math, and we want to multiply the
UV by the size of the shape. We also then need to do
a store named attribute, so we'll move this away. Yeah. Not into the frame. We'll then do a store named
attribute on top here. Save as before,
we're going to do a vector face corner UV
map spelling here matters. We're then going to drag this from the multiplier that
we multiply the distance by the UV map into this node over here into the value
of the vector face corner. So these blocks
are way too small. So what we want to
do is we increase this divide, let's do 40. There we go. Now let's
actually bring it. So 40 seems to make these
lines the same size. So let's do a quick test. Let's up the road width, and they stay the same. Let's lower the road width,
and they stay the same. Let's increase the
sidewalk width, stays the same, increase the brick width and
they stay the same. So that calculation
is pretty much it. That's a very easy one to do because it's just
a UV in its own. We'll move this
into its end frame, and we'll just call
this calculate UV. And we'll just make this white, just because we've been
doing it the whole time. Then the next what I
think we're going to do is we're going to do
these yellow lines. So let's do that quick. So we're going into the
yellow lines group. So here we again have
these two lines. So this will be similar
to the sidewalk. But we're also going to do this the same as
the white lines. So just create a new material. We'll call this
material yellow lines. In this material in
the shading editor, we're going to drag the
yellow line base color you're provided with in here. We're then going to
create a mapping node, put it into vector, put
it in an attribute. The attribute name is
UV map spelling here matters, and we're
going to do that. Now we have that yellow
line base color. Back in Gonods, we know that we need to capture attribute
to both of these lines. We're going to input a capture attribute on both of these here. We're then also going to
do a spline parameter, and we're going to do a factor into both values over here. We're going to move this
curve up so it's straighter. At the bottom, we're
going to do the same. Just capture attribute
on both lines. Then do a spline parameter. Then we're going to
calculate the U for t
9. Part08 Transfering Tools To Unreal: So now I'm unreal. We're in a new scene from the games tab, we just created a blank project. So before we start, there's
a few things we need to do. So, we need to install the UltimshPlug in.
So how do we do that? We want to go to the
Ulti Misha website. So you want to Google Ultimsh. The problem with that is you get to this page with Ultimsh two. At the time of
recording, there's not a personal license for T, and it'll take you to the page that's nine
to $9 on Unreal. However, if you look for
the Ulti mesh gum Road, you'll get to this
ultimshPersonal page. We assume that by the
time the tutorial is out, two point oh will have
a personal release, but it'll be on the
same page as this. So just go to God
Ulta mesh Gum Road, and you'll find the
ultra mesh personal. Here you can just make the price zero and just say purchase. This will then lead you
to the content page. So once you've
purchased this product, you can just view content. You want to download this
Ulta mesh 1.4 zip for 5.2 Unreal 5.2 is the
version you'll be using, so we just download this. Once you've then
downloaded that, you'll get a zip like this, which you can then just extract and you'll get this ultra
mesh file or ultimash folder. You'll then go to your
actual unreal 5.2 engine and you'll just drag this Ulti mesh plugin
into the plugins folder. Here you can see, I
just have it here. I already have it
dragged in here, so I don't want to reinstall it. You're then just going
to drag it in here. So once you've done that, you just need to go to Edit, plug ins and look for lamesh. Here you can see use geometry
nodes in tight Unreal. We just want to take that on. We need to restart
unreL for that, we're just going to
restart that quickly. I'm just going to pause
until my unrel restarts. Once your unreel restarts, it'll take you back
to this plug in page. Where you just need to double check that li mesh is enabled. And then the next thing you
want to do is you want to go to edit project settings. Wait for that to open.
In the search bar, search for Alta mesh. Here you're going to
see the Max idle time. We'll just make this 30
seconds rather than 15, and the max memory going
to increase a bit. The executable path, you just need to go to
your blender folder. In the blender folder, you want to take the
blender dot EXE, and now that should work. From here, we're going to
go to the content draw. We're going to
create a new folder. No, not a new collection. So we're going to
do a under content, make a new folder,
call this tools. In tools, we're going to start
with the trash generator. So let's do trash scatter. You can't do space as an unreal. So quite simple. What you're going to do here
is you're going to pull the trash scatter file
you've made in here. Just give it a second to update. You'll see it all come
in as a la mesh object. If you then double
click on this. You'll get this window. So this will show you what
everything looks like. And you can see
it brought it in, but it doesn't read the
materials correctly. It reads where the
materials need to go, but it doesn't read
the materials in. So we're going to
worry about that now. But let's just test it first. So you drag the
trash scatter in. Now you'll see we have the
trashcater we've made. We can adjust values in
the side bar over here. So if we adjust the densities, you'll see updates in
pretty much real time. You can also make some
settings at the bottom here, export on move or however
you want it to be, and this is promotes your
whole interaction bar. At the end of a node, you can also click
the convert button. The materials and stuff do
freak out before you convert. So I would suggest
that if you feel done with something and you know you're not going
to move it again, do convert it just to save
yourself from annoyance. There are still
some bugs we found that are to be fixed and should be fixed by
the time they get to you. But if not, there is still
a workaround we found. So one of the things
that don't work like we want empty is if you go to modeling and you add a rectangle
on the floor, if you then accept that rectangle and we edit
it with poly editing, so let's move this up. So we'll make a cube. We'll call this
rectangle trash one. We're going to edit rename. It's called this trash one. In the trash scatter,
we're going to specify that it needs
to be on that object. Under this ground geometry
we created as an input, we're going to add an object. On the input type, we're going to make this
geometry actor. We're going to keep going down and we're
going to make this refer to that rectangle.
So here's the problem. The trash is offset from
where that rectangle is. The easiest solution drag the trash to be on
top of the rectangle. So let's say something
like that's about correct. Then select both objects, press Control G. This will
then give you a group. The group moves on its own, and you can't select the
trash scatter individually. If you do want to edit
the trash to this value, you need to write groups unlock, then you can just go
to the trash gata and edit that individually as well. But if you move them
together, they'll work. Let's test this again
with the poly editing. If we then make
this poly longer, now you see it won't update. This is because Alta
Mesh is currently set to export on move and
export on finishing move. Export on every frame
has a tendency to crash. So what you can do is just move it one way and then just back,
and the node will update. If Export on every frame
works for you, that's good. Just be sure to test
it before you try it. For the trash generator,
it imports quite easily. The one thing we also want
to test is just to see if we can get an object to be
the exclusion object. For this, we're just going
to add a shape, sphere. And then in the
exclusion objects, we're going to drag
the sphere in. So we'll lock the trash
scatter final and we'll drag the sphere into the exclusion
objects collection. We'll also then set the
exclusion zone size to four and we'll move the trashcaa ever so
slightly just to update it. So let's move the sphere into a densely packed area and just play with a
seed to update the node. Making the exclusion
zone is a make as eight. They're just doing some
testing or stream. It seems like the
exclusion object isn't being picked up
where its location is. This is the same
bug we're having with the collections over here. So for now, this
isn't working for me, but just be sure to
test it on your side, and it should work. It's just because there's a location difference and
unreal doesn't like that. Well, Altimsh isn't liking
that too much at the moment. So the trash is good. It works as we expected to except now obviously
for the exclusion, we're then just going
to change a few things. So let's do a semi dense
trash as the example. And we're then just going
to apply the materials. What we're going to
do is we're just going to go back
to the selection. You'll also see it does apply. It bakes the geometry node to the actual trash
scatter over here. All the models show
here. We just good. We're going to create a
new follow this texture. We're going to drag the models in that you're
provided with as well. Let's get those models. So we're going to go into this, let's call this
models, not texts. In models, we're then going
to drag all the trash in. It should bring some of
their maps and stuff with. We say that create new
materials for all of these. So we're sure it brings
all our materials over. So see what happened. So it brought our
materials over over here. So what we're going
to do is we're going to create a new folder, and we're going to
call this materials. We're then just
going to move all of these materials in here. Just along with the
textures as well. We're also just going to
have to reassign these maps. Wat till the acupy. So for last tents, actually I think we
use the last tens. I don't use last tents.
Cardboard box two. See it. It's trying
to read materials. But we don't trust the
import less lead or that. So for cardboard box two, we want box two, not box two dirty. Box two base color. See why box two maps,
not all in one place. Box to roughness
and box to normal. So these you can just plug straight in roughness
to roughness. Normal to normal safe. And then go for the next
one, cardboard box three. Base color, colour to color. So dock this in day out so we don't have to keep going back and
forth the whole time. Tools, trash s cutter, models, materials, box three. Box three, base color we
have box three normal, and box three roughness. And then we just want to
save that box D dirty. Base to base, rough to
rough, normal to normal. Then the cups, lids,
mugs material. Base to base, normal to
normal and rough to rough. Save that. Then for the generic snacks,
we'll do the same. So base, normal, rough. Save that. So you'll see that the node
isn't updating currently. That's because we haven't
done the override materials. So the plan is to
just finish these quick and then just
to update them here. So don't worry if you don't see your nodes updating currently. The liquid, there is
no liquid objects, so we can skip that one. The next one we want to do
is this MI trash clutter. So for the trash clutter, so trash base color.
Trash normal. And trash roughness. Then the next one is pens
which is spelled wrong. So pants No, not too
specular too roughness. Base to base, normal
to normal, save. Pants to uses the same. This is just to allow for there
to be some color changes, which we don't really
need to implement here. It was more about the way to get here and understanding how
to get these tools into unreal and to make an
environment artists be able to use these these
materials are applied and going to the **** like that. Shirt two. Using the
same shirt colors, same thing with the pants. This is to change color in them. We just aren't changing
color in this tutorial. You would just multiply
the base color with a color if you do want
to change colors though. Then the last one
is the T shirt. A base to base, normal to normal
roughness to roughness. That's all the
materials assigned. And now we can go
back to the node. And in the node, you'll see this materials and overwrite
materials element over here. So here you can just
match the names. Trash later to trash luster, generic snakes to
generic snakes, Mg to mix, move the ev update. It hasn't updated yet. See if it's still compiling. It seems to still
just be compiling. Well, just keep inputting all
of the materials in here. Now you can see we have the
actual textured objects. There are still some boxes
that are untextured. Sure what that would be.'s
play with the seed again. Sometimes you just have
to force to refresh. So then prepare shaders again. Let's just check these boxes. Now that those
materials are assigned, we can just play around
with the values. Something like that, and I'll
play around the seed a bit. If some models are staying in
one place for some reason, So it seems like we're
having a brogue. These converts happen. Let's do the density
as we wanted to. So a large density of
two, four, and two. And after we've done
that, we'll convert. So there are these
untextured ones in between, but this seems to be the
previous shape we had. So if we then just do a convert, And all of them lose
their materials. Let's see if it just didn't
update the materials. So let's delete both of these. And now after we've
assigned the materials, let's pull the trash
scatter in again. It's confirmed the
materials are overwritten. It seems like we
need to override the materials in the
trash scatter itself. So if you open the
trash scatter, let's assign the
materials in here. So we'll just redo that
again in cardboard box, got two. 230, box three. So her'll see the actual update. So I think this was just a we need to assign it
over here, not in there. So just assigning the materials. And they were going
to save this. And we're is going
to put it in again. So a big reason why that also is a problem is because
each node is its own. So even if we just
take this trash node, we duplicate it
over to the right. If we change this trash
node on the right to be a much less dense trash node. So let's do something like this. These nodes have nothing
to do with each other. So the mistake the first
time was we assigned it to just the one node. So you can change one nodes, materials on its own, as well. So just remember to assign it in the actual base ulta mesh here, not in the side of here. So that does it for
the trash lutter. So we've imported that. The next one we're going
to import is the road. So before we start
the row generator, if you're into this trash
scatter final, just one thing. On this converted lass, make this do not convert. Sometimes Alta mesh can break
your UVs if you do convert, so just leave that
do not convert. Then for the row generator, what we're going to
do is we're going to import the row
generator texture. Then we're going to
just drag that in here. We're just gonna wait for that
to render and it renders. So we'll confirm everything's correct. That looks about right. So there's one bug
we'll see here. So we'll smooth the
road over a little bit. But the bug we'll
see here is that Unreal reads these
intersections quite badly. Right. For this, we'll
need a control in this. So just before we
continue with it here, let's open the rot
texture blend file. The problem is that these values don't seem to be read
correctly into unreal. So what we want to do about that is we actually want to create a new input
that we can control. So what we're going to
do is we're going to link a new input over
here to the start angle. The start angle will control
where the how it's rotated. It's the sweep angle we
don't want to control. We just want to control
the start angle. So there's going to
be start angle, one, two, three, and we're
going to start angle four. In the group, we're just
going to rename these to sidewalk sidewalk angle
angle zero to three, angle zero, one, two, and three. Then we want to get these
into input as well. So from the main group, drag four new inputs
in for these. So just something
like that. Let's just do a quick test on these. Now, if we adjust these that'll
move, but the other one, the intersection sidewalks
themselves won't move. So it affix that here, just make four inputs as well. So again, just to start
angle on all of these. These start angles are
in the same order, so the one value should
just change both. So we're just going
to do zero, one, two, and three, and then
just collapse that. So now if you play around
with these angles, you'll see that
they just adjust. So we're just going
to save this. And now, this will just
be a good showcase of how to update a node here. So outside of blender, you'll see these
nodes don't appear. However, if you then
go refresh sync, it should bring those
values in for you. So let's see if it. It did not, so let's just try a reimport. We're just going to
reimport the entire node. Just wearing in front load. So now if you drag it in
now we have those angles. If we pull this up and we push this back to
where it needs to be. So here you'll see the problem with unreal reading these nodes. They are terrible. So we're going to have to adjust these. So let's see. The first
angle is correct. So let's see, there was six So that'll just rotate
that angle correctly. But it's made a duplicate, let's just see if that's the
node that hasn't updated. Also, just tick
update on move here. So if we go in settings
just enable update on move. It's duplicated the
node for some reason, so we're just going
to track this in. For now, just also set this convert at last
to do not convert. We want to be able to control when it converts on our own. We don't want it to be
constantly converting. Let's wait for this
one to import. So then we're just going to go back here now that we've
imported the new road. So the first one I
said is correct, let's see what the
second one should be. So if we make the
second value three. So that's this one over here. So let's try minus three maybe. These values make no sense, so this is more trial and error. We're also then just
going to enable export on move. Let's try one. Two, Let's try six. Let's try the same value
for the first one? No. Let's minus that value. No. Let's tra eight. Even 11 seems to be correct. Let's try 10.8. 10.95 11 seems about correct. Then for the other corners, These are just going to have
to find a value that works. It's also not It doesn't
update very well live, so we just need to
keep inputting values. Let's see 9.5 on this one, 9.7, 9.3, four, 9.45 will be correct. 43. So just line that up. Won't you get this right once
I'd recommend just writing down these values just to have them secure for the
next time you're doing a row Okay. So 785. That's correct. So now your road is unreal? So we can adjust
this road width. Let's make it 25. Roads wider and
everything still adjusts. We can also increase
the sidewalk width. Want a bit of a
wider sidewalk here, it's to a 24 sidewalk. Just specifying where
this needs to be saved. Just as a backup. Always
backup these tools. Sometimes the interaction
breaks and it does crash. So just to make sure
I just keep saving your scene, so that does work. Let's wait for it to regenerate. And now we can just adjust these switch the benches
on the sidewalk around. So as to bench also
distance to two. It's like a five. So they want to
flip the benches, so tick the flip benches button. And now we just have something a bit more statically pleasing. For the textures, we're then
going to make a new folder. New folder, textures. We didn't have models
to import here, so here we just need to
import the textures. I'm just going to drag and
drop these textures in here. Then we're going to create
a material material. Call this one asphalt. Into the asphalt and
assign these materials. So I using height. So normal into the normal and the roughness
into the roughness. So that does it for the asphalt. Do they want to make
a material material or the sidewalk Mm. Color into color,
dock this layout. Normal into normal and
rough inter rough. We also then duplicated
this for the intersection, duplicate the sidewalk,
call it sidewalk. Call int. We'll tile these differently. Then create a street
bench has its material. Going to create a material
for the yellow line. Yellow line. So base color, opacity. Then because we have
an opacity here, we just want to set the shading
bottle to be translucent. Blend motive translucent. Sorry, not the shading model. Then this opacity
can go into opacity. So now we have a
line of the opacity. Then we want to make a
white line material. So material material, white line M. So
for the white line, we don't have an opacity mask, so we're just going
to do base color, set the blend mode
to translucent. But then going to add a
hold one and left lick, add a value, press tab, add a math node. It's here, you can
actually multiply. Multiply and you
want to multiply the Alpha with this constant
and that gas in opacity. Make this bottom
value just like a ten Let's do the RGBA into this. So if you do the RGBA
into this value, it will then just
give you the cut out. And it's going
to save that. So then we're going to start
applying these materials. We're also going to just need to actually make material for
the street lights and so on. So let's do street Bench. So the street bench. It's going to try
these materials in But I also just need to
drag in the street light, create a new folder and just drag in the street
light materials, create a new material. And then we're going to apply the street light
materials to this. That should not do it for
most of our materials. We have one more. We have a concrete, so concrete. So we're going to create a
new folder for concrete. So we drag this in. Make a new material,
and apply the maps. And now we've got
the material sorted. So now we can just
apply them to the road. So to avoid the issue
from the first one, we'll go into the
road generators over here in the actual viewer. So for the bench, we're going to apply the
bench material. The bushes and so on, I'm going to replace
on in the gray box. There's no need for them now. We also didn't put
in the green zone. So I just want to follow
for the green zone. Drag its material in the
green zone as a base color. There's no need for it
to have anything more. So green zone drag
the green zone color in save now in the
road generator again, green zone to green zone, light it does material, the road will be the asphalt, the sidewalk will be the
sidewalk, sidewalk intersection, concrete for the
sidewalk bricks, street light for
the street light, white light for the white line, and yellow line for
the yellow line. So we got to save that and
just see what do we get. So once that's saved, you can just re import the road. And now it comes in
with its materials. So, let's see. We
have some bugs. We have some tiling bugs. We don't have general
bugs, just some tiling. So it's gonna then adjust these. Let's hide the intersection
for now while we buy these the
intersection works. We're aware of that. We might actually need to put
in these values again just to be sure so we can test
how these two live together. So I just input my
value is just ofstream. No one wants to see that again. In the textures, we want to have some
more tiling on these. So in the asphalt, what we're going to do
is we're going to add a texture coordinate. We're just going to
move everything aside. So just so we can
get to this UV, this texture coordinate
then goes into all the UVs. Let's say we want to
do a tiling of 24. So we'll do 24 U and
V tiling and save. So now, if we look, that's about the tiling we
want for the road. Can also make this color darker by just
holding three left licking and then just
dragging this texture up. I want to add a multiply. We just want to
multiply the black with the RGB color from the top and then that
goes into base color. I want to make this base
color quite a bit lighter. Want to do something like there just to make this
asphalt a bit darker. Something like that is
quite a lot better, but we can still
go a bit darker. This is personal preference. It's just what I
think looks good. So something like that. Then for the sidewalks, we're
going to do the same. We're going to do a texture
coordinate, into the UVs. Let's start with the
titling of 24 by 24. Save that. It looks a bit good in the V. I'd like to make it a little
bit longer say it's at 25. I something like
that looks good. Then we want to do the same for the intersection sidewalk. So start with 24, 24, we made this 125, so it's just the same here. See if these scales line up, they should they were
quite the same size. So they do line up quite nicely. I For these sidewalks, it has this concrete material
applied. That looks good. These bushes and so on are
replacing the blockout. Street lights have
their texture. The other issue you'll now
see with the road is there are some normal issues
on some of these here. The solution for this is the road we want to just convert
when we're done with it. If you then convert currently unconvert the
road will just disappear. Reimport it. Just to AI intersection. It's not necessary
to have that now. So what happens is
on the R generator, we just want to set
this one to static. This one we can actually bake. Then let's convert
to static mesh. Save that. And now
if you convert, these materials should work. But you'll need to
just red drag it in because the setting won't
change on the live one. So height intersection.
So here we go. I used to have this
convert button back. Di vient convert. Then now the immaterials
actually work. Happier with that. Then
for the bushes and so on, we'll replace that in
the blockout stage. Then for the next node, we can move on to
the building node. We're going to go back to tools. Let's just delete this
one. We don't need to have all the nodes
in one place at once. Then in the tools,
we're going to create a new folder called
this buildings. I'm actually going to import both building generators here. So bowling one and two. Just wait for those inboard. Once they've imported, do you mean to bring the
row generator in. Let's pull final one in. So if you then drag and
drop your building tool in, you taste of it pulls in.
So that looks correct. So let's just do the settings
here before we continue. This we want to convert it to a static mesh, so that's fine. Its material seems to
have pulled through. In building two is going
to confirm the same. That does look correct. We're then aim to
make a new folder. We're going to call
this textures. Let's call this models because these models also have
textures that come with. Let's call this models. Then we're just going to
import the one and two models. They share quite a
few similarities. Let's start with importing one. We drag all these models in, import all, create new
materials for them. Once that's in, it seems to have assigned its materials on its
own quite a bit. Seems good. So let's create a new folder
all the materials. It's going to drag all the taxes and materials into this folder. Then in the building
generator one, start assigning these materials. And so aircon to aircon cables to
cables, concrete. Apply there. Dot struck
is news fake dark glass. It's going to make this
material a bit more metallic. It's going to add
a constant inter metallic and just make that a seven for a bit
nicer glass feel. Yeah. So we're back to bolding one. It's bolding two.
So bolding one. Recovering from that crash. So we're still busy
with bolding one. I'm not sure why that
removed itself from here. Gonna re drag that in. I'll just keep
reassigning materials and dock this layout. There are sometimes duplicates
of the same material, assign the same one to them. Dragging the large
granite tiles, and you can see it's
updating on the left. Being to middle black needs
to be a little darker. Something like
that. We save that. I want to do adjustment to
the painted metal black. We want to do a constant,
three and left click. We don't want to do a multiply. We want to multiply
the base color with this black color black over here into base
color over here. We just want to
say this lighter. We're looking for a
mid grayish type tone. Something like that will
be good. That should do it for our
building generator. Let's track that in. There we go. For the building generator, we're going to do the
same as for the trash. Going to go to modeling,
create a rectangle. For this, just make sure your
snapping and stuff is on. You can still sometimes
get it on a wrong angle. If you do that, you just
need to adjust the wall. It's going to create a cube. Except that we're
then going to rename this plane to just building one. And in the geometry here we're
just going to go to actor, set this to building one. And now, you'll see
that the shape is offset again as same
as with the trash. So we can just drag
that closer over here. And we can just group these two. When they're grouped, you
can still edit the poly. So here you can see, we've
got that issue we get in blender where it's not
exactly on the snap. So you just have to increase
it a little bit and move it, then it'll just fix itself. So we confirm that the
building shape works. Now, let's confirm that some other things of the
building work as well. So let's set the floors to five. Set the upper floors to two, set the entrance
spacing to eight. So everything seems
to be working. Yeah, that's a fully
functional building generator. One thing we want to test
is in the ground plane, go to poly edit, do an edge loop right the way
through, and cut out a corner. We want to confirm that this
works for any custom shape, we're just going to accept
that and we want to move both. Immediately, the building
generator updates, but we have to move
some edges here. I'll move this one out a little
bit, as well as this one. Check for the update. I
see move out quite a bit. This one, we want to move
out a little bit as well. Now I want to bring the left
side one out a little bit. You might have these problems, you might not have
these problems. This is just because it's not snapping to great very well. That fixes the left side. Now for the right side, let's
bring it in a little bit. That's too far. Just not getting the snapping
point right. There we go. So, that's fine. And we've confirmed
that bolding one works. Boulding two won't have
an issue with working because we would
assume that it's just the same with
models change out. So with bowling two, let's
just test the floors. That seems to work. So let's
just delete building two, and we're just going to
assign the materials to this. So con cables, fake
gloss, granite tiles. And then the white
plaster, as well. Easy concrete for
the white plaster, but you'll be provided with
a white plaster texture. H we're going to save that and we're going
to drag bowling two in it's textis work. One last final thing want to test is we're
just going to drag the bowling in get it to
be on the ground level, you can see that the shadows aren't taking very well on this. We're just going
to do a convert. We're going to click convert. And there we go.
Now, the shutters and so on and all the materials
are falling correctly. So that does it for all
of the tool imports. From here, we're going to just refine the materials
a little bit, and we're going to start a blockout scene from that blockout scene where
then you're going to go to your final and we're
just going to make a nice looking scene
using all of these tools. This is the end of the
follow along piece. The rest of the pieces
is more about how would a environment artist use these tools if you
give them to them. So let's get into it.
10. Part09 Creating Our Scene Part1: A.
11. Part09 Creating Our Scene Part2: Y. Mmm. I I I I
12. Part09 Creating Our Scene Part3: And
FastTrackTutorials, Premium 3D Art Education
