xrblocks 0.1.0 → 0.3.0

package/build/addons/utils/Palette.js

@@ -10,23 +10,11 @@ class XRPalette {
      */
     constructor() {
         this.fullGColors_ = [
-            0x174EA6,
-            0xA50E0E,
-            0xE37400,
-            0x0D652D,
-            0x4285F4,
-            0xEA4335,
-            0xFBBC04,
-            0x34A853,
-            0xD2E3FC,
-            0xFAD2CF,
-            0xFEEFC3,
-            0xCEEAD6,
-            0xF1F3F4,
-            0x9AA0A6,
+            0x174ea6, 0xa50e0e, 0xe37400, 0x0d652d, 0x4285f4, 0xea4335, 0xfbbc04,
+            0x34a853, 0xd2e3fc, 0xfad2cf, 0xfeefc3, 0xceead6, 0xf1f3f4, 0x9aa0a6,
             0x202124,
         ];
-        this.liteGColors_ = [0xEA4335, 0x4285F4, 0x34AB53, 0xFBBC04];
+        this.liteGColors_ = [0xea4335, 0x4285f4, 0x34ab53, 0xfbbc04];
         this.lastRandomColor_ = null;
         if (XRPalette.instance) {
             return XRPalette.instance;

package/build/addons/virtualkeyboard/Keyboard.js

@@ -88,12 +88,13 @@ class Keyboard extends xb.Script {
         this.onEnterPressed = null;
         this.onTextChanged = null;
         this.keyRows = [];
-        this.subspace =
-            new xb.SpatialPanel({ useDefaultPosition: false, showEdge: false });
+        this.subspace = new xb.SpatialPanel({
+            useDefaultPosition: false,
+            showEdge: false,
+        });
         this.subspace.isRoot = true;
         this.add(this.subspace);
-        this.mainPanel =
-            this.subspace.add(new xb.Panel({ backgroundColor: KEYBOARD_COLOR }));
+        this.mainPanel = this.subspace.add(new xb.Panel({ backgroundColor: KEYBOARD_COLOR }));
         this.mainGrid = new xb.Grid();
         this.mainPanel.add(this.mainGrid);
         this.mainGrid.addRow({ weight: ROW_TOP_PADDING });
@@ -135,16 +136,16 @@ class Keyboard extends xb.Script {
         if (textKeys.length === 0) {
             let currentColumnWeight = 0;
             row.addCol({ weight: 0.145 });
-            specialKeys.forEach(key => {
+            specialKeys.forEach((key) => {
                 currentColumnWeight += key.weight || COLUMN_WEIGHT;
             });
             const missingWeight = TARGET_COLUMN_WEIGHT - currentColumnWeight;
             if (missingWeight > 1) {
-                const leftKeys = specialKeys.filter(key => key.position === 'left');
-                const rightKeys = specialKeys.filter(key => key.position === 'right');
-                const weightForLeftKeys = (missingWeight / 3) / (leftKeys.length || 1);
-                const weightForRightKeys = (missingWeight * 2 / 3) / (rightKeys.length || 1);
-                specialKeys.forEach(key => {
+                const leftKeys = specialKeys.filter((key) => key.position === 'left');
+                const rightKeys = specialKeys.filter((key) => key.position === 'right');
+                const weightForLeftKeys = missingWeight / 3 / (leftKeys.length || 1);
+                const weightForRightKeys = (missingWeight * 2) / 3 / (rightKeys.length || 1);
+                specialKeys.forEach((key) => {
                     let finalWeight = key.weight || COLUMN_WEIGHT;
                     if (key.position === 'left') {
                         finalWeight += weightForLeftKeys;
@@ -156,14 +157,14 @@ class Keyboard extends xb.Script {
                 });
             }
             else {
-                specialKeys.forEach(key => this.createSpecialButtons(row, key));
+                specialKeys.forEach((key) => this.createSpecialButtons(row, key));
             }
             return;
         }
-        const leftSpecialKeys = specialKeys.filter(key => key.position === 'left');
-        const rightSpecialKeys = specialKeys.filter(key => key.position === 'right');
+        const leftSpecialKeys = specialKeys.filter((key) => key.position === 'left');
+        const rightSpecialKeys = specialKeys.filter((key) => key.position === 'right');
         let remainingWeight = TARGET_COLUMN_WEIGHT;
-        leftSpecialKeys.forEach(key => {
+        leftSpecialKeys.forEach((key) => {
             this.createSpecialButtons(row, key);
             remainingWeight -= key.weight;
         });
@@ -172,7 +173,7 @@ class Keyboard extends xb.Script {
             this.createTextButtons(row, key, shiftKey);
             remainingWeight -= COLUMN_WEIGHT;
         });
-        rightSpecialKeys.forEach(key => {
+        rightSpecialKeys.forEach((key) => {
             const finalWeight = (key.weight || COLUMN_WEIGHT) + remainingWeight;
             this.createSpecialButtons(row, { ...key, weight: finalWeight });
         });
@@ -186,7 +187,7 @@ class Keyboard extends xb.Script {
             fontSize: FONT_SIZE,
             backgroundColor: DEFAULT_KEY_COLOR,
             originalKey: key,
-            shiftKey: shiftKey
+            shiftKey: shiftKey,
         });
         keyPanel.add(textButton);
         this.textButtons.push(textButton);
@@ -248,17 +249,19 @@ class Keyboard extends xb.Script {
         }
     }
     refreshKeyboard() {
-        this.textButtons.forEach(button => {
+        this.textButtons.forEach((button) => {
             const isLetter = button.originalKey.length === 1 && button.originalKey.match(/[a-z]/i);
             let newText;
             const produceUpper = this.isShifted !== this.isCapsLockOn;
             if (isLetter) {
-                newText = produceUpper ? button.originalKey.toUpperCase() :
-                    button.originalKey.toLowerCase();
+                newText = produceUpper
+                    ? button.originalKey.toUpperCase()
+                    : button.originalKey.toLowerCase();
             }
             else {
-                newText = this.isShifted ? (button.shiftKey || button.originalKey) :
-                    button.originalKey;
+                newText = this.isShifted
+                    ? button.shiftKey || button.originalKey
+                    : button.originalKey;
             }
             button.setText(newText);
         });

package/build/addons/volumes/VolumetricCloud.glsl.js

@@ -120,7 +120,7 @@ void main(){
   if ( color.a == 0.0 ) discard;
 
 }
-`
+`,
 };
 
 export { VolumetricCloudShader };

package/build/addons/volumes/VolumetricCloud.js

@@ -43,15 +43,18 @@ class VolumetricCloud extends THREE.Object3D {
                 for (let x = 0; x < this.size; x++) {
                     // Calculates the density based on the distance from the center.
                     const d = 1.0 -
-                        vector.set(x, y, z)
+                        vector
+                            .set(x, y, z)
                             .subScalar(this.size / 2)
                             .divideScalar(this.size)
                             .length();
                     // Populates the data array with density influenced by noise.
-                    data[i] = (this.size +
-                        this.size *
-                            perlin.noise(x * this.cloudScale / 1.5, y * this.cloudScale, z * this.cloudScale / 1.5)) *
-                        d * d;
+                    data[i] =
+                        (this.size +
+                            this.size *
+                                perlin.noise((x * this.cloudScale) / 1.5, y * this.cloudScale, (z * this.cloudScale) / 1.5)) *
+                            d *
+                            d;
                     i++;
                 }
             }

package/build/agent/Agent.d.ts

@@ -2,6 +2,19 @@ import { AI } from '../ai/AI';
 import { Context } from './Context';
 import { Memory } from './Memory';
 import { Tool } from './Tool';
+/**
+ * Lifecycle callbacks for agent events.
+ */
+export interface AgentLifecycleCallbacks {
+    /** Called when a session starts */
+    onSessionStart?: () => void | Promise<void>;
+    /** Called when a session ends */
+    onSessionEnd?: () => void | Promise<void>;
+    /** Called after a tool is executed */
+    onToolExecuted?: (toolName: string, result: unknown) => void;
+    /** Called when an error occurs */
+    onError?: (error: Error) => void;
+}
 /**
  * An agent that can use an AI to reason and execute tools.
  */
@@ -11,7 +24,9 @@ export declare class Agent {
     tools: Tool[];
     memory: Memory;
     contextBuilder: Context;
-    constructor(ai: AI, tools?: Tool[], instruction?: string);
+    lifecycleCallbacks?: AgentLifecycleCallbacks;
+    isSessionActive: boolean;
+    constructor(ai: AI, tools?: Tool[], instruction?: string, callbacks?: AgentLifecycleCallbacks);
     /**
      * Starts the agent's reasoning loop with an initial prompt.
      * @param prompt - The initial prompt from the user.
@@ -25,4 +40,13 @@ export declare class Agent {
      */
     private run;
     findTool(name: string): Tool | undefined;
+    /**
+     * Get the current session state.
+     * @returns Object containing session information
+     */
+    getSessionState(): {
+        isActive: boolean;
+        toolCount: number;
+        memorySize: number;
+    };
 }

package/build/agent/SkyboxAgent.d.ts

@@ -2,11 +2,127 @@ import type * as GoogleGenAITypes from '@google/genai';
 import * as THREE from 'three';
 import { AI } from '../ai/AI';
 import { CoreSound } from '../sound/CoreSound';
-import { Agent } from './Agent';
+import { Agent, AgentLifecycleCallbacks } from './Agent';
+import { ToolResult } from './Tool';
+/**
+ * State information for a live session.
+ */
+export interface LiveSessionState {
+    /** Whether the session is currently active */
+    isActive: boolean;
+    /** Timestamp when session started */
+    startTime?: number;
+    /** Timestamp when session ended */
+    endTime?: number;
+    /** Number of messages received */
+    messageCount: number;
+    /** Number of tool calls executed */
+    toolCallCount: number;
+    /** Last error message if any */
+    lastError?: string;
+}
+/**
+ * Skybox Agent for generating 360-degree equirectangular backgrounds through conversation.
+ *
+ * @example Basic usage
+ * ```typescript
+ * // 1. Enable audio (required for live sessions)
+ * await xb.core.sound.enableAudio();
+ *
+ * // 2. Create agent
+ * const agent = new xb.SkyboxAgent(xb.core.ai, xb.core.sound, xb.core.scene);
+ *
+ * // 3. Start session
+ * await agent.startLiveSession({
+ *   onopen: () => console.log('Session ready'),
+ *   onmessage: (msg) => handleMessage(msg),
+ *   onclose: () => console.log('Session closed')
+ * });
+ *
+ * // 4. Clean up when done
+ * await agent.stopLiveSession();
+ * xb.core.sound.disableAudio();
+ * ```
+ *
+ * @example With lifecycle callbacks
+ * ```typescript
+ * const agent = new xb.SkyboxAgent(
+ *   xb.core.ai,
+ *   xb.core.sound,
+ *   xb.core.scene,
+ *   {
+ *     onSessionStart: () => updateUI('active'),
+ *     onSessionEnd: () => updateUI('inactive'),
+ *     onError: (error) => showError(error)
+ *   }
+ * );
+ * ```
+ *
+ * @remarks
+ * - Audio must be enabled BEFORE starting live session using `xb.core.sound.enableAudio()`
+ * - Users are responsible for managing audio lifecycle
+ * - Always call `stopLiveSession()` before disabling audio
+ * - Session state can be checked using `getSessionState()` and `getLiveSessionState()`
+ */
 export declare class SkyboxAgent extends Agent {
     private sound;
-    constructor(ai: AI, sound: CoreSound, scene: THREE.Scene);
-    startLiveSession(callbacks: GoogleGenAITypes.LiveCallbacks): Promise<void>;
+    private sessionState;
+    constructor(ai: AI, sound: CoreSound, scene: THREE.Scene, callbacks?: AgentLifecycleCallbacks);
+    /**
+     * Starts a live AI session for real-time conversation.
+     *
+     * @param callbacks - Optional callbacks for session events. Can also be set using ai.setLiveCallbacks()
+     * @throws If AI model is not initialized or live session is not available
+     *
+     * @remarks
+     * Audio must be enabled separately using `xb.core.sound.enableAudio()` before starting the session.
+     * This gives users control over when microphone permissions are requested.
+     */
+    startLiveSession(callbacks?: GoogleGenAITypes.LiveCallbacks): Promise<void>;
+    /**
+     * Stops the live AI session.
+     *
+     * @remarks
+     * Audio must be disabled separately using `xb.core.sound.disableAudio()` after stopping the session.
+     */
     stopLiveSession(): Promise<void>;
+    /**
+     * Wraps user callbacks to track session state and trigger lifecycle events.
+     * @param callbacks - The callbacks to wrap.
+     * @returns The wrapped callbacks.
+     */
+    private wrapCallbacks;
+    /**
+     * Sends tool execution results back to the AI.
+     *
+     * @param response - The tool response containing function results
+     */
     sendToolResponse(response: GoogleGenAITypes.LiveSendToolResponseParameters): Promise<void>;
+    /**
+     * Validates that a tool response has the correct format.
+     * @param response - The tool response to validate.
+     * @returns True if the response is valid, false otherwise.
+     */
+    private validateToolResponse;
+    /**
+     * Helper to create a properly formatted tool response from a ToolResult.
+     *
+     * @param id - The function call ID
+     * @param name - The function name
+     * @param result - The ToolResult from tool execution
+     * @returns A properly formatted FunctionResponse
+     */
+    static createToolResponse(id: string, name: string, result: ToolResult): GoogleGenAITypes.FunctionResponse;
+    /**
+     * Gets the current live session state.
+     *
+     * @returns Read-only session state information
+     */
+    getLiveSessionState(): Readonly<LiveSessionState>;
+    /**
+     * Gets the duration of the session in milliseconds.
+     *
+     * @returns Duration in ms, or null if session hasn't started
+     */
+    getSessionDuration(): number | null;
 }

package/build/agent/Tool.d.ts

@@ -1,8 +1,22 @@
-import type * as GoogleGenAITypes from '@google/genai';
+import * as GoogleGenAITypes from '@google/genai';
 export interface ToolCall {
     name: string;
     args: unknown;
 }
+/**
+ * Standardized result type for tool execution.
+ * @typeParam T - The type of data returned on success.
+ */
+export interface ToolResult<T = unknown> {
+    /** Whether the tool execution succeeded */
+    success: boolean;
+    /** The result data if successful */
+    data?: T;
+    /** Error message if execution failed */
+    error?: string;
+    /** Additional metadata about the execution */
+    metadata?: Record<string, unknown>;
+}
 export type ToolSchema = Omit<GoogleGenAITypes.Schema, 'type' | 'properties'> & {
     properties?: Record<string, ToolSchema>;
     type?: keyof typeof GoogleGenAITypes.Type;
@@ -15,7 +29,8 @@ export type ToolOptions = {
     /** The parameters of the tool */
     parameters?: ToolSchema;
     /** A callback to execute when the tool is triggered */
-    onTriggered?: (args: unknown) => unknown;
+    onTriggered?: (args: unknown) => unknown | Promise<unknown>;
+    behavior?: 'BLOCKING' | 'NON_BLOCKING' | GoogleGenAITypes.Behavior;
 };
 /**
  * A base class for tools that the agent can use.
@@ -25,16 +40,17 @@ export declare class Tool {
     description?: string;
     parameters?: ToolSchema;
     onTriggered?: (args: unknown) => unknown;
+    behavior?: 'BLOCKING' | 'NON_BLOCKING';
     /**
      * @param options - The options for the tool.
      */
     constructor(options: ToolOptions);
     /**
-     * Executes the tool's action.
+     * Executes the tool's action with standardized error handling.
      * @param args - The arguments for the tool.
-     * @returns The result of the tool's action.
+     * @returns A promise that resolves with a ToolResult containing success/error information.
      */
-    execute(args: unknown): unknown;
+    execute(args: unknown): Promise<ToolResult>;
     /**
      * Returns a JSON representation of the tool.
      * @returns A valid FunctionDeclaration object.

package/build/agent/index.d.ts

@@ -1,4 +1,5 @@
 export * from './Agent';
 export * from './Memory';
+export * from './SkyboxAgent';
 export * from './Tool';
 export * from './tools/index';

package/build/agent/tools/GenerateSkyboxTool.d.ts

@@ -1,6 +1,6 @@
 import * as THREE from 'three';
 import { AI } from '../../ai/AI';
-import { Tool } from '../Tool';
+import { Tool, ToolResult } from '../Tool';
 /**
  * A tool that generates a 360-degree equirectangular skybox image
  * based on a given prompt using an AI service.
@@ -12,9 +12,9 @@ export declare class GenerateSkyboxTool extends Tool {
     /**
      * Executes the tool's action.
      * @param args - The prompt to use to generate the skybox.
-     * @returns A promise that resolves with the result of the skybox generation.
+     * @returns A promise that resolves with a ToolResult containing success/error information.
      */
     execute(args: {
         prompt: string;
-    }): Promise<string>;
+    }): Promise<ToolResult<string>>;
 }

package/build/agent/tools/GetWeatherTool.d.ts

@@ -1,13 +1,12 @@
-import { Tool } from '../Tool';
+import { Tool, ToolResult } from '../Tool';
 export interface GetWeatherArgs {
     latitude: number;
     longitude: number;
 }
-export type GetWeatherToolResults = {
-    error?: string;
-    temperature?: number;
-    weathercode?: number;
-};
+export interface WeatherData {
+    temperature: number;
+    weathercode: number;
+}
 /**
  * A tool that gets the current weather for a specific location.
  */
@@ -16,7 +15,7 @@ export declare class GetWeatherTool extends Tool {
     /**
      * Executes the tool's action.
      * @param args - The arguments for the tool.
-     * @returns A promise that resolves with the weather information.
+     * @returns A promise that resolves with a ToolResult containing weather information.
      */
-    execute(args: GetWeatherArgs): Promise<GetWeatherToolResults>;
+    execute(args: GetWeatherArgs): Promise<ToolResult<WeatherData>>;
 }

package/build/ai/AI.d.ts

@@ -60,7 +60,7 @@ export declare class AI extends Script {
     query(input: {
         prompt: string;
     }, tools?: never[]): Promise<GeminiResponse | string | null>;
-    startLiveSession(config?: {}): Promise<GoogleGenAITypes.Session>;
+    startLiveSession(config?: GoogleGenAITypes.LiveConnectConfig, model?: string): Promise<GoogleGenAITypes.Session>;
     stopLiveSession(): Promise<void>;
     setLiveCallbacks(callbacks: GoogleGenAITypes.LiveCallbacks): Promise<void>;
     sendToolResponse(response: GoogleGenAITypes.LiveSendToolResponseParameters): void;

package/build/ai/Gemini.d.ts

@@ -25,10 +25,7 @@ export declare class Gemini extends BaseAIModel {
     init(): Promise<void>;
     isAvailable(): boolean;
     isLiveAvailable(): false | typeof GoogleGenAITypes.Modality | undefined;
-    startLiveSession(params?: {
-        tools?: GoogleGenAITypes.FunctionDeclaration[];
-        systemInstruction?: GoogleGenAITypes.ContentUnion | string;
-    }): Promise<GoogleGenAITypes.Session>;
+    startLiveSession(params?: GoogleGenAITypes.LiveConnectConfig, model?: string): Promise<GoogleGenAITypes.Session>;
     stopLiveSession(): Promise<void>;
     setLiveCallbacks(callbacks: GoogleGenAITypes.LiveCallbacks): void;
     sendToolResponse(response: GoogleGenAITypes.LiveSendToolResponseParameters): void;

package/build/camera/XRDeviceCamera.d.ts

@@ -23,7 +23,7 @@ export declare class XRDeviceCamera extends VideoStream<XRDeviceCameraDetails> {
     /**
      * @param options - The configuration options.
      */
-    constructor({ videoConstraints, willCaptureFrequently }?: Partial<DeviceCameraOptions>);
+    constructor({ videoConstraints, willCaptureFrequently, }?: Partial<DeviceCameraOptions>);
     /**
      * Retrieves the list of available video input devices.
      * @returns A promise that resolves with an

package/build/core/Core.d.ts

@@ -2,6 +2,7 @@ import * as THREE from 'three';
 import { AI } from '../ai/AI';
 import { XRDeviceCamera } from '../camera/XRDeviceCamera';
 import { Depth } from '../depth/Depth';
+import { GestureRecognition } from '../input/gestures/GestureRecognition';
 import { Input } from '../input/Input';
 import { Lighting } from '../lighting/Lighting';
 import { Physics } from '../physics/Physics';
@@ -49,13 +50,14 @@ export declare class Core {
     /** The main camera for rendering. */
     camera: THREE.PerspectiveCamera;
     /** The root scene graph for all objects. */
-    scene: THREE.Scene;
+    scene: THREE.Scene<THREE.Object3DEventMap>;
     /** Represents the user in the XR scene. */
     user: User;
     /** Manages all UI elements. */
     ui: UI;
     /** Manages all (spatial) audio playback. */
     sound: CoreSound;
+    private renderSceneBound;
     /** Manages the desktop XR simulator. */
     simulator: Simulator;
     /** Manages drag-and-drop interactions. */
@@ -76,6 +78,7 @@ export declare class Core {
     xrButton?: XRButton;
     effects?: XREffects;
     ai: AI;
+    gestureRecognition?: GestureRecognition;
     transition?: XRTransition;
     currentFrame?: XRFrame;
     scriptsManager: ScriptsManager;

package/build/core/Options.d.ts

@@ -2,6 +2,7 @@ import { AIOptions } from '../ai/AIOptions';
 import { DeviceCameraOptions } from '../camera/CameraOptions.js';
 import { DepthOptions } from '../depth/DepthOptions.js';
 import { HandsOptions } from '../input/HandsOptions.js';
+import { GestureRecognitionOptions } from '../input/gestures/GestureRecognitionOptions.js';
 import { LightingOptions } from '../lighting/LightingOptions.js';
 import { PhysicsOptions } from '../physics/PhysicsOptions';
 import { SimulatorOptions } from '../simulator/SimulatorOptions';
@@ -63,11 +64,22 @@ export declare class Options {
      * Whether to request a stencil buffer.
      */
     stencil: boolean;
+    /**
+     * Canvas element to use for rendering.
+     * If not defined, a new element will be added to document body.
+     */
+    canvas?: HTMLCanvasElement;
+    /**
+     * Any additional required features when initializing webxr.
+     */
+    webxrRequiredFeatures: string[];
+    referenceSpaceType: XRReferenceSpaceType;
     controllers: InputOptions;
     depth: DepthOptions;
     lighting: LightingOptions;
     deviceCamera: DeviceCameraOptions;
     hands: HandsOptions;
+    gestures: GestureRecognitionOptions;
     reticles: ReticleOptions;
     sound: SoundOptions;
     ai: AIOptions;
@@ -140,6 +152,11 @@ export declare class Options {
      * @returns The instance for chaining.
      */
     enableHands(): this;
+    /**
+     * Enables the gesture recognition block and ensures hands are available.
+     * @returns The instance for chaining.
+     */
+    enableGestures(): this;
     /**
      * Enables the visualization of rays for hand tracking.
      * @returns The instance for chaining.

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

@@ -4,11 +4,13 @@ export declare class ScreenshotSynthesizer {
     private pendingScreenshotRequests;
     private virtualCanvas?;
     private virtualBuffer;
+    private virtualRenderTarget?;
     private virtualRealCanvas?;
     private virtualRealBuffer;
-    private realVirtualRenderTarget?;
+    private virtualRealRenderTarget?;
     private fullScreenQuad?;
-    onAfterRender(renderer: THREE.WebGLRenderer, deviceCamera?: XRDeviceCamera): Promise<void>;
+    private renderTargetWidth;
+    onAfterRender(renderer: THREE.WebGLRenderer, renderSceneFn: () => void, deviceCamera?: XRDeviceCamera): Promise<void>;
     private createVirtualImageDataURL;
     private resolveVirtualOnlyRequests;
     private createVirtualRealImageDataURL;
@@ -18,7 +20,7 @@ export declare class ScreenshotSynthesizer {
      * Requests a screenshot from the scene as a DataURL.
      * @param overlayOnCamera - If true, overlays the image on a camera image
      *     without any projection or aspect ratio correction.
-     * @returns Promise which returns the screenshot.
+     * @returns Promise which returns the screenshot as a data uri.
      */
-    getScreenshot(overlayOnCamera?: boolean): Promise<unknown>;
+    getScreenshot(overlayOnCamera?: boolean): Promise<string>;
 }

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

@@ -35,7 +35,7 @@ export declare class XRTransition extends MeshScript<THREE.SphereGeometry, THREE
     private targetAlpha;
     private defaultBackgroundColor;
     constructor();
-    init({ renderer, camera, timer, scene, options }: {
+    init({ renderer, camera, timer, scene, options, }: {
         renderer: THREE.WebGLRenderer;
         camera: THREE.Camera;
         timer: THREE.Timer;

package/build/depth/Depth.d.ts

@@ -12,7 +12,8 @@ export declare class Depth {
     private projectionMatrixInverse;
     private xrRefSpace?;
     view: XRView[];
-    depthData: XRCPUDepthInformation[];
+    cpuDepthData: XRCPUDepthInformation[];
+    gpuDepthData: XRWebGLDepthInformation[];
     depthArray: DepthArray[];
     depthMesh?: DepthMesh;
     private depthTextures?;
@@ -53,8 +54,9 @@ export declare class Depth {
      * @returns Vertex at (u, v)
      */
     getVertex(u: number, v: number): THREE.Vector3 | null;
-    updateDepthData(depthData: XRCPUDepthInformation, view_id?: number): void;
-    getTexture(view_id: number): THREE.DataTexture | undefined;
+    updateCPUDepthData(depthData: XRCPUDepthInformation, view_id?: number): void;
+    updateGPUDepthData(depthData: XRWebGLDepthInformation, view_id?: number): void;
+    getTexture(view_id: number): THREE.DataTexture | THREE.ExternalTexture | undefined;
     update(frame: XRFrame): void;
     updateLocalDepth(frame: XRFrame): void;
     renderOcclusionPass(): void;

package/build/depth/DepthMesh.d.ts

@@ -30,6 +30,11 @@ export declare class DepthMesh extends MeshScript {
     private lastColliderUpdateTime;
     private options;
     private depthTextureMaterialUniforms?;
+    private depthTarget;
+    private depthTexture;
+    private depthScene;
+    private depthCamera;
+    private gpuPixels;
     private RAPIER?;
     private blendedWorld?;
     private rigidBody?;
@@ -38,7 +43,7 @@ export declare class DepthMesh extends MeshScript {
     /**
      * Initialize the depth mesh.
      */
-    init({ camera, renderer }: {
+    init({ camera, renderer, }: {
         camera: THREE.Camera;
         renderer: THREE.WebGLRenderer;
     }): void;
@@ -47,6 +52,8 @@ export declare class DepthMesh extends MeshScript {
      * and depth data.
      */
     updateDepth(depthData: XRCPUDepthInformation): void;
+    updateGPUDepth(depthData: XRWebGLDepthInformation): void;
+    convertGPUToGPU(depthData: XRWebGLDepthInformation): XRCPUDepthInformation;
     /**
      * Method to manually update the full resolution geometry.
      * Only needed if options.updateFullResolutionGeometry is false.