Chapter 10: Transformation Matrices — The Math Behind 3D Transforms | Math for Unity3D — Free Ebook

What is a Matrix?

A matrix is a rectangular grid of numbers arranged in rows and columns. Matrices are used throughout mathematics and physics to represent linear transformations — operations that map one set of coordinates to another. In 3D graphics, one particular type of matrix is ubiquitous: the 4×4 transformation matrix.

Every time Unity moves a GameObject, rotates it, or scales it, there is a 4×4 matrix operating behind the scenes. The Transform component is a high-level interface over that matrix. When the GPU renders a mesh, it multiplies every vertex position by a chain of matrices — one for the object's position in the world, one for the camera's view, one for the projection. Understanding matrices gives you direct access to that machinery.

The Identity Matrix

The simplest 4×4 matrix is the identity matrix. It is the equivalent of multiplying by 1: any point or vector you transform through it comes out unchanged.

// Identity matrix layout (rows × columns):
// | 1  0  0  0 |
// | 0  1  0  0 |
// | 0  0  1  0 |
// | 0  0  0  1 |

Matrix4x4 identity = Matrix4x4.identity;

The pattern is simple: 1s along the main diagonal, 0s everywhere else. If you think of each column as encoding where one of the basis axes ends up after the transformation, the identity says: X stays as X, Y stays as Y, Z stays as Z, and the origin stays at the origin.

A Transformation Matrix Encodes Three Things

A general 4×4 transformation matrix encodes rotation, scale, and translation in a single mathematical object. This is why Unity's class is called Matrix4x4 and why the key constructor method is Matrix4x4.TRS — TRS stands for Translation, Rotation, Scale.

The power of this encoding is that combining two transformations is as simple as multiplying two matrices. Multiply the parent matrix by the child matrix and you get the combined transform — exactly what Unity does internally when computing world-space positions from a hierarchy of GameObjects.

Anatomy of a 4×4 Transform Matrix

Let's open the matrix and look at what each part means. For a TRS matrix with position p, rotation R, and scale s:

// Column-major layout (Unity stores matrices column by column):
//
//  Column:   0        1        2        3
//          | Rx*sx   Ry*sy   Rz*sz   tx |   row 0
//          | Ux*sx   Uy*sy   Uz*sz   ty |   row 1
//          | Fx*sx   Fy*sy   Fz*sz   tz |   row 2
//          |  0       0       0       1 |   row 3
//
// Where R = Right axis, U = Up axis, F = Forward axis
// sx, sy, sz = scale on each axis
// tx, ty, tz = translation (position)

Breaking it down:

Columns 0, 1, 2 — rows 0 to 2: the upper-left 3×3 submatrix. Each column is one of the three local axes (Right, Up, Forward) scaled by the corresponding scale value. This submatrix encodes both rotation and scale combined.
Column 3 — rows 0 to 2: the translation. These three values (tx, ty, tz) are the world-space position of the object's origin.
Row 3: always (0, 0, 0, 1) for affine transforms (transforms that preserve parallel lines — which includes all combinations of translation, rotation, and uniform scale).

The reason for using 4×4 matrices instead of 3×3 is precisely to handle translation. A 3×3 matrix can encode rotation and scale, but not translation — translation is an additive operation, not a multiplicative one. By working in 4D homogeneous coordinates (appending a w component of 1 to every position and 0 to every direction), translation becomes a matrix multiplication, which means all three operations can be composed with a single multiply.

Unity's Matrix4x4 Class

Unity exposes matrix operations through the Matrix4x4 struct in the UnityEngine namespace. Here are the most important methods and properties.

Creating a TRS Matrix

Vector3    position = new Vector3(3f, 0f, 5f);
Quaternion rotation = Quaternion.Euler(0f, 45f, 0f);
Vector3    scale    = new Vector3(1f, 1f, 1f);

Matrix4x4 m = Matrix4x4.TRS(position, rotation, scale);

This is the standard way to build a transform matrix from its components. It is equivalent to the matrix stored in a GameObject's Transform when its parent is the scene root.

Extracting Components from a Matrix

// Position (column 3, rows 0-2)
Vector3 extractedPosition = m.GetColumn(3);

