Up to date

This page is up to date for Godot 4.1. If you still find outdated information, please open an issue.

Room scale in XR

One of the staples of XR projects is the ability to walk around freely in a large space. This space is often constrained by the room the player is physically in with tracking sensors placed within this space. With the advent of inside out tracking however ever larger play spaces are possible.

As a developer this introduces a number of interesting challenges. In this document we will look at a number of the challenges you may face and outline some solutions. We’ll discuss the issues and challenges for seated XR games in another document.

In traditional first person games a player is represented by a CharacterBody3D node. This node is moved by processing traditional controller, mouse or keyboard input. A camera is attached to this node at a location roughly where the player’s head will be.

Applying this model to the XR setup, we add an XROrigin3D node as a child of the character body, and add a XRCamera3D as a child of the origin node. At face value this seems to work. However, upon closer examination this model does not take into account that there are two forms of movement in XR. The movement through controller input, and the physical movement of the player in the real world.

As a result, the origin node does not represent the position of the player. It represents the center, or start of, the tracking space in which the player can physically move. As the player moves around their room this movement is represented through the tracking of the players headset. In game this translates to the camera node’s position being updated accordingly. For all intents and purposes, we are tracking a disembodied head. Unless body tracking is available, we have no knowledge of the position or orientation of the player’s body.

../../_images/XRRoomCenterWalk.gif

The first problem this causes is fairly obvious. When the player moves with controller input, we can use the same approach in normal games and move the player in a forward direction. However the player isn’t where we think they are and as we move forward we’re checking collisions in the wrong location.

../../_images/XRRoomWalkOffCliff.gif

The second problem really shows itself when the player walks further away from the center of the tracking space and uses controller input to turn. If we rotate our character body, the player will be moved around the room in a circular fashion.

../../_images/XRRoomRotateOrigin.gif

If we fix the above issues, we will find a third issue. When the path for the player is blocked in the virtual world, the player can still physically move forward.

../../_images/XRRoomWalkWall.gif

We will look at solving the first two problem with two separate solutions, and then discuss dealing with the third.

Origin centric solution

Looking at the first approach for solving this we are going to change our structure. This is the approach currently implemented in XR Tools.

../../_images/xr_room_scale_origin_body.webp

In this setup we mark the character body as top level so it does not move with the origin.

We also have a helper node that tells us where our neck joint is in relation to our camera. We use this to determine where our body center is.

Processing our character movement is now done in three steps.

Step 1

In the first step we’re going to process the physical movement of the player. We determine where the player is right now, and attempt to move our character body there.

  1. func _process_on_physical_movement(delta):
  2.   # Remember our current velocity, we'll apply that later
  3.   var current_velocity = $CharacterBody3D.velocity
  5.   # Remember where our player body currently is
  6.   var org_player_body: Vector3 = $CharacterBody3D.global_transform.origin
  8.   # Determine where our player body should be
  9.   var player_body_location: Vector3 = $XRCamera3D.transform * $XRCamera3D/Neck.transform.origin
  10.   player_body_location.y = 0.0
  11.   player_body_location = global_transform * player_body_location
  13.   # Attempt to move our character
  14.   $CharacterBody3D.velocity = (player_body_location - org_player_body) / delta
  15.   $CharacterBody3D.move_and_slide()
  17.   # Set back to our current value
  18.   $CharacterBody3D.velocity = current_velocity
  20.   # Check if we managed to move all the way, ignoring height change
  21.   var movement_left = player_body_location - $CharacterBody3D.global_transform.origin
  22.   movement_left.y = 0.0
  23.   if (movement_left).length() > 0.01:
  24.     # We'll talk more about what we'll do here later on
  25.     return true
  26.   else:
  27.     return false
  29. func _physics_process(delta):
  30.   var is_colliding = _process_on_physical_movement(delta)

Note that we’re returning true from our _process_on_physical_movement function when we couldn’t move our player all the way.

Step 2

The second step is to handle rotation of the player as a result of user input.

