Class: Options
Defined in: src/core/Options.ts:141
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:349
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; tokenProvider?: GeminiTokenProvider; 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; tokenProvider?: GeminiTokenProvider; 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.tokenProvider?
Optional async provider for Gemini Live ephemeral tokens. The returned
string should be the name from authTokens.create() (for example,
auth_tokens/...). It is called for every new Live session; it does not
replace apiKey for queries or image generation.
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-6-luna'
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
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.enableScene?
() => ContextOptions
context.enableSetOfMark?
() => ContextOptions
context.enableVisibleObjects?
() => ContextOptions
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; resolutionScale?: number; }; updateAllViews?: 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; resolutionScale?: number; } = ...
depth.occlusion.enabled?
boolean = false
depth.occlusion.resolutionScale?
number = 0.5
depth.updateAllViews?
boolean = false
Whether to extract and upload CPU depth for all stereo views instead of only view 0.
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; }; targetDevice?: string; 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.targetDevice?
string
The DEVICE_CAMERA_PARAMETERS key (such as 'galaxyxr', 'aura' or
'quest3') whose intrinsics and pose describe the headset camera. When
unset, the profile comes from the user agent, which cannot tell Aura from
Galaxy XR. A valid ?camera=<profile> URL parameter overrides this. Read or
switch the active profile at runtime with XRDeviceCamera.targetDevice.
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
enableLayers?
() => Options
enableObjectDetection?
() => Options
enablePlaneDetection?
() => Options
enableReticles?
() => Options
enableSceneContext?
() => Options
enableSegmentation?
() => Options
enableSerializer?
(serializer?) => this
enableSetOfMarkContext?
() => Options
enableSimulator?
boolean = true
enableSplats?
(options?) => this
enableStrokes?
() => Options
enableVisibleObjectsContext?
() => Options
enableVR?
() => Options
enableWebGPU?
(options?) => this
enableXRTransitions?
() => Options
fallbackToVR?
boolean = true
Falls back to immersive-vr when the browser supports it but not
immersive-ar, unless camera-access or depth-sensing is required.
formFactor?
"auto" | "xr" | "hud" | "vr" | "desktop" | "mobile"
foveationLevel?
number
Optional fixed foveation level from 0 (none) to 1 (maximum), applied by the three.js XR manager when supported by the renderer and device. Finite values are clamped to this range; unset values leave three.js's default foveation level of 1 unchanged.
framebufferScaleFactor?
Optional WebXR framebuffer scale factor. Set to a number (e.g., 1.5) or
'native' to query XRWebGLLayer.getNativeFramebufferScaleFactor(session)
before the XR session starts.
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.
layers?
{ enabled?: boolean; video?: boolean; } = ...
layers.enabled?
boolean = false
Whether to request the layers session feature.
layers.video?
boolean = true
Whether a video shown through VideoView should be presented as a composition layer when the platform allows it.
Falls back to rendering into the scene as a texture when it cannot, so an app can leave this on and still work everywhere.
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?: { Ball?: { }; ColliderDesc?: { ball?: (radius) => RapierColliderDesc; convexHull?: (vertices) => ... | ...; cuboid?: (hx, hy, hz) => RapierColliderDesc; trimesh?: (vertices, indices) => RapierColliderDesc; }; EventQueue?: { }; init?: () => Promise<void>; QueryFilterFlags?: { ONLY_FIXED?: number; }; RigidBodyDesc?: { dynamic?: () => RapierRigidBodyDesc; fixed?: () => RapierRigidBodyDesc; kinematicPositionBased?: () => RapierRigidBodyDesc; }; World?: { }; }; 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?
{ Ball?: { }; ColliderDesc?: { ball?: (radius) => RapierColliderDesc; convexHull?: (vertices) => ... | ...; cuboid?: (hx, hy, hz) => RapierColliderDesc; trimesh?: (vertices, indices) => RapierColliderDesc; }; EventQueue?: { }; init?: () => Promise<void>; QueryFilterFlags?: { ONLY_FIXED?: number; }; RigidBodyDesc?: { dynamic?: () => RapierRigidBodyDesc; fixed?: () => RapierRigidBodyDesc; kinematicPositionBased?: () => RapierRigidBodyDesc; }; World?: { }; }
Instance of RAPIER.
physics.RAPIER.Ball?
{ }
physics.RAPIER.ColliderDesc?
{ ball?: (radius) => RapierColliderDesc; convexHull?: (vertices) => ... | ...; cuboid?: (hx, hy, hz) => RapierColliderDesc; trimesh?: (vertices, indices) => RapierColliderDesc; }
physics.RAPIER.ColliderDesc.ball?
(radius) => RapierColliderDesc
physics.RAPIER.ColliderDesc.convexHull?
(vertices) => ... | ...
physics.RAPIER.ColliderDesc.cuboid?
(hx, hy, hz) => RapierColliderDesc
physics.RAPIER.ColliderDesc.trimesh?
(vertices, indices) => RapierColliderDesc
physics.RAPIER.EventQueue?
{ }
physics.RAPIER.init?
() => Promise<void>
physics.RAPIER.QueryFilterFlags?
{ ONLY_FIXED?: number; }
physics.RAPIER.QueryFilterFlags.ONLY_FIXED?
number
physics.RAPIER.RigidBodyDesc?
{ dynamic?: () => RapierRigidBodyDesc; fixed?: () => RapierRigidBodyDesc; kinematicPositionBased?: () => RapierRigidBodyDesc; }
physics.RAPIER.RigidBodyDesc.dynamic?
() => RapierRigidBodyDesc
physics.RAPIER.RigidBodyDesc.fixed?
() => RapierRigidBodyDesc
physics.RAPIER.RigidBodyDesc.kinematicPositionBased?
() => RapierRigidBodyDesc
physics.RAPIER.World?
{ }
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'
rendererBackend?
"webgl" | "webgpu" | "serializer"
reticles?
{ defaultRenderDistance?: number; enabled?: boolean; hoverRing?: boolean; maxDistance?: number; projectOnDepthMesh?: boolean; scaleWithDistance?: 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.hoverRing?
boolean = false
Shows a ring around a reticle over interactive targets. The reticle's dark border already outlines it, so this is off by default.
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.
reticles.scaleWithDistance?
boolean = true
Scales reticles with their distance from the viewer, so they stay legible far away without covering nearby UI. Turn off to keep a fixed world size.
serializer?
SerializerRendererFactory | { dispose?: () => void; domElement?: { }; getPixelRatio?: () => number; getSize?: (target?) => object; isSplitEngineSerializer?: true; render?: (scene, camera) => void; setAnimationLoop?: (callback) => void; setPixelRatio?: (value) => void; setSize?: (width, height, updateStyle?) => void; shadowMap?: { autoUpdate?: boolean; enabled?: boolean; type?: ShadowMapType; }; xr?: { addEventListener?: <T>(type, listener) => void; enabled?: boolean; getBinding?: () => XRWebGLBinding | null; getCamera?: () => ArrayCamera; getController?: (index) => XRTargetRaySpace; getControllerGrip?: (index) => XRGripSpace; getFrame?: () => XRFrame | undefined; getHand?: (index) => XRHandSpace; getReferenceSpace?: () => XRReferenceSpace | null; getSession?: () => XRSession | null; isPresenting?: boolean; removeEventListener?: <T>(type, listener) => void; setFramebufferScaleFactor?: (factor) => void; setReferenceSpaceType?: (type) => void; setSession?: (session) => Promise<void>; updateCamera?: (camera) => void; }; }
Optional Split Engine serializer instance or factory function used when
rendererBackend is 'serializer'.
setAppDescription?
(description) => Options
setAppTitle?
(title) => Options
setFramebufferScaleFactor?
(scaleFactor) => Options
simulateAdditiveDisplay?
boolean = false
Makes an alpha-blend passthrough session composite like an additive display by preserving destination RGB while forcing output alpha to zero. Has no effect in opaque or additive sessions.
simulatedDimming?
number = 0
Constant alpha written by additive display simulation. 0 preserves all
passthrough; 1 fully dims it. Read every frame while simulation is active.
simulator?
{ activeEnvironmentIndex?: number; blendingMode?: "screen" | "normal"; defaultHand?: Handedness; defaultMode?: SimulatorMode; deviceCamera?: { enabled?: boolean; }; displayDiagonalFov?: number; 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; fadeInDelayMs?: number; overlayElement?: string; overlayEnabled?: 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.displayDiagonalFov?
number
Optional diagonal field of view in degrees for a glasses display.
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; fadeInDelayMs?: number; overlayElement?: string; overlayEnabled?: 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.fadeInDelayMs?
number = 5000
simulator.instructions.overlayElement?
string = 'xrblocks-simulator-overlay-instructions'
simulator.instructions.overlayEnabled?
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
splats?
{ enable?: (options?) => this; enabled?: boolean; maxPixelRadius?: number; maxShDegree?: number; maxStdDev?: number; method?: RadixProjectionMethod; minAlpha?: number; minContribution?: number; minPixelRadius?: number; renderOrder?: number; sortBits?: RadixSortBits; sortWorkers?: number; } = ...
splats.enable?
(options?) => this
splats.enabled?
boolean = false
Whether the Radix splats configuration was explicitly enabled.
splats.maxPixelRadius?
number
Optional maximum screen-space Gaussian radius in pixels.
splats.maxShDegree?
number
Optional maximum Spherical Harmonics degree (0–4).
splats.maxStdDev?
number = ...
Gaussian cutoff in standard deviations (defaults to Math.sqrt(4) = 2.0
to bound stereo alpha-blending overdraw on mobile XR GPUs; Radix's upstream
desktop default is Math.sqrt(8)).
splats.method?
RadixProjectionMethod = 'ewa'
Splat projection method used by Radix's SplatRenderer.
splats.minAlpha?
number = ...
Minimum splat/fragment alpha threshold (0–1). Culls near-invisible
splats before sorting and tightens per-splat screen-space quad bounds
(sqrt(2 * ln(alpha / minAlpha))). Defaults to 5 / 255 (~0.02).
splats.minContribution?
number
Optional minimum integrated 2D screen contribution (opacity * 2π * sqrt(det(cov2D))
in pixel²·alpha) required to sort and draw a splat.
splats.minPixelRadius?
number
Optional minimum screen-space Gaussian radius in pixels.
splats.renderOrder?
number = -1
Render order assigned to the shared SplatRenderer mesh in the scene.
splats.sortBits?
RadixSortBits = 16
Sort key width in bits (16, 24, or 32). Defaults to 16 (65,536
depth buckets, executing 2 GPU radix-sort passes instead of 3–4 to keep
stereo XR command encoding and compute time within a single 72/90 Hz vsync).
splats.sortWorkers?
number
Number of background workers in Radix's shared CPU sort pool when
WebGPURenderer runs on its WebGL2 fallback backend (forceWebGL: true).
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?
"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" = 'index-finger-tip'
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.
targetFrameRate?
number
Optional target WebXR session frame rate in frames per second. The browser
applies this only when the active session advertises the rate in
supportedFrameRates and supports updateTargetFrameRate().
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.
useSerializer?
(serializer?) => this
webgpuOptions?
{ forceWebGL?: boolean; requiredLimits?: {[key: string]: number | "adapter" | undefined; }; }
Optional configuration for WebGPU renderer.
webgpuOptions.forceWebGL?
boolean
Uses the WebGL2 backend of WebGPURenderer. When unset, the SDK checks
WebXR+WebGPU availability separately from 2D navigator.gpu and enables
this automatically on XR devices lacking XRGPUBinding or an
xrCompatible WebGPU adapter so immersive sessions and TSL subsystems
(such as @sparkjsdev/radix) still start on WebGL2.
webgpuOptions.requiredLimits?
{[key: string]: number | "adapter" | undefined; }
Optional WebGPU device limits to request (clamped to the adapter's
supported limits). Pass 'adapter' to request the full hardware maximum
for a given limit.
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@0.10.34/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@0.10.34/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@0.10.34/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:261
camera
camera:
object
Defined in: src/core/Options.ts:269
far
far:
number=500
near
near:
number=0.01
canvas?
optionalcanvas:HTMLCanvasElement
Defined in: src/core/Options.ts:173
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:286
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
context:
ContextOptions
Defined in: src/core/Options.ts:264
controllers
controllers:
InputOptions
Defined in: src/core/Options.ts:250
debugging
debugging:
boolean=false
Defined in: src/core/Options.ts:164
Global flag for enabling various debugging features.
depth
depth:
DepthOptions
Defined in: src/core/Options.ts:251
deviceCamera
deviceCamera:
DeviceCameraOptions
Defined in: src/core/Options.ts:253
enableSimulator
enableSimulator:
boolean=true
Defined in: src/core/Options.ts:279
fallbackToVR
fallbackToVR:
boolean=true
Defined in: src/core/Options.ts:319
Falls back to immersive-vr when the browser supports it but not
immersive-ar, unless camera-access or depth-sensing is required.
foveationLevel?
optionalfoveationLevel:number
Defined in: src/core/Options.ts:221
Optional fixed foveation level from 0 (none) to 1 (maximum), applied by the three.js XR manager when supported by the renderer and device. Finite values are clamped to this range; unset values leave three.js's default foveation level of 1 unchanged.
framebufferScaleFactor?
optionalframebufferScaleFactor:FramebufferScaleFactor
Defined in: src/core/Options.ts:206
Optional WebXR framebuffer scale factor. Set to a number (e.g., 1.5) or
'native' to query XRWebGLLayer.getNativeFramebufferScaleFactor(session)
before the XR session starts.
gestures
gestures:
GestureRecognitionOptions
Defined in: src/core/Options.ts:255
hands
hands:
HandsOptions
Defined in: src/core/Options.ts:254
headGestures
headGestures:
HeadGestureRecognitionOptions
Defined in: src/core/Options.ts:256
interaction
interaction:
InteractionOptions
Defined in: src/core/Options.ts:259
layers
layers:
LayersOptions
Defined in: src/core/Options.ts:266
lighting
lighting:
LightingOptions
Defined in: src/core/Options.ts:252
logarithmicDepthBuffer
logarithmicDepthBuffer:
boolean=false
Defined in: src/core/Options.ts:160
Whether to use a logarithmic depth buffer. Useful for depth-aware occlusions.
permissions
permissions:
object
Defined in: src/core/Options.ts:307
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:265
referenceSpaceType
referenceSpaceType:
XRReferenceSpaceType='local-floor'
Defined in: src/core/Options.ts:248
reticles
reticles:
ReticleOptions
Defined in: src/core/Options.ts:258
serializer?
optionalserializer:SerializerRenderer|SerializerRendererFactory
Defined in: src/core/Options.ts:199
Optional Split Engine serializer instance or factory function used when
rendererBackend is 'serializer'.
simulateAdditiveDisplay
simulateAdditiveDisplay:
boolean=false
Defined in: src/core/Options.ts:228
Makes an alpha-blend passthrough session composite like an additive display by preserving destination RGB while forcing output alpha to zero. Has no effect in opaque or additive sessions.
simulatedDimming
simulatedDimming:
number=0
Defined in: src/core/Options.ts:234
Constant alpha written by additive display simulation. 0 preserves all
passthrough; 1 fully dims it. Read every frame while simulation is active.
simulator
simulator:
SimulatorOptions
Defined in: src/core/Options.ts:262
sound
sound:
SoundOptions
Defined in: src/core/Options.ts:260
splats
splats:
SplatsOptions
Defined in: src/core/Options.ts:267
stencil
stencil:
boolean=false
Defined in: src/core/Options.ts:168
Whether to request a stencil buffer.
strokes
strokes:
StrokeRecognitionOptions
Defined in: src/core/Options.ts:257
targetFrameRate?
optionaltargetFrameRate:number
Defined in: src/core/Options.ts:213
Optional target WebXR session frame rate in frames per second. The browser
applies this only when the active session advertises the rate in
supportedFrameRates and supports updateTargetFrameRate().
transition
transition:
XRTransitionOptions
Defined in: src/core/Options.ts:268
usePostprocessing
usePostprocessing:
boolean=false
Defined in: src/core/Options.ts:277
Whether to use post-processing effects.
webgpuOptions?
optionalwebgpuOptions:WebGPURendererOptions
Defined in: src/core/Options.ts:193
Optional configuration for WebGPU renderer.
webxrOptionalFeatures
webxrOptionalFeatures:
string[]
Defined in: src/core/Options.ts:244
Any additional optional features when initializing webxr.
webxrRequiredFeatures
webxrRequiredFeatures:
string[] =[]
Defined in: src/core/Options.ts:239
Any additional required features when initializing webxr.
world
world:
WorldOptions
Defined in: src/core/Options.ts:263
xrButton
xrButton:
object
Defined in: src/core/Options.ts:291
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:313
Accessors
antialias
Get Signature
get antialias():
boolean
Defined in: src/core/Options.ts:148
Whether to use antialiasing.
Returns
boolean
Set Signature
set antialias(
value):void
Defined in: src/core/Options.ts:152
Parameters
value
boolean
Returns
void
formFactor
Get Signature
get formFactor():
"auto"|"xr"|"hud"|"vr"|"desktop"|"mobile"
Defined in: src/core/Options.ts:323
Returns
"auto" | "xr" | "hud" | "vr" | "desktop" | "mobile"
Set Signature
set formFactor(
formFactor):void
Defined in: src/core/Options.ts:332
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
rendererBackend
Get Signature
get rendererBackend():
"webgl"|"webgpu"|"serializer"
Defined in: src/core/Options.ts:181
The rendering backend to use.
Returns
"webgl" | "webgpu" | "serializer"
Set Signature
set rendererBackend(
value):void
Defined in: src/core/Options.ts:185
Parameters
value
"webgl" | "webgpu" | "serializer"
Returns
void
Methods
enableAI()
enableAI():
Options
Defined in: src/core/Options.ts:680
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:478
Enables a standard simulator-driven setup for automation and external test harnesses.
Parameters
config
Returns
Options
The instance for chaining.
enableCamera()
enableCamera(
facingMode):Options
Defined in: src/core/Options.ts:613
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:691
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:738
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:525
Enables depth sensing in WebXR with default options.
Returns
Options
The instance for chaining.
enableFaceDetection()
enableFaceDetection():
Options
Defined in: src/core/Options.ts:586
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:642
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:671
Enables the visualization of rays for hand tracking.
Returns
Options
The instance for chaining.
enableHands()
enableHands():
Options
Defined in: src/core/Options.ts:633
Enables hand tracking.
Returns
Options
The instance for chaining.
enableHeadGestures()
enableHeadGestures():
Options
Defined in: src/core/Options.ts:652
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:572
Enables human pose detection.
Returns
Options
The instance for chaining.
enableLayers()
enableLayers():
Options
Defined in: src/core/Options.ts:543
Enables WebXR composition layers.
Content presented as a layer is composited once at its own resolution rather than being drawn into the eye buffer and resampled again, so video and text come out sharper, and the compositor keeps reprojecting it to the latest head pose even when the app's own frame rate dips.
Requested optionally, and each layer falls back to ordinary in-scene rendering where the platform cannot present one.
Returns
Options
The instance for chaining.
enableObjectDetection()
enableObjectDetection():
Options
Defined in: src/core/Options.ts:561
Enables object detection.
Returns
Options
The instance for chaining.
enablePlaneDetection()
enablePlaneDetection():
Options
Defined in: src/core/Options.ts:552
Enables plane detection.
Returns
Options
The instance for chaining.
enableReticles()
enableReticles():
Options
Defined in: src/core/Options.ts:516
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:700
Enables agent-facing scene context.
Returns
Options
The instance for chaining.
enableSegmentation()
enableSegmentation():
Options
Defined in: src/core/Options.ts:600
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.
enableSerializer()
enableSerializer(
serializer?):this
Defined in: src/core/Options.ts:444
Configures Core to use a SplitEngineSerializer renderer backend instead of THREE.WebGLRenderer.
Parameters
serializer?
Optional SplitEngineSerializer instance or factory function.
SerializerRenderer | SerializerRendererFactory
Returns
this
enableSetOfMarkContext()
enableSetOfMarkContext():
Options
Defined in: src/core/Options.ts:718
Enables agent-facing Set-of-Mark context.
Returns
Options
The instance for chaining.
enableSplats()
enableSplats(
options?):this
Defined in: src/core/Options.ts:422
Enables 3D Gaussian Splatting (@sparkjsdev/radix) and switches the
renderer backend to WebGPURenderer unless another backend was explicitly
selected (for example 'serializer' or ?rendererBackend=webgl).
On XR devices where WebXR+WebGPU is not yet enabled (such as default
Chrome on Android XR), Core.init() automatically initializes
WebGPURenderer on its WebGL2 backend and Radix uses its built-in WebGL2 +
Web Worker sort fallback.
Parameters
options?
Optional Radix splat rendering settings.
enable?
(options?) => this
enabled?
boolean = false
Whether the Radix splats configuration was explicitly enabled.
maxPixelRadius?
number
Optional maximum screen-space Gaussian radius in pixels.
maxShDegree?
number
Optional maximum Spherical Harmonics degree (0–4).
maxStdDev?
number = ...
Gaussian cutoff in standard deviations (defaults to Math.sqrt(4) = 2.0
to bound stereo alpha-blending overdraw on mobile XR GPUs; Radix's upstream
desktop default is Math.sqrt(8)).
method?
RadixProjectionMethod = 'ewa'
Splat projection method used by Radix's SplatRenderer.
minAlpha?
number = ...
Minimum splat/fragment alpha threshold (0–1). Culls near-invisible
splats before sorting and tightens per-splat screen-space quad bounds
(sqrt(2 * ln(alpha / minAlpha))). Defaults to 5 / 255 (~0.02).
minContribution?
number
Optional minimum integrated 2D screen contribution (opacity * 2π * sqrt(det(cov2D))
in pixel²·alpha) required to sort and draw a splat.
minPixelRadius?
number
Optional minimum screen-space Gaussian radius in pixels.
renderOrder?
number = -1
Render order assigned to the shared SplatRenderer mesh in the scene.
sortBits?
RadixSortBits = 16
Sort key width in bits (16, 24, or 32). Defaults to 16 (65,536
depth buckets, executing 2 GPU radix-sort passes instead of 3–4 to keep
stereo XR command encoding and compute time within a single 72/90 Hz vsync).
sortWorkers?
number
Number of background workers in Radix's shared CPU sort pool when
WebGPURenderer runs on its WebGL2 fallback backend (forceWebGL: true).
Returns
this
The instance for chaining.
enableStrokes()
enableStrokes():
Options
Defined in: src/core/Options.ts:661
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:709
Enables agent-facing visible objects context.
Returns
Options
The instance for chaining.
enableVR()
enableVR():
Options
Defined in: src/core/Options.ts:468
Sets the session mode to VR and disables the simulator passthrough scene.
Returns
Options
enableWebGPU()
enableWebGPU(
options?):this
Defined in: src/core/Options.ts:401
Configures Core to use THREE.WebGPURenderer instead of THREE.WebGLRenderer.
Parameters
options?
Optional WebGPU renderer settings such as forceWebGL.
Returns
this
enableXRTransitions()
enableXRTransitions():
Options
Defined in: src/core/Options.ts:727
Enables the XR transition component for toggling VR.
Returns
Options
The instance for chaining.
parseUrlParams()
protectedparseUrlParams():void
Defined in: src/core/Options.ts:354
Returns
void
setAppDescription()
setAppDescription(
description):Options
Defined in: src/core/Options.ts:758
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:748
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.
setFramebufferScaleFactor()
setFramebufferScaleFactor(
scaleFactor):Options
Defined in: src/core/Options.ts:769
Sets the WebXR framebuffer scale factor (a numeric multiplier or 'native'
to use XRWebGLLayer.getNativeFramebufferScaleFactor(session)).
Parameters
scaleFactor
Numeric scale factor or 'native'.
Returns
Options
The instance for chaining.
useSerializer()
useSerializer(
serializer?):this
Defined in: src/core/Options.ts:459
Alias for enableSerializer that configures Core to use a
SplitEngineSerializer renderer backend.
Parameters
serializer?
Optional SplitEngineSerializer instance or factory function.
SerializerRenderer | SerializerRendererFactory
Returns
this