With so many amazing online resources it’s never been easier to get started with Unity, but without an understanding of how the engine handles translation, rotation, and scale you probably won’t get very far.
This is particularly true when importing 3D assets into your project, as not every 3D software package interprets data in the same way. Small differences can have big consequences.
Unity uses a left-handed, Y-up, Z-forward coordinate system. This bears some similarity to other common 3D software like Maya and Houdini, but there are key differences in the way each application interprets mesh data. These differences will determine the direction your mesh is oriented when it is imported into Unity.
This guide will explore the ins and outs of Unity’s coordinate system, why understanding its eccentricities is so important, and how it differs from other 3D packages you may be used to working with.
World Coordinate System Quick Guide
Here is a table that demonstrates how the Unity coordinate system compares to other game engines and 3D software packages. For those already familiar with terms like up axis and left/right handed, this may tell you all you need to know to figure the rest out for yourselves. If that’s the case, thanks for dropping by and good luck!
Defining a ‘coordinate system’
The mathematical term ‘coordinate system’ describes a method of using numbers to determine position in 2D and/or 3D space. In a game engine it’s the coordinate system’s role to define both the location of each object as well as the direction it’s facing. With this data you can calculate the distance between objects, their rotation, velocity, and all sorts of other useful information.
There are multiple systems for calculating and interpreting coordinates. By default Unity uses (and strongly prefers you to use) a Cartesian coordinate system. This is the basis for what we discuss in this guide. Although converting between other systems is possible using C# and a whole lot of additional calculation, it’s beyond the scope of this introductory breakdown.
No matter which system you choose to work with the information within this guide should remain relevant.
Plotting your position
The most important thing to remember is that the virtual space inside your Unity scene is determined by three axes; X, Y, and Z. These axes represent the left/right, up/down, and forward/back directions respectively.
Unity’s version of the 3D translation widget, a tool that allows us to move objects around the scene.
Each object in your game world stores a value for each axis, the three of which combined telling Unity where to place the object in the scene. Should you change your object’s Y value, for example, your object will move up or down. The direction of the motion will depend on whether you add or subtract from the axis’s value.
This is what we call ‘moving in the Y axis’.
The point at which all three axes intersect is called the origin. On one side of the origin an axis value will be a positive value, and on the other it will be negative. For example, 8 is the same distance from the origin as -8, just on the opposite side. A value of zero sits right on the origin of that axis.
The positive direction of each axis is also commonly called the forward vector, right vector, and up vector.
Y-Up or Z-Up, why does it matter?
This is the first key point of difference where Unity may not align the other software you’re using to make your art. Some 3D packages, like Blender, have defined (at least by default) the positive Z axis as their up vector.
As you might expect, this can cause unexpected results when transferring 3D objects between programs. Changing the definition of an axis (in this instance, moving the up axis from Z to Y) will fundamentally change how that data is interpreted. Things will have a tendency to go sideways on you.
This conversion can be done automatically on import, allowing your mesh to retain its original orientation even if the exported coordinate space is different.
The difference between left and right-handed systems
The second important distinction between Unity and some other commonly used engines and packages is that Unity uses a left-handed coordinate system. What this means is that the X axis (which defines your right vector) is inverted when brought into a program that uses a right-handed system.
The result when importing an asset from right-handed Z-up Blender (left) into left-handed Y-up Unity.
The easiest way to visualize which is which is to use your hand. Hold it with your palm facing to your side as if you’re reaching to shake someone’s hand. Point your thumb upwards like a thumbs-up to represent your up vector (Y+). Point your index finger forward, this (unsurprisingly) becomes your hand’s forward vector (Z+). Finally, curl your middle finger so it points perpendicular to your palm. This is your hand’s right vector (X+).
If you did this exercise with your left hand, then you will be aligned with Unity’s coordinate system and your right vector will be pointing to the right. Instead, if you used your right hand (as Maya does, for example) it will be pointing to the left. This is the difference between left and right handed systems.
Unity’s left-handed coordinate system (left) compared to the same asset in Maya. Note the direction of the X Axis!
The most common issue that this inverse left/right situation causes is that art assets imported into Unity from right-handed 3D programs will be flipped in their X axis, as their right vector will be pointing the other way. This can obviously have an adverse effect on asymmetrical assets, and mess with your rigged/animated meshes. Just something to keep in mind.
World vs. Local space
In Unity (and most other 3D graphics programs) several coordinate systems work in tandem to simulate the virtual 3D space that makes up your game world. In Unity these are called world space and local space.
Other coordinate systems (such as screen space and UV space) are used to map the position of objects in 2D, but we’ll talk about those another time.
World (or Universal) space
World space is the coordinate system for the scene itself. Its origin is in the center of your scene, and it is to world space that the grid in the editor viewport aligns. You cannot change the direction of this coordinate system. In world space, Y+ is always up, X+ is always right, and Z+ is always forward.
Local (or Relative) space
Local space is a coordinate system that is relative to the rotation of a specific object. It’s origin is at the pivot point of the object itself, and its axes will change depending on which direction it is facing.
You can think of an object’s local space like its point-of-view. If your object is upside down, then its relative up axis (still positive Y for the object) would point downwards in world space, but upwards relative to the object.
It’s like our hand example from earlier: If you rotate your wrist, all of the local axes (represented by your fingers) will follow.
You can switch your transform tool between coordinate systems by pressing the Toggle Tool Handle Rotation button in the top left of the editor, or by pressing its hotkey ‘x’.
One important thing to keep in mind is that the transform values in the inspector may not reflect the active coordinate system of your transform tool. If your object is a child of another object, those values will be in local space and relative to its parent. Likewise, if it is not a child, the values will be in world space, regardless of your transform tool’s settings.
Final thoughts
Thanks for reading my guide. I hope it’s helped you visualize the differences between the coordinate systems you encounter in the wild, and eases the process of converting between them to make sure your art imports in and out of Unity as you expect.
If you think I’ve missed anything (it wouldn’t be the first time) please reach out and let me know! It’s important to me that these guides stay relevant, and I welcome any and all feedback.
