Up to date
This page is up to date for Godot
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.
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.
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.
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.
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.
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.
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.
func _process_on_physical_movement(delta): # Remember our current velocity, we'll apply that later var current_velocity = $CharacterBody3D.velocity # Remember where our player body currently is var org_player_body: Vector3 = $CharacterBody3D.global_transform.origin # Determine where our player body should be var player_body_location: Vector3 = $XRCamera3D.transform * $XRCamera3D/Neck.transform.origin player_body_location.y = 0.0 player_body_location = global_transform * player_body_location # Attempt to move our character $CharacterBody3D.velocity = (player_body_location - org_player_body) / delta $CharacterBody3D.move_and_slide() # Set back to our current value $CharacterBody3D.velocity = current_velocity # Check if we managed to move all the way, ignoring height change var movement_left = player_body_location - $CharacterBody3D.global_transform.origin movement_left.y = 0.0 if (movement_left).length() > 0.01: # We'll talk more about what we'll do here later on return true else: return false func _physics_process(delta): 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.
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
This function should obtain the necessary input and return the rotational speed in radians per second.
func _get_rotational_input() -> float: # Implement this function to return rotation in radians per second.