// Local axes
Vector3 rightAxis   = m.GetColumn(0);   // transform.right
Vector3 upAxis      = m.GetColumn(1);   // transform.up
Vector3 forwardAxis = m.GetColumn(2);   // transform.forward

// Rotation (removes scale from the rotation-scale columns)
Quaternion extractedRotation = m.rotation;

// Lossy scale (magnitude of each column of the rotation-scale submatrix)
Vector3 extractedScale = m.lossyScale;

These extraction methods let you read information from an arbitrary matrix as if it were a Transform. This is useful when you receive a matrix from a shader, from a serialized file, or from a GPU instancing system, and need to work with its components individually.

Transforming Points and Directions

Vector3 localPoint     = new Vector3(1f, 0f, 0f);
Vector3 worldPoint     = m.MultiplyPoint3x4(localPoint);   // includes translation
Vector3 worldDirection = m.MultiplyVector(localPoint);     // ignores translation

The distinction between MultiplyPoint3x4 and MultiplyVector is important:

MultiplyPoint3x4 — use for positions. It applies rotation, scale, and translation. A local-space point comes out in world space.
MultiplyVector — use for directions and normals. It applies rotation and scale but not translation. This is correct because a direction has no position; moving the origin should not change a direction vector.

Inverting a Matrix

Matrix4x4 inverse = Matrix4x4.Inverse(m);

// Transform from world space back to local space:
Vector3 localPoint = inverse.MultiplyPoint3x4(worldPoint);

The inverse of a TRS matrix undoes the transform. This is the mathematical equivalent of transform.InverseTransformPoint. Inverting is more expensive than a forward multiply, so cache the inverse when you need it repeatedly.

When to Use Matrices

For the vast majority of Unity development, you should use the Transform API: transform.position, transform.rotation, transform.TransformPoint, and so on. These are clear, expressive, and well-optimised. So when do matrices earn their place?

Custom Shaders and HLSL

In shader code (HLSL / Cg), there is no Transform component. Vertices are transformed by matrix multiplication explicitly. The standard Unity shader matrices are:

