Class: Options

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

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:208

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; }; } = ...

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'

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.

controllers?

{ debug?: boolean; enabled?: boolean; enabledMouse?: boolean; performRaycastOnUpdate?: 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.performRaycastOnUpdate?

boolean = true

Whether to perform raycast on update. This is needed for the reticle to work properly.

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 = true

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

enableControllers?

() => Options

enableDepth?

() => Options

enableFaceDetection?

() => Options

enableGestures?

() => Options

enableHandRays?

() => Options

enableHands?

() => Options

enableHumanDetection?

() => Options

enableObjectDetection?

() => Options

enablePlaneDetection?

() => Options

enableReticles?

() => Options

enableSegmentation?

() => Options

enableSimulator?

boolean = true

enableStrokes?

() => Options

enableUI?

() => 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.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.

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?

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

reticles.defaultDistance?

number = 0

When set to a positive value, the reticle is placed at this distance (in meters) along the controller ray when no intersection is found, instead of being hidden. Set to 0 to hide the reticle on miss.

reticles.enabled?

boolean = true

setAppDescription?

(description) => Options

setAppTitle?

(title) => Options

simulator?

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

simulator.activeEnvironmentIndex?

number = 0

simulator.blendingMode?

"normal" | "screen" = 'normal'

simulator.defaultHand?

Handedness = Handedness.LEFT

simulator.defaultMode?

SimulatorMode = SimulatorMode.USER

simulator.deviceCamera?

{ enabled?: boolean; } = ...

simulator.deviceCamera.enabled?

boolean = true

simulator.environments?

readonly ({ name?: string; scenePath?: string | null; scenePlanesPath?: string | null; videoPath?: string; } | undefined)[] = ...

simulator.geminiLivePanel?

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

simulator.geminiLivePanel.element?

string = 'xrblocks-simulator-geminilive'

simulator.geminiLivePanel.enabled?

boolean = false

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.initialScenePosition?

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

simulator.initialScenePosition.x?

number = -1.6

simulator.initialScenePosition.y?

number = 0.3

simulator.initialScenePosition.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.modeToggle?

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

simulator.modeToggle.enabled?

boolean = false

simulator.modeToggle.toggleKey?

Keycodes | null = ...

simulator.modeToggle.toggleOrder?

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

simulator.modeToggle.toggleOrder.Hands?

SimulatorMode = SimulatorMode.POINTER_LOCK

simulator.modeToggle.toggleOrder.Navigation?

SimulatorMode = SimulatorMode.CONTROLLER

simulator.modeToggle.toggleOrder.PointerLock?

SimulatorMode = SimulatorMode.USER

simulator.modeToggle.toggleOrder.User?

SimulatorMode = SimulatorMode.POSE

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; leftHandOrigin?: { x?: number; y?: number; z?: number; }; radius?: number; rightHandOrigin?: { x?: number; y?: number; z?: number; }; } = ...

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

simulator.reachDistance.enabled?

boolean = false

simulator.reachDistance.leftHandOrigin?

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

The shoulder/chest origin point for the left hand in local camera space.

simulator.reachDistance.leftHandOrigin.x?

number = -0.2

simulator.reachDistance.leftHandOrigin.y?

number = -0.2

simulator.reachDistance.leftHandOrigin.z?

number = 0

simulator.reachDistance.radius?

number = 0.75

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

simulator.reachDistance.rightHandOrigin?

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

The shoulder/chest origin point for the right hand in local camera space.

simulator.reachDistance.rightHandOrigin.x?

number = 0.2

simulator.reachDistance.rightHandOrigin.y?

number = -0.2

simulator.reachDistance.rightHandOrigin.z?

number = 0

simulator.renderToRenderTexture?

boolean = true

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.

uikit?

{ enable?: (uikit) => this; enabled?: boolean; reversePainterSortStable?: (a, b) => number; } = ...

uikit.enable?

(uikit) => this

uikit.enabled?

boolean = false

Whether UIKit support is enabled.

uikit.reversePainterSortStable?

(a, b) => number

The custom sorting function provided by @pmndrs/uikit.

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?

{ debugging?: boolean; 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?: ... | ...; wasmFilesUrl?: ... | ...; }; }; enable?: () => HumansOptions; enabled?: boolean; pollingIntervalMs?: number; }; 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; }; 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.debugging?

boolean = false

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?: ... | ...; wasmFilesUrl?: ... | ...; }; }; enable?: () => HumansOptions; enabled?: boolean; pollingIntervalMs?: number; } = ...

world.humans.backendConfig?

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

Configuration options for the active pose detection backend.

world.humans.backendConfig.activeBackend?

string = 'mediapipe'

world.humans.backendConfig.mediapipe?

{ minPoseDetectionConfidence?: ... | ...; minPosePresenceConfidence?: ... | ...; minTrackingConfidence?: ... | ...; modelAssetPath?: ... | ...; numPoses?: ... | ...; 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.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.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; } = ...

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.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:128

antialias

antialias: boolean = true

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

Whether to use antialiasing.

camera

camera: object

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

far

far: number = 500

near

near: number = 0.01

canvas?

optional canvas: HTMLCanvasElement

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

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:151

controllers

controllers: InputOptions

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

debugging

debugging: boolean = false

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

Global flag for enabling various debugging features.

