Class: Options

Defined in: src/core/Options.ts:100

A central configuration class for the entire XR Blocks system. It aggregates all settings and provides chainable methods for enabling common features.

Constructors

Constructor

new Options(options?): Options

Defined in: src/core/Options.ts:229

Constructs the Options object by merging default values with provided custom options.

Parameters

options?

A custom options object to override the defaults.

ai?

{ enabled?: boolean; gemini?: { apiKey?: string; config?: { }; enabled?: boolean; keyValid?: boolean; liveModel?: string; model?: string; urlParam?: string; }; globalUrlParams?: { key?: string; }; model?: AIModel; openai?: { apiKey?: string; enabled?: boolean; model?: string; urlParam?: string; }; promptForApiKey?: boolean; } = ...

ai.enabled?

boolean = false

ai.gemini?

{ apiKey?: string; config?: { }; enabled?: boolean; keyValid?: boolean; liveModel?: string; model?: string; urlParam?: string; } = ...

ai.gemini.apiKey?

string = ''

ai.gemini.config?

{ } = {}

ai.gemini.enabled?

boolean = false

ai.gemini.keyValid?

boolean = false

ai.gemini.liveModel?

string = GEMINI_DEFAULT_LIVE_MODEL

ai.gemini.model?

string = GEMINI_DEFAULT_FLASH_MODEL

ai.gemini.urlParam?

string = 'geminiKey'

ai.globalUrlParams?

{ key?: string; } = ...

ai.globalUrlParams.key?

string = 'key'

ai.model?

AIModel = 'gemini'

ai.openai?

{ apiKey?: string; enabled?: boolean; model?: string; urlParam?: string; } = ...

ai.openai.apiKey?

string = ''

ai.openai.enabled?

boolean = false

ai.openai.model?

string = 'gpt-4.1'

ai.openai.urlParam?

string = 'openaiKey'

ai.promptForApiKey?

boolean = false

Show a browser dialog before AI starts so a prototype user can provide, replace, or remove an API key kept only for the current page. Disabled by default. The dialog is skipped when the page URL or keys.json already provides a key.

antialias?

boolean = true

Whether to use antialiasing.

camera?

{ far?: number; near?: number; } = ...

camera.far?

number = 500

camera.near?

number = 0.01

canvas?

{ }

Canvas element to use for rendering. If not defined, a new element will be added to document body.

catchScriptExceptions?

boolean = true

Whether to catch all exceptions thrown by developer scripts in the main update loop and physics step, and log them using console.error instead of crashing the application. When enabled, exceptions in one script will not prevent other scripts or subsystems from updating.

context?

{ debugging?: boolean; enable?: () => ContextOptions; enabled?: boolean; enableScene?: () => ContextOptions; enableSetOfMark?: () => ContextOptions; enableVisibleObjects?: () => ContextOptions; scene?: { enable?: () => SceneOptions; enabled?: boolean; enableSetOfMark?: () => SceneOptions; enableVisibleObjects?: () => SceneOptions; pollingIntervalMs?: number; som?: { enable?: () => SceneSetOfMarkOptions; enabled?: boolean; }; visibleObjects?: { enable?: () => SceneVisibilityOptions; enabled?: boolean; occlusionOpacityThreshold?: number; }; }; } = ...

context.debugging?

boolean = false

context.enable?

() => ContextOptions

context.enabled?

boolean = false

context.scene?

{ enable?: () => SceneOptions; enabled?: boolean; enableSetOfMark?: () => SceneOptions; enableVisibleObjects?: () => SceneOptions; pollingIntervalMs?: number; som?: { enable?: () => SceneSetOfMarkOptions; enabled?: boolean; }; visibleObjects?: { enable?: () => SceneVisibilityOptions; enabled?: boolean; occlusionOpacityThreshold?: number; }; } = ...

context.scene.enable?

() => SceneOptions

context.scene.enabled?

boolean = false

context.scene.enableSetOfMark?

() => SceneOptions

context.scene.enableVisibleObjects?

() => SceneOptions

context.scene.pollingIntervalMs?

number = 3000

context.scene.som?

{ enable?: () => SceneSetOfMarkOptions; enabled?: boolean; } = ...

context.scene.som.enable?

() => SceneSetOfMarkOptions

context.scene.som.enabled?

boolean = false

context.scene.visibleObjects?

{ enable?: () => SceneVisibilityOptions; enabled?: boolean; occlusionOpacityThreshold?: number; } = ...

context.scene.visibleObjects.enable?

() => SceneVisibilityOptions

context.scene.visibleObjects.enabled?

boolean = false

context.scene.visibleObjects.occlusionOpacityThreshold?

number = 0

Raycast hits on materials with effective opacity less than or equal to this threshold are ignored for line-of-sight occlusion.

controllers?

{ debug?: boolean; enabled?: boolean; enabledMouse?: boolean; visualization?: boolean; visualizeRays?: boolean; } = ...

controllers.debug?

boolean = false

Whether to enable debugging features for controllers.

controllers.enabled?

boolean = true

Whether controller input is enabled.

controllers.enabledMouse?

boolean = true

Whether mouse input should act as a controller on desktop.

controllers.visualization?

boolean = false

Whether to show controller models.

controllers.visualizeRays?

boolean = false

Whether to show the ray lines extending from the controllers.

debugging?

boolean = false

Global flag for enabling various debugging features.

depth?

{ dataFormatPreference?: readonly (XRDepthDataFormat | undefined)[]; debugging?: boolean; depthMesh?: { colliderUpdateFps?: number; depthFullResolution?: number; depthMeshUpdateFps?: number; enabled?: boolean; ignoreEdgePixels?: number; opacity?: number; patchHoles?: boolean; patchHolesUpper?: boolean; renderShadow?: boolean; shadowOpacity?: number; showDebugTexture?: boolean; updateFullResolutionGeometry?: boolean; updateVertexNormals?: boolean; useDepthTexture?: boolean; useDownsampledGeometry?: boolean; useDualCollider?: boolean; }; depthTexture?: { applyGaussianBlur?: boolean; applyKawaseBlur?: boolean; constantKernel?: boolean; enabled?: boolean; }; depthTypeRequest?: readonly (XRDepthType | undefined)[]; enabled?: boolean; matchDepthView?: boolean; occlusion?: { enabled?: boolean; }; usagePreference?: readonly (XRDepthUsage | undefined)[]; } = ...

depth.dataFormatPreference?

readonly (XRDepthDataFormat | undefined)[] = ...

depth.debugging?

boolean = false

depth.depthMesh?

{ colliderUpdateFps?: number; depthFullResolution?: number; depthMeshUpdateFps?: number; enabled?: boolean; ignoreEdgePixels?: number; opacity?: number; patchHoles?: boolean; patchHolesUpper?: boolean; renderShadow?: boolean; shadowOpacity?: number; showDebugTexture?: boolean; updateFullResolutionGeometry?: boolean; updateVertexNormals?: boolean; useDepthTexture?: boolean; useDownsampledGeometry?: boolean; useDualCollider?: boolean; } = ...

depth.depthMesh.colliderUpdateFps?

number = 5

depth.depthMesh.depthFullResolution?

number = 160

depth.depthMesh.depthMeshUpdateFps?

number = 0

FPS cap for depth mesh geometry updates. 0 = update every frame.

depth.depthMesh.enabled?

boolean = false

depth.depthMesh.ignoreEdgePixels?

number = 3

depth.depthMesh.opacity?

number = 1.0

depth.depthMesh.patchHoles?

boolean = false

depth.depthMesh.patchHolesUpper?

boolean = false

depth.depthMesh.renderShadow?

boolean = false

depth.depthMesh.shadowOpacity?

number = 0.25

depth.depthMesh.showDebugTexture?

boolean = false

depth.depthMesh.updateFullResolutionGeometry?

boolean = false

depth.depthMesh.updateVertexNormals?

boolean = false

depth.depthMesh.useDepthTexture?

boolean = false

depth.depthMesh.useDownsampledGeometry?

boolean = true

depth.depthMesh.useDualCollider?

boolean = false

depth.depthTexture?

{ applyGaussianBlur?: boolean; applyKawaseBlur?: boolean; constantKernel?: boolean; enabled?: boolean; } = ...

