Transform3D in Godot – Complete Guide

Transform3D is a powerful class in Godot 4, a leading game development engine, that allows developers to manipulate objects in 3D space with precision. Understanding how to use Transform3D can greatly enhance the realism and functionality of your 3D game environments.

What is Transform3D?

Transform3D is a 3×4 matrix that is essential for representing 3D transformations in Godot. With it, you can perform translations, rotations, and scaling on 3D objects, moving your game characters and objects through 3D space with ease. It consists of a Basis and an Origin vector, which together define the position and orientation of objects in the world.

What is Transform3D for?

The primary purpose of Transform3D is to define how an object is transformed in a three-dimensional space. Whether you’re positioning a character, rotating a spaceship, or resizing a treasure chest, Transform3D is the mathematical tool that makes it all possible. It’s the backbone of 3D movement and interaction in Godot.

Why Should I Learn It?

If you’re delving into 3D game development, mastering Transform3D is indispensable. Here’s why:

– It allows for intricate control over 3D object movements and interactions.
– Understanding Transform3D opens up a world of possibilities in creating dynamic and immersive 3D experiences.
– It’s a fundamental concept that forms the basis of more advanced game mechanics and effects.

By grasping the capabilities of Transform3D, you’ll be well on your way to creating more engaging and responsive games. Let’s dive into the world of 3D transformations and unleash the potential of your game designs.

CTA Small Image

Basic Transformations with Transform3D

Creating and manipulating Transform3D objects is a core skill for any 3D game developer using Godot. Let’s start by looking at some basic Transform3D operations.

Instantiating a Transform3D Object
To begin working with Transform3D, you first need to create an instance of the class. Here’s how you can create a new Transform3D object:

var my_transform = Transform3D()

If you’d like to create a Transform3D with a specific starting point, you can define the Basis and the Origin:

var origin = Vector3(0, 0, 0)
var basis = Basis()
var my_transform = Transform3D(basis, origin)

Translation (Moving an Object)
To move an object to a new position in 3D space, you apply a translation to its Transform3D:

my_transform.origin += Vector3(5, 0, 0) # Move the object 5 units to the right

You can also set the position directly:

my_transform.origin = Vector3(10, 2, 3) # Position the object at coordinates (10, 2, 3)

Rotation (Rotating an Object)
Rotating objects can add to the dynamic feel of your game. Here’s how to apply a rotation to the Transform3D’s Basis:

# Rotate the object 45 degrees around the Y axis
my_transform.basis = my_transform.basis.rotated(Vector3.UP, deg2rad(45))

You can combine rotations around multiple axes by chaining rotated calls:

# Rotate 30 degrees around Y axis then 90 degrees around Z axis
my_transform.basis = my_transform.basis.rotated(Vector3.UP, deg2rad(30)).rotated(Vector3.FORWARD, deg2rad(90))

Scaling (Resizing an Object)
Altering the size of an object can be done by scaling. Here’s how you apply a uniform scale to all axes:

my_transform.basis = my_transform.basis.scaled(Vector3(2, 2, 2)) # Double the size of the object

To apply different scales to each axis, use distinct values for each vector component:

my_transform.basis = my_transform.basis.scaled(Vector3(2, 1, 0.5)) # Scale width by 2, leave height as is, half the depth

By understanding these basic Transform3D operations, you’ve made the first steps towards mastering 3D object manipulation in Godot. In the next section, we’ll explore how to apply these transformations to actual objects in your game scene.Applying Transform3D to 3D Nodes in Godot is crucial for moving, rotating, and scaling objects in your scene. Let’s delve into how you can apply the Transform3D operations to nodes.

Applying a Transformation
To apply a Transform3D to a node directly, use the `transform` property of the 3D node:

# Assuming 'my_node' is a reference to a Spatial node in your scene
my_node.transform = my_transform

It’s important to note that this will replace the current transform of the node with the new one.

Combining Transforms
If you want to combine the current transform of a node with a new Transform3D, such as adding a new translation or rotation, you use the multiplication (`*`) operator:

# Move 'my_node' up by 4 units without affecting its current transform
my_node.global_transform = my_node.global_transform * Transform3D().translated(Vector3(0, 4, 0))

Relative Transformations
You can also apply transformations relative to a node’s current position and orientation, without directly modifying the transform property:

# Rotate 'my_node' around its own Z-axis
my_node.rotate_object_local(Vector3.FORWARD, deg2rad(45))
# Translate 'my_node' locally on the X-axis
my_node.translate_object_local(Vector3.RIGHT * 5)

Working with Global Transforms
It’s essential to understand the difference between local and global transforms. Local transforms are relative to the object’s parent, while global transforms are relative to the world. Here’s how to set an absolute world position for a node:

# Set the absolute global position of 'my_node' to the origin (0,0,0)
my_node.global_transform.origin = Vector3.ZERO

Sometimes you may need to convert between local and global space:

# Convert a local point to global
var global_point = my_node.to_global(Vector3(1, 0, 0))

