xrblocks 0.4.0 → 0.5.1

package/build/xrblocks.js

@@ -14,9 +14,9 @@
  * limitations under the License.
  *
  * @file xrblocks.js
- * @version v0.4.0
- * @commitid 385db96
- * @builddate 2025-11-20T21:08:04.032Z
+ * @version v0.5.1
+ * @commitid 896d66f
+ * @builddate 2025-12-06T06:19:44.629Z
  * @description XR Blocks SDK, built from source with the above commit ID.
  * @agent When using with Gemini to create XR apps, use **Gemini Canvas** mode,
  * and follow rules below:
@@ -1849,6 +1849,27 @@ function deepMerge(obj1, obj2) {
     }
 }
 
+/**
+ * Default parameters for rgb to depth projection.
+ * For RGB and depth, 4:3 and 1:1, respectively.
+ */
+const DEFAULT_RGB_TO_DEPTH_PARAMS = {
+    scale: 1,
+    scaleX: 0.75,
+    scaleY: 0.63,
+    translateU: 0.2,
+    translateV: -0.02,
+    k1: -0.046,
+    k2: 0,
+    k3: 0,
+    p1: 0,
+    p2: 0,
+    xc: 0,
+    yc: 0,
+};
+/**
+ * Configuration options for the device camera.
+ */
 class DeviceCameraOptions {
     constructor(options) {
         this.enabled = false;
@@ -1856,10 +1877,14 @@ class DeviceCameraOptions {
          * Hint for performance optimization on frequent captures.
          */
         this.willCaptureFrequently = false;
+        /**
+         * Parameters for RGB to depth UV mapping given different aspect ratios.
+         */
+        this.rgbToDepthParams = { ...DEFAULT_RGB_TO_DEPTH_PARAMS };
         deepMerge(this, options);
     }
 }
-// Base configuration for all common capture settings
+// Base configuration for all common capture settings.
 const baseCaptureOptions = {
     enabled: true,
     videoConstraints: {
@@ -2408,6 +2433,8 @@ class DepthOptions {
         // Occlusion pass.
         this.occlusion = { enabled: false };
         this.useFloat32 = true;
+        this.depthTypeRequest = ['raw'];
+        this.matchDepthView = true;
         deepMerge(this, options);
     }
 }
@@ -3314,24 +3341,6 @@ const aspectRatios = {
     depth: 1.0,
     RGB: 4 / 3,
 };
-/**
- * Parameters for RGB to depth UV mapping (manually calibrated for aspect
- * ratios. For RGB and depth, 4:3 and 1:1, respectively.
- */
-const rgbToDepthParams = {
-    scale: 1,
-    scaleX: 0.75,
-    scaleY: 0.63,
-    translateU: 0.2,
-    translateV: -0.02,
-    k1: -0.046,
-    k2: 0,
-    k3: 0,
-    p1: 0,
-    p2: 0,
-    xc: 0,
-    yc: 0,
-};
 /**
  * Maps a UV coordinate from a RGB space to a destination depth space,
  * applying Brown-Conrady distortion and affine transformations based on
@@ -3366,42 +3375,40 @@ function transformRgbToDepthUv(rgbUv, xrDeviceCamera) {
         console.error('Invalid aspect ratios provided.');
         return null;
     }
-    // Determine the relative scaling required to fit the overlay within the base
+    const params = xrDeviceCamera?.rgbToDepthParams ?? DEFAULT_RGB_TO_DEPTH_PARAMS;
+    // Determine the relative scaling required to fit the overlay within the base.
     let relativeScaleX, relativeScaleY;
     if (aspectRatios.depth > aspectRatios.RGB) {
-        // Base is wider than overlay ("letterboxing")
+        // Base is wider than overlay ("letterboxing").
         relativeScaleY = 1.0;
         relativeScaleX = aspectRatios.RGB / aspectRatios.depth;
     }
     else {
-        // Base is narrower than overlay ("pillarboxing")
+        // Base is narrower than overlay ("pillarboxing").
         relativeScaleX = 1.0;
         relativeScaleY = aspectRatios.depth / aspectRatios.RGB;
     }
-    // Convert input source UV [0, 1] to a normalized coordinate space [-0.5, 0.5]
+    // Convert input source UV [0, 1] to normalized coordinates in [-0.5, 0.5].
     const u_norm = rgbUv.u - 0.5;
     const v_norm = rgbUv.v - 0.5;
-    // Apply the FORWARD Brown-Conrady distortion model
-    const u_centered = u_norm - rgbToDepthParams.xc;
-    const v_centered = v_norm - rgbToDepthParams.yc;
+    // Apply the FORWARD Brown-Conrady distortion model.
+    const u_centered = u_norm - params.xc;
+    const v_centered = v_norm - params.yc;
     const r2 = u_centered * u_centered + v_centered * v_centered;
-    const radial = 1 +
-        rgbToDepthParams.k1 * r2 +
-        rgbToDepthParams.k2 * r2 * r2 +
-        rgbToDepthParams.k3 * r2 * r2 * r2;
-    const tanX = 2 * rgbToDepthParams.p1 * u_centered * v_centered +
-        rgbToDepthParams.p2 * (r2 + 2 * u_centered * u_centered);
-    const tanY = rgbToDepthParams.p1 * (r2 + 2 * v_centered * v_centered) +
-        2 * rgbToDepthParams.p2 * u_centered * v_centered;
-    const u_distorted = u_centered * radial + tanX + rgbToDepthParams.xc;
-    const v_distorted = v_centered * radial + tanY + rgbToDepthParams.yc;
-    // Apply initial aspect ratio scaling and translation
-    const u_fitted = u_distorted * relativeScaleX + rgbToDepthParams.translateU;
-    const v_fitted = v_distorted * relativeScaleY + rgbToDepthParams.translateV;
-    // Apply the final user-controlled scaling (zoom and stretch)
-    const finalNormX = u_fitted * rgbToDepthParams.scale * rgbToDepthParams.scaleX;
-    const finalNormY = v_fitted * rgbToDepthParams.scale * rgbToDepthParams.scaleY;
-    // Convert the final normalized coordinate back to a UV coordinate [0, 1]
+    const radial = 1 + params.k1 * r2 + params.k2 * r2 * r2 + params.k3 * r2 * r2 * r2;
+    const tanX = 2 * params.p1 * u_centered * v_centered +
+        params.p2 * (r2 + 2 * u_centered * u_centered);
+    const tanY = params.p1 * (r2 + 2 * v_centered * v_centered) +
+        2 * params.p2 * u_centered * v_centered;
+    const u_distorted = u_centered * radial + tanX + params.xc;
+    const v_distorted = v_centered * radial + tanY + params.yc;
+    // Apply initial aspect ratio scaling and translation.
+    const u_fitted = u_distorted * relativeScaleX + params.translateU;
+    const v_fitted = v_distorted * relativeScaleY + params.translateV;
+    // Apply the final user-controlled scaling (zoom and stretch).
+    const finalNormX = u_fitted * params.scale * params.scaleX;
+    const finalNormY = v_fitted * params.scale * params.scaleY;
+    // Convert the final normalized coordinate back to a UV coordinate [0, 1].
     const finalU = finalNormX + 0.5;
     const finalV = finalNormY + 0.5;
     return { u: finalU, v: 1.0 - finalV };
@@ -3665,12 +3672,13 @@ class XRDeviceCamera extends VideoStream {
     /**
      * @param options - The configuration options.
      */
-    constructor({ videoConstraints = { facingMode: 'environment' }, willCaptureFrequently = false, } = {}) {
+    constructor({ videoConstraints = { facingMode: 'environment' }, willCaptureFrequently = false, rgbToDepthParams = DEFAULT_RGB_TO_DEPTH_PARAMS, } = {}) {
         super({ willCaptureFrequently });
         this.isInitializing_ = false;
         this.availableDevices_ = [];
         this.currentDeviceIndex_ = -1;
         this.videoConstraints_ = { ...videoConstraints };
+        this.rgbToDepthParams = rgbToDepthParams;
     }
     /**
      * Retrieves the list of available video input devices.
@@ -3722,7 +3730,7 @@ class XRDeviceCamera extends VideoStream {
             return;
         this.isInitializing_ = true;
         this.setState_(StreamState.INITIALIZING);
-        // Reset state for the new stream
+        // Reset state for the new stream.
         this.currentTrackSettings_ = undefined;
         this.currentDeviceIndex_ = -1;
         try {
@@ -3756,7 +3764,7 @@ class XRDeviceCamera extends VideoStream {
             if (!videoTracks.length) {
                 throw new Error('MediaStream has no video tracks.');
             }
-            // After the stream is active, we can get the ID of the track
+            // After the stream is active, we can get the track ID.
             const activeTrack = videoTracks[0];
             this.currentTrackSettings_ = activeTrack.getSettings();
             console.debug('Active track settings:', this.currentTrackSettings_);
@@ -3766,10 +3774,10 @@ class XRDeviceCamera extends VideoStream {
             else {
                 console.warn('Stream started without deviceId as it was unavailable');
             }
-            this.stop_(); // Stop any previous stream before starting new one
+            this.stop_(); // Stop any previous stream before starting new one.
             this.stream_ = stream;
             this.video_.srcObject = stream;
-            this.video_.src = ''; // Required for some browsers to reset the src
+            this.video_.src = ''; // Required for some browsers to reset the src.
             await new Promise((resolve, reject) => {
                 this.video_.onloadedmetadata = () => {
                     this.handleVideoStreamLoadedMetadata(resolve, reject, true);
@@ -3781,7 +3789,7 @@ class XRDeviceCamera extends VideoStream {
                 };
                 this.video_.play();
             });
-            // Once the stream is loaded and dimensions are known, set the final state
+            // Once stream is loaded and dimensions are known, set the final state.
             const details = {
                 width: this.width,
                 height: this.height,
@@ -3803,7 +3811,7 @@ class XRDeviceCamera extends VideoStream {
     /**
      * Sets the active camera by its device ID. Removes potentially conflicting
      * constraints such as facingMode.
-     * @param deviceId - Device id.
+     * @param deviceId - Device ID
      */
     async setDeviceId(deviceId) {
         const newIndex = this.availableDevices_.findIndex((device) => device.deviceId === deviceId);
@@ -4402,13 +4410,19 @@ class WebXRSessionManager extends THREE.EventDispatcher {
 const XRBUTTON_WRAPPER_ID = 'XRButtonWrapper';
 const XRBUTTON_CLASS = 'XRButton';
 class XRButton {
-    constructor(sessionManager, startText = 'ENTER XR', endText = 'END XR', invalidText = 'XR NOT SUPPORTED', startSimulatorText = 'START SIMULATOR', showEnterSimulatorButton = false, startSimulator = () => { }) {
+    constructor(sessionManager, permissionsManager, startText = 'ENTER XR', endText = 'END XR', invalidText = 'XR NOT SUPPORTED', startSimulatorText = 'START SIMULATOR', showEnterSimulatorButton = false, startSimulator = () => { }, permissions = {
+        geolocation: false,
+        camera: false,
+        microphone: false,
+    }) {
         this.sessionManager = sessionManager;
+        this.permissionsManager = permissionsManager;
         this.startText = startText;
         this.endText = endText;
         this.invalidText = invalidText;
         this.startSimulatorText = startSimulatorText;
         this.startSimulator = startSimulator;
+        this.permissions = permissions;
         this.domElement = document.createElement('div');
         this.simulatorButtonElement = document.createElement('button');
         this.xrButtonElement = document.createElement('button');
@@ -4443,7 +4457,17 @@ class XRButton {
         button.innerHTML = this.startText;
         button.disabled = false;
         button.onclick = () => {
-            this.sessionManager.startSession();
+            this.permissionsManager
+                .checkAndRequestPermissions(this.permissions)
+                .then((result) => {
+                if (result.granted) {
+                    this.sessionManager.startSession();
+                }
+                else {
+                    this.xrButtonElement.textContent =
+                        'Error:' + result.error + '\nPlease try again.';
+                }
+            });
         };
     }
     showXRNotSupported() {
@@ -7172,6 +7196,7 @@ class SimulatorOptions {
     constructor(options) {
         this.initialCameraPosition = { x: 0, y: 1.5, z: 0 };
         this.scenePath = XR_BLOCKS_ASSETS_PATH + 'simulator/scenes/XREmulatorsceneV5_livingRoom.glb';
+        this.videoPath = undefined;
         this.initialScenePosition = { x: -1.6, y: 0.3, z: 0 };
         this.defaultMode = SimulatorMode.USER;
         this.defaultHand = Handedness.LEFT;
@@ -7188,7 +7213,10 @@ class SimulatorOptions {
             enabled: true,
             element: 'xrblocks-simulator-hand-pose-panel',
         };
-        this.geminilive = false;
+        this.geminiLivePanel = {
+            enabled: false,
+            element: 'xrblocks-simulator-geminilive',
+        };
         this.stereo = {
             enabled: false,
         };
@@ -7436,6 +7464,14 @@ class Options {
             // Whether to autostart the simulator even if WebXR is available.
             alwaysAutostartSimulator: false,
         };
+        /**
+         * Which permissions to request before entering the XR session.
+         */
+        this.permissions = {
+            geolocation: false,
+            camera: false,
+            microphone: false,
+        };
         deepMerge(this, options);
     }
     /**
@@ -7476,6 +7512,7 @@ class Options {
      * @returns The instance for chaining.
      */
     enableObjectDetection() {
+        this.permissions.camera = true;
         this.world.enableObjectDetection();
         return this;
     }
@@ -7486,6 +7523,7 @@ class Options {
      * @returns The instance for chaining.
      */
     enableCamera(facingMode = 'environment') {
+        this.permissions.camera = true;
         this.deviceCamera = new DeviceCameraOptions(facingMode === 'environment'
             ? xrDeviceCameraEnvironmentOptions
             : xrDeviceCameraUserOptions);
@@ -7516,14 +7554,6 @@ class Options {
         this.controllers.visualizeRays = true;
         return this;
     }
-    /**
-     * Enables the Gemini Live feature.
-     * @returns The instance for chaining.
-     */
-    enableGeminiLive() {
-        this.simulator.geminilive = true;
-        return this;
-    }
     /**
      * Enables a standard set of AI features, including Gemini Live.
      * @returns The instance for chaining.
@@ -9785,8 +9815,8 @@ class SimulatorInterface {
         }
     }
     showGeminiLivePanel(simulatorOptions) {
-        if (simulatorOptions.geminilive) {
-            const element = document.createElement('xrblocks-simulator-geminilive');
+        if (simulatorOptions.geminiLivePanel.enabled) {
+            const element = document.createElement(simulatorOptions.geminiLivePanel.element);
             document.body.appendChild(element);
             this.elements.push(element);
         }
@@ -9830,6 +9860,9 @@ class SimulatorScene extends THREE.Scene {
     }
     async init(simulatorOptions) {
         this.addLights();
+        if (simulatorOptions.videoPath) {
+            return;
+        }
         if (simulatorOptions.scenePath) {
             await this.loadGLTF(simulatorOptions.scenePath, new THREE.Vector3(simulatorOptions.initialScenePosition.x, simulatorOptions.initialScenePosition.y, simulatorOptions.initialScenePosition.z));
         }
@@ -9967,6 +10000,21 @@ class Simulator extends Script {
         if (this.options.stereo.enabled) {
             this.setupStereoCameras(camera);
         }
+        if (this.options.videoPath) {
+            this.videoElement = document.createElement('video');
+            this.videoElement.src = this.options.videoPath;
+            this.videoElement.loop = true;
+            this.videoElement.muted = true;
+            this.videoElement.play().catch((e) => {
+                console.error(`Simulator: Failed to play video at ${this.options.videoPath}`, e);
+            });
+            this.videoElement.addEventListener('error', () => {
+                console.error(`Simulator: Error loading video at ${this.options.videoPath}`, this.videoElement?.error);
+            });
+            const videoTexture = new THREE.VideoTexture(this.videoElement);
+            videoTexture.colorSpace = THREE.SRGBColorSpace;
+            this.backgroundVideoQuad = new FullScreenQuad(new THREE.MeshBasicMaterial({ map: videoTexture }));
+        }
         this.virtualSceneRenderTarget = new THREE.WebGLRenderTarget(renderer.domElement.width, renderer.domElement.height, { stencilBuffer: options.stencil });
         const virtualSceneMaterial = new THREE.MeshBasicMaterial({
             map: this.virtualSceneRenderTarget.texture,
@@ -10076,6 +10124,9 @@ class Simulator extends Script {
             this.sparkRenderer.defaultView.encodeLinear = false;
         }
         this.renderer.setRenderTarget(null);
+        if (this.backgroundVideoQuad) {
+            this.backgroundVideoQuad.render(this.renderer);
+        }
         this.renderer.render(this.simulatorScene, camera);
         this.renderer.clearDepth();
     }
@@ -11751,7 +11802,7 @@ class TextView extends View {
     }
     setTextColor(color) {
         if (Text && this.textObj instanceof Text) {
-            this.textObj.color = color;
+            this.textObj.color = getColorHex(color);
         }
     }
     /**
@@ -12141,7 +12192,7 @@ class TextButton extends TextView {
      */
     constructor(options = {}) {
         const geometry = new THREE.PlaneGeometry(1, 1);
-        const colorVec4 = getVec4ByColorString(options.backgroundColor ?? '#00000000');
+        const colorVec4 = getVec4ByColorString(options.backgroundColor ?? '#000000');
         const { opacity = 0.0, radius = SquircleShader.uniforms.uRadius.value, boxSize = SquircleShader.uniforms.uBoxSize.value, } = options;
         const uniforms = {
             ...SquircleShader.uniforms,
@@ -12191,6 +12242,9 @@ class TextButton extends TextView {
         // Applies our own overrides to the default values.
         this.fontSize = options.fontSize ?? this.fontSize;
         this.fontColor = options.fontColor ?? this.fontColor;
+        this.hoverColor = options.hoverColor ?? this.hoverColor;
+        this.selectedFontColor =
+            options.selectedFontColor ?? this.selectedFontColor;
         this.width = options.width ?? this.width;
         this.height = options.height ?? this.height;
     }
@@ -12213,20 +12267,19 @@ class TextButton extends TextView {
         if (!this.textObj) {
             return;
         }
-        if (this.textObj) {
-            this.textObj.renderOrder = this.renderOrder + 1;
-        }
+        // Update render order to ensure text appears on top of the button mesh
+        this.textObj.renderOrder = this.renderOrder + 1;
         const ux = this.ux;
         if (ux.isHovered()) {
             if (ux.isSelected()) {
-                this.setTextColor(0x666666);
+                this.setTextColor(this.selectedFontColor);
             }
             else {
-                this.setTextColor(0xaaaaaa);
+                this.setTextColor(this.hoverColor);
             }
         }
         else {
-            this.setTextColor(0xffffff);
+            this.setTextColor(this.fontColor);
             this.uniforms.uOpacity.value = this.defaultOpacity * this.opacity;
         }
     }
@@ -13842,6 +13895,7 @@ class ObjectDetector extends Script {
             }
             if (this.options.objects.showDebugVisualizations) {
                 this._visualizeBoundingBoxesOnImage(base64Image, parsedResponse);
+                this._visualizeDepthMap(cachedDepthArray);
             }
             const detectionPromises = parsedResponse.map(async (item) => {
                 const { ymin, xmin, ymax, xmax, objectName, ...additionalData } = item || {};
@@ -13890,7 +13944,7 @@ class ObjectDetector extends Script {
      * Retrieves a list of currently detected objects.
      *
      * @param label - The semantic label to filter by (e.g., 'chair'). If null,
-     *     all objects are returned.
+     * all objects are returned.
      * @returns An array of `Object` instances.
      */
     get(label = null) {
@@ -13927,8 +13981,7 @@ class ObjectDetector extends Script {
      * Draws the detected bounding boxes on the input image and triggers a
      * download for debugging.
      * @param base64Image - The base64 encoded input image.
-     * @param detections - The array of detected objects from the
-     * AI response.
+     * @param detections - The array of detected objects from the AI response.
      */
     _visualizeBoundingBoxesOnImage(base64Image, detections) {
         const img = new Image();
@@ -13977,6 +14030,71 @@ class ObjectDetector extends Script {
         };
         img.src = base64Image;
     }
+    /**
+     * Generates a visual representation of the depth map, normalized to 0-1 range,
+     * and triggers a download for debugging.
+     * @param depthArray - The raw depth data array.
+     */
+    _visualizeDepthMap(depthArray) {
+        const width = this.depth.width;
+        const height = this.depth.height;
+        if (!width || !height || depthArray.length === 0) {
+            console.warn('Cannot visualize depth map: missing dimensions or data.');
+            return;
+        }
+        // 1. Find Min/Max for normalization (ignoring 0/invalid depth).
+        let min = Infinity;
+        let max = -Infinity;
+        for (let i = 0; i < depthArray.length; ++i) {
+            const val = depthArray[i];
+            if (val > 0) {
+                if (val < min)
+                    min = val;
+                if (val > max)
+                    max = val;
+            }
+        }
+        // Handle edge case where no valid depth exists.
+        if (min === Infinity) {
+            min = 0;
+            max = 1;
+        }
+        if (min === max) {
+            max = min + 1; // Avoid divide by zero
+        }
+        // 2. Create Canvas.
+        const canvas = document.createElement('canvas');
+        canvas.width = width;
+        canvas.height = height;
+        const ctx = canvas.getContext('2d');
+        const imageData = ctx.createImageData(width, height);
+        const data = imageData.data;
+        // 3. Fill Pixels.
+        for (let i = 0; i < depthArray.length; ++i) {
+            const raw = depthArray[i];
+            // Normalize to 0-1.
+            // Typically 0 means invalid/sky in some depth APIs, so we keep it black.
+            // Otherwise, map [min, max] to [0, 1].
+            const normalized = raw === 0 ? 0 : (raw - min) / (max - min);
+            const byteVal = Math.floor(normalized * 255);
+            const stride = i * 4;
+            data[stride] = byteVal; // R
+            data[stride + 1] = byteVal; // G
+            data[stride + 2] = byteVal; // B
+            data[stride + 3] = 255; // Alpha
+        }
+        ctx.putImageData(imageData, 0, 0);
+        // 4. Download.
+        const timestamp = new Date()
+            .toISOString()
+            .slice(0, 19)
+            .replace('T', '_')
+            .replace(/:/g, '-');
+        const link = document.createElement('a');
+        link.download = `depth_debug_${timestamp}.png`;
+        link.href = canvas.toDataURL('image/png');
+        link.click();
+    }
     /**
      * Creates a simple debug visualization for an object based on its position
      * (center of its 2D detection bounding box).
@@ -14397,6 +14515,216 @@ class XRTransition extends MeshScript {
     }
 }
 
+/**
+ * A utility class to manage and request browser permissions for
+ * Location, Camera, and Microphone.
+ */
+class PermissionsManager {
+    /**
+     * Requests permission to access the user's geolocation.
+     * Note: This actually attempts to fetch the position to trigger the prompt.
+     */
+    async requestLocationPermission() {
+        if (!('geolocation' in navigator)) {
+            return {
+                granted: false,
+                status: 'error',
+                error: 'Geolocation is not supported by this browser.',
+            };
+        }
+        return new Promise((resolve) => {
+            navigator.geolocation.getCurrentPosition(() => {
+                resolve({ granted: true, status: 'granted' });
+            }, (error) => {
+                let errorMsg = 'Unknown error';
+                switch (error.code) {
+                    case error.PERMISSION_DENIED:
+                        errorMsg = 'User denied the request.';
+                        break;
+                    case error.POSITION_UNAVAILABLE:
+                        errorMsg = 'Location information is unavailable.';
+                        break;
+                    case error.TIMEOUT:
+                        errorMsg = 'The request to get user location timed out.';
+                        break;
+                }
+                resolve({ granted: false, status: 'denied', error: errorMsg });
+            }, { timeout: 10000 } // 10 second timeout
+            );
+        });
+    }
+    /**
+     * Requests permission to access the microphone.
+     * Opens a stream to trigger the prompt, then immediately closes it.
+     */
+    async requestMicrophonePermission() {
+        return this.requestMediaPermission({ audio: true });
+    }
+    /**
+     * Requests permission to access the camera.
+     * Opens a stream to trigger the prompt, then immediately closes it.
+     */
+    async requestCameraPermission() {
+        return this.requestMediaPermission({ video: true });
+    }
+    /**
+     * Requests permission for both camera and microphone simultaneously.
+     */
+    async requestAVPermission() {
+        return this.requestMediaPermission({ video: true, audio: true });
+    }
+    /**
+     * Internal helper to handle getUserMedia requests.
+     * Crucially, this stops the tracks immediately after permission is granted
+     * so the hardware doesn't remain active.
+     */
+    async requestMediaPermission(constraints) {
+        if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
+            return {
+                granted: false,
+                status: 'error',
+                error: 'Media Devices API is not supported by this browser.',
+            };
+        }
+        try {
+            const stream = await navigator.mediaDevices.getUserMedia(constraints);
+            // Permission granted. Now stop the stream to release hardware.
+            stream.getTracks().forEach((track) => track.stop());
+            return { granted: true, status: 'granted' };
+        }
+        catch (err) {
+            // Handle common getUserMedia errors
+            const status = 'denied';
+            let errorMessage = 'Permission denied';
+            if (err instanceof Error) {
+                if (err.name === 'NotFoundError' ||
+                    err.name === 'DevicesNotFoundError') {
+                    return {
+                        granted: false,
+                        status: 'error',
+                        error: 'Hardware not found.',
+                    };
+                }
+                errorMessage = err.message || errorMessage;
+            }
+            return { granted: false, status: status, error: errorMessage };
+        }
+    }
+    /**
+     * Requests multiple permissions sequentially.
+     * Returns a single result: granted is true only if ALL requested permissions are granted.
+     */
+    async checkAndRequestPermissions({ geolocation = false, camera = false, microphone = false, }) {
+        const results = [];
+        // 1. Handle Location
+        if (geolocation) {
+            const status = await this.checkPermissionStatus('geolocation');
+            if (status === 'granted') {
+                results.push({ granted: true, status: 'granted' });
+            }
+            else {
+                results.push(await this.requestLocationPermission());
+            }
+        }
+        // 2. Handle Media (Camera & Mic)
+        // We group these because requestAVPermission can ask for both in one prompt
+        if (camera && microphone) {
+            const camStatus = await this.checkPermissionStatus('camera');
+            const micStatus = await this.checkPermissionStatus('microphone');
+            if (camStatus === 'granted' && micStatus === 'granted') {
+                results.push({ granted: true, status: 'granted' });
+            }
+            else if (camStatus === 'granted') {
+                // Only need mic
+                results.push(await this.requestMicrophonePermission());
+            }
+            else if (micStatus === 'granted') {
+                // Only need camera
+                results.push(await this.requestCameraPermission());
+            }
+            else {
+                // Need both
+                results.push(await this.requestAVPermission());
+            }
+        }
+        else if (camera) {
+            const status = await this.checkPermissionStatus('camera');
+            if (status === 'granted') {
+                results.push({ granted: true, status: 'granted' });
+            }
+            else {
+                results.push(await this.requestCameraPermission());
+            }
+        }
+        else if (microphone) {
+            const status = await this.checkPermissionStatus('microphone');
+            if (status === 'granted') {
+                results.push({ granted: true, status: 'granted' });
+            }
+            else {
+                results.push(await this.requestMicrophonePermission());
+            }
+        }
+        // 3. Aggregate results
+        if (results.length === 0) {
+            return { granted: true, status: 'granted' };
+        }
+        const allGranted = results.every((r) => r.granted);
+        const anyDenied = results.find((r) => r.status === 'denied');
+        const anyError = results.find((r) => r.status === 'error');
+        // Aggregate errors
+        const errors = results
+            .filter((r) => r.error)
+            .map((r) => r.error)
+            .join(' | ');
+        let finalStatus = 'granted';
+        if (anyError)
+            finalStatus = 'error';
+        else if (anyDenied)
+            finalStatus = 'denied';
+        return {
+            granted: allGranted,
+            status: finalStatus,
+            error: errors || undefined,
+        };
+    }
+    /**
+     * 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'
+     */
+    async checkPermissionStatus(permissionName) {
+        if (!navigator.permissions || !navigator.permissions.query) {
+            return 'unknown';
+        }
+        try {
+            let queryName;
+            // Map friendly names to API PermissionName types
+            // Note: 'camera' and 'microphone' are part of the newer spec,
+            // but strictly Typed TypeScript might expect specific descriptor objects.
+            if (permissionName === 'geolocation') {
+                queryName = 'geolocation';
+            }
+            else if (permissionName === 'camera' ||
+                permissionName === 'microphone') {
+                const descriptor = { name: permissionName };
+                const result = await navigator.permissions.query(descriptor);
+                return result.state;
+            }
+            else {
+                return 'unknown';
+            }
+            const result = await navigator.permissions.query({ name: queryName });
+            return result.state;
+        }
+        catch (error) {
+            // Firefox and Safari have incomplete Permissions API support
+            console.warn(`Error checking permission status for ${permissionName}`, error);
+            return 'unknown';
+        }
+    }
+}
+
 /**
  * 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
@@ -14456,6 +14784,7 @@ class Core {
                 await script.initPhysics(this.physics);
             }
         });
+        this.permissionsManager = new PermissionsManager();
         if (Core.instance) {
             return Core.instance;
         }
@@ -14564,6 +14893,8 @@ class Core {
                 dataFormatPreference: [
                     this.options.depth.useFloat32 ? 'float32' : 'luminance-alpha',
                 ],
+                depthTypeRequest: options.depth.depthTypeRequest,
+                matchDepthView: options.depth.matchDepthView,
             };
             this.depth.init(this.camera, options.depth, this.renderer, this.registry, this.scene);
         }
@@ -14600,7 +14931,7 @@ class Core {
         // Sets up xrButton.
         let shouldAutostartSimulator = this.options.xrButton.alwaysAutostartSimulator;
         if (!shouldAutostartSimulator && options.xrButton.enabled) {
-            this.xrButton = new XRButton(this.webXRSessionManager, options.xrButton?.startText, options.xrButton?.endText, options.xrButton?.invalidText, options.xrButton?.startSimulatorText, options.xrButton?.showEnterSimulatorButton, this.startSimulator.bind(this));
+            this.xrButton = new XRButton(this.webXRSessionManager, this.permissionsManager, options.xrButton?.startText, options.xrButton?.endText, options.xrButton?.invalidText, options.xrButton?.startSimulatorText, options.xrButton?.showEnterSimulatorButton, this.startSimulator.bind(this), options.permissions);
             document.body.appendChild(this.xrButton.domElement);
         }
         this.webXRSessionManager.addEventListener(WebXRSessionEventType.UNSUPPORTED, () => {
@@ -16828,5 +17159,5 @@ class VideoFileStream extends VideoStream {
     }
 }
 
-export { AI, AIOptions, AVERAGE_IPD_METERS, ActiveControllers, Agent, AnimatableNumber, AudioListener, AudioPlayer, BACK, BackgroundMusic, CategoryVolumes, Col, Core, CoreSound, DEFAULT_DEVICE_CAMERA_HEIGHT, DEFAULT_DEVICE_CAMERA_WIDTH, DOWN, Depth, DepthMesh, DepthMeshOptions, DepthOptions, DepthTextures, DetectedObject, DetectedPlane, DeviceCameraOptions, DragManager, DragMode, ExitButton, FORWARD, FreestandingSlider, GazeController, Gemini, GeminiOptions, GenerateSkyboxTool, GestureRecognition, GestureRecognitionOptions, GetWeatherTool, Grid, HAND_BONE_IDX_CONNECTION_MAP, HAND_JOINT_COUNT, HAND_JOINT_IDX_CONNECTION_MAP, HAND_JOINT_NAMES, Handedness, Hands, HandsOptions, HorizontalPager, IconButton, IconView, ImageView, Input, InputOptions, Keycodes, LEFT, LEFT_VIEW_ONLY_LAYER, LabelView, Lighting, LightingOptions, LoadingSpinnerManager, MaterialSymbolsView, MeshScript, ModelLoader, ModelViewer, MouseController, NEXT_SIMULATOR_MODE, NUM_HANDS, OCCLUDABLE_ITEMS_LAYER, ObjectDetector, ObjectsOptions, OcclusionPass, OcclusionUtils, OpenAI, OpenAIOptions, Options, PageIndicator, Pager, PagerState, Panel, PanelMesh, Physics, PhysicsOptions, PinchOnButtonAction, PlaneDetector, PlanesOptions, RIGHT, RIGHT_VIEW_ONLY_LAYER, Registry, Reticle, ReticleOptions, RotationRaycastMesh, Row, SIMULATOR_HAND_POSE_NAMES, SIMULATOR_HAND_POSE_TO_JOINTS_LEFT, SIMULATOR_HAND_POSE_TO_JOINTS_RIGHT, SOUND_PRESETS, ScreenshotSynthesizer, Script, ScriptMixin, ScriptsManager, ScrollingTroikaTextView, SetSimulatorModeEvent, ShowHandsAction, Simulator, SimulatorCamera, SimulatorControlMode, SimulatorControllerState, SimulatorControls, SimulatorDepth, SimulatorDepthMaterial, SimulatorHandPose, SimulatorHandPoseChangeRequestEvent, SimulatorHands, SimulatorInterface, SimulatorMediaDeviceInfo, SimulatorMode, SimulatorOptions, SimulatorRenderMode, SimulatorScene, SimulatorUser, SimulatorUserAction, SketchPanel, SkyboxAgent, SoundOptions, SoundSynthesizer, SpatialAudio, SpatialPanel, SpeechRecognizer, SpeechRecognizerOptions, SpeechSynthesizer, SpeechSynthesizerOptions, SplatAnchor, StreamState, TextButton, TextScrollerState, TextView, Tool, UI, UI_OVERLAY_LAYER, UP, UX, User, VIEW_DEPTH_GAP, VerticalPager, VideoFileStream, VideoStream, VideoView, View, VolumeCategory, WaitFrame, WalkTowardsPanelAction, World, WorldOptions, XRButton, XRDeviceCamera, XREffects, XRPass, XRTransitionOptions, XR_BLOCKS_ASSETS_PATH, ZERO_VECTOR3, add, ai, aspectRatios, callInitWithDependencyInjection, clamp, clampRotationToAngle, core, cropImage, extractYaw, getColorHex, getDeltaTime, getUrlParamBool, getUrlParamFloat, getUrlParamInt, getUrlParameter, getVec4ByColorString, getXrCameraLeft, getXrCameraRight, init, initScript, lerp, loadStereoImageAsTextures, loadingSpinnerManager, lookAtRotation, objectIsDescendantOf, parseBase64DataURL, placeObjectAtIntersectionFacingTarget, print, rgbToDepthParams, scene, showOnlyInLeftEye, showOnlyInRightEye, showReticleOnDepthMesh, transformRgbToDepthUv, transformRgbUvToWorld, traverseUtil, uninitScript, urlParams, user, world, xrDepthMeshOptions, xrDepthMeshPhysicsOptions, xrDepthMeshVisualizationOptions, xrDeviceCameraEnvironmentContinuousOptions, xrDeviceCameraEnvironmentOptions, xrDeviceCameraUserContinuousOptions, xrDeviceCameraUserOptions };
+export { AI, AIOptions, AVERAGE_IPD_METERS, ActiveControllers, Agent, AnimatableNumber, AudioListener, AudioPlayer, BACK, BackgroundMusic, CategoryVolumes, Col, Core, CoreSound, DEFAULT_DEVICE_CAMERA_HEIGHT, DEFAULT_DEVICE_CAMERA_WIDTH, DEFAULT_RGB_TO_DEPTH_PARAMS, DOWN, Depth, DepthMesh, DepthMeshOptions, DepthOptions, DepthTextures, DetectedObject, DetectedPlane, DeviceCameraOptions, DragManager, DragMode, ExitButton, FORWARD, FreestandingSlider, GazeController, Gemini, GeminiOptions, GenerateSkyboxTool, GestureRecognition, GestureRecognitionOptions, GetWeatherTool, Grid, HAND_BONE_IDX_CONNECTION_MAP, HAND_JOINT_COUNT, HAND_JOINT_IDX_CONNECTION_MAP, HAND_JOINT_NAMES, Handedness, Hands, HandsOptions, HorizontalPager, IconButton, IconView, ImageView, Input, InputOptions, Keycodes, LEFT, LEFT_VIEW_ONLY_LAYER, LabelView, Lighting, LightingOptions, LoadingSpinnerManager, MaterialSymbolsView, MeshScript, ModelLoader, ModelViewer, MouseController, NEXT_SIMULATOR_MODE, NUM_HANDS, OCCLUDABLE_ITEMS_LAYER, ObjectDetector, ObjectsOptions, OcclusionPass, OcclusionUtils, OpenAI, OpenAIOptions, Options, PageIndicator, Pager, PagerState, Panel, PanelMesh, Physics, PhysicsOptions, PinchOnButtonAction, PlaneDetector, PlanesOptions, RIGHT, RIGHT_VIEW_ONLY_LAYER, Registry, Reticle, ReticleOptions, RotationRaycastMesh, Row, SIMULATOR_HAND_POSE_NAMES, SIMULATOR_HAND_POSE_TO_JOINTS_LEFT, SIMULATOR_HAND_POSE_TO_JOINTS_RIGHT, SOUND_PRESETS, ScreenshotSynthesizer, Script, ScriptMixin, ScriptsManager, ScrollingTroikaTextView, SetSimulatorModeEvent, ShowHandsAction, Simulator, SimulatorCamera, SimulatorControlMode, SimulatorControllerState, SimulatorControls, SimulatorDepth, SimulatorDepthMaterial, SimulatorHandPose, SimulatorHandPoseChangeRequestEvent, SimulatorHands, SimulatorInterface, SimulatorMediaDeviceInfo, SimulatorMode, SimulatorOptions, SimulatorRenderMode, SimulatorScene, SimulatorUser, SimulatorUserAction, SketchPanel, SkyboxAgent, SoundOptions, SoundSynthesizer, SpatialAudio, SpatialPanel, SpeechRecognizer, SpeechRecognizerOptions, SpeechSynthesizer, SpeechSynthesizerOptions, SplatAnchor, StreamState, TextButton, TextScrollerState, TextView, Tool, UI, UI_OVERLAY_LAYER, UP, UX, User, VIEW_DEPTH_GAP, VerticalPager, VideoFileStream, VideoStream, VideoView, View, VolumeCategory, WaitFrame, WalkTowardsPanelAction, World, WorldOptions, XRButton, XRDeviceCamera, XREffects, XRPass, XRTransitionOptions, XR_BLOCKS_ASSETS_PATH, ZERO_VECTOR3, add, ai, aspectRatios, callInitWithDependencyInjection, clamp, clampRotationToAngle, core, cropImage, extractYaw, getColorHex, getDeltaTime, getUrlParamBool, getUrlParamFloat, getUrlParamInt, getUrlParameter, getVec4ByColorString, getXrCameraLeft, getXrCameraRight, init, initScript, lerp, loadStereoImageAsTextures, loadingSpinnerManager, lookAtRotation, objectIsDescendantOf, parseBase64DataURL, placeObjectAtIntersectionFacingTarget, print, scene, showOnlyInLeftEye, showOnlyInRightEye, showReticleOnDepthMesh, transformRgbToDepthUv, transformRgbUvToWorld, traverseUtil, uninitScript, urlParams, user, world, xrDepthMeshOptions, xrDepthMeshPhysicsOptions, xrDepthMeshVisualizationOptions, xrDeviceCameraEnvironmentContinuousOptions, xrDeviceCameraEnvironmentOptions, xrDeviceCameraUserContinuousOptions, xrDeviceCameraUserOptions };
 //# sourceMappingURL=xrblocks.js.map