3D coordinate system in Unity - Deep Dive

Overview - 3D coordinate system

What is it?

A 3D coordinate system is a way to describe positions in three-dimensional space using three numbers. In Unity, these numbers represent the X, Y, and Z axes, which correspond to width, height, and depth. This system helps place and move objects in a virtual world. It is like a map that tells you exactly where something is in 3D space.

Why it matters

Without a 3D coordinate system, it would be impossible to position or move objects in a 3D game or simulation. Imagine trying to build a house without knowing where the walls or doors go. The 3D coordinate system solves this by giving a clear, consistent way to locate everything. It makes creating and interacting with 3D worlds possible and understandable.

Where it fits

Before learning about the 3D coordinate system, you should understand basic math concepts like numbers and directions. After this, you can learn about transformations like rotation and scaling, and how to use vectors and matrices to manipulate objects in Unity.

Mental Model

Core Idea

A 3D coordinate system uses three numbers to pinpoint exact locations in space along width (X), height (Y), and depth (Z) axes.

Think of it like...

Think of it like a room with three walls meeting at a corner: one wall goes left-right (X), one goes floor-ceiling (Y), and one goes front-back (Z). Any object in the room can be described by how far it is from that corner along each wall.

       Y (up)
        |
        |
        |      Z (depth)
        |     /
        |    /
        |   /
        |  /
        | /____ X (width)
       (0,0,0)

Build-Up - 7 Steps

1

Foundation

Understanding the Three Axes

Concept: Learn what the X, Y, and Z axes represent in 3D space.

In Unity, the X axis runs left to right, the Y axis runs bottom to top, and the Z axis runs front to back. Each axis is a straight line that helps measure distance in that direction. Together, they form a grid that covers all space around the origin point (0,0,0).

Result

You can now identify directions and positions using X, Y, and Z values.

Knowing the meaning of each axis is the foundation for understanding how objects are placed and moved in 3D space.

2

Foundation

The Origin Point Explained

Concept: Understand the starting reference point (0,0,0) in the 3D coordinate system.

The origin is where all three axes meet. It is the 'zero' point for X, Y, and Z. Positions are measured as distances from this point. For example, (2, 3, 4) means 2 units right, 3 units up, and 4 units forward from the origin.

Result

You can now describe any point in space relative to the origin.

The origin acts like the home base or starting point for all positioning in 3D space.

3

Intermediate

Using Vectors to Represent Positions

🤔Before reading on: do you think a position in 3D space can be stored as a single object or must it be three separate numbers? Commit to your answer.

Concept: Positions in Unity are stored as Vector3 objects that hold X, Y, and Z values together.

Unity uses the Vector3 type to group the three coordinates into one object. This makes it easy to pass positions around, calculate distances, and perform math on points. For example, Vector3(1, 2, 3) represents a point 1 unit right, 2 units up, and 3 units forward.

Result

You can now use Vector3 to handle 3D positions efficiently in Unity scripts.

Understanding Vector3 as a single object simplifies working with 3D positions and enables powerful math operations.

4

Intermediate

Coordinate System Orientation in Unity

🤔Before reading on: do you think Unity uses a left-handed or right-handed coordinate system? Commit to your answer.

Concept: Unity uses a left-handed coordinate system where the Y axis points up, X points right, and Z points forward.

In Unity's left-handed system, if you point your left thumb up (Y), your index finger right (X), then your middle finger points forward (Z). This orientation affects how rotations and movements behave. Knowing this helps predict object behavior.

Result

You can now correctly interpret directions and rotations in Unity's 3D space.

Knowing the coordinate system orientation prevents confusion when moving or rotating objects.

5

Intermediate

Local vs World Coordinates

🤔Before reading on: do you think an object's position is always relative to the world origin or can it be relative to another object? Commit to your answer.

Concept: Positions can be relative to the world origin (world coordinates) or relative to a parent object (local coordinates).

World coordinates describe an object's position in the entire scene. Local coordinates describe position relative to the object's parent. For example, a child object at (1,0,0) local means 1 unit right from its parent, not necessarily from the world origin.

Result

You can now understand and use both local and world positions to control objects precisely.

Distinguishing local and world coordinates is key to managing complex object hierarchies and movements.

6

Advanced

Transform Component and Coordinate System

🤔Before reading on: do you think the Transform component stores position only, or also rotation and scale? Commit to your answer.

Concept: The Transform component in Unity stores position, rotation, and scale, all based on the 3D coordinate system.

Every GameObject has a Transform that holds its position (Vector3), rotation (Quaternion or Euler angles), and scale (Vector3). Position uses the 3D coordinate system to place the object. Rotation changes orientation around axes. Scale changes size along axes.

Result

You can now manipulate objects fully in 3D space using the Transform component.

Understanding that position, rotation, and scale share the coordinate system helps unify object transformations.

7

Expert

Coordinate System Pitfalls and Floating Point Precision

🤔Before reading on: do you think floating point precision errors can affect object positioning in large Unity scenes? Commit to your answer.

Concept: Floating point numbers used for coordinates have limited precision, which can cause small errors in large or distant scenes.

Unity uses 32-bit floats for positions, which means very large or very small numbers lose accuracy. This can cause jittering or incorrect collisions far from the origin. Developers use techniques like origin rebasing or floating origin to fix this.

Result

You understand why objects may behave oddly far from the origin and how to mitigate it.

