Original subtitles

by the end of this video you'll understand all the fundamentals of the array modifier and see

just how powerful it is on its own what's up i'm jonathan and welcome to maker tales where i'm

sharing my maker journey to help you go further in yours so don't forget to subscribe and hit

that little bell icon to never miss an opportunity to keep making this video is all about the array

modifier and just how powerful it is all on its own i am having to do just on its own as it's such

a powerful modifier with other modifiers that i want to show you just the modifier itself and then

how it does with other modifiers later on starting from a fresh blender file let's invert our

selection delete our camera light because we're about to explore the array modifier now before

i jump into this i need to say that i am going to be splitting this up into two videos one is very

much just the array modifier in itself what it does and everything about it the next video will

be things very similar to the array modifier as well as advanced use cases of the array modifier

because the array modifier is a behemoth it works so great with other modifiers so let's go ahead

and let's get started with this remember that if you haven't followed me on the other modifiers i

really suggest that you do at least the other modifiers if not the entire course because i

really have gone into a lot of detail so let's go ahead and let's apply this array now if you don't

know what an array is let's make this a little bit more visually sort of clear what's going on

so let's go ahead let's put on our wireframe so we can see the wireframe and let's take a look at

the modifier itself so right this minute we have a fit type of fixed count of two let's ignore this

offset for now but so one two there we go we have two cubes here one is the original the other one

is this copy keep this in mind though they are a copy they aren't mesh so you can't go ahead and

edit it but you can edit the root object which edits itself so this is so to speak an instance

of the array okay so that's that now let's talk about this whole relative offset thing we will

go into the fit type a little bit later so this relative offset right this minute is set to one so

why is this here what's exactly going on well the relative offset is based off the bounding box we

learned this over in the boolean modifier exactly what it means but basically it's a box that can

fit around your mesh as close as possible so that would mean that if we set this to two

you would have the space in between these two right now to have another one of those meshes

and just to illustrate this a little bit more visually let's just move this on the x and you

can see that there is enough space now to fit that there however if we were to move this on the y and

by the way this here is how you can do diagonal arrays so if we increase the count you'll see it

there we go a diagonal array and so just on the y you can see that the bounding box is

just as wide as the cube itself all right let's undo that i hope that explained the relative

offset now let's talk about the constant offset one thing to keep in mind while we're going over

there is that you can have two of them on at the same time i haven't really used this that much but

i have seen some people create some great things using multiple offsets on arrays all right so what

is this constant offset well the best way that i like to look at it is basically think of it as

you're duplicating it so doing a shift d and then moving it along so if we drop down here

you can see we're moving along one millimeter and that's exactly the result we would get here

so as you can imagine if we move this by three and our cube is two millimeters you can see that

up at the top we have one millimeter gap between these two all right i think that's pretty clear

on how that works and you can obviously set this on the y and the z however you're wanting

right so let's go ahead and let's increase our count to five for now i want to skip over this

object offset right now because it's going to be way too complicated to go straight into that

because we'll spend the rest of the video on there so let's talk about the merge and the caps i'm not

going to talk about uvs because we don't really use them in precision modeling so this constant

offset let's set this to two so they're touching right next to each other and we now already know

what a merge would do that's basically gone ahead and merged all of our meshes together here because

right this minute this is a real mesh but when you go ahead and apply it it would go ahead and merge

all of these together all right so we understand that from many other ones and now we have

this here caps what exactly is a cap well i'm pretty sure you can gather what a cap is but if

we create some mesh you will understand a little caveat to keep in mind here so we're going to move

that there do a shifty and we're going to do a strange edit to this one and apply the scale of it

so right here first things first before i put in any cap i want you to see that if we go ahead into

up here and we go to our tools and our origin point we can move our origin point wherever

we want it doesn't matter because the array is doing it off the mesh itself not the origin point

now let's do the same with caps once we show what that is so the start cap another little caveat

is it's before the beginning and this is after the end for the end cap it doesn't go ahead

and put the first one right at the beginning and right at the end these are like additional ones

and they will use the origin point for this and if we go ahead and move the origin point now

you will see how it affects the end and start okay so with that covered let's go into the more

complicated things now so to get more complicated let's start on the easier side of things i'm just

going to undo here and delete these here let's just quickly cover the fit type fit type isn't

that complicated but it can be a little bit weird so fit type we have fit length and curve i think

they're pretty self-explanatory here so first one fit length right this minute we have this set to

three millimeters the length is zero so if we set this to 30 we should basically get 10 of these

let's take a look we have 11 along here because basically it's taking it from the relativity

of the middle of the bounding box so it has just that little bit extra to be able to make 11.

but as you can see depending on the length is depending how many copies it's going to make along

that length type now you might have got quite excited seeing this little fit length saying fit

curve now it is quite interesting this fit curve so let's go ahead and let's create a bezier curve

so we've got this bezier curve i'm going to scale this up a bit i'm going to apply the scale i'm