As the input used can differ based on your needs we are simply calling the function _get_rotational_input. This function should obtain the necessary input and return the rotational speed in radians per second.

  1. func _get_rotational_input() -> float:
  2.   # Implement this function to return rotation in radians per second.
  3.   return 0.0
  5. func _copy_player_rotation_to_character_body():
  6.   # We only copy our forward direction to our character body, we ignore tilt
  7.   var camera_forward: Vector3 = -$XRCamera3D.global_transform.basis.z
  8.   var body_forward: Vector3 = Vector3(camera_forward.x, 0.0, camera_forward.z)
  10.   $CharacterBody3D.global_transform.basis = Basis.looking_at(body_forward, Vector3.UP)
  12. func _process_rotation_on_input(delta):
  13.   var t1 := Transform3D()
  14.   var t2 := Transform3D()
  15.   var rot := Transform3D()
  17.   # We are going to rotate the origin around the player
  18.   var player_position = $CharacterBody3D.global_transform.origin - global_transform.origin
  20.   t1.origin = -player_position
  21.   t2.origin = player_position
  22.   rot = rot.rotated(Vector3(0.0, 1.0, 0.0), _get_rotational_input() * delta)
  23.   global_transform = (global_transform * t2 * rot * t1).orthonormalized()
  25.   # Now ensure our player body is facing the correct way as well
  26.   _copy_player_rotation_to_character_body()
  28. func _physics_process(delta):
  29.   var is_colliding = _process_on_physical_movement(delta)
  30.   if !is_colliding:
  31.     _process_rotation_on_input(delta)

Step 3

The third and final step is moving the player forwards, backwards or sideways as a result of user input.

Just like with the rotation the inputs differ from project to project so we are simply calling the function _get_movement_input. This function should obtain the necessary input and return a directional vector scaled to the required velocity.

  1. var gravity = ProjectSettings.get_setting("physics/3d/default_gravity")
  3. func _get_movement_input() -> Vector2:
  4.   # Implement this to return requested directional movement in meters per second.
  5.   return Vector2()
  7. func _process_movement_on_input(delta):
  8.   # Remember where our player body currently is
  9.   var org_player_body: Vector3 = $CharacterBody3D.global_transform.origin
  11.   # We start with applying gravity
  12.   $CharacterBody3D.velocity.y -= gravity * delta
  14.   # Now we add in our movement
  15.   var input: Vector2 = _get_movement_input()
  16.   var movement: Vector3 = ($CharacterBody3D.global_transform.basis * Vector3(input.x, 0, input.y))
  17.   $CharacterBody3D.velocity.x = movement.x
  18.   $CharacterBody3D.velocity.z = movement.z
  20.   # Attempt to move our player
  21.   $CharacterBody3D.move_and_slide()
  23.   # And now apply the actual movement to our origin
  24.   global_transform.origin += $CharacterBody3D.global_transform.origin - org_player_body
  26. func _physics_process(delta):
  27.   var is_colliding = _process_on_physical_movement(delta)
  28.   if !is_colliding:
  29.     _process_rotation_on_input(delta)
  30.     _process_movement_on_input(delta)

Character body centric solution

In this setup we are going to keep our character body as our root node and as such is easier to combine with traditional game mechanics.

../../_images/xr_room_scale_character_body.webp

Here we have a standard character body with collision shape, and our XR origin node and camera as normal children. We also have our neck helper node.

Processing our character movement is done in the same three steps but implemented slightly differently.

Step 1

In this approach step 1 is where all the magic happens. Just like with our previous approach we will be applying our physical movement to the character body, but we will counter that movement on the origin node.

This will ensure that the players location stays in sync with the character body’s location.

  1. # Helper variables to keep our code readable
  2. @onready var origin_node = $XROrigin3D
  3. @onready var camera_node = $XROrigin3D/XRCamera3D
  4. @onready var neck_position_node = $XROrigin3D/XRCamera3D/Neck
  6. func _process_on_physical_movement(delta) -> bool:
  7.   # Remember our current velocity, we'll apply that later
  8.   var current_velocity = velocity
  10.   # Start by rotating the player to face the same way our real player is
  11.   var camera_basis: Basis = origin_node.transform.basis * camera_node.transform.basis
  12.   var forward: Vector2 = Vector2(camera_basis.z.x, camera_basis.z.z)
  13.   var angle: float = forward.angle_to(Vector2(0.0, 1.0))
  15.   # Rotate our character body
  16.   transform.basis = transform.basis.rotated(Vector3.UP, angle)
  18.   # Reverse this rotation our origin node
  19.   origin_node.transform = Transform3D().rotated(Vector3.UP, -angle) * origin_node.transform
  21.   # Now apply movement, first move our player body to the right location
  22.   var org_player_body: Vector3 = global_transform.origin
  23.   var player_body_location: Vector3 = origin_node.transform * camera_node.transform * neck_position_node.transform.origin
  24.   player_body_location.y = 0.0
  25.   player_body_location = global_transform * player_body_location
  27.   velocity = (player_body_location - org_player_body) / delta
  28.   move_and_slide()
  30.   # Now move our XROrigin back
  31.   var delta_movement = global_transform.origin - org_player_body
  32.   origin_node.global_transform.origin -= delta_movement
  34.   # Return our value
  35.   velocity = current_velocity
  37.   if (player_body_location - global_transform.origin).length() > 0.01:
  38.     # We'll talk more about what we'll do here later on
  39.     return true
  40.   else:
  41.     return false
  43. func _physics_process(delta):
  44.   var is_colliding = _process_on_physical_movement(delta)

