Material maker 1.6 - your first brick wall, what is normal map, how does slope blur, and gradients
Watch on YouTubeVideo summary
In this tutorial, Anfa introduces Material Maker 1.6 by demonstrating how to construct realistic brick textures using a procedural, non-destructive workflow. The process begins with selecting a basic brick pattern and applying colorization nodes to define the distinct colors of the bricks and mortar. By manipulating gradient curves and interpolation modes—such as linear, smooth step, and cubic—the creator explores how different settings affect the transition between colors. While linear gradients offer sharp edges, cubic interpolation allows for smooth, continuous curves that can create interesting visual effects, though it requires careful management to avoid overshooting or instability when points are moved too closely together.
To add depth and realism to the flat brick surface, the tutorial explains the function of normal maps, which use fake normal vectors to simulate three-dimensional bumps on a two-dimensional texture. Anfa breaks down how normal maps store X, Y, and Z vector information to define surface orientation, noting that while they create an illusion of depth through lighting tricks, they do not actually extrude geometry. The video also covers the nuances between height maps and depth maps, explaining why values often need to be inverted in software like GDAU to correctly simulate protruding elements. Furthermore, the creator demonstrates how parallax occlusion mapping can enhance this effect by simulating view-dependent displacement, although true geometric displacement requires tessellated models which are computationally expensive and less suitable for real-time applications.
The final stages of the tutorial focus on refining the texture with slope blur and multi-warp nodes to achieve chipped edges and worn surfaces. Anfa compares standard slope blur with multi-warp modes like minimum, maximum, and blur, showing how these tools can manipulate height data to create irregularities that mimic real-world wear. To add variety, random noise patterns are generated using FBM noise and applied selectively to the bricks while keeping the mortar uniform, utilizing blending modes like overlay to maintain color saturation. The video concludes by adding grainy details to the mortar to reduce its cartoonish appearance, resulting in a textured, believable brick wall that serves as a solid foundation for further material creation.
Read the full video transcript
Hey, I'm Anfa. Welcome to another
material maker tutorial. In this
tutorial, we're going to make some
bricks because bricks are the bees
knees.
Wait, no, that would be hive. That would
be beehive. That's a bees knee. No,
wait. What? We're doing brick. Stop it.
All right. So, uh you should be already
a bit familiar with what you're seeing
right here. And actually what we can do
is keep this below others so our little
sweet um
key hint
stays stays visible. All right, sweet.
So let's make some bricks.
Thankfully, Material Maker provides us
with some brick patterns. Let's just
type brick.
And you can see that we have quite a few
different versions of bricks.
Now a cool thing is that we can build
with the simplest one
and make something that then we can
replace the basic underlying
pattern and achieve uh something very
similar but with
um well a different shape. So let's try
and do that kind of like a modular
approach.
Well, because this is all procedural.
This is non-destructive. So, we can
replace the
first inputs and all entire process is
going to just adapt and
work. That's the power of being
procedural.
All right. So, the very basic thing we
need to do is just see how this looks.
All right. I'm using my mouse wheel to
zoom. I'm mouse middle clicking my my
mouse wheel uh and moving my mouse to
pan. So, this is our brick. That's not
the best. I'm going to reduce the
resolution to 1024 cuz that's really not
going to make a big of a difference and
it's going to speed up processing and
maybe make this a bit faster.
Not that we need that much speed, but
well, I'm recording this at the same
time, so you know, it's always a bit
harder on a computer to just to do it
when you're recording rather than just
doing it. Okay, I'm going to try to make
this tutorial not 20 hours long.
Okay, so the basic thing we want to do
is make the brick stand out.
No, that's a different thing. First, we
need to change the colors.
So I'm going to do type colorize. And
you can see the second thing is filter
colorize.
And here it is. So now I'm going to just
drag and drop these here.
So now our output is colorized. Now
because the curve here is the gradient
is exactly the same as it was before
then well it didn't change much. But if
I swap these around, and we can also use
this little tools menu to reverse or
evenly distribute.
We can already see that now we have
black bricks with white mortar, which is
kind of more what we would expect. Now
I'm going to change the bricks to be
red. So, I'm clicking on this little
thing here, and double clicking opens
the color uh picker, but I can also
single click on this button on the
bottom. I'm going to pick my color of
brick. Pick your color of brick. Maybe
let's make it a little bit orangey. Tiny
bit orangey. Sweet. Clicking again.
It's saved. Now, what if I make the
transition to mortar a bit different?
like a little bit of a darker thing. So,
there's like a little outline around my
bricks. Cool. And finally, the mortar is
kind of blindingly bright. So, I'm going
to tone it down a bit.
Okay, that's a very simple, kind of
cartoony looking brick texture. We can
make it more, we can make it super retro
by dropping our resolution all the way
down. We could also change this
interpolation mode of our gradient here.
By default, it's linear,
but we can also go with
smooth step
or cubic
or constant.
Now, if we want to do pixelated bricks,
constant is going to be our friend here.
Um,
yeah,
that's nice. That's nice pixelated
bricks. Okay, but we're not going to do
pixels. Um, so I'm going to back off
from this and go to cubic. Cubic is an
interesting thing because
your nodes in this or your points in
this gradient kind of give the
trajectory. So
if we go with a histogram. Oh no, maybe
we can do it somewhere something else.
Is it called profile? Right, profile.
Okay, I'm going to insert another
colorize node just to show you how does
the interpolation work. Colorize.
So
let's go with this profile and going to
go with curve
and let's go with preview.
Now you can see this is our gradient and
this is our curve, our profile. I'm
going to make this a bit wider
and I'm going to go I think if I
shiftclick it's going to stick this one.
No control. Okay, control-clicking makes
it stick. So, you know, even if I click
on different nodes, preview is locked
here.
I can actually open up a second preview
2D. I think shift
locks things to the second one. Yeah.
So, if I hold shift and click
um on something, it's going to be stick
stuck to the preview 2D second. And I
can't if I controlclick on something,
it's going to be
put here. What is this lock?
What does it lock? Does it lock?
Um
Oh, this is the locking. Okay, so it
locks what is put there.
But I can still Okay, that's kind of
weird. I don't understand this fully.
Maybe I shouldn't be teaching you things
I don't fully understand. Let's go back
to things I do understand. All right. So
um I'm going to control-click to lock
this profile to the top and I'm going to
shift click.
Need to un shift click to put our
gradient. So now I'm going to open up
this gradient editor. Now we can do pin.
So this expanded gradient editor view
doesn't close when we click away. That's
nice. So now let's maybe switch the view
type to clamp
so we don't have this repeating thing.
And let's observe the
the profile. So you can see now this is
basically showing us the value from 0 to
one
in relation to the horizontal axis.
So I can basically draw a line using
this gradient. Now what look what
happens when I switch to smooth step.
You can see now it's a little bit of an
S.
And this S
if I insert a point here we have two
S's.
which touch.
So, this is interesting because it's
called smooth step, but it doesn't
really create like a very super smooth
transition if we have a point in the
middle. That's interesting, right? I can
right click with my mouse to delete a
point.
And I can double click with my left
mouse button to insert a point. So,
smooth is interesting.
It's creating this smooth curve, but
it's creating a smooth step curve
between each
pair of points. So, yeah, that's
interesting. Now, let's switch to cubic.
Ah, this is going to be cool. So you can
see by the way if you hit control you
can snap the position of
uh the point
to 10 like 20th of um
to 12th of the position. And also this
slider here is basically um letting you
set the position or you can even type
0.5 is exactly in the middle and you can
switch between points in your gradient
editor here. So you don't have to click
on these things at all. You don't have
to touch this bar. You can switch points
here. I mean okay you do need to touch
it if you want to add a point. I think
there's no other way to add points other
than double clicking.
Right. But let's go back to our
nice little curve. I'm going to delete
this and I'm going to
try and hit. Okay. So, you can see cubic
is actually really interesting.
If I move this middle point, you can see
that we actually have a very smooth
curve.
Oh, so if I go too far, that curve kind
of overshoots.
Now, if I go back, if I insert another
point,
you can see that cubic kind of goes
bonkers uh in a good way. So, I'm going
to insert a bunch of points. And the
cool thing about a cubic is that it can
stay kind of sort of linear.
But if you start moving things around,
you can see that everything is kind of
like
behaving like this line is like a trace
of an object that has a mass and it
accelerates upwards and downwards and
like
so the curve is smooth in that the
derivative of this curve is continuous.
I don't see any discontinuities.
Not so much with smooth step. There's a
bunch of discontinuities. I think if we
took a derivative of this, we would have
a bunch of discontinuities. So this is
not
uh a smooth curve if I as I would say
which is interesting given the name
smooth step. But cubic interpolation,
yeah, it does make smooth things. But if
you put the similar values too close
together, look how crazy it gets.
That's insane.
I love it.
Right. So, that's what that was a little
digression about the gradient editor and
the curves or our interpolation type.
And now, let's go back to linear. You
can see this is exactly what you'd
expect. Sharp corners,
not not a smooth curve by any means, but
there is no overshoot. And with cubic,
well, there is overshoot. And you can do
crazy things if you're not careful. But
you can also achieve some really nice
smooth curves. Love it. Okay, let's get
rid of these. Delete. Let's go back to
our brick. I'm going to zoom in with my
mouse wheel. My mouse wheel.
And let's switch to preview 3D. Okay.
So, this is nice, but the bricks are
kind of flat. So, let's add a normal map
and just take this,
put it through the normal map and put it
into the normal map output. And just
like that, our bricks are now looking
bumpy.
Now, if you don't know what a normal map
does, we can visualize it if we
decompose
its output. So let's connect this to a
decompose node. And now the decompose
node basically
takes a multi- channelannel
input like a color
which is red, green, blue or an RGBA
which is red, green, blue and alpha and
it outputs red, green, blue and alpha in
separate channels. So we can look at
them. Now we can see this is red and
this
is the horizontal information of our
normal map. So this tells us the gray
thing is the neutral,
the black is pointing to the left and
white is pointing to the right.
If we go back to our normal map, you can
see these are the edges of our bricks,
the vertical edges of our bricks, which
create patterns in the horizontal
component of our normal map.
Interesting. Now, let's look at the
green channel of the normal map. Huh.
Here we have the horizontal edges
creating patterns in the vertical
component of our normal map because we
have horizontal X and vertical Y.
Now, if you put them together, we get
this. Now, you might be used to a normal
map looking a little bit different, and
I'm going to show you why. Normal
convert.
So, if we convert this normal map to an
OpenGL format, I think um well, we can
see what happens. I'm going to control
shift D, duplicate this decompose node,
and now we can compare. So you can see
that it actually flipped the ver the the
the value of our horizontal information.
So the red channel it's flipped. What
was black is now white and vice versa.
How about the horiz vertical one? The
vertical one stayed unchanged. Okay.
What about the third one? What did the
third one even do?
Well, that's the interesting thing. So
he see this is blue.
So X Y Z this is the not the vertical
this is the third dimension this is the
depth depth information in the normal
map. What? Yes.
And let's look at this one. Oh, it's
also inverted. What was black is now
white and what was gray is gray.
What? Yes. So you can see the normal map
contains
nothing more than a vector a three
component vector. So xyz that's a free
components of our vector. Every pixel in
here
and there are pixels if we look really
closely because the normal map node has
a buffer and so it converts
it renders our shader which is doesn't
have pixels. This is like you know
mathematically defined. This is infinite
precision. It's as many pixels as you
ever want to show. But their normal map
has a buffer which you can disable.
By the way, if you do controll and click
and drag up, you can zoom in as well.
I'm going to disable the buffer and you
will see that this changes a little bit.
Huh.
Let's switch to a much more chunky
thing. If I turn on the buffer, you can
see that
this is smoother.
Now, we normally want the buffer because
converting things to normal map is a
little bit of expensive thing. So if you
have anything more complex behi before
the normal map node, if you disable the
buffer, you might suffer some
performance penalty.
Let's go back to 1024. Okay, so
right back to the normal maps. I keep
going into degressions. Well, I guess
that's going to be the theme for these
tutorials, digressions. But I hope
you're going to learn things anyway.
So horizontal vertical
for dimension
depth.
So this is the value that says how much
does the
point on this normal map point towards
the screen. When it's white, it means
it's perfectly perpendicular to the
screen or parallel rather. Sorry,
perpendicular. Perpendicular is the
vector is the normal vector. So normal
vector
is the vector that is perpendicular to a
surface
and a normal map is imposing
a different normal vector that is not
real. It's fake. It's a it's a trick.
It's a mathematical trick to make flat
things look bumpy. So it's imposing an a
fake normal vector onto a flat surface
which interacts with the lighting of the
3D scene and gives us the feeling sorry
the look the appearance of depth of
three dimensions even though the texture
is really flat as we can see
can I yeah if I hold shift
I can look you can see that our bricks
are not really sticking out
however we can fix that too you See if
we connect this thing to here.
Well, now something weird happened.
First, let's think that what we've just
done. So, this is the depth input.
GDAU exposes this as um depth mapping or
it's sometimes called height mapping or
displacement mapping.
So what this does is it further
simulates depth. So now if I zoom out
you can see that our bricks appear to
have parallax effect and that is exactly
what is going on. There is some shader
trickery going on that looks at every
point on this sphere and says okay from
which direction is the is the view is
the observer looking at us. So where's
the camera? Okay. So if the camera is
here and our normal vector of the
geometry is this, then that means if we
offset the sample of the texture
underlying this direction by that much,
it's going to look like this is bump.
This is uh extruded, which is a neat
visual trick, but it's not. There is no
geometry behind it. So this is wrong. Of
course, we can fix that by inserting an
invert node. I'm going to click, drag,
drop, and type invert. Enter. Click and
drag and replace the depth input.
Huh, nice. Now, why did that work? So,
if I click here, you can see this is our
black and white. This is our mask for
bricks. Bricks are bright.
Grout is dark. Grout mortar.
What does it tell us? that the high
values correspond with things sticking
out. But this is called a depth map. So
in a depth map, the bright values are
pushing in and not sticking out. That's
why we had to invert this. So our bricks
now are black and our mortar is white.
So this is converted to a depth map from
a height map. This is called a height
map. This is a little bit
counterintuitive. I kind of wish that
material maker would hide this off this
weirdness uh and just call this a
height,
but it kind of forces you to think more
akin to what is really going on because
we can only simulate things being
um extruded inwards. We can't really
properly simulate things poking out. As
you can see our our silhouette is still
totally totally flat. Now there is there
are is technology to do parallax
occlusion mapping which this is doing
with silhouette correction. I don't know
how to do that but it's possible. It
exists. The technology is out there but
we don't have it in GDAU at least. I
mean unless you implement it yourself or
find some shaders
but we can do this. However, we can
still do better if we switch the model
configure and do it tessillated.
That's going to make our sphere more
dense but well that doesn't show any
difference. Okay, I'm going to switch
this static PBR material type. I'm going
to right click on top and go to static
PBR material displacement.
Click.
Whoa. What just happened? Look, our
bricks are actually physically
as much physically as pixels on a screen
can be. There is actual geometry now.
And unfortunately, it's really not high
fidelity. So, let's go back to the model
menu, sphere configure, and click this
tessillated, which adds a lot more
geometry that can be displaced. And this
is a proper displacement material.
Now, if we wanted to export this one,
I don't know how it would export to
GDAU. Honestly, I haven't tried doing
static material. I have not tried using
displacement materials for GDAU, but
this wouldn't work well in Blender. And
I believe it's well no I don't think we
can do 3D displacement here but
yeah this is what you would do if you
were making materials for offline
rendering
because tessellation kind of fell out of
favor because it's quite expensive and
there are cheaper ways to achieve
similar effects that are not as
hardcore.
So uh we don't generally use the
displacement
with actual geometry and vertices being
pushed in and out. Uh we usually use
parallax occlusion mapping which fakes
that effect. But of course our
silhouette is going to be wrong. And you
can see it is pushing in instead of
pushing out.
But well that's the best we can do. Now
we can tone this down a bit with our
depth
slider. And I will tone it down a bit
because it looked ridiculous. H we can
also crank it up just for fun. It does
look trippy, doesn't it? It's like
there's like we're looking for a lens
like a looking glass or something. I
don't know. Weird. Weird.
Let's make it rotate a little bit. And
back off with this depth effect. Let's
type in one 0.5.
0.15. Okay, let's get rid of this
business
and let's go back to our brick. Now,
every
Substance Designer tutorial for brick is
going to use slope blur. Let's do that
cuz you're going to ask, how do you do
slope blur? Well, like this. Okay, I'm
going to do the same trick we did
before, which is shift rightclick on our
output, which inserts a reroute node. By
the way, we can right click and we can
have a preview in here.
Route nodes are cool like that, huh?
Let's make it a huge preview. I like
huge previews. Huge previews are the
best previews, won't you agree? Okay,
now slow blur is an interesting effect.
It's kind of doing multiple
passes of displacement at different um
Why am I talking about this? I'm just
going to show you. Okay, we need some
some noise. So, let's go right click.
Now, we can learn another thing while
we're at it. So, you can see on the top
here, we have a a bunch of things. Drag
a node from the list to the slot to add
it to the quick access. So, this is a
quick access menu that is populated with
a bunch of things.
That's interesting. And we can drag in
different things.
Cool. Okay. Let's see what's the first
one. Shape. Uhhuh. Noise. FBM. All
right. Colorize.
Transform.
Tyler.
Blend. And math. Well, that's all useful
things. We're going to use noise FBM.
Let's just connect this to the height
map of our slope blur. Click on it. And
look at that.
Well, it's a bit much. So, I'm going to
turn down the sigma.
Now, if I connect this to our route
node, reroute node, you can see our
bricks are now kind of wonky,
and we generally would like that.
Okay, this is not necessarily
what you would do in a standard material
substance substance designer tutorial.
What you would do is something called
multi wrap. I mean
multi wrap is like a better version of
slope blur which can do a bunch of other
things. So let's go and do that. So I'm
going to connect the same inputs.
Now, if we compare,
there's an important difference. I'm
going to switch this.
Wow, look at that. That's nice. This
looks like our part of our bricks are
just, you know, broken off. Awesome.
Let's turn down the intensity to one.
Okay, that's low. Maybe two. Cool.
Oh, nice. All right. So, how does does
this work? And why is it different than
slope blur? So slope of blur would be
identical if we selected blur mode in
multi-warp.
I mean it's not identical because the
the intensity is different.
It seems like it's a little different.
Okay, it's not identical. It does look a
little different, but it's quite close.
So slope blur is kind of like multi-warp
in blur mode,
but multi-worp has the power of being
able to do minimum mode and maximum.
Now, it's kind of hard to understand
what this is doing, but we're going to
make it easier. We're going to use a
math
node and we'll connect the original
input
and subtract from it the multi-warp
output. So I'm going to change this mode
from a + b to a minus b. That's a
subtraction.
And now
you can see.
Okay. One more thing. I'm going to
duplicate this math node and I'm going
to add
um
absolute. Absolute.
Yep. So now this turns negative values
into positive values. Cool. Okay. So
minimum,
you can see the difference here is that
we're just chopping things off.
Blur is we both chop things off and add
things in.
And max we are only adding things in.
Maybe this isn't the best. Maybe if I
did this that would be better.
Okay. Yeah. So the difference blur, we
are both adding and subtracting. Min,
we're just subtracting. And max, we're
just adding. Okay, that's kind of weird.
This looks cool, though. Um, maybe we
can use it somehow. I don't know. All
right, so basically minimum is um it's
applying warp multiple times and then
it's calculating the lowest value. It's
like storing the lowest value of every
warp. We can do a warp on our own if we
go with warp node. So what does warp do?
Uh warp
we need to change the
the epsilon which is the distance of
sampling the input the the height map
and warp as you can see kind of does
similar thing to our slope blur.
So how is this even different? Well, the
difference is in the corners. You can
see warp has our gives us a sharp
corner, but slope
gives us a blurred one. Now, why? That's
because slope blur is well, it's doing
warp, but it's doing multiple passes of
warp and averaging them together. The
cool thing is we can actually recreate
that if we go with variation.
Iterate
iterate variations. Haha. If we connect
this here, now we can have up to four
different variables that this node can
iterate for us and combine the results
with a given function.
Crazy. Let's go. So, I'm going to change
the strength to be dollar question mark
one.
Look at that. Our iterate variations is
giving us something very close to our
slope blur. It's just there's
more steps. So if you make the steps
smaller.
There we go. Plus maybe if we increase
the resolution. Oh, but now sigma is
different. Yeah.
Oh, but we're not doing blur. We're
doing max. Look, if I do average though,
we get
almost the same thing as slope blur.
There is like minor differences, but
it's really it's it's pretty much the
same thing.
So, you can make your own slope blur
and yeah, just add add a buffer after
after this. Oh, no, sorry. Iterate
buffer is a different thing. Iterate the
buffer is an incredible tool, but that's
I would call that an advanced thing. So,
um, we'll do that in a few tutorials, I
think. Um, okay.
That's that was supposed to be our first
brick. Shoot. Okay. We we've done a bit
of um exploration,
so we stick to multi-warp in minimum
mode. You know, it does them blur. It
does the warping multiple times at
different strengths and then just keeps
the smallest values that that result
from this which gives us this effect of
our bricks having chipped edges which is
perfect.
Now there are few things we could
improve. One thing is I would like this
mortar to be smaller. So I'm going to
change the mortar and make it less.
I'd like to increase the bevel.
I'd like to round the bricks a little
bit. So, let's round the bricks.
Nice.
And I also like to change the color of
every brick so it's not the same brick
every time.
Now, that's going to require us to use
the fill.
So the fill, if I click on it, maybe
I'll reset this
center view.
The fill contains information about
areas, distinct areas in this
in this input
or on our canvas. If I click and drag, I
can connect fill to
fill to random gray.
or random color. Random gray ploop.
Click. Okay, that gives us a different
colors for every brick. If I click, left
click here to randomize. You can see we
have different random patterns. I'm
going to just find one that seems most
uniform,
like least
crazy.
Okay, this is fine.
Okay. So, what I want to do now is
change the color of the bricks. So, I'm
going to add a blend node. I click and
drag. I'm going to click on this and
I'll connect this here
and this to LBO. Okay,
that kind of does what I want, but not
not entirely.
I like that it changed the color from
deep reddish orange to beigy. It's kind
of actually kind of nice nice color. The
problem is that our bricks are
there's like really sharp cutff change
in in the between the bricks. We don't
like that. We need to make it so that
the mortar is uniform color but the
brick itself is not. So we need to mask
this out somehow. Okay, maybe we can use
this. What if I just connect this to our
opacity?
Oh, look. That just fixed it.
Huh? Why?
Well, because this is a mask that shows
our bricks in white and the mortar in
black.
If I connect it to opacity, I can even
make it 100%. that makes it so our
random gray is only mixed or blended
in places where this mask is white. Now,
if I change our
mortar color to blue, so it nicely shows
up, you can see there is a smooth
transition between the blue and the
color of the brick.
If I back this off, you can see.
Yeah, it's exactly the same thing.
I'm going to change this back to neutral
gray.
And now,
so we've masked our bricks to give them
different colors. The problem is they're
black and white, but we can change the
blend mode. Maybe overlay is going to be
nice.
Just a little bit. Yeah, it's perfect.
Some bricks are a bit darker, some bit
bricks are a bit lighter. Overlay is a
great mix mode. It's kind of like making
if the input is lower than the if the
background is smaller than layer one,
then it acts like addition. No,
I don't remember. There's
there is some place where there is
descriptions for all of them but overlay
is basically make it can a neutral gray
thing
will not change anything. So if I go
uniform
and I select grayscale
if I plug that into layer one
I can crank overlay up to a million.
Well okay maybe not that high.
Okay, I think I'm going to like I'm I'm
bumping into um rounding errors, but um
you can see that uniform gray which is
like sorry uniform gray middle gray.5
gives absolutely no difference at all.
The color between these two is not
changing. If I plug in the random gray,
well, that is changing.
So, you can see overlay is a great
blending mode. If you have ever painted
textures by hand in Photoshop or or
CDA, you probably have used overlay
blending mode a lot. It's amazing for
adding highlights and shadows and
altering colors of things. If you just
give it black and white, it can vary the
brightness while keeping saturation
of the colors. So that's great because
if we did normal blend mode, that would
achieve a similar thing, but it would
fade our colors to to to nothing to to
desaturated grays, whites and blacks. If
I just switch back to overlay, yeah,
some of our bricks are black and some of
our white, but as soon as we back off,
we still have saturation. And if I
switch to normal, well, it's all
grayish.
So, overlay, there are blending modes
worth um exploring.
Some of them are more crazy than others.
Maybe you want a hard mix. I I won't
judge. Actually, we could use hard mix
here. It kind of does cool things. Make
some of the bricks more orange.
I like that. That's nice. Okay, you know
what? Let's do one more thing and we'll
cut it cuz we're already 40 minutes.
Let's keep these under an hour. All
right, so we have our bricks, but the
mortar is kind of uniform. This is
really cartoony. Let's try and make it a
little bit less cartoony.
How can we achieve that? Well, maybe we
can make our mortar a little bit grainy
like a little like real mortar is. So,
let's get some grainy patterns. How can
we get that? Okay, right click.
Maybe noise.
Okay, let's zoom in. Well, if I increase
the scale to maximum on both axes.
Oh, that's grainy. Okay. Um, okay. I'm
going to shift
right click again to insert another
reroute. Oh, it's funny. It's
disconnected it.
Um,
okay. I'm going to insert a blend.
I want to be able to insert. Um, sorry.
Now, this blend blends are a default
thing. So, it it breaks our stuff. Let's
Let's turn it to not zero. So I want to
pass this thing to colorize
and to opacity.
But for depth and normal map, I want
this with an extra graininess.
Let's put it in here.
Um, and actually
turn it on. Okay.
Well, that's green. All right. Actually,
kind of looks good on the bricks, too.
But I feel like we need more on our
mortar and less on our If we blend this
all the way in, it kind of makes
everything look flat. That's really,
really weird. How about overlay again?
Oh, that's interesting. So, now it seems
like it's kind of chomping into our
bricks and popping out of the mortar.
That's really cool. Now, what's going on
here is we're basically clipping. So, we
are adding bright values to something
that's already white and it's being
clipped. So, that's why we're losing
detail. Uh, in here, it's kind of neat.
Actually, looks cool. I think I might
keep that. I just want to try one thing,
and that's going to be a math node.
Let's go click and drag. Bloop. And
let's go smooth step.
And put this back in.
Huh, that's interesting.
I'll just have less of that.
And I'm going to make this smaller.
Um,
by the way, you need to keep this uh
powers of two unless otherwise it's not
going to repeat correct correctly. So,
you can see if I do 17, it's like wait,
does it
it does correctly repeat? What the
flick?
Something changed. I guess that's might
be that that must be new.
Okay, we can go 15* 15.
All right, so this is actually some cool
detail on the bricks, but it's not what
I wanted to do. I wanted to do something
else. Let's go add another layer. And
this is going to blend this pink white
gradient, which is the default. Let's
disable that. I want more grain. I want
a different grain. So, I'm going to add
more FBM noise. Let's change the type.
Maybe simplex.
Cool. Let's go back. No. Okay. Sweet.
Random seed. All right. That's really
grainy. Let's try that.
Okay. Now, I just want this grouch to be
um
to be sticking out. So, I'm going to
select the blending mode to be additive.
Oh, that's great. That's good. That's
nice.
I I'd like to just not be affecting the
bricks, though. So, let's do the same
thing we did previously with the color
changing or variation. And just drag and
drop this here to opacity.
Now, what does this do? Oh, it makes it
so that that only applies to our bricks,
of course, because we need to invert
this. Okay, so click and drag. Ploop.
Invert. Oh, it's Look, it's here. And
now I'm plopping this here.
Okay, that does what we expected it to.
Let's move these things back so we have
a little bit more
cleaner view.
Okay.
And I would say this is a brick. All
right.
Not the prettiest one, but if it's your
first brick, that's not a bad one.
Yeah,
let's call it a day. Thank you for
watching. I hope you've learned
something. If you have any questions or
suggestions, please leave them in the
comment section below. If you want me to
make more, you can help me by donating
money. Uh, you can find me on Patreon,
patreon.com
or on Libraay, libape.com
or on coffee
co-fe.comorg/adalpha0000
or you can just go to my website anfaxyz
and find all the links there. Or you can
just enjoy your life. Hopefully you do.
Peace.