depth.depthTexture.applyGaussianBlur?

boolean = false

depth.depthTexture.applyKawaseBlur?

boolean = false

depth.depthTexture.constantKernel?

boolean = false

depth.depthTexture.enabled?

boolean = false

depth.depthTypeRequest?

readonly (XRDepthType | undefined)[] = ...

depth.enabled?

boolean = false

depth.matchDepthView?

boolean = false

depth.occlusion?

{ enabled?: boolean; } = ...

depth.occlusion.enabled?

boolean = false

depth.usagePreference?

readonly (XRDepthUsage | undefined)[] = []

deviceCamera?

{ cameraLabel?: string; enabled?: boolean; rgbToDepthParams?: { k1?: number; k2?: number; k3?: number; p1?: number; p2?: number; scale?: number; scaleX?: number; scaleY?: number; translateU?: number; translateV?: number; xc?: number; yc?: number; }; videoConstraints?: { }; willCaptureFrequently?: boolean; } = ...

deviceCamera.cameraLabel?

string

deviceCamera.enabled?

boolean = false

deviceCamera.rgbToDepthParams?

{ k1?: number; k2?: number; k3?: number; p1?: number; p2?: number; scale?: number; scaleX?: number; scaleY?: number; translateU?: number; translateV?: number; xc?: number; yc?: number; } = ...

Parameters for RGB to depth UV mapping given different aspect ratios.

deviceCamera.rgbToDepthParams.k1?

number

deviceCamera.rgbToDepthParams.k2?

number

deviceCamera.rgbToDepthParams.k3?

number

deviceCamera.rgbToDepthParams.p1?

number

deviceCamera.rgbToDepthParams.p2?

number

deviceCamera.rgbToDepthParams.scale?

number

deviceCamera.rgbToDepthParams.scaleX?

number

deviceCamera.rgbToDepthParams.scaleY?

number

deviceCamera.rgbToDepthParams.translateU?

number

deviceCamera.rgbToDepthParams.translateV?

number

deviceCamera.rgbToDepthParams.xc?

number

deviceCamera.rgbToDepthParams.yc?

number

deviceCamera.videoConstraints?

{ }

Constraints for getUserMedia. This will guide the initial camera selection.

deviceCamera.willCaptureFrequently?

boolean = false

Hint for performance optimization on frequent captures.

enableAI?

() => Options

enableAutomationMode?

(config) => Options

enableCamera?

(facingMode) => Options

enableContext?

() => Options

enableControllers?

() => Options

enableDepth?

() => Options

enableFaceDetection?

() => Options

enableGestures?

() => Options

enableHandRays?

() => Options

enableHands?

() => Options

enableHeadGestures?

() => Options

enableHumanDetection?

() => Options

enableObjectDetection?

() => Options

enablePlaneDetection?

() => Options

enableReticles?

() => Options

enableSceneContext?

() => Options

enableSegmentation?

() => Options

enableSetOfMarkContext?

() => Options

enableSimulator?

boolean = true

enableStrokes?

() => Options

enableVisibleObjectsContext?

() => Options

enableVR?

() => Options

enableXRTransitions?

() => Options

formFactor?

"auto" | "xr" | "hud" | "vr" | "desktop" | "mobile"

gestures?

{ enable?: () => GestureRecognitionOptions; enabled?: boolean; gestureRecognizer?: { dispose?: () => void; getGestureConfigurations?: () => Record<string, GestureConfiguration>; init?: () => Promise<void>; recognize?: (context) => GestureScoreMap | Promise<GestureScoreMap>; }; gestures?: {[key: string]: { enabled?: boolean; threshold?: number; } | undefined; }; minimumConfidence?: number; poseEstimator?: { dispose?: () => void; getHandContext?: (handedness) => HandContext | null; getHandContexts?: () => Partial<Record<HandLabel, HandContext>>; init?: (dependencies?) => Promise<void>; }; setGestureConfig?: (name, config) => GestureRecognitionOptions; setGestureEnabled?: (name, enabled) => GestureRecognitionOptions; setGestureRecognizer?: (gestureRecognizer) => GestureRecognitionOptions; setPoseEstimator?: (poseEstimator) => GestureRecognitionOptions; updateIntervalMs?: number; } = ...

gestures.enable?

() => GestureRecognitionOptions

gestures.enabled?

boolean = false

gestures.gestureRecognizer?

{ dispose?: () => void; getGestureConfigurations?: () => Record<string, GestureConfiguration>; init?: () => Promise<void>; recognize?: (context) => GestureScoreMap | Promise<GestureScoreMap>; } = ...

gestures.gestureRecognizer.dispose?

() => void

gestures.gestureRecognizer.getGestureConfigurations?

() => Record<string, GestureConfiguration>

gestures.gestureRecognizer.init?

() => Promise<void>

gestures.gestureRecognizer.recognize?

(context) => GestureScoreMap | Promise<GestureScoreMap>

gestures.gestures?

{[key: string]: { enabled?: boolean; threshold?: number; } | undefined; } = {}

gestures.minimumConfidence?

number = 0.6

gestures.poseEstimator?

{ dispose?: () => void; getHandContext?: (handedness) => HandContext | null; getHandContexts?: () => Partial<Record<HandLabel, HandContext>>; init?: (dependencies?) => Promise<void>; } = ...

gestures.poseEstimator.dispose?

() => void

gestures.poseEstimator.getHandContext?

(handedness) => HandContext | null

gestures.poseEstimator.getHandContexts?

() => Partial<Record<HandLabel, HandContext>>

gestures.poseEstimator.init?

(dependencies?) => Promise<void>

gestures.setGestureConfig?

(name, config) => GestureRecognitionOptions

gestures.setGestureEnabled?

(name, enabled) => GestureRecognitionOptions

gestures.setGestureRecognizer?

(gestureRecognizer) => GestureRecognitionOptions

gestures.setPoseEstimator?

(poseEstimator) => GestureRecognitionOptions

gestures.updateIntervalMs?

number = 33

hands?

{ debugging?: boolean; enabled?: boolean; enableHands?: () => HandsOptions; enableHandsVisualization?: () => HandsOptions; visualization?: boolean; visualizeJoints?: boolean; visualizeMeshes?: boolean; } = ...

hands.debugging?

boolean = false

hands.enabled?

boolean = false

Whether hand tracking is enabled.

hands.enableHands?

() => HandsOptions

hands.enableHandsVisualization?

() => HandsOptions

hands.visualization?

boolean = false

Whether to show any hand visualization.

hands.visualizeJoints?

boolean = false

Whether to show the tracked hand joints.

hands.visualizeMeshes?

boolean = false

Whether to show the virtual hand meshes.

headGestures?

{ enable?: () => HeadGestureRecognitionOptions; enabled?: boolean; gestureRecognizer?: { dispose?: () => void; getGestureConfigurations?: () => Record<string, HeadGestureConfiguration>; init?: () => Promise<void>; recognize?: (context) => HeadGestureScoreMap | Promise<HeadGestureScoreMap>; setGestureConfig?: (name, config) => void; }; gestures?: {[key: string]: { enabled?: boolean; threshold?: number; } | undefined; }; historyDurationMs?: number; maximumSampleAngleRadians?: number; maximumSampleGapMs?: number; minimumConfidence?: number; releaseConfidence?: number; setGestureConfig?: (name, config) => HeadGestureRecognitionOptions; setGestureEnabled?: (name, enabled) => HeadGestureRecognitionOptions; setGestureRecognizer?: (gestureRecognizer) => HeadGestureRecognitionOptions; updateIntervalMs?: number; warmupDurationMs?: number; } = ...

headGestures.enable?

() => HeadGestureRecognitionOptions

headGestures.enabled?

boolean = false

headGestures.gestureRecognizer?

{ dispose?: () => void; getGestureConfigurations?: () => Record<string, HeadGestureConfiguration>; init?: () => Promise<void>; recognize?: (context) => HeadGestureScoreMap | Promise<HeadGestureScoreMap>; setGestureConfig?: (name, config) => void; } = ...

headGestures.gestureRecognizer.dispose?

() => void

headGestures.gestureRecognizer.getGestureConfigurations?

() => Record<string, HeadGestureConfiguration>

headGestures.gestureRecognizer.init?

() => Promise<void>