Knowing floating point limits prevents mysterious bugs in large-scale 3D worlds and guides better design.

Under the Hood

Unity represents 3D positions internally as three 32-bit floating point numbers for X, Y, and Z. These values are stored in Vector3 structs. The coordinate system is left-handed, meaning the cross product of X and Y points in the Z direction. Transformations like translation, rotation, and scaling are applied using matrix math behind the scenes, combining local and parent transforms to compute world positions.

Why designed this way?

The left-handed coordinate system was chosen for consistency with DirectX graphics API, which Unity originally targeted. Using floats balances memory use and precision for real-time performance. Vector3 structs simplify passing and manipulating positions. Matrix math allows efficient combination of multiple transformations, essential for hierarchical objects.

┌───────────────┐
│   Vector3     │
│ ┌───────────┐ │
│ │ float X   │ │
│ │ float Y   │ │
│ │ float Z   │ │
│ └───────────┘ │
└─────┬─────────┘
      │
      ▼
┌─────────────────────────┐
│ Transform Component      │
│ ┌ Position (Vector3)    │
│ ├ Rotation (Quaternion) │
│ └ Scale (Vector3)       │
└─────────┬───────────────┘
          │
          ▼
┌─────────────────────────┐
│ Matrix Math Combines     │
│ Local and Parent Transforms│
└─────────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Is Unity's coordinate system right-handed or left-handed? Commit to your answer.

Common Belief: Many believe Unity uses a right-handed coordinate system like some other 3D tools.

Reality: Unity uses a left-handed coordinate system where Z points forward, not backward.

Why it matters: Assuming the wrong system causes confusion in rotations and directions, leading to bugs in object movement and camera control.

Quick: Does an object's position always mean its distance from the world origin? Commit to your answer.

Common Belief: People often think an object's position is always relative to the world origin.

Reality: Positions can be local to a parent object, meaning the same local position can map to different world positions.

Why it matters: Ignoring local coordinates leads to errors in hierarchical object placement and unexpected behavior when moving parents.

Quick: Can floating point precision cause visible errors in object positioning? Commit to your answer.

Common Belief: Many assume floating point precision is perfect for all practical purposes in Unity scenes.

Reality: Floating point precision errors occur especially far from the origin, causing jitter or collision issues.

Why it matters: Not accounting for precision limits can cause hard-to-debug glitches in large open-world games.

Quick: Is the Y axis always 'up' in every 3D software? Commit to your answer.

Common Belief: Some believe Y is always the vertical axis in all 3D coordinate systems.

Reality: Different software uses different conventions; Unity uses Y as up, but others may use Z as up.

Why it matters: Assuming Y is always up can cause errors when importing models or switching between tools.

Expert Zone

1

Local coordinate changes affect children but not the parent's world position, which is crucial for complex animations.

2

Floating origin techniques reset the world origin dynamically to maintain precision in large scenes without disrupting gameplay.

3

Quaternion rotations avoid gimbal lock problems common with Euler angles, but require understanding of their non-intuitive math.

When NOT to use

The standard 3D coordinate system is not suitable for 2D games or UI layouts where 2D coordinate systems or screen space coordinates are better. For very large-scale simulations, specialized coordinate systems like geospatial coordinates or double precision floats may be needed.

Production Patterns

In production, developers use parent-child hierarchies with local coordinates for modular object control. Floating origin systems are implemented in open-world games to avoid precision errors. Vector3 math is combined with physics and animation systems to create smooth, realistic movements.

Connections

Vector Mathematics

Builds-on

Understanding 3D coordinates deeply connects to vector math concepts like addition, subtraction, dot and cross products, which are essential for movement and physics.

Geographic Coordinate Systems

Similar pattern

Both use multiple numbers to locate points in space, but geographic systems use latitude, longitude, and altitude, showing how coordinate systems adapt to different contexts.

Human Spatial Awareness

Analogous process

Our brain uses a mental 3D coordinate system to understand where objects are around us, helping us navigate and interact with the world.

Common Pitfalls

#1 Confusing local and world coordinates causes objects to appear in wrong places.

Wrong approach:

transform.position = new Vector3(1, 0, 0); // assuming this moves object 1 unit right globally

Correct approach:

transform.localPosition = new Vector3(1, 0, 0); // moves object 1 unit right relative to parent

Root cause:

Misunderstanding that transform.position is world space and transform.localPosition is local space.

#2 Ignoring floating point precision leads to jitter in large scenes.

Wrong approach:

Placing objects at positions like (100000, 0, 100000) without adjustments.

Correct approach:

Implement floating origin by resetting the scene origin near the player to keep coordinates small.

Root cause:

Not realizing that floating point numbers lose accuracy at large magnitudes.

#3 Assuming Y axis is always up when importing models from other software.

Wrong approach:

Directly using imported model coordinates without adjusting for axis differences.

Correct approach:

Apply coordinate system conversion to match Unity's Y-up system.

Root cause:

Not accounting for different coordinate system conventions across tools.

Key Takeaways

A 3D coordinate system uses X, Y, and Z axes to describe positions in space clearly and consistently.

Unity uses a left-handed coordinate system with Y as up, which affects how objects move and rotate.

Positions can be local to a parent or global in the world, and understanding this distinction is crucial for correct object placement.

Floating point precision limits can cause errors far from the origin, requiring special techniques in large scenes.

The Transform component unifies position, rotation, and scale, all based on the 3D coordinate system, enabling full control of objects.