unity_ObjectToWorld — the Model matrix (same as the object's TRS matrix). Transforms a vertex from object space to world space.
UNITY_MATRIX_V — the View matrix. Transforms from world space to camera space.
UNITY_MATRIX_P — the Projection matrix. Transforms from camera space to clip space.
UnityObjectToClipPos(vertex) — convenience function that applies Model × View × Projection in one call (replaces the old mul(UNITY_MATRIX_MVP, vertex)).

Batch Point Transformations

If you need to transform thousands of points from local space to world space every frame — for a particle system, a procedural mesh, or a point cloud — calling transform.TransformPoint in a loop is perfectly fine, but building a single Matrix4x4 and calling MultiplyPoint3x4 in the loop is faster because the matrix is constructed only once.

Matrix4x4 localToWorld = transform.localToWorldMatrix;

for (int i = 0; i < localPoints.Length; i++)
{
    worldPoints[i] = localToWorld.MultiplyPoint3x4(localPoints[i]);
}

This pattern is common in editor tools, procedural geometry generation, and runtime mesh deformation.

Complex Parent-Child Math Without Hierarchy

Sometimes you need to simulate a parent-child relationship without actually parenting GameObjects — for example, in a data-driven system where the hierarchy is computed at runtime, or in a Job/Burst context where you cannot access GameObjects at all. Matrices let you compose these relationships with pure math.

Saving and Restoring Transforms

A Matrix4x4 snapshot captures position, rotation, and scale in one value that can be stored in a list, serialized to disk, or compared cheaply. This is useful for undo systems, recording replays, and animation baking.

// Save
Matrix4x4 snapshot = transform.localToWorldMatrix;

// Restore
transform.position   = snapshot.GetColumn(3);
transform.rotation   = snapshot.rotation;
transform.localScale = snapshot.lossyScale;

Graphics.DrawMeshInstanced — GPU Instancing

This is arguably the most common reason to work with matrices directly in modern Unity. GPU instancing lets you render thousands of identical meshes (trees, rocks, enemies) in a single draw call by passing an array of Matrix4x4 transforms to the GPU. No individual GameObjects, no per-instance draw calls — just one batch.

Custom TRS Transform Example

Let's see a concrete comparison between the high-level Transform API and direct matrix math for the same operation: transforming a point from local space to world space.

using UnityEngine;

public class MatrixDemo : MonoBehaviour
{
    public Transform referenceObject;
    public Vector3 localPoint = new Vector3(1f, 0f, 0f);

    void Update()
    {
        // High-level approach
        Vector3 worldPointA = referenceObject.TransformPoint(localPoint);

        // Matrix approach — equivalent result
        Matrix4x4 m = Matrix4x4.TRS(
            referenceObject.position,
            referenceObject.rotation,
            referenceObject.lossyScale
        );
        Vector3 worldPointB = m.MultiplyPoint3x4(localPoint);

        // Both should be identical
        Debug.DrawLine(worldPointA, worldPointB, Color.red); // zero-length line if equal
    }
}

In practice, referenceObject.TransformPoint is what Unity calls internally — it reads the object's localToWorldMatrix and multiplies through it, exactly as above. Understanding this removes the mystery from Unity's Transform API.

Combining Matrices

When you parent a GameObject in Unity, the engine combines the parent's transform and the child's local transform to compute the child's world transform. The underlying operation is matrix multiplication:

Matrix4x4 parentMatrix = parentTransform.localToWorldMatrix;
Matrix4x4 childLocal   = Matrix4x4.TRS(
    childLocalPosition,
    childLocalRotation,
    childLocalScale
);

// Combined world transform of the child
Matrix4x4 childWorld = parentMatrix * childLocal;

This is exactly what transform.localToWorldMatrix returns for a child GameObject. The matrix approach lets you perform the same calculation without a hierarchy — useful for procedural systems, Jobs, or any situation where creating GameObjects is too expensive.

Order Matters

Matrix multiplication is not commutative. A * B is generally not the same as B * A. The convention is: apply transforms from right to left. In the expression parentMatrix * childLocal, the child's local transform is applied first, then the parent's world transform is applied to the result. This matches the mathematical convention for composing functions: f(g(x)) means apply g first, then f.

Getting the order wrong produces wildly incorrect results. A common mistake is to accidentally write childLocal * parentMatrix — this scales and rotates in world space first, then applies the parent, which is almost never what you want.

Matrices in Shaders

Every vertex shader in Unity performs at least one matrix multiplication. Understanding what each matrix does demystifies shader programming significantly.

// Minimal Unity vertex shader using matrices explicitly:
Shader "Custom/MatrixDemo"
{
    SubShader
    {
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"

            struct appdata { float4 vertex : POSITION; };
            struct v2f    { float4 pos : SV_POSITION; float3 worldPos : TEXCOORD0; };

            v2f vert(appdata v)
            {
                v2f o;
                // Standard clip-space transform (Model-View-Projection)
                o.pos = UnityObjectToClipPos(v.vertex);

                // World-space position using the Object-To-World matrix
                o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;

                return o;
            }

            fixed4 frag(v2f i) : SV_Target
            {
                // Use world position for something (e.g., world-space fog)
                return fixed4(i.worldPos * 0.1, 1.0);
            }
            ENDCG
        }
    }
}

The key line is mul(unity_ObjectToWorld, v.vertex). This is the same multiplication as m.MultiplyPoint3x4(localPoint) in C# — just written in HLSL and using the matrix Unity has already computed for the current object. Everything you learned about TRS matrices above applies directly here.

Practical Example: GPU Instancing Setup

GPU instancing lets you render enormous numbers of identical meshes efficiently. The Unity API Graphics.DrawMeshInstanced accepts an array of up to 1023 Matrix4x4 values per call, each defining the world transform of one instance. No GameObjects, no Rigidbodies — just matrices and a mesh.

using UnityEngine;

public class GPUInstancedRenderer : MonoBehaviour
{
    public Mesh mesh;
    public Material material;       // must have GPU instancing enabled
    public int instanceCount = 500;
    public float spread = 20f;

    private Matrix4x4[] matrices;