headGestures.gestureRecognizer.recognize?

(context) => HeadGestureScoreMap | Promise<HeadGestureScoreMap>

headGestures.gestureRecognizer.setGestureConfig?

(name, config) => void

headGestures.gestures?

{[key: string]: { enabled?: boolean; threshold?: number; } | undefined; } = {}

headGestures.historyDurationMs?

number = 1500

headGestures.maximumSampleAngleRadians?

number = ...

headGestures.maximumSampleGapMs?

number = 250

headGestures.minimumConfidence?

number = 0.6

headGestures.releaseConfidence?

number = 0.4

headGestures.setGestureConfig?

(name, config) => HeadGestureRecognitionOptions

headGestures.setGestureEnabled?

(name, enabled) => HeadGestureRecognitionOptions

headGestures.setGestureRecognizer?

(gestureRecognizer) => HeadGestureRecognitionOptions

headGestures.updateIntervalMs?

number = 16

headGestures.warmupDurationMs?

number = 200

interaction?

{ longSelectDuration?: number; raycastMode?: RaycastMode; } = ...

interaction.longSelectDuration?

number = 0.75

Seconds a stable object selection must be held before long-select.

interaction.raycastMode?

RaycastMode = 'continuous'

When to sample ray intersections for interaction.

lighting?

{ castDirectionalLightShadow?: boolean; debugging?: boolean; enabled?: boolean; useAmbientSH?: boolean; useDirectionalLight?: boolean; useDynamicSoftShadow?: boolean; } = ...

lighting.castDirectionalLightShadow?

boolean = false

Cast shadows using diretional light.

lighting.debugging?

boolean = false

Enables debugging renders and logs.

lighting.enabled?

boolean = false

Enables XR lighting.

lighting.useAmbientSH?

boolean = false

Add ambient spherical harmonics to lighting.

lighting.useDirectionalLight?

boolean = false

Add main diredtional light to lighting.

lighting.useDynamicSoftShadow?

boolean = false

Adjust hardness of shadows according to relative brightness of main light.

logarithmicDepthBuffer?

boolean = false

Whether to use a logarithmic depth buffer. Useful for depth-aware occlusions.

permissions?

{ camera?: boolean; geolocation?: boolean; microphone?: boolean; } = ...

Which permissions to request before entering the XR session.

permissions.camera?

boolean = false

permissions.geolocation?

boolean = false

permissions.microphone?

boolean = false

physics?

{ fps?: number; gravity?: { x?: number; y?: number; z?: number; }; RAPIER?: { init?: () => Promise<void>; }; useEventQueue?: boolean; worldStep?: boolean; } = ...

physics.fps?

number = 45

The target frames per second for the physics simulation loop.

physics.gravity?

{ x?: number; y?: number; z?: number; } = ...

The global gravity vector applied to the physics world.

physics.gravity.x?

number = 0.0

physics.gravity.y?

number = -9.81

physics.gravity.z?

number = 0.0

physics.RAPIER?

{ init?: () => Promise<void>; }

Instance of RAPIER.

physics.RAPIER.init?

() => Promise<void>

physics.useEventQueue?

boolean = false

If true, an event queue will be created and passed to world.step(), enabling the handling of collision and contact events.

physics.worldStep?

boolean = true

If true, the Physics manager will automatically call world.step() on its fixed interval. Set to false if you want to control the simulation step manually.

referenceSpaceType?

XRReferenceSpaceType = 'local-floor'

reticles?

{ defaultRenderDistance?: number; enabled?: boolean; maxDistance?: number; projectOnDepthMesh?: boolean; } = ...

reticles.defaultRenderDistance?

number = 0

Distance in meters at which to render the reticle when no valid hit is found. Set to 0 to hide the reticle on a miss.

reticles.enabled?

boolean = true

reticles.maxDistance?

number

Maximum reticle drawing distance in meters. It does not limit targeting.

reticles.projectOnDepthMesh?

boolean = false

Whether reticles use the real-world depth mesh as a surface.

setAppDescription?

(description) => Options

setAppTitle?

(title) => Options

simulator?

{ activeEnvironmentIndex?: number; blendingMode?: "screen" | "normal"; defaultHand?: Handedness; defaultMode?: SimulatorMode; deviceCamera?: { enabled?: boolean; }; environments?: readonly ({ manifestPath?: string; name?: string; } | undefined)[]; geminiLivePanel?: { element?: string; enabled?: boolean; }; handPhysics?: { contactOffset?: number; enabled?: boolean; friction?: number; mass?: number; radius?: number; restitution?: number; }; handPosePanel?: { element?: string; enabled?: boolean; }; initialCameraPosition?: { x?: number; y?: number; z?: number; }; instructions?: { customInstructions?: readonly ({ description?: ... | ...; header?: ... | ...; videoSrc?: ... | ...; } | undefined)[]; element?: string; enabled?: boolean; showAutomatically?: boolean; }; leftHandOrigin?: { x?: number; y?: number; z?: number; }; modeToggle?: { enabled?: boolean; toggleKey?: Keycodes | null; toggleOrder?: { Editor?: SimulatorMode; Hands?: SimulatorMode; Navigation?: SimulatorMode; PointerLock?: SimulatorMode; User?: SimulatorMode; }; }; navMesh?: { enabled?: boolean; eyeHeight?: number; showDebugVisualizations?: boolean; }; physics?: { enabled?: boolean; }; reachAngle?: { angle?: number; enabled?: boolean; }; reachDistance?: { enabled?: boolean; radius?: number; }; renderToRenderTexture?: boolean; rightHandOrigin?: { x?: number; y?: number; z?: number; }; simulatorSettingsPanel?: { element?: string; enabled?: boolean; }; stereo?: { enabled?: boolean; }; } = ...

simulator.activeEnvironmentIndex?

number = 0

simulator.blendingMode?

"screen" | "normal" = 'normal'

simulator.defaultHand?

Handedness = Handedness.LEFT

simulator.defaultMode?

SimulatorMode = SimulatorMode.USER

simulator.deviceCamera?

{ enabled?: boolean; } = ...

simulator.deviceCamera.enabled?

boolean = true

simulator.environments?

readonly ({ manifestPath?: string; name?: string; } | undefined)[] = ...

simulator.geminiLivePanel?

{ element?: string; enabled?: boolean; } = ...

simulator.geminiLivePanel.element?

string = 'xrblocks-simulator-geminilive'

simulator.geminiLivePanel.enabled?

boolean = false

simulator.handPhysics?

{ contactOffset?: number; enabled?: boolean; friction?: number; mass?: number; radius?: number; restitution?: number; } = ...

Optional physical constraints for simulated hands. Requires Rapier.

simulator.handPhysics.contactOffset?

number

simulator.handPhysics.enabled?

boolean

simulator.handPhysics.friction?

number

simulator.handPhysics.mass?

number

simulator.handPhysics.radius?

number

simulator.handPhysics.restitution?

number

simulator.handPosePanel?

{ element?: string; enabled?: boolean; } = ...

simulator.handPosePanel.element?

string = 'xrblocks-simulator-hand-pose-panel'

simulator.handPosePanel.enabled?

boolean = true

simulator.initialCameraPosition?

{ x?: number; y?: number; z?: number; } = ...

simulator.initialCameraPosition.x?

number = 0

simulator.initialCameraPosition.y?

number = 1.5

simulator.initialCameraPosition.z?

number = 0

simulator.instructions?

{ customInstructions?: readonly ({ description?: ... | ...; header?: ... | ...; videoSrc?: ... | ...; } | undefined)[]; element?: string; enabled?: boolean; showAutomatically?: boolean; } = ...

simulator.instructions.customInstructions?

readonly ({ description?: ... | ...; header?: ... | ...; videoSrc?: ... | ...; } | undefined)[] = ...

simulator.instructions.element?

string = 'xrblocks-simulator-instructions'

simulator.instructions.enabled?

boolean = true

simulator.instructions.showAutomatically?

boolean = false

simulator.leftHandOrigin?

{ x?: number; y?: number; z?: number; } = ...

Shoulder/chest origin of the left hand in local camera space.

simulator.leftHandOrigin.x?

number = -0.2

simulator.leftHandOrigin.y?

number = -0.2

simulator.leftHandOrigin.z?

