WebXRInterface

Overview ¶

WebXR is an open standard that allows creating VR and AR applications that run in the web browser.

As such, this interface is only available when running in Web exports.

WebXR supports a wide range of devices, from the very capable (like Valve Index, HTC Vive, Oculus Rift and Quest) down to the much less capable (like Google Cardboard, Oculus Go, GearVR, or plain smartphones).

Since WebXR is based on JavaScript, it makes extensive use of callbacks, which means that graphics.gd/classdb/WebXRInterface is forced to use signals, where other XR interfaces would instead use functions that return a result immediately. This makes graphics.gd/classdb/WebXRInterface quite a bit more complicated to initialize than other XR interfaces.

Here's the minimum code required to start an immersive VR session:

package main

import (
	"graphics.gd/classdb/Button"
	"graphics.gd/classdb/Node3D"
	"graphics.gd/classdb/OS"
	"graphics.gd/classdb/Viewport"
	"graphics.gd/classdb/WebXRInterface"
	"graphics.gd/classdb/XRServer"
	"graphics.gd/variant/Object"
)

type NodeWebXR struct {
	Node3D.Extension[NodeWebXR]

	Button Button.Instance

	webxr_interface WebXRInterface.Instance
	vr_supported    bool
}

func (n *NodeWebXR) Ready() {
	n.Button.AsBaseButton().OnPressed(func() {
		if !n.vr_supported {
			OS.Alert("Your browser doesn't support VR")
			return
		}
		// We want an immersive VR session, as opposed to AR ('immersive-ar') or a
		// simple 3DoF viewer ('viewer').
		n.webxr_interface.SetSessionMode("immersive-vr")
		// 'bounded-floor' is room scale, 'local-floor' is a standing or sitting
		// experience (it puts you 1.6m above the ground if you have 3DoF headset),
		// whereas as 'local' puts you down at the XROrigin.
		// This list means it'll first try to request 'bounded-floor', then
		// fallback on 'local-floor' and ultimately 'local', if nothing else is
		// supported.
		n.webxr_interface.SetRequestedReferenceSpaceTypes("bounded-floor, local-floor, local")
		// In order to use 'local-floor' or 'bounded-floor' we must also
		// mark the features as required or optional. By including 'hand-tracking'
		// as an optional feature, it will be enabled if supported.
		n.webxr_interface.SetRequiredFeatures("local-floor")
		n.webxr_interface.SetOptionalFeatures("bounded-floor, hand-tracking")

		// This will return false if we're unable to even request the session,
		// however, it can still fail asynchronously later in the process, so we
		// only know if it's really succeeded or failed when our
		// _webxr_session_started() or _webxr_session_failed() methods are called.
		if !n.webxr_interface.AsXRInterface().Initialize() {
			OS.Alert("Failed to initialize")
			return
		}
	})

	n.webxr_interface = Object.To[WebXRInterface.Instance](XRServer.FindInterface("WebXR"))
	if n.webxr_interface != WebXRInterface.Nil {
		// WebXR uses a lot of asynchronous callbacks, so we connect to various
		// signals in order to receive them.
		n.webxr_interface.OnSessionSupported(func(session_mode string, supported bool) {
			if session_mode == "immersive-vr" {
				n.vr_supported = supported
			}
		})
		n.webxr_interface.OnSessionStarted(func() {
			n.Button.AsCanvasItem().SetVisible(false)
			// This tells Godot to start rendering to the headset.
			Viewport.Get(n.AsNode()).SetUseXr(true)
			// This will be the reference space type you ultimately got, out of the
			// types that you requested above. This is useful if you want the game to
			// work a little differently in 'bounded-floor' versus 'local-floor'.
			print("Reference space type: ", n.webxr_interface.ReferenceSpaceType())
			// This will be the list of features that were successfully enabled
			// (except on browsers that don't support this property).
			print("Enabled features: ", n.webxr_interface.EnabledFeatures())
		})
		n.webxr_interface.OnSessionEnded(func() {
			n.Button.AsCanvasItem().SetVisible(true)
			// If the user exits immersive mode, then we tell Godot to render to the web
			// page again.
			Viewport.Get(n.AsNode()).SetUseXr(false)
		})
		n.webxr_interface.OnSessionFailed(func(message string) {
			OS.Alert("Failed to initialize: " + message)
		})
	}
}

There are a couple ways to handle "controller" input:

- Using graphics.gd/classdb/XRController3D nodes and their [Instance.OnXrcontroller3d.ButtonPressed] and [Instance.OnXrcontroller3d.ButtonReleased] signals. This is how controllers are typically handled in XR apps in Godot, however, this will only work with advanced VR controllers like the Oculus Touch or Index controllers, for example.

- Using the Instance.OnSelect, Instance.OnSqueeze and related signals. This method will work for both advanced VR controllers, and non-traditional input sources like a tap on the screen, a spoken voice command or a button press on the device itself.

You can use both methods to allow your game or app to support a wider or narrower set of devices and input methods, or to allow more advanced interactions with more advanced devices.