xrblocks 0.3.1 → 0.5.0

package/build/addons/ai/GeminiManager.d.ts

@@ -26,6 +26,7 @@ export declare class GeminiManager extends xb.Script<GeminiManagerEventMap> {
     currentInputText: string;
     currentOutputText: string;
     tools: xb.Tool[];
+    scheduleAheadTime: number;
     constructor();
     init(): void;
     startGeminiLive({ liveParams, model, }?: {

package/build/addons/ai/GeminiManager.js

@@ -1,6 +1,7 @@
 import * as xb from 'xrblocks';
 import { AUDIO_CAPTURE_PROCESSOR_CODE } from './AudioCaptureProcessorCode.js';
 
+const DEFAULT_SCHEDULE_AHEAD_TIME = 1.0;
 class GeminiManager extends xb.Script {
     constructor() {
         super();
@@ -19,6 +20,7 @@ class GeminiManager extends xb.Script {
         this.currentInputText = '';
         this.currentOutputText = '';
         this.tools = [];
+        this.scheduleAheadTime = DEFAULT_SCHEDULE_AHEAD_TIME;
     }
     init() {
         this.xrDeviceCamera = xb.core.deviceCamera;
@@ -191,10 +193,9 @@ class GeminiManager extends xb.Script {
         }
     }
     scheduleAudioBuffers() {
-        const SCHEDULE_AHEAD_TIME = 0.2;
         while (this.audioQueue.length > 0 &&
             this.nextAudioStartTime <=
-                this.audioContext.currentTime + SCHEDULE_AHEAD_TIME) {
+                this.audioContext.currentTime + this.scheduleAheadTime) {
             const audioBuffer = this.audioQueue.shift();
             const source = this.audioContext.createBufferSource();
             source.buffer = audioBuffer;

package/build/core/Core.d.ts

@@ -21,6 +21,7 @@ import { XREffects } from './components/XREffects';
 import { XRTransition } from './components/XRTransition';
 import { Options } from './Options';
 import { User } from './User';
+import { PermissionsManager } from './components/PermissionsManager';
 /**
  * Core is the central engine of the XR Blocks framework, acting as a
  * singleton manager for all XR subsystems. Its primary goal is to abstract
@@ -84,6 +85,7 @@ export declare class Core {
     scriptsManager: ScriptsManager;
     renderSceneOverride?: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera) => void;
     webXRSessionManager?: WebXRSessionManager;
+    permissionsManager: PermissionsManager;
     /**
      * Core is a singleton manager that manages all XR "blocks".
      * It initializes core components and abstractions like the scene, camera,

package/build/core/Options.d.ts

@@ -95,6 +95,7 @@ export declare class Options {
      * Whether to use post-processing effects.
      */
     usePostprocessing: boolean;
+    enableSimulator: boolean;
     /**
      * Configuration for the XR session button.
      */
@@ -104,9 +105,17 @@ export declare class Options {
         endText: string;
         invalidText: string;
         startSimulatorText: string;
-        enableSimulator: boolean;
+        showEnterSimulatorButton: boolean;
         alwaysAutostartSimulator: boolean;
     };
+    /**
+     * Which permissions to request before entering the XR session.
+     */
+    permissions: {
+        geolocation: boolean;
+        camera: boolean;
+        microphone: boolean;
+    };
     /**
      * Constructs the Options object by merging default values with provided
      * custom options.
@@ -160,11 +169,6 @@ export declare class Options {
      * @returns The instance for chaining.
      */
     enableHandRays(): this;
-    /**
-     * Enables the Gemini Live feature.
-     * @returns The instance for chaining.
-     */
-    enableGeminiLive(): this;
     /**
      * Enables a standard set of AI features, including Gemini Live.
      * @returns The instance for chaining.

package/build/core/components/PermissionsManager.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Interface representing the result of a permission request.
+ */
+export interface PermissionResult {
+    granted: boolean;
+    status: PermissionState | 'unknown' | 'error';
+    error?: string;
+}
+/**
+ * A utility class to manage and request browser permissions for
+ * Location, Camera, and Microphone.
+ */
+export declare class PermissionsManager {
+    /**
+     * Requests permission to access the user's geolocation.
+     * Note: This actually attempts to fetch the position to trigger the prompt.
+     */
+    requestLocationPermission(): Promise<PermissionResult>;
+    /**
+     * Requests permission to access the microphone.
+     * Opens a stream to trigger the prompt, then immediately closes it.
+     */
+    requestMicrophonePermission(): Promise<PermissionResult>;
+    /**
+     * Requests permission to access the camera.
+     * Opens a stream to trigger the prompt, then immediately closes it.
+     */
+    requestCameraPermission(): Promise<PermissionResult>;
+    /**
+     * Requests permission for both camera and microphone simultaneously.
+     */
+    requestAVPermission(): Promise<PermissionResult>;
+    /**
+     * Internal helper to handle getUserMedia requests.
+     * Crucially, this stops the tracks immediately after permission is granted
+     * so the hardware doesn't remain active.
+     */
+    private requestMediaPermission;
+    /**
+     * Requests multiple permissions sequentially.
+     * Returns a single result: granted is true only if ALL requested permissions are granted.
+     */
+    checkAndRequestPermissions({ geolocation, camera, microphone, }: {
+        geolocation?: boolean;
+        camera?: boolean;
+        microphone?: boolean;
+    }): Promise<PermissionResult>;
+    /**
+     * Checks the current status of a permission without triggering a prompt.
+     * Useful for UI state (e.g., disabling buttons if already denied).
+     * * @param permissionName - 'geolocation', 'camera', or 'microphone'
+     */
+    checkPermissionStatus(permissionName: 'geolocation' | 'camera' | 'microphone'): Promise<PermissionState | 'unknown'>;
+}

package/build/core/components/WebXRSessionManager.d.ts

@@ -34,6 +34,7 @@ export declare class WebXRSessionManager extends THREE.EventDispatcher<WebXRSess
     private sessionOptions?;
     private onSessionEndedBound;
     private xrModeSupported?;
+    private waitingForXRSession;
     constructor(renderer: THREE.WebGLRenderer, sessionInit: XRSessionInit, mode: XRSessionMode);
     /**
      * Checks for WebXR support and availability of the requested session mode.

package/build/core/components/XRButton.d.ts

@@ -1,15 +1,22 @@
+import { PermissionsManager } from './PermissionsManager';
 import { WebXRSessionManager } from './WebXRSessionManager';
 export declare class XRButton {
     private sessionManager;
+    private permissionsManager;
     private startText;
     private endText;
     private invalidText;
     private startSimulatorText;
     startSimulator: () => void;
+    private permissions;
     domElement: HTMLDivElement;
     simulatorButtonElement: HTMLButtonElement;
     xrButtonElement: HTMLButtonElement;
-    constructor(sessionManager: WebXRSessionManager, startText?: string, endText?: string, invalidText?: string, startSimulatorText?: string, enableSimulator?: boolean, startSimulator?: () => void);
+    constructor(sessionManager: WebXRSessionManager, permissionsManager: PermissionsManager, startText?: string, endText?: string, invalidText?: string, startSimulatorText?: string, showEnterSimulatorButton?: boolean, startSimulator?: () => void, permissions?: {
+        geolocation: boolean;
+        camera: boolean;
+        microphone: boolean;
+    });
     private createSimulatorButton;
     private createXRButtonElement;
     private onSessionReady;

package/build/depth/DepthOptions.d.ts

@@ -28,6 +28,8 @@ export declare class DepthOptions {
         enabled: boolean;
     };
     useFloat32: boolean;
+    depthTypeRequest: XRDepthType[];
+    matchDepthView: boolean;
     constructor(options?: DeepReadonly<DeepPartial<DepthOptions>>);
 }
 export declare const xrDepthMeshOptions: {
@@ -58,6 +60,8 @@ export declare const xrDepthMeshOptions: {
         readonly enabled: boolean;
     };
     readonly useFloat32: boolean;
+    readonly depthTypeRequest: readonly XRDepthType[];
+    readonly matchDepthView: boolean;
 };
 export declare const xrDepthMeshVisualizationOptions: {
     readonly debugging: boolean;
@@ -87,6 +91,8 @@ export declare const xrDepthMeshVisualizationOptions: {
         readonly enabled: boolean;
     };
     readonly useFloat32: boolean;
+    readonly depthTypeRequest: readonly XRDepthType[];
+    readonly matchDepthView: boolean;
 };
 export declare const xrDepthMeshPhysicsOptions: {
     readonly debugging: boolean;
@@ -116,4 +122,6 @@ export declare const xrDepthMeshPhysicsOptions: {
         readonly enabled: boolean;
     };
     readonly useFloat32: boolean;
+    readonly depthTypeRequest: readonly XRDepthType[];
+    readonly matchDepthView: boolean;
 };

package/build/simulator/Simulator.d.ts

@@ -42,6 +42,8 @@ export declare class Simulator extends Script {
     effects?: XREffects;
     virtualSceneRenderTarget?: THREE.WebGLRenderTarget;
     virtualSceneFullScreenQuad?: FullScreenQuad;
+    backgroundVideoQuad?: FullScreenQuad;
+    videoElement?: HTMLVideoElement;
     camera?: SimulatorCamera;
     options: SimulatorOptions;
     renderer: THREE.WebGLRenderer;

package/build/simulator/SimulatorOptions.d.ts

@@ -23,6 +23,7 @@ export declare class SimulatorOptions {
         z: number;
     };
     scenePath: string;
+    videoPath?: string;
     initialScenePosition: {
         x: number;
         y: number;
@@ -43,7 +44,10 @@ export declare class SimulatorOptions {
         enabled: boolean;
         element: string;
     };
-    geminilive: boolean;
+    geminiLivePanel: {
+        enabled: boolean;
+        element: string;
+    };
     stereo: {
         enabled: boolean;
     };

package/build/sound/AudioPlayer.d.ts

@@ -14,6 +14,7 @@ export declare class AudioPlayer extends Script {
     private categoryVolumes?;
     private volume;
     private category;
+    scheduleAheadTime: number;
     constructor(options?: AudioPlayerOptions);
     /**
      * Sets the CategoryVolumes instance for this player to respect