number = 0

simulator.modeToggle?

{ enabled?: boolean; toggleKey?: Keycodes | null; toggleOrder?: { Editor?: SimulatorMode; Hands?: SimulatorMode; Navigation?: SimulatorMode; PointerLock?: SimulatorMode; User?: SimulatorMode; }; } = ...

simulator.modeToggle.enabled?

boolean = false

simulator.modeToggle.toggleKey?

Keycodes | null = ...

simulator.modeToggle.toggleOrder?

{ Editor?: SimulatorMode; Hands?: SimulatorMode; Navigation?: SimulatorMode; PointerLock?: SimulatorMode; User?: SimulatorMode; } = DEFAULT_MODE_TOGGLE_ORDER

simulator.modeToggle.toggleOrder.Editor?

SimulatorMode = SimulatorMode.USER

simulator.modeToggle.toggleOrder.Hands?

SimulatorMode = SimulatorMode.POINTER_LOCK

simulator.modeToggle.toggleOrder.Navigation?

SimulatorMode = SimulatorMode.CONTROLLER

simulator.modeToggle.toggleOrder.PointerLock?

SimulatorMode = SimulatorMode.EDITOR

simulator.modeToggle.toggleOrder.User?

SimulatorMode = SimulatorMode.POSE

simulator.navMesh?

{ enabled?: boolean; eyeHeight?: number; showDebugVisualizations?: boolean; } = ...

simulator.navMesh.enabled?

boolean = false

simulator.navMesh.eyeHeight?

number = 1.5

simulator.navMesh.showDebugVisualizations?

boolean = false

simulator.physics?

{ enabled?: boolean; } = ...

Controls the isolated physics world used by the desktop simulator.

simulator.physics.enabled?

boolean = true

simulator.reachAngle?

{ angle?: number; enabled?: boolean; } = ...

Limits the angular cone in front of the user within which controllers can move.

simulator.reachAngle.angle?

number = Math.PI

The maximum full cone angle in radians around the camera's forward direction (default is Math.PI, a front hemisphere).

simulator.reachAngle.enabled?

boolean = false

simulator.reachDistance?

{ enabled?: boolean; radius?: number; } = ...

Limits how far each hand controller can travel from the user's shoulder origin.

simulator.reachDistance.enabled?

boolean = false

simulator.reachDistance.radius?

number = 0.75

The maximum distance in meters a controller can move from its origin point.

simulator.renderToRenderTexture?

boolean = true

simulator.rightHandOrigin?

{ x?: number; y?: number; z?: number; } = ...

Shoulder/chest origin of the right hand in local camera space.

simulator.rightHandOrigin.x?

number = 0.2

simulator.rightHandOrigin.y?

number = -0.2

simulator.rightHandOrigin.z?

number = 0

simulator.simulatorSettingsPanel?

{ element?: string; enabled?: boolean; } = ...

simulator.simulatorSettingsPanel.element?

string = 'xrblocks-simulator-settings'

simulator.simulatorSettingsPanel.enabled?

boolean = true

simulator.stereo?

{ enabled?: boolean; } = ...

simulator.stereo.enabled?

boolean = false

sound?

{ speechRecognizer?: { commandConfidenceThreshold?: number; commands?: readonly (string | undefined)[]; continuous?: boolean; enabled?: boolean; interimResults?: boolean; lang?: string; playSimulatorActivationSounds?: boolean; }; speechSynthesizer?: { allowInterruptions?: boolean; enabled?: boolean; }; } = ...

sound.speechRecognizer?

{ commandConfidenceThreshold?: number; commands?: readonly (string | undefined)[]; continuous?: boolean; enabled?: boolean; interimResults?: boolean; lang?: string; playSimulatorActivationSounds?: boolean; } = ...

sound.speechRecognizer.commandConfidenceThreshold?

number = 0.7

Minimum confidence (0-1) for a command.

sound.speechRecognizer.commands?

readonly (string | undefined)[] = []

Keywords to detect as commands.

sound.speechRecognizer.continuous?

boolean = false

If true, recognition continues after a pause.

sound.speechRecognizer.enabled?

boolean = true

sound.speechRecognizer.interimResults?

boolean = false

If true, provides interim results.

sound.speechRecognizer.lang?

string = 'en-US'

Recognition language (e.g., 'en-US').

sound.speechRecognizer.playSimulatorActivationSounds?

boolean = true

If true, play activation sounds in simulator.

sound.speechSynthesizer?

{ allowInterruptions?: boolean; enabled?: boolean; } = ...

sound.speechSynthesizer.allowInterruptions?

boolean = false

If true, a new call to speak() will interrupt any ongoing speech.

sound.speechSynthesizer.enabled?

boolean = false

stencil?

boolean = false

Whether to request a stencil buffer.

strokes?

{ enable?: () => StrokeRecognitionOptions; enabled?: boolean; endDelay?: number; joint?: "wrist" | "thumb-metacarpal" | "thumb-phalanx-proximal" | "thumb-phalanx-distal" | "thumb-tip" | "index-finger-metacarpal" | "index-finger-phalanx-proximal" | "index-finger-phalanx-intermediate" | "index-finger-phalanx-distal" | "index-finger-tip" | "middle-finger-metacarpal" | "middle-finger-phalanx-proximal" | "middle-finger-phalanx-intermediate" | "middle-finger-phalanx-distal" | "middle-finger-tip" | "ring-finger-metacarpal" | "ring-finger-phalanx-proximal" | "ring-finger-phalanx-intermediate" | "ring-finger-phalanx-distal" | "ring-finger-tip" | "pinky-finger-metacarpal" | "pinky-finger-phalanx-proximal" | "pinky-finger-phalanx-intermediate" | "pinky-finger-phalanx-distal" | "pinky-finger-tip"; maxPoints?: number; providerConfig?: { onedollar?: { supportedShapes?: readonly (... | ...)[]; }; provider?: "onedollar"; }; startDelay?: number; } = ...

strokes.enable?

() => StrokeRecognitionOptions

strokes.enabled?

boolean = true

Master switch for the stroke recognition block.

strokes.endDelay?

number = 0.2

Delay in seconds to ignore points before gesture end.

strokes.joint?

The hand joint to track for stroke recognition.

strokes.maxPoints?

number = 1000

Maximum number of points to capture in a single stroke.

strokes.providerConfig?

{ onedollar?: { supportedShapes?: readonly (... | ...)[]; }; provider?: "onedollar"; } = ...

Configuration for the stroke recognition provider.

strokes.providerConfig.onedollar?

{ supportedShapes?: readonly (... | ...)[]; } = ...

Options specific to the 'onedollar' provider.

strokes.providerConfig.onedollar.supportedShapes?

readonly (... | ...)[] = DEFAULT_SUPPORTED_SHAPES

strokes.providerConfig.provider?

"onedollar" = ...

Backing provider that recognizes strokes.

'onedollar': $1 Unistroke recognizer.

strokes.startDelay?

number = 0.2

Delay in seconds after gesture start before recording points.

transition?

{ defaultBackgroundColor?: number; enabled?: boolean; transitionTime?: number; } = ...

transition.defaultBackgroundColor?

number = 0xffffff

The default background color for VR transitions.

transition.enabled?

boolean = false

Whether the transition effect is enabled.

transition.transitionTime?

number = 0.5

The duration of the transition in seconds.

usePostprocessing?

boolean = false

Whether to use post-processing effects.

webxrOptionalFeatures?

readonly (string | undefined)[] = ...

Any additional optional features when initializing webxr.

webxrRequiredFeatures?

readonly (string | undefined)[] = []

Any additional required features when initializing webxr.

world?

