# Blender 3D: Noob to Pro/The Empty Object

|previous=Deforming Meshes using the Curve Modifier
}}
```
![](Blender268ObjectContextTransformPanel.png "Blender268ObjectContextTransformPanel.png")

Every object in a scene has common settings in the Object
![](Blender255ObjectContextButton.png "Blender255ObjectContextButton.png")
Context. This includes the common transform settings shown at right:
location in the scene, overall rotation and overall scaling. Most
objects also have additional properties, such as the geometry of a mesh
and the materials that govern how it appears in the render.

The **Empty object** has none of these additional properties. It has the
overall transform settings, and not much else. And it has no appearance
in the final render. So what is the point of having such a thing?

In fact, it has many uses, such as:

-   In the Physics
    ![](Blender255PhysicsContextButton.png "Blender255PhysicsContextButton.png")
    Context, it can be set as the source of a force field (e.g. wind).
-   It can be used as the parent for multiple
    other objects. That way they can be moved together just by moving
    the Empty, rather than each child object individually.
-   It can be used as a target object in an **array modifier**, where it
    adds its transformation to the copies of the object being modified
    by the array.
-   It is a handy marker and place holder if you are moving things
    around. You can mark an object\'s original position, and then put it
    back easily where the empty object is.

In these situations, the invisibility of the Empty in the render is an
advantage, because it can be placed wherever necessary, without
introducing unwanted clutter into the final image.

## Using an Empty With the Array Modifier

!The types of
Empties Open a
new default Blender document, complete with default cube. Add a new
Empty object to the scene. It doesn't matter what type of Empty you
choose; the options just control its appearance in the 3D view, not the
actual behaviour of the Empty. Besides, you can change your mind about
this later anyway.

![](Blender268ArrayModifierWithEmpty1.png "Blender268ArrayModifierWithEmpty1.png")
Now select the default cube, go to the Modifiers
![](Blender255ObjectModifiersContextButton.png "Blender255ObjectModifiersContextButton.png")
Context and add an Array modifier. In the properties header, there are
three different ways the modifier can produce its copies of the original
object: via a Constant Offset, Relative Offset, or Object Offset. The
Constant and Relative offsets only allow a simple displacement for the
copies, but the Object Offset looks at the full transformation of the
specified object, which can include rotation and scaling.

Here I have unchecked the default Relative Offset, checked Object
Offset, and from the popup menu for selecting the target object, I have
selected my Empty (which by default would have been called "Empty").

But if you look at your 3D view, nothing seems to have happened: the
cube is still sitting, unmoved, in its original position. In fact, it
might be hard to see the Empty, because it would have been inserted in
the same position as the cube, so it ends up within it. If you switch to
Wireframe  view, you should be able to
see the Empty sitting within the cube.

Before doing anything further, increase the Count field in the cube's
array modifier to 3. This will give you a clearer idea of the effect of
subsequent manipulations. Doing so will not have any noticeable effect
to start with, because all the copies will be lying right on top of each
other.

Now select the Empty, and move it to one side: you will immediately see
a second copy of the cube follow the empty, and the third copy move *by
the same amount in the same direction*, so it ends up beyond that.

Return the Empty to its original location, and this time try moving the
cube. As the original cube moves, you will see the second copy stay with
the Empty at the centre of the scene, while the third copy moves beyond
that, by the same distance and in the same direction as the second copy
is removed from the original cube.

Now if you return the cube to the same location as the Empty, select
both and try moving them together, you will see no additional copies of
the cube appear, because they remain exactly on top of the original
cube.

The rule for using an Object Offset with the Array modifier is this:


In other words:

-   the translation applied is the difference between their origins.
-   the rotation applied is the difference between their object
    rotations.
-   the scaling applied is the *ratio* between their object scaling
    factors.

Try moving the Empty to one side, as before; this time leave it there,
so the three copies of the cube are nicely spread out. Now try applying
a rotation to the Empty; see how this applies the corresponding rotation
to the second copy (the one located where the Empty is), while the third
copy gets *twice* that rotation.

Return the Empty to its unrotated state, and this time try rotating the
cube: see how the second copy (where the Empty is) stays unmoved, while
the third copy gets the opposite rotation.

Undo the rotations, and now try scaling: shrinking/enlarging the Empty
correspondingly shrinks/enlarges the second copy, while the third copy
gets transformed by the *square* of the shrink/enlarge ratio (the ratio
multiplied by itself, or alternatively the ratio raised to the second
power). Or shrink/enlarge the original cube, and see the second copy
stay unchanged (as before), while the third copy enlarges/shrinks by the
*inverse* ratio.

When you change the transformation of the original cube, the second copy
always stays unchanged because the Object Offset transformation is the
*inverse* of the transformation you are applying to the original; hence
it always cancels out for the second copy, but you can see corresponding
increasing powers of it applied to subsequent copies.

### Editing the Modified Object

Make sure the Empty is positioned so the array instances are well
separated. Select the cube,  into Edit
mode, select all the vertices, and try transforming them: moving,
rotating or scaling.

Note the difference in behaviour from doing this to the cube in Object
mode: this time all the copies of the cube transform along in unison.
This is because we are not affecting the object transformation, which is
what controls the behaviour of the array modifier.

### Arranging Object Copies in a Circle

Which brings us to a convenient trick for a common need: arranging
copies of an object in a neat circle.

The easiest way to do this is start with the cube and the Empty in their
original central positions. Suppose you want 8 copies of the cube in
your circle; the angle between them then needs to be 360° ÷ 8 = 45°. So
rotate the Empty by 45°. Now select the cube. Set the Fixed Count field
of its Array modifier to 8.  into Edit
mode, and move all the vertices to one side. You should see the other 7
copies of the cube correspondingly move away from the centre in
different directions, maintaining a nice neat circle arrangement. Your
cube mesh is simply being rotated about its origin, which is not where
the vertices are, but where the Empty is!