going to move this over this way a little bit and then let's go ahead and tell our array to be that

bezier curve and let's take a look at this on the top so as you can see on the length of this curve

it has gone ahead and arrayed now if we go ahead and edit this curve you can see that it will

be less and more keep in mind that it does take into consideration the total of the curve so as

you can see as we stretch this curve out it gets longer because technically that's what's happening

so it's the curve full length of the curve what's happening here now you might be saying okay but i

want to array along that curve that's going to come in the next video we need to understand

the full modifier first okay so we've got that there we understand the length and we understand

the curve now let's go ahead and let's talk about this object offset so the object offset is very

similar to two other ones that we've already done which is the mirror modifier and the screw

modifier so you'll see a lot of similarities soon so we're going to just move this out we're going

to put our 3d cursor over on the world origin here and let's go ahead and create ourselves a null

because as we know this object is going to need something that's going to need an origin point

because that's usually what's going to happen when we're talking about other objects so let's click

this object offset onto our empty let's turn off this constant offset because we don't want

to double one so let's turn on this object offset and you'll see what happens right now boom we now

have five copies along the distance of the offset of this origin point to that origin point yes you

heard that right origin points are now important so if we move just the origin of this you can see

that it's the relationship between the origin point and this other object that controls this

now let's go ahead and explore that a little bit further so that means that our other object here

are empty if this empty goes about and i don't know starts to rotate what would happen oh that

means that it's going ahead and every single time it does an array it's rotating that amount

it also applies to scale and position so let's go and put that rotation on once again

then let's go ahead and scale this and then let's also do a little i don't know g z upwards

as you can see we're starting to get this step up effect now if you can truly understand the origin

and object relationship with the array modifier this is how we go ahead and do radial arrays

now how would we go about doing that well we need to go ahead and say your origin point of this is

where the origin point of your controlling object is so let's go ahead and do that all

we're going to do is right click set the origin point to the 3d cursor because the 3d cursor is

at the zero zero so with that done we now should understand that the distance of where this is

in relationship to this point here is the radius of our radial array

i hope that makes sense let's go ahead let's move our origin object here of this origin offset and

you'll see as we turn it it creates this radial effect now there is a mathematical way of figuring

out the perfect amount and blender makes this quite easy because remember blender inputs

are mathematical inputs as well so we can go right here to our rotation amount and let's just

go ahead we have 5 here so 360 degrees divided by 5 and there we go the perfect amount needed

so let's go ahead and let's make this a little bit more complicated let's go and set this to 12

and let's go and do a nice 360 divided by 12. and now we have this sort of like clock hand

you could imagine so there we go that's a nice radial ray and the distance set here is basically

the diameter or the radius whatever you're wanting to deal with perfect let's go ahead and move this

oh dear what's happening here it's all going crazy and not what i want

yes we are now bound by our origins you have to move these both collectively

and when you rotate them and do strange things with them they have to be done collectively as

well so how can we do this in such a way that we can then connect this all together to one operator

we're coming now to the a realm of something called rigging within blender but this is

i wouldn't even consider this really breaking but it technically is so we're going to create

another null here a single arrow and we're going to go ahead and make this nice and big

and this is very similar to the screw modifier in the sense that we're going to select both of these

and we're going to parent them to this now before i do that you might say well why don't you just

parent the cube to that and you'll be fine right okay well let's do that i'm going to

parent it to our original null there so it's got nothing to do with that arrow there and yeah

it works okay great moving it rotating it okay but you know what i'm really wanting to change

what's happening here so let's change the segments and now okay i'm wanting to go back

to my five now i'm wanting to rotate just this so that would be rotating oh wait what's how would

i how there's your problem you can no longer set the rotation in an easy way it can still be done

so how do we go about and fix this well we tell both of these objects

to be the child sorry the child of this parent so we select the children and bring it to the parent

and then we parent it and now we will still have our rotation

we can still go ahead and move this however we want and then we can select this big arrow that

we've created and this controls the whole radial array however we want we can go ahead and rotate

it we could even go ahead and scale it if we want you can do absolutely everything using that

now something else we can go ahead and do now that we have this whole thing it doesn't need this

you could have done it beforehand but we can go ahead and move this

and start to create a whole bunch of crazy things with it as you can see we can scale this in

start getting really creative i don't know how this really goes with precision modeling

but you can get some pretty crazy results very quickly with arrays and understanding

how they all work collectively well done for getting through the fundamentals of the

array modifier as you can see it is an extremely powerful modifier all on its own and just you wait

and see when you start adding other modifiers to it it explodes in functionality a huge thank you

to my patrons you guys are absolutely awesome and it's the reason why i'm able to create all these

videos here completely for free and if you're enjoying what i'm making here you think i'm worthy

of your support i would love to see you there too don't forget that we have a discord and that's

linked down in the description thank you for watching keep making and let the quest continue