How to make a circular array using offset object as center?

We know that the there is an Object Offset option for Array modifier, but when trying to make a circular array with that offset object as the center of the array circle, it always doesn't behave quite like what's expected. So how to make a nice and controllable circular array?

P.S.: There is an old trick on CGCookie about moving the object's origin. I wonder if there is any way to do this without changing the location of the origin. :)

• Why don't you want to move the origin? Of course it is possible, you just have to calculate the rotation and translation of the empty manually. Not hard with a little bit of trigonometry but generally unnecessary.
– his
Jan 6, 2014 at 3:13
• Since the original origin will be taken in further use. And it is not so easy to calculate it back unless it fits any item listed in the SHIFT CTRL ALT C menu. Jan 6, 2014 at 3:25
– his
Jan 6, 2014 at 5:41
• The link on CGCookie seems to be gone. I couldn't find it but would love to see the other option as well if you can relink? Thanks! Mar 31, 2016 at 5:54
• @fabriced Oh right, it does outdated. Luckily I tried to find the video on YouTube. Please recheck the updated link. Apr 1, 2016 at 0:43

Add an empty at the origin of the object that you want to duplicate. (Remember to hit CtrlA and select rotate and scale, to apply transormations on the original object). Then, add an array modifier with object offset linked to this empty.

Set the 3D cursor to the desired centre of the circle. Add another empty here. Make it the parent of the other empty. Now select only the centre empty. Rotate. The amount of rotation is of course dependent on the number of objects, e.g. 12 objects = 30°.

If you want the single elements to "touch" as in your picture you need to either adjust the object width or the radius. The circumference of the circle is 2 * PI * radius, so the width has to be the nth (e.g. 12) part of it. (Or, if it is not about absolute exactness, it can be done visually.)

You probably want to parent the object to the centre empty.

This circle is "controllable" as you can simply change the angle by rotating the centre empty.

• Hi his, I just updated my question with more detail. Could you please take a further look at it? Thanks. Jan 6, 2014 at 3:08
• This makes sense to me. I just wonder what if the cube already got a parent before that, in that case, you have to clear the old one and parent it to the center empty (then parent back again?). But your idea is indeed what I mean by "controllable". Jan 6, 2014 at 6:52
• The cube would be the parent, the centre empty its child, and the outer empty the child of the centre empty. So no problem there.
– his
Jan 6, 2014 at 6:57
• Good point. Yeah, I think this solves all concerning problems. By the way, I bet the Pivot constraint can be used instead, similarly. So it seems plenty of ways in doing so. If you think the Pivot constraint works as well, please consider complementing that in your answer to guide other guys better. :) Jan 6, 2014 at 7:06
• Probably. But that constraint is marked with "very buggy", even in the GUI. I would refrain from using it yet for productive work.
– his
Jan 6, 2014 at 7:19

Just want to complement with several tricks that I just figured out. They all share with the same idea - to offset the rotation pivot of the Offset Object:

Variant 1:

Using 3D Cursor as pivot. (PROS: Fast and straight forward. CONS: Not suitable for animation)

First, use an empty object in Object Offset section in the Array modifier setting, then, all you have to do is to rotate the empty object, instead of the arrayed object itself:

Variant 2:

Using another object as rotate center.

Note that this variant uses two empties; one at the cube center (just like Variant 1) and one for the pivot point (replacing the 3D Cursor in Variant 1).

To do the actual rotation after setting the Active Element as Pivot Point, first Right-Click the empty at the cube center to select it, then Shift+Right-Click the pivot center empty to select that as well, then R to rotate.

Variant 3:

Parenting.

Variant 4:

Using Pivot constraint.

Variant 5:

Using Hook modifier and Copy Location constraint.