depth

depth: DepthOptions

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

deviceCamera

deviceCamera: DeviceCameraOptions

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

enableSimulator

enableSimulator: boolean = true

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

gestures

gestures: GestureRecognitionOptions

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

hands

hands: HandsOptions

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

lighting

lighting: LightingOptions

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

logarithmicDepthBuffer

logarithmicDepthBuffer: boolean = false

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

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

permissions

permissions: object

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

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:132

referenceSpaceType

referenceSpaceType: XRReferenceSpaceType = 'local-floor'

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

reticles

reticles: ReticleOptions

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

simulator

simulator: SimulatorOptions

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

sound

sound: SoundOptions

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

stencil

stencil: boolean = false

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

Whether to request a stencil buffer.

strokes

strokes: StrokeRecognitionOptions

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

transition

transition: XRTransitionOptions

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

uikit

uikit: UIKitOptions

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

usePostprocessing

usePostprocessing: boolean = false

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

Whether to use post-processing effects.

webxrOptionalFeatures

webxrOptionalFeatures: string[] = []

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

Any additional optional features when initializing webxr.

webxrRequiredFeatures

webxrRequiredFeatures: string[] = []

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

Any additional required features when initializing webxr.

world

world: WorldOptions

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

xrButton

xrButton: object

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

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:178

Accessors

formFactor

Get Signature

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

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

Returns

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

Set Signature

set formFactor(formFactor): void

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

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:424

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:258

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:372

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.

enableControllers()

enableControllers(): Options

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

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:303

Enables depth sensing in WebXR with default options.

Returns

Options

The instance for chaining.

enableFaceDetection()

enableFaceDetection(): Options

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

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:395

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:415

Enables the visualization of rays for hand tracking.

Returns

Options

The instance for chaining.

enableHands()

enableHands(): Options

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

Enables hand tracking.

Returns

Options

The instance for chaining.

enableHumanDetection()

enableHumanDetection(): Options

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

Enables human pose detection.

Returns

Options

The instance for chaining.

enableObjectDetection()

enableObjectDetection(): Options

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

Enables object detection.

Returns

Options

The instance for chaining.

enablePlaneDetection()

enablePlaneDetection(): Options

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

Enables plane detection.

Returns

Options

The instance for chaining.

enableReticles()

enableReticles(): Options

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

Enables reticles for visualizing targets of hand rays in WebXR.

Returns

Options

The instance for chaining.

enableSegmentation()

enableSegmentation(): Options

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

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.

enableStrokes()

enableStrokes(): Options

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

Enables the stroke recognition block and ensures gestures are available.

Returns

Options

The instance for chaining.

enableUI()

enableUI(): Options

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

Enables a standard set of options for a UI-focused experience.

Returns

Options

The instance for chaining.

enableVR()

enableVR(): Options

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

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

Returns

Options

enableXRTransitions()

enableXRTransitions(): Options

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

Enables the XR transition component for toggling VR.

Returns

Options

The instance for chaining.

parseUrlParams()

protected parseUrlParams(): void

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

Returns

void

setAppDescription()

setAppDescription(description): Options

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

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:455

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?​

antialias?​

camera?​

camera.far?​

camera.near?​

canvas?​

catchScriptExceptions?​

controllers?​

controllers.debug?​

controllers.enabled?​

controllers.enabledMouse?​

controllers.performRaycastOnUpdate?​

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?​

depth.depthTexture.enabled?​

depth.depthTypeRequest?​

depth.enabled?​

depth.matchDepthView?​

depth.occlusion?​

depth.occlusion.enabled?​

depth.usagePreference?​

deviceCamera?​

deviceCamera.cameraLabel?​

deviceCamera.enabled?​

deviceCamera.rgbToDepthParams?​

deviceCamera.rgbToDepthParams.k1?​

deviceCamera.rgbToDepthParams.k2?​

deviceCamera.rgbToDepthParams.k3?​

deviceCamera.rgbToDepthParams.p1?​

deviceCamera.rgbToDepthParams.p2?​

deviceCamera.rgbToDepthParams.scale?​

deviceCamera.rgbToDepthParams.scaleX?​

deviceCamera.rgbToDepthParams.scaleY?​

deviceCamera.rgbToDepthParams.translateU?​

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?

antialias?

camera?

camera.far?

camera.near?

canvas?

catchScriptExceptions?

controllers?

controllers.debug?

controllers.enabled?

controllers.enabledMouse?

controllers.performRaycastOnUpdate?

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?

depth.depthTexture.enabled?

depth.depthTypeRequest?

depth.enabled?

depth.matchDepthView?

depth.occlusion?

depth.occlusion.enabled?

depth.usagePreference?

deviceCamera?

deviceCamera.cameraLabel?

deviceCamera.enabled?

deviceCamera.rgbToDepthParams?

deviceCamera.rgbToDepthParams.k1?

deviceCamera.rgbToDepthParams.k2?

deviceCamera.rgbToDepthParams.k3?

deviceCamera.rgbToDepthParams.p1?

deviceCamera.rgbToDepthParams.p2?

deviceCamera.rgbToDepthParams.scale?

deviceCamera.rgbToDepthParams.scaleX?

deviceCamera.rgbToDepthParams.scaleY?

deviceCamera.rgbToDepthParams.translateU?