{ anchors?: { debugging?: boolean; enable?: () => AnchorsOptions; enabled?: boolean; enablePersistence?: () => AnchorsOptions; maxStoredAnchors?: number; persistent?: boolean; simulatorFallback?: boolean; storageKey?: string; }; debugging?: boolean; enableAnchorPersistence?: () => WorldOptions; enableAnchors?: () => WorldOptions; enabled?: boolean; enableFaceDetection?: () => WorldOptions; enableHumanDetection?: () => WorldOptions; enableMeshDetection?: () => WorldOptions; enableObjectDetection?: () => WorldOptions; enablePlaneDetection?: () => WorldOptions; enableSegmentation?: () => WorldOptions; enableSoundDetection?: () => WorldOptions; faces?: { backendConfig?: { activeBackend?: string; mediapipe?: { minFaceDetectionConfidence?: ... | ...; minFacePresenceConfidence?: ... | ...; minTrackingConfidence?: ... | ...; modelAssetPath?: ... | ...; numFaces?: ... | ...; outputFaceBlendshapes?: ... | ... | ...; outputFacialTransformationMatrixes?: ... | ... | ...; wasmFilesUrl?: ... | ...; }; }; enable?: () => FacesOptions; enabled?: boolean; pollingIntervalMs?: number; }; humans?: { backendConfig?: { activeBackend?: string; mediapipe?: { minPoseDetectionConfidence?: ... | ...; minPosePresenceConfidence?: ... | ...; minTrackingConfidence?: ... | ...; modelAssetPath?: ... | ...; numPoses?: ... | ...; useWorker?: ... | ... | ...; wasmFilesUrl?: ... | ...; }; }; enable?: () => HumansOptions; enabled?: boolean; pollingIntervalMs?: number; useDepthProjection?: boolean; }; initiateRoomCapture?: boolean; meshes?: { enable?: () => MeshDetectionOptions; enabled?: boolean; showDebugVisualizations?: boolean; }; objects?: { backendConfig?: { activeBackend?: "gemini" | "mediapipe"; gemini?: { generationConfig?: ... | ...; responseSchema?: ... | ...; systemInstruction?: ... | ...; }; mediapipe?: { modelAssetPath?: ... | ...; scoreThreshold?: ... | ...; wasmFilesUrl?: ... | ...; }; }; debugging?: boolean; enable?: () => ObjectsOptions; enabled?: boolean; objectImageMargin?: number; pollingIntervalMs?: number; showDebugVisualizations?: boolean; simulatorOverride?: boolean; }; planes?: { debugging?: boolean; enable?: () => PlanesOptions; enabled?: boolean; showDebugVisualizations?: boolean; }; segmentation?: { backendConfig?: { activeBackend?: string; mediapipe?: { modelAssetPath?: ... | ...; outputCategoryMask?: ... | ... | ...; wasmFilesUrl?: ... | ...; }; }; enable?: () => SegmentationOptions; enabled?: boolean; pollingIntervalMs?: number; }; sounds?: { backendConfig?: { activeBackend?: string; mediapipe?: { chunkSamples?: ... | ...; modelAssetPath?: ... | ...; wasmFilesUrl?: ... | ...; }; }; enable?: () => SoundsOptions; enabled?: boolean; showDebugInfo?: boolean; }; } = ...

world.anchors?

{ debugging?: boolean; enable?: () => AnchorsOptions; enabled?: boolean; enablePersistence?: () => AnchorsOptions; maxStoredAnchors?: number; persistent?: boolean; simulatorFallback?: boolean; storageKey?: string; } = ...

world.anchors.debugging?

boolean = false

Logs anchor lifecycle transitions.

world.anchors.enable?

() => AnchorsOptions

world.anchors.enabled?

boolean = false

Whether the anchor subsystem is created at all.

world.anchors.enablePersistence?

() => AnchorsOptions

world.anchors.maxStoredAnchors?

number = 128

Upper bound on saved handles. Persistent handles accumulate across sessions and would otherwise grow without limit; the oldest are evicted first once the cap is reached.

world.anchors.persistent?

boolean = false

Whether anchor handles are saved so they can be restored in a later session. Requires platform support for persistent handles; when the platform only offers session-scoped anchors this degrades to in-session behaviour rather than failing.

world.anchors.simulatorFallback?

boolean = false

Whether to hold poses locally when the platform has no anchor support.

Off by default: on a real headset a silent stand-in would look like working anchors while nothing is actually pinned. Demos and desktop development opt in deliberately.

world.anchors.storageKey?

string = ...

Storage key used when persistence is enabled.

Defaults to a page-scoped key. Set it explicitly to share anchors between pages, or to keep a stable key if the app might move path.

world.debugging?

boolean = false

world.enableAnchorPersistence?

() => WorldOptions

world.enableAnchors?

() => WorldOptions

world.enabled?

boolean = false

world.enableFaceDetection?

() => WorldOptions

world.enableHumanDetection?

() => WorldOptions

world.enableMeshDetection?

() => WorldOptions

world.enableObjectDetection?

() => WorldOptions

world.enablePlaneDetection?

() => WorldOptions

world.enableSegmentation?

() => WorldOptions

world.enableSoundDetection?

() => WorldOptions

world.faces?

{ backendConfig?: { activeBackend?: string; mediapipe?: { minFaceDetectionConfidence?: ... | ...; minFacePresenceConfidence?: ... | ...; minTrackingConfidence?: ... | ...; modelAssetPath?: ... | ...; numFaces?: ... | ...; outputFaceBlendshapes?: ... | ... | ...; outputFacialTransformationMatrixes?: ... | ... | ...; wasmFilesUrl?: ... | ...; }; }; enable?: () => FacesOptions; enabled?: boolean; pollingIntervalMs?: number; } = ...

world.faces.backendConfig?

{ activeBackend?: string; mediapipe?: { minFaceDetectionConfidence?: ... | ...; minFacePresenceConfidence?: ... | ...; minTrackingConfidence?: ... | ...; modelAssetPath?: ... | ...; numFaces?: ... | ...; outputFaceBlendshapes?: ... | ... | ...; outputFacialTransformationMatrixes?: ... | ... | ...; wasmFilesUrl?: ... | ...; }; } = ...

Configuration options for the active face detection backend.

world.faces.backendConfig.activeBackend?

string = 'mediapipe'

world.faces.backendConfig.mediapipe?

{ minFaceDetectionConfidence?: ... | ...; minFacePresenceConfidence?: ... | ...; minTrackingConfidence?: ... | ...; modelAssetPath?: ... | ...; numFaces?: ... | ...; outputFaceBlendshapes?: ... | ... | ...; outputFacialTransformationMatrixes?: ... | ... | ...; wasmFilesUrl?: ... | ...; } = ...

world.faces.backendConfig.mediapipe.minFaceDetectionConfidence?

... | ... = 0.5

The minimum confidence score [0.0, 1.0] required for a face to be detected.

world.faces.backendConfig.mediapipe.minFacePresenceConfidence?

... | ... = 0.5

The minimum confidence score [0.0, 1.0] required to confirm a face is still present.

world.faces.backendConfig.mediapipe.minTrackingConfidence?

... | ... = 0.5

The minimum confidence score [0.0, 1.0] required for tracking landmarks between frames.

world.faces.backendConfig.mediapipe.modelAssetPath?

... | ... = 'https://storage.googleapis.com/mediapipe-models/face_landmarker/face_landmarker/float16/latest/face_landmarker.task'

world.faces.backendConfig.mediapipe.numFaces?

... | ... = 1

The maximum number of simultaneous faces to track.

world.faces.backendConfig.mediapipe.outputFaceBlendshapes?

... | ... | ... = true

Whether to compute and emit per-face blendshape weights (52 ARKit-compatible categories). Required for facial expression mirroring, lipsync feeds, and avatar animation.

world.faces.backendConfig.mediapipe.outputFacialTransformationMatrixes?

... | ... | ... = true

Whether to compute and emit the 4x4 facial transformation matrix for each face. Provides a stable rigid head pose for parenting objects to the head (glasses, masks, hats).

world.faces.backendConfig.mediapipe.wasmFilesUrl?

... | ... = 'https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@latest/wasm'

world.faces.enable?

() => FacesOptions

world.faces.enabled?

boolean = false

world.faces.pollingIntervalMs?

number = 0

Minimum delay in milliseconds between continuous face detection runs. A value of 0 runs again as soon as the previous detection finishes.

world.humans?

{ backendConfig?: { activeBackend?: string; mediapipe?: { minPoseDetectionConfidence?: ... | ...; minPosePresenceConfidence?: ... | ...; minTrackingConfidence?: ... | ...; modelAssetPath?: ... | ...; numPoses?: ... | ...; useWorker?: ... | ... | ...; wasmFilesUrl?: ... | ...; }; }; enable?: () => HumansOptions; enabled?: boolean; pollingIntervalMs?: number; useDepthProjection?: boolean; } = ...