    void Start()
    {
        matrices = new Matrix4x4[instanceCount];
        for (int i = 0; i < instanceCount; i++)
        {
            Vector3    position = new Vector3(
                Random.Range(-spread, spread),
                0f,
                Random.Range(-spread, spread)
            );
            Quaternion rotation = Quaternion.Euler(0f, Random.Range(0f, 360f), 0f);
            Vector3    scale    = Vector3.one * Random.Range(0.5f, 1.5f);

            matrices[i] = Matrix4x4.TRS(position, rotation, scale);
        }
    }

    void Update()
    {
        // One draw call renders all instances
        Graphics.DrawMeshInstanced(mesh, 0, material, matrices);
    }
}

Enable Enable GPU Instancing on the material in the Inspector. With this single script and a simple material, you can render 500 trees or rocks in one draw call — a dramatic improvement over 500 individual GameObjects, each with its own draw call.

For more than 1023 instances, split the array into batches and call DrawMeshInstanced multiple times. Even with multiple calls, the performance is far better than individual draw calls because there is no per-object CPU overhead.

Animating Instances

Because you control the matrices directly, you can animate instances cheaply:

void Update()
{
    float t = Time.time;
    for (int i = 0; i < matrices.Length; i++)
    {
        // Extract current position from the matrix, add a wave offset
        Vector3 basePos  = matrices[i].GetColumn(3);
        Vector3 animPos  = basePos + Vector3.up * Mathf.Sin(t + i * 0.5f) * 0.3f;

        // Rebuild the matrix with the animated position
        matrices[i] = Matrix4x4.TRS(animPos,
                                    matrices[i].rotation,
                                    matrices[i].lossyScale);
    }
    Graphics.DrawMeshInstanced(mesh, 0, material, matrices);
}

This pattern — compute on CPU, upload matrix array, one draw call — is the basis of most large-scale vegetation and crowd rendering systems.

Matrix vs Transform — When to Prefer Each

After reading this chapter, you might wonder whether you should replace all your Transform API calls with matrix math. The answer is almost always no. Here is a clear guide:

Use the Transform API (99% of the time)

Moving, rotating, and scaling GameObjects during gameplay
Parenting and unparenting objects
Converting points between local and world space on a per-frame basis
Any situation where you are working with a small number of objects
Anything involving physics (always drive physics through Rigidbody, not Transform)

Use Matrix4x4 Directly

Graphics API — Graphics.DrawMeshInstanced, Graphics.DrawMesh, and similar low-level rendering calls require matrix arrays.
Unity Jobs and Burst — Job structs cannot access MonoBehaviour or Transform (they live on the main thread). Matrix math is fully blittable and runs safely in Jobs.
Shader data — passing transform data to shaders through Material property blocks or constant buffers requires matrices.
Mathematical operations on many points — if you are transforming thousands of points in a loop, computing the matrix once and reusing it is faster than calling TransformPoint repeatedly.
Serialized transform data — storing a complete transform as a single Matrix4x4 value (16 floats) is compact and fast to read back.

A Note on Numerical Precision

One subtle issue with matrices: if you decompose a matrix (extract rotation with m.rotation, scale with m.lossyScale, and position with m.GetColumn(3)) and then reconstruct it with Matrix4x4.TRS, the result may differ very slightly from the original due to floating-point rounding. This is rarely a problem in practice — the error is on the order of 0.000001 — but it is worth knowing if you are doing many successive decompose-reconstruct cycles.

Summary

Transformation matrices are the mathematical bedrock of all 3D graphics. While Unity's high-level APIs hide them for everyday use, understanding matrices gives you access to the full power of the rendering pipeline — from batch instancing to custom shaders. Here is what you can now do:

Explain what a 4×4 transformation matrix is and why 4×4 (not 3×3) is used
Read the anatomy of a TRS matrix: rotation-scale in the upper-left 3×3, translation in column 3
Create a Matrix4x4 with Matrix4x4.TRS
Extract position, rotation, scale, and local axes from a matrix
Transform points and directions through a matrix
Invert a matrix to reverse a transform
Combine matrices with multiplication (and know that order matters)
Use GPU instancing with Graphics.DrawMeshInstanced
Understand where shader matrices come from and what they do

With this chapter, you have completed the mathematical toolkit of a professional Unity3D developer. The next and final section of the book is the conclusion — a full recap of everything you have learned and a roadmap for where to go next.

Chapter 10: Transformation Matrices — The Math Behind 3D Transforms