In essence the code above will move the character body to where the player is, and then move the origin node back in equal amounts. The result is that the player stays centered above the character body.

We start with applying the rotation. The character body should be facing where the player was looking the previous frame. We calculate our camera orientation in the space of the character body. We can now calculate the angle by which the player has rotated their head. We rotate our character body by the same amount so our character body faces the same direction as the player. And then we reverse the rotation on the origin node so the camera ends up aligned with the player again.

For the movement we do much the same. The character body should be where the player was standing the previous frame. We calculate by how much the player has moved from this location. Then we attempt to move the character body to this location.

As the player may hit a collision body and be stopped, we only move the origin point back by the amount we actually moved the character body. The player may thus move away from this location but that will be reflected in the positioning of the player.

As with our previous solution we return true if this is the case.

Step 2

In this step we again apply the rotation based on controller input. However in this case the code is nearly identical to how one would implement this in a normal first person game.

As the input used can differ based on your needs we are simply calling the function _get_rotational_input. This function should obtain the necessary input and return the rotational speed in radians per second.

  1. func _get_rotational_input() -> float:
  2.   # Implement this function to return rotation in radians per second.
  3.   return 0.0
  5. func _process_rotation_on_input(delta):
  6.   rotation.y += _get_rotational_input() * delta
  8. func _physics_process(delta):
  9.   var is_colliding = _process_on_physical_movement(delta)
  10.   if !is_colliding:
  11.     _process_rotation_on_input(delta)

Step 3

For step three we again apply the movement based on controller input. However just like at step 2, we can now implement this as we would in a normal first person game.

Just like with the rotation the inputs differ from project to project so we are simply calling the function _get_movement_input. This function should obtain the necessary input and return a directional vector scaled to the required velocity.

  1. func _get_movement_input() -> Vector2:
  2.   # Implement this to return requested directional movement in meters per second.
  3.   return Vector2()
  5. func _process_movement_on_input(delta):
  6.   var movement_input = _get_movement_input()
  7.   var direction = global_transform.basis * Vector3(movement_input.x, 0, movement_input.y)
  8.   if direction:
  9.     velocity.x = direction.x
  10.     velocity.z = direction.z
  11.   else:
  12.     velocity.x = move_toward(velocity.x, 0, delta)
  13.     velocity.z = move_toward(velocity.z, 0, delta)
  15.   move_and_slide()
  17. func _physics_process(delta):
  18.   var is_colliding = _process_on_physical_movement(delta)
  19.   if !is_colliding:
  20.     _process_rotation_on_input(delta)
  21.     _process_movement_on_input(delta)

When the player walks to somewhere they shouldn’t

Think of a situation where the player is outside a locked room. You don’t want the player to go into that room until the door is unlocked. You also don’t want the player to see what is in this room.

The logic for moving the player through controller input nicely prevents this. The player encounters a static body, and the code prevents the player from moving into the room.

However with XR, nothing is preventing the player from taking a real step forward.

With both the approaches worked out up above we will prevent the character body from moving where the player can’t go. As the player has physically moved to this location, the camera will now have moved into the room.

The logical solution would be to prevent the movement altogether and adjust the placement of the XR origin point so the player stays outside of the room.

The problem with this approach is that physical movement is now not replicated in the virtual space. This will cause nausea for the player.

What many XR games do instead, is to measure the distance between where the player physically is, and where the players virtual body has been left behind. As this distance increases, usually to a distance of a few centimeters, the screen slowly blacks out.

Our solutions up above would allow us to add this logic into the code at the end of step 1.

Further improvements to the code presented could be:

  • allowing controller input as long as this distance is still small,

  • still applying gravity to the player even when controller input is disabled.

Further suggestions for improvements

The above provides two good options as starting points for implementing room scale XR games.

A few more things that are worth pointing out that you will likely want to implement:

  • The height of the camera can be used to detect whether the player is standing up, crouching, jumping or lying down. You can adjust the size and orientation of the collision shape accordingly. Extra bonus points for adding multiple collision shapes so the head and body have their own, more accurately sized, shapes.

  • When a scene first loads, the player may be far away from the center of the tracking space. This could result in the player spawning into a different room than our origin point. The game will now attempt, and fail, to move the player body from the starting point to where the player is standing. You should implement a reset function that moves the origin point so the player is in the correct starting position.

Both of the above improvements require the player to be ready and standing up straight. There is no guarantee as the player may still be putting their headset on.

Many games, including XR Tools, solve this by introducing an intro screen or loading screen where the player must press a button when they are ready. This starting environment is often a large location where the positioning of the player has little impact on what the player sees. When the player is ready, and presses the button, this is the moment you record the position and height of the camera.