world.humans.backendConfig?

{ activeBackend?: string; mediapipe?: { minPoseDetectionConfidence?: ... | ...; minPosePresenceConfidence?: ... | ...; minTrackingConfidence?: ... | ...; modelAssetPath?: ... | ...; numPoses?: ... | ...; useWorker?: ... | ... | ...; wasmFilesUrl?: ... | ...; }; } = ...

Configuration options for the active pose detection backend.

world.humans.backendConfig.activeBackend?

string = 'mediapipe'

world.humans.backendConfig.mediapipe?

{ minPoseDetectionConfidence?: ... | ...; minPosePresenceConfidence?: ... | ...; minTrackingConfidence?: ... | ...; modelAssetPath?: ... | ...; numPoses?: ... | ...; useWorker?: ... | ... | ...; wasmFilesUrl?: ... | ...; } = ...

world.humans.backendConfig.mediapipe.minPoseDetectionConfidence?

... | ... = 0.5

The minimum confidence score [0.0, 1.0] required for a pose to be detected.

world.humans.backendConfig.mediapipe.minPosePresenceConfidence?

... | ... = 0.5

The minimum confidence score [0.0, 1.0] required to confirm a pose is still present.

world.humans.backendConfig.mediapipe.minTrackingConfidence?

... | ... = 0.5

The minimum confidence score [0.0, 1.0] required for tracking landmarks between frames.

world.humans.backendConfig.mediapipe.modelAssetPath?

... | ... = 'https://storage.googleapis.com/mediapipe-models/pose_landmarker/pose_landmarker_full/float16/latest/pose_landmarker_full.task'

world.humans.backendConfig.mediapipe.numPoses?

... | ... = 1

The maximum number of simultaneous human poses/bodies to track.

world.humans.backendConfig.mediapipe.useWorker?

... | ... | ... = true

Run inference in a web worker so a detection pass does not stall the render loop. The worker is limited to the CPU delegate because MediaPipe only creates a GPU surface for a real DOM canvas, so set this to false to trade a blocked main thread for GPU inference. Falls back to the main thread automatically when workers are unavailable.

world.humans.backendConfig.mediapipe.wasmFilesUrl?

... | ... = 'https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@latest/wasm'

world.humans.enable?

() => HumansOptions

world.humans.enabled?

boolean = false

world.humans.pollingIntervalMs?

number = 0

Minimum delay in milliseconds between continuous pose detection runs. A value of 0 runs again as soon as the previous detection finishes.

world.humans.useDepthProjection?

boolean = true

Project each landmark onto the depth mesh to find its world position.

This is what you want when the people being detected are physically in front of you, since the ray lands on their actual body. Turn it off when the camera is showing someone who is not part of the depth scene, such as a webcam feed on the desktop simulator: every ray would then hit the surrounding geometry instead and the skeleton would be smeared across it. With projection off, landmarks are placed along the view ray at a fixed distance, which keeps the body correctly proportioned.

world.initiateRoomCapture?

boolean = false

world.meshes?

{ enable?: () => MeshDetectionOptions; enabled?: boolean; showDebugVisualizations?: boolean; } = ...

world.meshes.enable?

() => MeshDetectionOptions

world.meshes.enabled?

boolean = false

world.meshes.showDebugVisualizations?

boolean = false

world.objects?

{ backendConfig?: { activeBackend?: "gemini" | "mediapipe"; gemini?: { generationConfig?: ... | ...; responseSchema?: ... | ...; systemInstruction?: ... | ...; }; mediapipe?: { modelAssetPath?: ... | ...; scoreThreshold?: ... | ...; wasmFilesUrl?: ... | ...; }; }; debugging?: boolean; enable?: () => ObjectsOptions; enabled?: boolean; objectImageMargin?: number; pollingIntervalMs?: number; showDebugVisualizations?: boolean; simulatorOverride?: boolean; } = ...

world.objects.backendConfig?

{ activeBackend?: "gemini" | "mediapipe"; gemini?: { generationConfig?: ... | ...; responseSchema?: ... | ...; systemInstruction?: ... | ...; }; mediapipe?: { modelAssetPath?: ... | ...; scoreThreshold?: ... | ...; wasmFilesUrl?: ... | ...; }; } = ...

Configuration for the detection backends.

world.objects.backendConfig.activeBackend?

"gemini" | "mediapipe" = ...

The active backend to use for detection.

world.objects.backendConfig.gemini?

{ generationConfig?: ... | ...; responseSchema?: ... | ...; systemInstruction?: ... | ...; } = ...

world.objects.backendConfig.gemini.generationConfig?

... | ... = ...

Extra Gemini generation config merged into the per-call config (over the SDK defaults). Use to pin sampling parameters such as temperature: 0 for deterministic detections.

world.objects.backendConfig.gemini.responseSchema?

... | ... = ...

world.objects.backendConfig.gemini.systemInstruction?

... | ... = ...

world.objects.backendConfig.mediapipe?

{ modelAssetPath?: ... | ...; scoreThreshold?: ... | ...; wasmFilesUrl?: ... | ...; } = ...

Configuration for MediaPipe backend.

world.objects.backendConfig.mediapipe.modelAssetPath?

... | ... = 'https://storage.googleapis.com/mediapipe-models/object_detector/efficientdet_lite2/int8/latest/efficientdet_lite2.tflite'

world.objects.backendConfig.mediapipe.scoreThreshold?

... | ... = 0.5

world.objects.backendConfig.mediapipe.wasmFilesUrl?

... | ... = 'https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@0.10.34/wasm'

world.objects.debugging?

boolean = false

world.objects.enable?

() => ObjectsOptions

world.objects.enabled?

boolean = false

world.objects.objectImageMargin?

number = 0.05

Margin to add when cropping the object image, as a percentage of image size.

world.objects.pollingIntervalMs?

number = 0

Minimum delay in milliseconds between continuous object detection runs. A value of 0 runs again as soon as the previous detection finishes.

world.objects.showDebugVisualizations?

boolean = false

world.objects.simulatorOverride?

boolean = false

Use simulator ground truth instead of a camera detector on desktop.

world.planes?

{ debugging?: boolean; enable?: () => PlanesOptions; enabled?: boolean; showDebugVisualizations?: boolean; } = ...

world.planes.debugging?

boolean = false

world.planes.enable?

() => PlanesOptions

world.planes.enabled?

boolean = false

world.planes.showDebugVisualizations?

boolean = false

world.segmentation?

{ backendConfig?: { activeBackend?: string; mediapipe?: { modelAssetPath?: ... | ...; outputCategoryMask?: ... | ... | ...; wasmFilesUrl?: ... | ...; }; }; enable?: () => SegmentationOptions; enabled?: boolean; pollingIntervalMs?: number; } = ...

world.segmentation.backendConfig?

{ activeBackend?: string; mediapipe?: { modelAssetPath?: ... | ...; outputCategoryMask?: ... | ... | ...; wasmFilesUrl?: ... | ...; }; } = ...

Configuration options for the active segmentation backend.

world.segmentation.backendConfig.activeBackend?

string = 'mediapipe'

world.segmentation.backendConfig.mediapipe?

{ modelAssetPath?: ... | ...; outputCategoryMask?: ... | ... | ...; wasmFilesUrl?: ... | ...; } = ...

world.segmentation.backendConfig.mediapipe.modelAssetPath?

... | ... = ...

world.segmentation.backendConfig.mediapipe.outputCategoryMask?

... | ... | ... = true

Output the per-pixel category mask. Required to produce a SegmentationMask.

world.segmentation.backendConfig.mediapipe.wasmFilesUrl?

... | ... = 'https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@latest/wasm'

world.segmentation.enable?

() => SegmentationOptions

world.segmentation.enabled?

boolean = false

world.segmentation.pollingIntervalMs?

number = 66

Minimum delay in milliseconds between continuous segmentation runs. A value of 0 runs again as soon as the previous inference finishes. Defaults to 66 (~15 fps), the rate the magic_window grab loop used before segmentation moved onto its own polling loop.

world.sounds?