# Convert a global point to local
var local_point = my_node.to_local(global_point)

With these Transform3D application examples, you’re now equipped to start manipulating objects in your 3D games with precision. Remember, practice is key in game development, so take these snippets, experiment with them, and watch your 3D Godot worlds come to life!Working with Transform3D in Godot also includes understanding more complex movements and relational transformations. Below you’ll find code examples that build on the previous basics and introduce more advanced concepts.

Complex Movement Patterns
You can create complex movement patterns by combining multiple transformations. For example, to move an object in a circle while keeping it facing the center, you could use:

# Move node in a circle while facing the origin
var angle = 0.0
var radius = 5.0

# Inside your process function
angle += delta # Increase the angle over time
var x = radius * sin(angle)
var z = radius * cos(angle)

# Update the node's transform
my_node.global_transform.origin = Vector3(x, my_node.global_transform.origin.y, z)

# Make it face the origin
my_node.look_at(Vector3.ZERO, Vector3.UP)

Local vs Global Rotations
Different scenarios require local or global rotations. Here’s an example rotating a node locally around its Y-axis, and then globally around the world’s Y-axis:

# Local rotation around Y-axis

# Global rotation around Y-axis
var global_rotation = Transform3D().rotated(Vector3.UP, deg2rad(45))
my_node.global_transform = global_rotation * my_node.global_transform

Inheriting and Ignoring Parental Transforms
At times, you might want certain nodes to ignore transformations of their parent. Godot allows you to directly set global_transform:

# This node's transform won't be affected by its parent's transform anymore

# To maintain the current global position and ignore parent's transform
my_node.global_transform = my_node.global_transform

Interpolating Between Transforms
Interpolation between two Transform3D objects can be used to create smooth transitions. Here’s an example using linear interpolation (lerp):

# Interpolate smoothly between current transform and a target transform over time
var progress = 0.0 # Range from 0.0 to 1.0
var target_transform = Transform3D(Basis(), Vector3(10, 0, 0))

# During a process or physics step, increase progress towards 1 at a certain rate
progress += delta * transition_speed
progress = min(progress, 1.0)

# Apply interpolated transform
my_node.transform = my_node.transform.interpolate_with(target_transform, progress)

Utilizing Quaternions
Quaternions are useful for representing rotations to avoid issues like gimbal lock. Godot’s Basis class can be converted to and from quaternions:

# Convert a basis to a quaternion
var quaternion = my_transform.basis.get_rotation_quaternion()

# Rotate the quaternion by 45 degrees around the Y-axis
quaternion = quaternion * Quat(Vector3.UP, deg2rad(45))

# Apply the quaternion as the new basis for my_transform
my_transform.basis = Basis(quaternion)

Manipulating Individual Axes
Sometimes, it’s necessary to manipulate only one of the axes of the Basis:

# Double the length of the X-axis vector of the basis
my_transform.basis.x *= 2.0

# Invert the direction of the Z-axis vector
my_transform.basis.z = -my_transform.basis.z

By incorporating these Transform3D techniques into your toolkit, you’re enhancing the range and depth of interactions within your games. Practice with these concepts, experiment with various scenarios, and continue expanding your knowledge as you bring more sophistication to your Godot 3D projects.

Where to Go Next in Your Game Development Journey

If you’ve enjoyed learning about working with Transform3D in Godot and are looking to enhance your game development skills further, we at Zenva encourage you to keep the momentum going! Dive deeper into the expansive world of game creation with our comprehensive Godot Game Development Mini-Degree. This series is designed to take you from the essential foundations to more intricate game development techniques, all at your own pace.

Whether you’re a beginner eager to get started or an advanced developer looking to polish your skills, Zenva’s courses cover a wide array of topics, including 2D and 3D game development, GDScript, and even how to craft engaging gameplay mechanics across various genres. Our instructors bring years of experience and a rich collection of real-world projects to the table, giving you the opportunity to build a portfolio that showcases your abilities.

For those seeking a broader array of Godot-related content, our full range of Godot courses awaits to further your development skills. Step into the role of a game developer with the confidence that Zenva’s courses will equip you with the knowledge you need to succeed in this exciting and ever-evolving industry.


As you’ve delved into the transformative powers of Transform3D in Godot, you’ve equipped yourself with essential 3D game development skills. Mastery of Transform3D paves the way for creating dynamic and interactive game experiences that captivate players. The concepts and techniques you’ve learned here are just the beginning. With practice, you will be able to bring to life even the most complex movements and interactions in your 3D worlds.

To continue on your path to becoming a game development virtuoso, we invite you to explore our Godot Game Development Mini-Degree. Advance your craft with our tailored courses and let Zenva be your guide in this thrilling adventure of creation and innovation. Your journey doesn’t end here — it evolves with each line of code and each game you bring into existence. Let’s build the future of gaming, together.

Python Blog Image

FINAL DAYS: Unlock coding courses in Unity, Godot, Unreal, Python and more.