Is this a procedural raspberry? Yes, it is. Is it done with geometry nodes? Of course it is. And is it hard to make? No. So, let's make one, when we
need to create a raspberry, we need a base mesh. And this is our base mesh. So now we go to this new
geometry nodes workspace, and let's add a new set of geometry
nodes. So when we look at the
raspberry, we see, it has some balls, right? I don't know how this balls are
called in English, but let's say these are like the juicy
balls, right? So for that, we can use a Point
instance node or a point distribute node. Point instance creates points
on every vertex of the mesh. So let's add a small cube here. This is gonna be the tiny
ball of the raspberry Now for the original raspberry, We're gonna instance this tiny
ball, right? And now on every vertex we have
this tiny ball and we want to make it also smaller. So let's add an attribute fill
node, which is gonna allow us to fill the scale attribute
with a certain number. So let's choose the scale
attribute and let's fill it with the value of 1. They have exactly the same size
as the sphere has here. Let's make them smaller and you see on every vertex, we have a point. This is not very raspberry-like. So let's use another node
called Point distribute. You see random written here and this
means that the points are going to be distributed randomly. Just as you see here, we can
increase the density, and we have more, but it's still not
looking like a raspberry. What a raspberry has is a hole
on the top. So to create this hole here, what we have to think of is
that let's say it's a raspberry, and we're gonna make this a little
bit bigger. We want to make sure that the
hole is appearing around here and on the Z axis. This part here is 0, right? And this part here is one and
this here is two... So to create a hole here, we just have to get
rid of all of these balls, right? And we have to make sure that
the density of the point distribute is 0 there and 1
down here, and we can do that using a compare node. So we can use the attribute
compare. And with this node, we can
compare the Z position of this raspberry. So, let's type in here Z
position of this raspberry and we can compare it to a
Float, which is a single value. In our case, this should be one,
right? And this results in an
attribute called density. When we input this density here,
everything disappears, and that's because you see, there's
a little exclamation sign here. And this says that no attribute
with name ''Z position''. So we have to create an
attribute called ''Z position'' and to create this ''Z position''
attribute, We can take the position
attribute and divide it into three different parts. X, Y and Z. And for that, again, another
new node called Attribute Separate XYZ, let's type in
here position. Since this is the attribute we wanna
divide into three parts or separate into three parts. The result X is going to be X. The Y is going to be Y, and the
Z is going to be R No it's gonna be Z of course. Now we have these attributes X,
Y and Z. We could actually call this
also Z position since this is what we are going to use here. And as you see, we have this
effect, but it's inverted and that's because everything
that's greater than 1 is going to be having the value of One. So everything that's greater up
here is having the value of 1 for the density. So all the balls are going to
appear there and if you want to have it
inverted, we can just switch it to less than. So everything that's lesser or
smaller in value than this one is going to have the density of
one. The balls are going to appear
there. This is already more like a
raspberry. I wouldn't Eat it definitely. It looks like too scary... What we have to do now is to
change the scale of these points to be random. So if you want to do something
random - for that we have a node called Attribute randomize
right. So let's write here scale and
now the scale is randomized from 0 to 1. We don't want that. Let's just play around with
those, you know, and you see they are overlapping in a very
strange sense - to fix that, we can use the poisson disk of
this point distribute and this algorithm just gives you the
minimum distance between two points. So when we increase this, it's
looking more like a berry, crank up this density and let's make it not so random in size .28 is
looking pretty nice. What we have to do is to deal
with this aging animation or ripening
animation to create this ripening animation. We have to make this berry
bigger, we can displace every point by the normal. The normal is telling us in
which direction is this ball for example, looking at. It's
looking around there and this ball down here is looking down
and this one here is looking at this direction and so on. So if you move every ball
outwards by this direction, well, we should have a bigger
berry, right? So to do that, we can use an
attribute mix node. attributes. Attribute mix. And let's add to the position
of these points the normal of these points,
and this is going to result back in the position, right? Because we eventually want the
position of all these points to change. Now, we have this Factor slider
and when it's zero, it's the same thing as before. But when you move this up, they
are gradually getting bigger. The young raspberry does look
okay But the old one does look very
strange because it has holes in it We can fix that by going to
this poisson disk distribution here and changing the minimum
distance. And also making these balls a
bit bigger. Maybe change the seed, if
something looks a bit too strange. And now this is a raspberry,
right? But here's the problem. The small raspberry is like a
ball, but the big raspberry is also like a ball and this isn't
correct at all. The bigger one should be
something like that. Let's add another attribute mix
note and let's think what we can do to solve this retarded
looking raspberry, right? So we can take the position of
these points and multiply their Z location with a larger
number. So that thay become stretched out
on the Z axis. And if we wanna do something
on a single axis, we can use a vector X Y & Z. We have to change them on Z
axis and the result will be the change in position, right? Now it looks like that, and when I
mix those, it does something strange. The first thing we have to
fix is to make sure it doesn't mix between this position and
this Vector, but it multiplies the position
with this vector and this creates something better, but
still it does look pretty retarded. So type 111 here because when it's zero, then
it's just going to eventually become like a worm or line whatever. So let's type in here one and
let's make this one here a bit bigger. Turn this Factor up. Let's make sure that our final
raspberry is going to look something like that. So that's a small raspberry and this is the big one and now let's use a value node
as the factor of both of these so we can control it. It's small. And now it's big, small, big,
small, big, middle-sized. We do have some problems with
the points. So we have to adjust something
here with this distance between them and maybe
make them just a tiny bit bigger. The raspberry is looking
pretty nice and you think this tutorial is gonna end here...
No, it isn't, we have a problem and the problem is that
when you make it smaller, put the 3D cursor here and make it
bigger. You see it has moved up and if
you have some leaves and some stalk of this berry, then it's
gonna intersect and it's not going to look very nice. To fix
that, we're going to use another
attribute mix node. Let's drive the position again
with a vector and result. back in position. But which kind of a vector? Well when it's small, it is
here. And when it's big, it should be
here. So it has to be moved down on
the z-axis. So, on the Z axis, we can
subtract something from the position of this raspberry. So, let's use the subtract here. Put the factor to 1 and let's
subtract something like that here. So when I move this factor to
zero, it's up there. And when I move it here, it's
in the correct position. And let's use the same value
here. And now, when I make it smaller, or bigger it stays in the same
place in the range of 0 to 1. If this raspberry is already
picked, it's empty from the inside, but when this raspberry
isn't picked, it has an interior. And we're going to create this,
of course procedurally. We add a cylinder because now,
you can add meshes in the geometry node workspace. And let's also add a join
geometry node to output both of these - cylinder, and also the raspberry to the
geometry output. First, of course, the cylinder
is very sharp. So let's add a Subdivision Surface modifier and put it here and increase
the level of it. And let's not use the Ngon but the
triangles. So it looks like that and this
is a pretty good interior already. We have to make it bigger and
for that we have a transform node, transform node and I'm
going to put it in a better space here like that. So transform node has the
translation, rotation and scale first, let's make it bigger
let's use a combine XYZ node and let's input 1 everywhere. So now it's the same scale as
it was before. I use the combined XYZ
because I want to have more control over the XYZ, when here, I can just only have
one input and it changes all of these values at once. So I take this vector, plug it
here, and let's make it bigger on the X and Y, something like
that. And on the Z, it should be
something like that, add another combine XYZ, plug it
into the translation and let's move it down on the Z axis. But now when you make
this smaller and actually, I should have a quick control for
that. So let's plug one from here
from here and also from here now we have a single control
for all of these parameters and we can call this AGE when the AGE is at one it looks pretty nice. When it's zero, it doesn't look
very nice. So we have to use the same age
value and drive the translation and scale of this interior basically When the age is at
one, it looks very strange now and when it's at zero it looks
even more strange. It has disappeared. So we can fix that by using a
map range note. Let's take the map range node
and let's drive the scale by this one node for a moment or
actually just X and Y scale. So the map range takes the
original scale which goes from 0 to 1 and you see from minimum
0 from Maximum 1, this is the original scale and it remaps it
to a different scale. Right now, it's at the maximum
position so we can increase the maximum as you see, it isn't
wide enough. So, let's increase the maximum
to something like that. And now, let's turn it down and
it has disappeared. So, let's increase the minimum
to something like that. So the X & Y scale of this interior part is looking pretty nice. The Z isn't very nice. So let's make this map range smaller. Let's add a new one here. Let's connect it to Z scale. We can't make any decisions right now
because it's offset so much. So let's use another map range And this map range is going to
drive the Z position. Turn it down to one and it's at
the minimum position. So we have to change the minimum to here. And when you move it to the
maximum, let's also turn this maximum down. To around here. And now what we can do is to go
back to this scale thing here and adjust the Z scale to make
sure it's perfect. And now that we have mapped
everything, You can see that the age and
the interior part are in a pretty good correlation. It looks like a raspberry! And
now we have to one final detail and this is adding these little
hair on the surface of this raspberry. I have three wonderful hair and
we're going to put them on the surface of this raspberry. To make these little things appear on the surface of
this raspberry. We could use the same point
distribute node or the points created by this
point distribute note and just instance on the same locations. But you see like they're
appearing on the exact same locations and this does look
pretty weird. So what we have to do is to
duplicate this whole thing like that and drag the geometry
from here - now we have two identical
copies of the shape of the raspberry. The first one is going to be
used for the raspberry and the other points are going to be
used for the little hair. So let's use another Point
instance node, and let's drag the second copy
here. Let's use the collection.
Uncheck the whole collection, and let's use the, I called
them ''tails'' in Estonian, drag them do this join geometry,
and we can't see them. Well, that's because they are
too small. So let's use an attribute fill
node to fill this scale, attribute with a different
number than the small number they have right now. They are
still in the same locations and that's because well, it's an
identical copy you know. What we can do is to
change the seed and they're looking different now, but also
there isn't so many hair on a raspberry. This would be kind of gross. So we can increase the distance
and also bring down the density quite a bit. And what we can also do is to
change the scale and maybe even randomize the
scale. This is looking more like a
real raspberry. The raspberry is ready. We have a lot of nodes here and
we have this single AGE Oh, you see, I forgot to use the
quick controls on the nodes down here as well. And here and now when l make it
smaller, it works you know. So the raspberry is ready now. You're gonna ask me how can I change the color of
the raspberry when it's getting older?
Well, for that, we have drivers. So you go to the shading
workspace, you add a material for this little ball here,
which is the basis of this raspberry. And for the base color, you add
a MixRGB node. When the factor is at 1, it's
going to have the color when it's like ripened. So something like really really
red. And when the factor is at zero
it's gonna have the color of something very fresh and not very sweet to eat. And now we have to change
between this and that, when it's getting older or when it's
still young. Now to make this slider move with the age, we're
gonna use a driver. Right click here and add a driver,
go here and select single property. So a single property in Blender
is gonna drive the value of this MixRGB node. The object is gonna be our
raspberry, and the path is the data path of this value. So, to get this value, we're
going to select the raspberry again. Take this age thing here and
copy data path and back in this material, we go and
edit this driver and paste the path here. And now when you change the age
it's getting greener or more red and now you just add some
subsurface scattering connect the color to the subsurface color
like that and then transmission and this is like a raspberry. I'm not going to show the whole
material because this is not a point of this tutorial. If you want to see what I used
the material is here. I'm also not going to show you
how to make these leaves because you know, the leaves are really
simple, I believe in you You can make these - they are
just planes with a green texture, you know. So well done! Now you have your own
raspberry. They are useful, you can make tea or
jam or animate them... Well you choose. If you have a
thing to ask, Let me know, either me or
someone from the Subscriber Mafia will help you. And that's pretty much it. I'm gonna go.