{ backendConfig?: { activeBackend?: string; mediapipe?: { chunkSamples?: ... | ...; modelAssetPath?: ... | ...; wasmFilesUrl?: ... | ...; }; }; enable?: () => SoundsOptions; enabled?: boolean; showDebugInfo?: boolean; } = ...

world.sounds.backendConfig?

{ activeBackend?: string; mediapipe?: { chunkSamples?: ... | ...; modelAssetPath?: ... | ...; wasmFilesUrl?: ... | ...; }; } = ...

world.sounds.backendConfig.activeBackend?

string = 'mediapipe'

world.sounds.backendConfig.mediapipe?

{ chunkSamples?: ... | ...; modelAssetPath?: ... | ...; wasmFilesUrl?: ... | ...; } = ...

world.sounds.backendConfig.mediapipe.chunkSamples?

... | ... = 16000

world.sounds.backendConfig.mediapipe.modelAssetPath?

... | ... = 'https://tfhub.dev/google/lite-model/yamnet/classification/tflite/1?lite-format=tflite'

world.sounds.backendConfig.mediapipe.wasmFilesUrl?

... | ... = 'https://cdn.jsdelivr.net/npm/@mediapipe/tasks-audio@0.10.35/wasm'

world.sounds.enable?

() => SoundsOptions

world.sounds.enabled?

boolean = false

world.sounds.showDebugInfo?

boolean = false

xrButton?

{ alwaysAutostartSimulator?: boolean; appDescription?: string; appTitle?: string; enabled?: boolean; endText?: string; invalidText?: string; showEnterSimulatorButton?: boolean; startSimulatorText?: string; startText?: string; } = ...

Configuration for the XR session button.

xrButton.alwaysAutostartSimulator?

boolean = false

xrButton.appDescription?

string = ''

xrButton.appTitle?

string = ''

xrButton.enabled?

boolean = true

xrButton.endText?

string = 'Exit XR'

xrButton.invalidText?

string = 'XR Not Supported'

xrButton.showEnterSimulatorButton?

boolean = false

xrButton.startSimulatorText?

string = 'Enter Simulator'

xrButton.startText?

string = 'Enter XR'

xrSessionMode?

XRSessionMode = 'immersive-ar'

Returns

Options

Properties

ai

ai: AIOptions

Defined in: src/core/Options.ts:149

antialias

antialias: boolean = true

Defined in: src/core/Options.ts:104

Whether to use antialiasing.

camera

camera: object

Defined in: src/core/Options.ts:155

far

far: number = 500

near

near: number = 0.01

canvas?

optional canvas: HTMLCanvasElement

Defined in: src/core/Options.ts:122

Canvas element to use for rendering. If not defined, a new element will be added to document body.

catchScriptExceptions

catchScriptExceptions: boolean = true

Defined in: src/core/Options.ts:172

context

context: ContextOptions

Defined in: src/core/Options.ts:152

controllers

controllers: InputOptions

Defined in: src/core/Options.ts:138

debugging

debugging: boolean = false

Defined in: src/core/Options.ts:113

Global flag for enabling various debugging features.

depth

depth: DepthOptions

Defined in: src/core/Options.ts:139

deviceCamera

deviceCamera: DeviceCameraOptions

Defined in: src/core/Options.ts:141

enableSimulator

enableSimulator: boolean = true

Defined in: src/core/Options.ts:165

gestures

gestures: GestureRecognitionOptions

Defined in: src/core/Options.ts:143

hands

hands: HandsOptions

Defined in: src/core/Options.ts:142

headGestures

headGestures: HeadGestureRecognitionOptions

Defined in: src/core/Options.ts:144

interaction

interaction: InteractionOptions

Defined in: src/core/Options.ts:147

lighting

lighting: LightingOptions

Defined in: src/core/Options.ts:140

logarithmicDepthBuffer

logarithmicDepthBuffer: boolean = false

Defined in: src/core/Options.ts:109

Whether to use a logarithmic depth buffer. Useful for depth-aware occlusions.

permissions

permissions: object

Defined in: src/core/Options.ts:193

Which permissions to request before entering the XR session.

camera

camera: boolean = false

geolocation

geolocation: boolean = false

microphone

microphone: boolean = false

physics

physics: PhysicsOptions

Defined in: src/core/Options.ts:153

referenceSpaceType

referenceSpaceType: XRReferenceSpaceType = 'local-floor'

Defined in: src/core/Options.ts:136

reticles

reticles: ReticleOptions

Defined in: src/core/Options.ts:146

simulator

simulator: SimulatorOptions

Defined in: src/core/Options.ts:150

sound

sound: SoundOptions

Defined in: src/core/Options.ts:148

stencil

stencil: boolean = false

Defined in: src/core/Options.ts:117

Whether to request a stencil buffer.

strokes

strokes: StrokeRecognitionOptions

Defined in: src/core/Options.ts:145

transition

transition: XRTransitionOptions

Defined in: src/core/Options.ts:154

usePostprocessing

usePostprocessing: boolean = false

Defined in: src/core/Options.ts:163

Whether to use post-processing effects.

webxrOptionalFeatures

webxrOptionalFeatures: string[]

Defined in: src/core/Options.ts:132

Any additional optional features when initializing webxr.

webxrRequiredFeatures

webxrRequiredFeatures: string[] = []

Defined in: src/core/Options.ts:127

Any additional required features when initializing webxr.

world

world: WorldOptions

Defined in: src/core/Options.ts:151

xrButton

xrButton: object

Defined in: src/core/Options.ts:177

Configuration for the XR session button.

alwaysAutostartSimulator

alwaysAutostartSimulator: boolean = false

appDescription

appDescription: string = ''

appTitle

appTitle: string = ''

enabled

enabled: boolean = true

endText

endText: string = 'Exit XR'

invalidText

invalidText: string = 'XR Not Supported'

showEnterSimulatorButton

showEnterSimulatorButton: boolean = false

startSimulatorText

startSimulatorText: string = 'Enter Simulator'

startText

startText: string = 'Enter XR'

xrSessionMode

xrSessionMode: XRSessionMode = 'immersive-ar'

Defined in: src/core/Options.ts:199

Accessors

formFactor

Get Signature

get formFactor(): "auto" | "xr" | "hud" | "vr" | "desktop" | "mobile"

Defined in: src/core/Options.ts:203

Returns

"auto" | "xr" | "hud" | "vr" | "desktop" | "mobile"

Set Signature

set formFactor(formFactor): void

Defined in: src/core/Options.ts:212

Form factor is a preset that configures the experience for a specific device type. Currently it only controls whether the simulator is enabled and should always be autostarted.

Parameters

formFactor

"auto" | "xr" | "hud" | "vr" | "desktop" | "mobile"

Returns

void

Methods

enableAI()

enableAI(): Options

Defined in: src/core/Options.ts:437

Enables a standard set of AI features, including Gemini Live.

Returns

Options

The instance for chaining.

enableAutomationMode()

enableAutomationMode(config): Options

Defined in: src/core/Options.ts:261

Enables a standard simulator-driven setup for automation and external test harnesses.

Parameters

config

AutomationModeOptions = {}

Returns

Options

The instance for chaining.

enableCamera()

enableCamera(facingMode): Options

Defined in: src/core/Options.ts:376

Enables device camera (passthrough) with a specific facing mode.

Parameters

facingMode

The desired camera facing mode, either 'environment' or 'user'.

"environment" | "user"

Returns

Options

The instance for chaining.

enableContext()

enableContext(): Options

Defined in: src/core/Options.ts:448

Enables agent-facing context detectors such as semantic trees, view visibility, and Set-of-Mark observations.

Returns

Options

The instance for chaining.

enableControllers()

enableControllers(): Options

Defined in: src/core/Options.ts:495

Enables input from hands and controllers. Note that this is enabled by default and can also be changed at runtime with xb.core.input.enableControllers() and xb.core.input.disableControllers().

Returns

Options

The instance for chaining.

enableDepth()

enableDepth(): Options

Defined in: src/core/Options.ts:307

Enables depth sensing in WebXR with default options.

Returns

Options

The instance for chaining.

enableFaceDetection()

enableFaceDetection(): Options

Defined in: src/core/Options.ts:349

Enables face landmark detection. Provides 478 per-face landmarks in world space, optional 52 ARKit-style blendshape weights, and an optional rigid 4x4 facial transformation matrix per detected face.