• How do you "drag-multiply"? (First gif) looks neat Mar 31, 2016 at 5:55
• I just select the cube then hit R to rotate along current pivot (I've switched pivot type to 3D Cursor, as seen in the same gif). Apr 1, 2016 at 0:32
• This does not work. Can you add description how you did it? Gifs are telling nothing. Sep 28, 2016 at 18:13
• When I hit R I'm just rotating selected object (not making 9 copies of it). Sep 29, 2016 at 10:30
• Your answer is not complete. It's not clear what you're doing from the beginning. What is the "offset object"? Are you using the array modifier? That's what @PawełAudionysos, me and others don't understand.
– ecv
Feb 14, 2018 at 12:28

To do that, you would need the arrayed object's origin to be in the same location as your offset object's origin. Try this test:

2. In Edit mode move that cube to the left. The cube's origin should remain unchanged and in the same location.
4. Rotate the empty (say... 5 degrees)
5. Add an Array modifier on the cube using the empty as your offset. You should see the circular array form around the empty.
• Hi Fweeb, yep, it works. :) But is there any way to avoid changing the location of the origin? I think that's I really meant, wait I should update the question, sorry for that. Jan 6, 2014 at 2:58
• If you want the arrayed object to keep its origin fixed, then you might be better off using Dupliverts instead of the array modifier. It's an older technique, but it does have the side benefit of being more memory efficient (Dupliverts uses instances whereas the array modifier generates geometry). Failing that, you could also try a path constraint (to a bezier circle) on a regular array with just a relative offset. Jan 6, 2014 at 5:30
• Sure Fweeb, I agree with the idea by using Dupliverts, and I know that way, too. I'm just thinking about using Array modifier, since it is much more flexible and controllable with less additional work, in case that I need to animate that. Jan 6, 2014 at 6:56

People have been struggling with Leon's answer. Here is how it works (I'm using default blender scene, with 3D Cursor placed at the origin):

2. Add an Empty (Shift + A > Empty > Plain Axis). This empty will act as the center point.
3. Add a cube and move it 5 units in Y direction. (Shift + A > Mesh > Cube, G, Y, 5, Enter).
4. Move cube's origin to 3D Cursor. (Ctrl + Shift + Alt + C, Origin to 3D Cursor).
5. Add Array modifier to the cube. Set number of copies to (say) 12 and turn off Relative Offset option.
6. Turn on Object Offset and choose empty from the drop-down list.
7. Make sure the cube is still selected, now press R and perform rotation. All the array elements will start following circular path around the empty. You can distribute them evenly by mouse or you can type an angle as you normally do in rotation.
• Thanks. Actually I didn't change the object origin, since normally you don't want to do that, which is why I use tricks (like two empties) as workaround. But your way is good if it is not quite a matter. :) Plus, I've updated the answer sometime ago. I think it should make things clearer. Feel free to discuss. Apr 22, 2018 at 3:25
• Yeah that didn't work...... May 8, 2021 at 14:23

There is a method that actually doesn't require an array modifier:

First figure out how many objects you need, then divide 360 by that number and you have the amount of degrees between each object. For this example, I use a step value of 10 degrees for 36 objects.

Then place the 3D-Cursor in the center of rotation and set the pivot point in the header to 3D-Cursor.

Select your object, duplicate it with SHIFTD and then without even confirming that hit R10RETURN.

That way, Blender considers duplication and rotation as a single action, not two.

You can now use the repeat hotkey SHIFTR to create a full circle of objects and they will be rotated evenly around the cursor.

You can use ALTD to create linked copies instead of SHIFTD if you want to save a bit of memory and filesize. All objects will then use the same mesh.

The advantage of this method is that you have ready to use objects which keep their axes and you save the time for setting up the modifier.

I used blender once to create so called Venetian blinds with an array modifier. To keep rotation of the array objects around there individual origin, I rigged the object to use with the array modifier to a single bone in the center of the object. When you rotate this bone, each object created by the array modifier will rotate around it's own center.

On recent versions of Blender (I'm using 3.0, the name of the node will change on earlier versions), it is possible to obtain a circular array, centered around the original object without creating any empty with Geometry Nodes.

You can then change the number of vertices and radius by changing the properties of the Mesh circle, or change the rotation by tweaking the Align Euler to Vector. The good thing is that you can also save this node and reuse it in multiple places without recreating this graph (in the modifier, simply choose the appropriate Geometry Node in the drop down). For instance, you can change the rotation this way:
Basically, the Mesh Circle creates a "circle" made of N segments centered on the current object. Then Instance on Points will copy the Instance (here our original object) on all the point contained in our Mesh Circle. What is trickier to understand is maybe the rotation. The diamond shape of the Rotation plug means that it is a Field, which means that it waits for a kind of Function (to provide a different rotation for each point). The red nodes (here Normal) are inputs of this function, and this function is evaluated for any point in Points (so basically, here we loop over the points in the circle, and for all of them we take the normal). The Align Euler to Vector part will return the appropriate rotation to ensure that the local X/Y/Z axis of the object (depending on what you choose on the first line) will point towards the Vector field, here the normal of each node.