【Godot】Learning Godot's 3D Space Fundamentals with Node3D and MeshInstance3D

Introduction: Why Node3D and MeshInstance3D Are Important

When starting 3D game development in Godot Engine, the most important concepts to understand first are Node3D and MeshInstance3D. These define the "location" and "appearance" of all objects in 3D space—truly the foundation of 3D scene components.

While Node2D was central in 2D game development, Node3D takes that role in 3D.

---

Godot 3D Space Fundamentals

Godot's 3D space is built on coordinate systems and units, just like the real world.

3D Coordinate System: Y-Up Right-Handed

Godot uses a right-handed coordinate system adopted by many 3D software. Particularly important is that the Y-axis represents up/down—"Y-Up".

Axis	Role	Positive Direction
Y-axis	Height (Up/Down)	Up
X-axis	Width (Left/Right)	Right
Z-axis	Depth (Forward/Backward)	Toward viewer (-Z is forward)

Also, in Godot's 3D space, 1 unit equals 1 meter. This serves as the standard when considering object sizes and movement distances.

Transform3D: The Object's "State" Itself

All objects in 3D space have their spatial state (position, rotation, scale) defined by a data structure called Transform3D.

Transform3D consists of two main elements:

1. Basis: A 3x3 matrix defining the object's rotation and scale.
2. Origin: A Vector3 defining the object's position.

The position, rotation, and scale properties commonly seen in the inspector are simply convenient properties provided for humans to intuitively manipulate this complex Transform3D.

---

Node3D: Foundation of "Existence" in Space

Node3D is the base class for all 3D nodes in Godot. Its most important role is holding Transform3D (position, rotation, scale) in 3D space.

Node3D itself has no visible form or physical collision detection. It exists purely to define a "point" or "coordinate system" in space.

Main Roles of Node3D

1. Object Placement: All 3D objects ultimately inherit from Node3D, so they always have a Transform.
2. Grouping and Parent-Child Relationships: This is Node3D's most powerful use. By using an empty Node3D as a parent and grouping multiple nodes as children, you can treat them as a single unit. Moving the parent moves all child objects together.
3. Relative Coordinate Reference Point: A child node's transform is always relative to the parent node's transform.

---

MeshInstance3D: Giving Objects "Appearance"

MeshInstance3D inherits from Node3D and adds the ability to render visual shapes (meshes).

While Node3D determines "where it exists," MeshInstance3D determines "what exists and how it looks."

Node	Role	Main Properties	Concept
Node3D	Location/Pose	transform (position, rotation, scale)	"Where" and "how" of existence
MeshInstance3D	Appearance/Shape	mesh, material_override	"What" and "in what way" of existence

For MeshInstance3D to render anything on screen, you must at minimum assign a Mesh resource (e.g., BoxMesh, SphereMesh, or an imported 3D model) to the mesh property.

---

Common Mistakes and Best Practices

Common Mistake	Why It's a Problem	Best Practice
Moving MeshInstance3D directly	When combined with physics, only the appearance moves while collision detection doesn't follow.	Use CharacterBody3D or RigidBody3D as root and place MeshInstance3D as a child.
Getting global coordinates with position	position is relative to parent. With deep scene hierarchies, you get unintended coordinates.	Always use global_transform.origin when you need global coordinates.
Flipping objects with scale	Negative scale (e.g., scale.x = -1) causes unexpected behavior in physics and some shaders.	Import models in correct orientation or adjust orientation with rotation.
Placing many MeshInstance3D individually	With many identical meshes, draw calls increase and performance degrades.	Consider using MultiMeshInstance3D.

---

Practical Example: Dynamic Object Creation and Hierarchy

Let's build a more practical scene using GDScript. The theme is "a rotating planet with an orbiting satellite."

@tool
extends Node3D

@export var rotation_speed: float = 1.0
@export var orbit_speed: float = 2.0
@export var orbit_distance: float = 4.0

var planet: MeshInstance3D
var satellite: MeshInstance3D

func _ready():
    if not has_node("PlanetPivot"):
        _create_celestial_bodies()

    planet = $PlanetPivot/Planet
    satellite = $PlanetPivot/SatellitePivot/Satellite

func _process(delta):
    if not Engine.is_editor_hint():
        # Planet rotation (rotate around Y-axis at rotation_speed degrees per second)
        planet.rotate_y(deg_to_rad(rotation_speed * delta))

        # Satellite orbit (rotate the parent Pivot)
        var satellite_pivot = satellite.get_parent()
        satellite_pivot.rotate_y(deg_to_rad(orbit_speed * delta))

func _create_celestial_bodies():
    # 1. Node3D as planet's rotation axis (Pivot)
    var planet_pivot = Node3D.new()
    planet_pivot.name = "PlanetPivot"
    add_child(planet_pivot)

    # 2. Planet body (MeshInstance3D)
    planet = MeshInstance3D.new()
    planet.name = "Planet"
    planet.mesh = SphereMesh.new()
    planet.mesh.radius = 1.5
    planet.mesh.height = 3.0
    var planet_material = StandardMaterial3D.new()
    planet_material.albedo_color = Color.DODGER_BLUE
    planet.set_surface_override_material(0, planet_material)
    planet_pivot.add_child(planet)

    # 3. Node3D as satellite's orbit axis (Pivot)
    var satellite_pivot = Node3D.new()
    satellite_pivot.name = "SatellitePivot"
    planet_pivot.add_child(satellite_pivot)

    # 4. Satellite body (MeshInstance3D)
    satellite = MeshInstance3D.new()
    satellite.name = "Satellite"
    satellite.mesh = SphereMesh.new()
    satellite.mesh.radius = 0.5
    satellite.mesh.height = 1.0
    var satellite_material = StandardMaterial3D.new()
    satellite_material.albedo_color = Color.LIGHT_GRAY
    satellite.set_surface_override_material(0, satellite_material)

    # Place satellite on orbit (position relative to parent)
    satellite.position = Vector3(orbit_distance, 0, 0)
    satellite_pivot.add_child(satellite)

Key Points

• Pivot Nodes: Rather than rotating the object itself directly, rotating its parent Pivot allows independent control of rotation and orbit.
• Parent-Child Relationships: Since satellite_pivot is a child of planet_pivot, moving the entire planet also moves the satellite.

---

Performance Considerations

While Node3D and MeshInstance3D are convenient, they can become performance bottlenecks depending on usage.

• Large Number of Nodes: Having thousands or tens of thousands of Node3D in the scene tree increases CPU load.
• Increased Draw Calls: Costs increase with more MeshInstance3D having different materials.

Alternative Patterns

• MultiMeshInstance3D: Optimal when placing large numbers of objects with the same mesh and material (e.g., forest trees).
• RenderingServer: For pushing performance to the limit, directly using the low-level API is an option.

Summary

This article explained the most fundamental elements of Godot's 3D development—Node3D and MeshInstance3D—covering their roles, relationships, and practical usage.

Concept	Keywords	Role
3D Space	Y-Up right-handed, 1 unit = 1m	Environment where objects exist
Transform3D	basis, origin	Define object's pose in space
Node3D	Parent-child relationships, Pivot	Skeleton defining location and pose
MeshInstance3D	mesh, material	Flesh defining appearance

Understanding the division of roles between these two nodes is key to mastering Godot 3D scene construction. Build the skeleton with Node3D, add flesh with MeshInstance3D. Keep this principle in mind and apply it to your game development.