3D Overview

var my_node = Node3D.new()

# Position (translation)
my_node.position = Vector3(10, 5, 0)

# Rotation (in radians)
my_node.rotation = Vector3(0, PI / 2, 0)

# Rotation in degrees (more intuitive)
my_node.rotation_degrees = Vector3(0, 90, 0)

# Scale
my_node.scale = Vector3(2, 2, 2)

# Move forward (negative Z direction)
my_node.translate_object_local(Vector3(0, 0, -1))

# Move in global space
my_node.global_translate(Vector3(5, 0, 0))

# Rotate around Y axis (yaw)
my_node.rotate_y(deg_to_rad(45))

# Rotate around custom axis in local space
my_node.rotate_object_local(Vector3.UP, deg_to_rad(90))

# Rotate in global space
my_node.global_rotate(Vector3.UP, deg_to_rad(30))

# Make the node look at a target
var target_position = Vector3(10, 0, 10)
my_node.look_at(target_position, Vector3.UP)

# Look at from a specific position
my_node.look_at_from_position(
    Vector3(0, 5, 0),  # Start position
    target_position,    # Target
    Vector3.UP          # Up direction
)

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

# Convert global point to local
var local_pos = my_node.to_local(Vector3(10, 5, 0))

Node3D (Root)
├─ Camera3D
├─ DirectionalLight3D (Sun)
├─ WorldEnvironment
└─ Level
    ├─ Player (CharacterBody3D)
    │   ├─ MeshInstance3D (Visual)
    │   └─ CollisionShape3D
    ├─ Floor (StaticBody3D)
    │   ├─ MeshInstance3D
    │   └─ CollisionShape3D
    └─ Props
        └─ MeshInstance3D

# Show/hide nodes
my_node.show()
my_node.hide()

# Toggle visibility
my_node.visible = !my_node.visible

# Check if visible in tree (considers parent visibility)
if my_node.is_visible_in_tree():
    print("Node is visible")

# Make transform independent of parent
my_node.top_level = true
# Now global_transform == transform

# Reset scale to Vector3.ONE while preserving position and rotation
my_node.orthonormalize()

# Disable scale globally
my_node.set_disable_scale(true)

func _ready():
    # Enable transform change notifications
    set_notify_transform(true)

func _notification(what):
    if what == NOTIFICATION_TRANSFORM_CHANGED:
        print("Global transform changed!")
    elif what == NOTIFICATION_LOCAL_TRANSFORM_CHANGED:
        print("Local transform changed!")

# Get parent Node3D (respects top_level)
var parent_3d = my_node.get_parent_node_3d()

# Get the 3D world
var world = my_node.get_world_3d()

extends Node3D

var speed = 5.0

func _process(delta):
    # Move in the direction the object is facing
    translate_object_local(Vector3(0, 0, -speed * delta))

extends Node3D

var orbit_center = Vector3.ZERO
var orbit_speed = 1.0
var orbit_radius = 5.0
var angle = 0.0

func _process(delta):
    angle += orbit_speed * delta
    position = orbit_center + Vector3(
        cos(angle) * orbit_radius,
        0,
        sin(angle) * orbit_radius
    )
    look_at(orbit_center, Vector3.UP)

extends Node3D

@export var target: Node3D
@export var follow_speed = 5.0

func _process(delta):
    if target:
        global_position = global_position.lerp(
            target.global_position,
            follow_speed * delta
        )