Returns

Options

The instance for chaining.

enableGestures()

enableGestures(): Options

Defined in: src/core/Options.ts:399

Enables the gesture recognition block and ensures hands are available.

Returns

Options

The instance for chaining.

enableHandRays()

enableHandRays(): Options

Defined in: src/core/Options.ts:428

Enables the visualization of rays for hand tracking.

Returns

Options

The instance for chaining.

enableHands()

enableHands(): Options

Defined in: src/core/Options.ts:390

Enables hand tracking.

Returns

Options

The instance for chaining.

enableHeadGestures()

enableHeadGestures(): Options

Defined in: src/core/Options.ts:409

Enables completed nod and shake recognition from the user's head pose.

Returns

Options

The instance for chaining.

enableHumanDetection()

enableHumanDetection(): Options

Defined in: src/core/Options.ts:335

Enables human pose detection.

Returns

Options

The instance for chaining.

enableObjectDetection()

enableObjectDetection(): Options

Defined in: src/core/Options.ts:325

Enables object detection.

Returns

Options

The instance for chaining.

enablePlaneDetection()

enablePlaneDetection(): Options

Defined in: src/core/Options.ts:316

Enables plane detection.

Returns

Options

The instance for chaining.

enableReticles()

enableReticles(): Options

Defined in: src/core/Options.ts:298

Enables reticles for visualizing targets of hand rays in WebXR.

Returns

Options

The instance for chaining.

enableSceneContext()

enableSceneContext(): Options

Defined in: src/core/Options.ts:457

Enables agent-facing scene context.

Returns

Options

The instance for chaining.

enableSegmentation()

enableSegmentation(): Options

Defined in: src/core/Options.ts:363

Enables semantic segmentation. Produces per-pixel person / background category masks from the device camera (MediaPipe, on-device). Unlike face and human detection it does not require depth.

Returns

Options

The instance for chaining.

enableSetOfMarkContext()

enableSetOfMarkContext(): Options

Defined in: src/core/Options.ts:475

Enables agent-facing Set-of-Mark context.

Returns

Options

The instance for chaining.

enableStrokes()

enableStrokes(): Options

Defined in: src/core/Options.ts:418

Enables the stroke recognition block and ensures gestures are available.

Returns

Options

The instance for chaining.

enableVisibleObjectsContext()

enableVisibleObjectsContext(): Options

Defined in: src/core/Options.ts:466

Enables agent-facing visible objects context.

Returns

Options

The instance for chaining.

enableVR()

enableVR(): Options

Defined in: src/core/Options.ts:251

Sets the session mode to VR and disables the simulator passthrough scene.

Returns

Options

enableXRTransitions()

enableXRTransitions(): Options

Defined in: src/core/Options.ts:484

Enables the XR transition component for toggling VR.

Returns

Options

The instance for chaining.

parseUrlParams()

protected parseUrlParams(): void

Defined in: src/core/Options.ts:234

Returns

void

setAppDescription()

setAppDescription(description): Options

Defined in: src/core/Options.ts:515

Sets the description of the app to be displayed above the XR button.

Parameters

description

string

The description of the app.

Returns

Options

The instance for chaining.

setAppTitle()

setAppTitle(title): Options

Defined in: src/core/Options.ts:505

Sets the title of the app to be displayed above the XR button.

Parameters

title

string

The title of the app.

Returns

Options

The instance for chaining.

Constructors​

Constructor​

Parameters​

options?​

ai?​

ai.enabled?​

ai.gemini?​

ai.gemini.apiKey?​

ai.gemini.config?​

ai.gemini.enabled?​

ai.gemini.keyValid?​

ai.gemini.liveModel?​

ai.gemini.model?​

ai.gemini.urlParam?​

ai.globalUrlParams?​

ai.globalUrlParams.key?​

ai.model?​

ai.openai?​

ai.openai.apiKey?​

ai.openai.enabled?​

ai.openai.model?​

ai.openai.urlParam?​

ai.promptForApiKey?​

antialias?​

camera?​

camera.far?​

camera.near?​

canvas?​

catchScriptExceptions?​

context?​

context.debugging?​

context.enable?​

context.enabled?​

context.enableScene?​

context.enableSetOfMark?​

context.enableVisibleObjects?​

context.scene?​

context.scene.enable?​

context.scene.enabled?​

context.scene.enableSetOfMark?​

context.scene.enableVisibleObjects?​

context.scene.pollingIntervalMs?​

context.scene.som?​

context.scene.som.enable?​

context.scene.som.enabled?​

context.scene.visibleObjects?​

context.scene.visibleObjects.enable?​

context.scene.visibleObjects.enabled?​

context.scene.visibleObjects.occlusionOpacityThreshold?​

controllers?​

controllers.debug?​

controllers.enabled?​

controllers.enabledMouse?​

controllers.visualization?​

controllers.visualizeRays?​

debugging?​

depth?​

depth.dataFormatPreference?​

depth.debugging?​

depth.depthMesh?​

depth.depthMesh.colliderUpdateFps?​

depth.depthMesh.depthFullResolution?​

depth.depthMesh.depthMeshUpdateFps?​

depth.depthMesh.enabled?​

depth.depthMesh.ignoreEdgePixels?​

depth.depthMesh.opacity?​

depth.depthMesh.patchHoles?​

depth.depthMesh.patchHolesUpper?​

depth.depthMesh.renderShadow?​

depth.depthMesh.shadowOpacity?​

depth.depthMesh.showDebugTexture?​

depth.depthMesh.updateFullResolutionGeometry?​

depth.depthMesh.updateVertexNormals?​

depth.depthMesh.useDepthTexture?​

depth.depthMesh.useDownsampledGeometry?​

depth.depthMesh.useDualCollider?​

depth.depthTexture?​

depth.depthTexture.applyGaussianBlur?​

depth.depthTexture.applyKawaseBlur?​

depth.depthTexture.constantKernel?​

Constructors

Constructor

Parameters

options?

ai?

ai.enabled?

ai.gemini?

ai.gemini.apiKey?

ai.gemini.config?

ai.gemini.enabled?

ai.gemini.keyValid?

ai.gemini.liveModel?

ai.gemini.model?

ai.gemini.urlParam?

ai.globalUrlParams?

ai.globalUrlParams.key?

ai.model?

ai.openai?

ai.openai.apiKey?

ai.openai.enabled?

ai.openai.model?

ai.openai.urlParam?

ai.promptForApiKey?

antialias?

camera?

camera.far?

camera.near?

canvas?

catchScriptExceptions?

context?

context.debugging?

context.enable?

context.enabled?

context.enableScene?

context.enableSetOfMark?

context.enableVisibleObjects?

context.scene?

context.scene.enable?

context.scene.enabled?

context.scene.enableSetOfMark?

context.scene.enableVisibleObjects?

context.scene.pollingIntervalMs?

context.scene.som?

context.scene.som.enable?

context.scene.som.enabled?

context.scene.visibleObjects?

context.scene.visibleObjects.enable?

context.scene.visibleObjects.enabled?

context.scene.visibleObjects.occlusionOpacityThreshold?

controllers?

controllers.debug?

controllers.enabled?

controllers.enabledMouse?

controllers.visualization?

controllers.visualizeRays?

debugging?

depth?

depth.dataFormatPreference?

depth.debugging?

depth.depthMesh?

depth.depthMesh.colliderUpdateFps?

depth.depthMesh.depthFullResolution?

depth.depthMesh.depthMeshUpdateFps?

depth.depthMesh.enabled?

depth.depthMesh.ignoreEdgePixels?

depth.depthMesh.opacity?

depth.depthMesh.patchHoles?

depth.depthMesh.patchHolesUpper?

depth.depthMesh.renderShadow?

depth.depthMesh.shadowOpacity?

depth.depthMesh.showDebugTexture?

depth.depthMesh.updateFullResolutionGeometry?

depth.depthMesh.updateVertexNormals?

depth.depthMesh.useDepthTexture?

depth.depthMesh.useDownsampledGeometry?

depth.depthMesh.useDualCollider?

depth.depthTexture?

depth.depthTexture.applyGaussianBlur?

depth.depthTexture.applyKawaseBlur?

depth.depthTexture.constantKernel?