@directivegames/genesys.js 3.1.24

package/dist/src/xr/actor-components/CanvasUIComponent.d.ts

@@ -0,0 +1,61 @@
+import * as THREE from 'three';
+import { Delegate } from '../../utils/Delegate.js';
+import { CanvasUI } from '../ui/CanvasUI.js';
+import { VRBaseComponent } from './VRBaseComponent.js';
+import type { VRBaseComponentOptions } from './VRBaseComponent.js';
+import type { EditorClassMeta } from '../../utils/EditorClassMeta.js';
+import type { CanvasUIConfig, CanvasUIContent } from '../ui/CanvasUI.js';
+export interface CanvasUIComponentOptions extends VRBaseComponentOptions {
+    /** Panel size in world units */
+    panelSize?: {
+        width: number;
+        height: number;
+    };
+    /** Canvas resolution */
+    canvasSize?: {
+        width: number;
+        height: number;
+    };
+    /** Panel opacity */
+    opacity?: number;
+    /** UI content configuration */
+    content?: CanvasUIContent;
+    /** UI element configuration */
+    uiConfig?: CanvasUIConfig;
+    /** Auto-attach to VR controllers */
+    enableVRInteraction?: boolean;
+    /** Auto-position relative to VR headset */
+    enableHeadTracking?: boolean;
+    /** Position offset from head when head tracking is enabled */
+    headTrackingOffset?: THREE.Vector3;
+    /** Rotation offset from head when head tracking is enabled */
+    headTrackingRotation?: THREE.Euler;
+    /** Whether this panel blocks interactions with panels behind it (default true) */
+    blockInteractionsBehind?: boolean;
+    /** Enable debug cube visualization for head tracking */
+    enableDebugCubes?: boolean;
+}
+export declare class CanvasUIComponent extends VRBaseComponent<CanvasUIComponentOptions> {
+    static readonly EDITOR_CLASS_META: EditorClassMeta;
+    static get DEFAULT_OPTIONS(): CanvasUIComponentOptions;
+    readonly onElementSelect: Delegate<[string], void>;
+    readonly onElementChange: Delegate<[string, unknown], void>;
+    private canvasUI;
+    private isInitialized;
+    private attachedCamera;
+    private attachmentFailed;
+    private debugCube;
+    constructor(options?: CanvasUIComponentOptions);
+    beginPlay(): void;
+    endPlay(): void;
+    tickPostPhysics(deltaTime: number): void;
+    getObject3D(): THREE.Object3D | null;
+    private initializeCanvasUI;
+    private setupElementCallbacks;
+    updateElement(elementName: string, content: string): void;
+    updateConfig(elementName: string, property: string, value: unknown): void;
+    getCanvasUI(): CanvasUI | null;
+    private attachToCamera;
+    private updateHeadTrackedPosition;
+    private detachFromCamera;
+}

package/dist/src/xr/actor-components/CanvasUIComponent.js

@@ -0,0 +1,418 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import * as THREE from 'three';
+import { EngineClass } from '../../systems/ClassRegistry.js';
+import { Delegate } from '../../utils/Delegate.js';
+import { CanvasUI } from '../ui/CanvasUI.js';
+import { VRBaseComponent } from './VRBaseComponent.js';
+let CanvasUIComponent = class CanvasUIComponent extends VRBaseComponent {
+    static get DEFAULT_OPTIONS() {
+        return {
+            ...super.DEFAULT_OPTIONS,
+            panelSize: { width: 1, height: 1 },
+            canvasSize: { width: 512, height: 512 },
+            opacity: 1.0,
+            enableVRInteraction: true,
+            enableHeadTracking: false,
+            blockInteractionsBehind: true,
+            enableDebugCubes: false,
+            headTrackingOffset: new THREE.Vector3(0, -0.2, -0.5),
+            headTrackingRotation: new THREE.Euler(0, 0, 0),
+            content: {},
+            uiConfig: {
+                body: {
+                    fontFamily: 'Arial',
+                    fontSize: 14,
+                    backgroundColor: '#0f0f23',
+                    fontColor: '#f8fafc',
+                    borderRadius: 10,
+                    textAlign: 'center'
+                }
+            }
+        };
+    }
+    constructor(options = {}) {
+        super(options);
+        Object.defineProperty(this, "onElementSelect", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "onElementChange", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "canvasUI", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "isInitialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "attachedCamera", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "attachmentFailed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "debugCube", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    beginPlay() {
+        super.beginPlay();
+        if (DEBUG)
+            console.log('🎨 CanvasUIComponent: Beginning play, initializing CanvasUI...');
+        this.initializeCanvasUI();
+    }
+    endPlay() {
+        if (this.canvasUI) {
+            // Clean up CanvasUI resources and remove event listeners
+            try {
+                // Remove controller event listeners to prevent handedness errors
+                const canvasUI = this.canvasUI;
+                if (canvasUI.controller) {
+                    canvasUI.controller.removeEventListener('select', canvasUI.onSelect);
+                    canvasUI.controller.removeEventListener('selectstart', canvasUI.onSelectStart);
+                    canvasUI.controller.removeEventListener('selectend', canvasUI.onSelectEnd);
+                }
+                if (canvasUI.controller1) {
+                    canvasUI.controller1.removeEventListener('select', canvasUI.onSelect);
+                    canvasUI.controller1.removeEventListener('selectstart', canvasUI.onSelectStart);
+                    canvasUI.controller1.removeEventListener('selectend', canvasUI.onSelectEnd);
+                }
+            }
+            catch (error) {
+                // Ignore cleanup errors during VR session end
+            }
+            // Detach from camera if attached
+            this.detachFromCamera();
+            // Remove mesh from parent before disposing
+            if (this.canvasUI.mesh.parent) {
+                this.canvasUI.mesh.parent.remove(this.canvasUI.mesh);
+            }
+            // Use the proper dispose method
+            this.canvasUI.dispose();
+        }
+        // Clean up debug cube
+        if (this.debugCube) {
+            if (this.debugCube.parent) {
+                this.debugCube.parent.remove(this.debugCube);
+            }
+            this.debugCube = null;
+        }
+        super.endPlay();
+    }
+    tickPostPhysics(deltaTime) {
+        if (this.canvasUI) {
+            this.canvasUI.update();
+            // Attach to camera if head tracking is enabled
+            if (this.options.enableHeadTracking) {
+                this.updateHeadTrackedPosition();
+            }
+        }
+        super.tickPostPhysics(deltaTime);
+    }
+    getObject3D() {
+        return this.canvasUI?.mesh ?? null;
+    }
+    initializeCanvasUI() {
+        if (this.isInitialized)
+            return;
+        const DEBUG = true;
+        const world = this.getWorld();
+        const gameLoop = world?.gameLoop;
+        const renderer = gameLoop?.renderer?.renderer ?? null;
+        const scene = world?.scene ?? null;
+        if (DEBUG)
+            console.log('🔧 CanvasUIComponent: GameLoop found:', !!gameLoop);
+        if (DEBUG)
+            console.log('🔧 CanvasUIComponent: Renderer found:', !!renderer);
+        if (DEBUG)
+            console.log('🔧 CanvasUIComponent: Scene found:', !!scene);
+        if (!renderer) {
+            console.error('❌ CanvasUIComponent: No renderer available');
+            return;
+        }
+        if (!scene) {
+            console.error('❌ CanvasUIComponent: No scene available');
+            return;
+        }
+        const content = this.options.content ?? {};
+        const uiConfig = this.options.uiConfig ?? {};
+        const config = {
+            panelSize: this.options.panelSize ?? { width: 1, height: 1 },
+            width: this.options.canvasSize?.width ?? 512,
+            height: this.options.canvasSize?.height ?? 512,
+            opacity: this.options.opacity ?? 1.0,
+            body: {
+                fontFamily: 'Arial',
+                fontSize: 14,
+                backgroundColor: '#1a1a2e',
+                fontColor: '#ffffff',
+                borderRadius: 10,
+                textAlign: 'center',
+                ...uiConfig.body
+            },
+            renderer,
+            scene,
+            ...uiConfig
+        };
+        if (DEBUG)
+            console.log('🎨 CanvasUIComponent: Creating CanvasUI with config:', {
+                hasRenderer: !!config.renderer,
+                hasScene: !!config.scene,
+                panelSize: config.panelSize,
+                width: config.width,
+                height: config.height
+            });
+        try {
+            // Setup onSelect callbacks for button elements to bridge to component delegates
+            this.setupElementCallbacks(config);
+            this.canvasUI = new CanvasUI(content, config);
+            // Set interaction blocking option
+            this.canvasUI.setBlockInteractionsBehind(this.options.blockInteractionsBehind ?? true);
+            // Add the mesh to hierarchy or scene based on head tracking
+            const object3D = this.canvasUI.mesh;
+            if (object3D) {
+                // Set depth test based on option
+                const material = object3D.material;
+                if (material) {
+                    const blockInteractions = this.options.blockInteractionsBehind ?? true;
+                    material.depthTest = blockInteractions;
+                    material.depthWrite = blockInteractions;
+                    // Set render order to ensure proper depth sorting
+                    object3D.renderOrder = blockInteractions ? 0 : 1000;
+                    if (DEBUG)
+                        console.log('🔍 CanvasUIComponent: Depth test/write set to:', blockInteractions, 'renderOrder:', object3D.renderOrder);
+                }
+                if (this.options.enableHeadTracking) {
+                    // Set initial position and rotation offsets for camera attachment
+                    object3D.position.copy(this.options.headTrackingOffset ?? new THREE.Vector3(0, 0, -1));
+                    object3D.rotation.copy(this.options.headTrackingRotation ?? new THREE.Euler(0, 0, 0));
+                    // Add to scene temporarily - will be moved to camera in tickPostPhysics
+                    const world = this.getWorld();
+                    if (world?.scene) {
+                        world.scene.add(object3D);
+                        if (DEBUG)
+                            console.log('✅ CanvasUIComponent: CanvasUI mesh added to scene temporarily for head tracking');
+                    }
+                    // Create multiple debug objects at different positions
+                    if (world?.scene && this.options.enableDebugCubes) {
+                        // Large red cube at UI position - should be very visible
+                        const cubeGeometry = new THREE.BoxGeometry(0.5, 0.5, 0.5);
+                        const cubeMaterial = new THREE.MeshBasicMaterial({
+                            color: 0xff0000,
+                            wireframe: false,
+                            transparent: false
+                        });
+                        this.debugCube = new THREE.Mesh(cubeGeometry, cubeMaterial);
+                        // Start at a fixed world position so we can see it initially
+                        this.debugCube.position.set(0, 2, -2);
+                        this.debugCube.rotation.copy(this.options.headTrackingRotation ?? new THREE.Euler(0, 0, 0));
+                        world.scene.add(this.debugCube);
+                        // Green sphere at origin
+                        const sphereGeometry = new THREE.SphereGeometry(0.1);
+                        const sphereMaterial = new THREE.MeshBasicMaterial({ color: 0x00ff00 });
+                        const debugSphere = new THREE.Mesh(sphereGeometry, sphereMaterial);
+                        debugSphere.position.set(0, 0, 0);
+                        world.scene.add(debugSphere);
+                        // Large blue cube very close to camera origin
+                        const blueCubeGeometry = new THREE.BoxGeometry(1, 1, 1);
+                        const blueCubeMaterial = new THREE.MeshBasicMaterial({ color: 0x0000ff });
+                        const blueCube = new THREE.Mesh(blueCubeGeometry, blueCubeMaterial);
+                        blueCube.position.set(0, 0, -0.1);
+                        world.scene.add(blueCube);
+                        // Huge yellow cube further away
+                        const yellowCubeGeometry = new THREE.BoxGeometry(2, 2, 2);
+                        const yellowCubeMaterial = new THREE.MeshBasicMaterial({ color: 0xffff00 });
+                        const yellowCube = new THREE.Mesh(yellowCubeGeometry, yellowCubeMaterial);
+                        yellowCube.position.set(0, 0, -3);
+                        world.scene.add(yellowCube);
+                        if (DEBUG)
+                            console.log('🔴 CanvasUIComponent: Debug objects added to scene');
+                    }
+                }
+                else {
+                    // Add to component hierarchy for normal positioning
+                    this.add(object3D);
+                    if (DEBUG)
+                        console.log('✅ CanvasUIComponent: CanvasUI mesh added to component hierarchy');
+                }
+                if (DEBUG)
+                    console.log('👁️ CanvasUIComponent: Mesh visible:', object3D.visible, 'position:', object3D.position);
+            }
+            this.isInitialized = true;
+            if (DEBUG)
+                console.log('🎉 CanvasUIComponent: CanvasUI initialized successfully');
+        }
+        catch (error) {
+            console.error('❌ CanvasUIComponent: Failed to initialize CanvasUI:', error);
+        }
+    }
+    setupElementCallbacks(config) {
+        // Setup onSelect callbacks for button elements to bridge to component delegates
+        Object.entries(config).forEach(([elementName, elementConfig]) => {
+            if (typeof elementConfig === 'object' && elementConfig !== null && 'type' in elementConfig) {
+                if (elementConfig.type === 'button' && !elementConfig.onSelect) {
+                    elementConfig.onSelect = () => {
+                        if (DEBUG)
+                            console.log(`🎯 CanvasUIComponent: Button "${elementName}" clicked`);
+                        this.onElementSelect.invoke(elementName);
+                    };
+                }
+                else if (elementConfig.type === 'picker' && !elementConfig.onChange) {
+                    elementConfig.onChange = (value) => {
+                        if (DEBUG)
+                            console.log(`🎨 CanvasUIComponent: Picker "${elementName}" changed to:`, value);
+                        this.onElementChange.invoke(elementName, value);
+                    };
+                }
+                else if (elementConfig.type === 'slider' && !elementConfig.onChange) {
+                    elementConfig.onChange = (value) => {
+                        if (DEBUG)
+                            console.log(`🎚️ CanvasUIComponent: Slider "${elementName}" changed to:`, value);
+                        this.onElementChange.invoke(elementName, value);
+                    };
+                }
+                else if (elementConfig.type === 'input-text') {
+                    elementConfig.onChanged ??= (text) => {
+                        if (DEBUG)
+                            console.log(`📝 CanvasUIComponent: Input "${elementName}" changed to:`, text);
+                        this.onElementChange.invoke(elementName, text);
+                    };
+                    elementConfig.onEnter ??= (text) => {
+                        if (DEBUG)
+                            console.log(`⏎ CanvasUIComponent: Input "${elementName}" entered:`, text);
+                        this.onElementChange.invoke(elementName, text);
+                    };
+                }
+            }
+        });
+    }
+    updateElement(elementName, content) {
+        if (this.canvasUI) {
+            this.canvasUI.updateElement(elementName, content);
+        }
+    }
+    updateConfig(elementName, property, value) {
+        if (this.canvasUI) {
+            this.canvasUI.updateConfig(elementName, property, value);
+        }
+    }
+    getCanvasUI() {
+        return this.canvasUI;
+    }
+    attachToCamera() {
+        if (!this.canvasUI?.mesh)
+            return;
+        const world = this.getWorld();
+        const camera = world?.getFirstPlayerPawn()?.getCamera();
+        if (!camera)
+            return;
+        // Check if already attached to this camera
+        if (this.attachedCamera === camera && this.canvasUI.mesh.parent === camera) {
+            return; // Already attached
+        }
+        try {
+            // Remove from current parent if any
+            if (this.canvasUI.mesh.parent) {
+                this.canvasUI.mesh.parent.remove(this.canvasUI.mesh);
+            }
+            // Apply the head tracking offset and rotation
+            const offset = this.options.headTrackingOffset ?? new THREE.Vector3(0, -0.2, -0.5);
+            const rotation = this.options.headTrackingRotation ?? new THREE.Euler(0, 0, 0);
+            this.canvasUI.mesh.position.copy(offset);
+            this.canvasUI.mesh.rotation.copy(rotation);
+            // Add the mesh to the camera
+            camera.add(this.canvasUI.mesh);
+            // Also attach debug cube to camera with same offsets
+            if (this.debugCube && this.options.enableDebugCubes) {
+                if (this.debugCube.parent) {
+                    this.debugCube.parent.remove(this.debugCube);
+                }
+                // Make debug cube larger and more visible when attached to camera
+                this.debugCube.scale.set(3, 3, 3);
+                // Try multiple positions - start with right in front
+                this.debugCube.position.set(0, 0, -0.5);
+                this.debugCube.rotation.set(0, 0, 0);
+                camera.add(this.debugCube);
+                // Add more debug cubes at different positions
+                for (let i = 0; i < 4; i++) {
+                    const extraCube = new THREE.Mesh(new THREE.BoxGeometry(0.2, 0.2, 0.2), new THREE.MeshBasicMaterial({ color: 0xff00ff }));
+                    const angle = (i / 4) * Math.PI * 2;
+                    extraCube.position.set(Math.cos(angle) * 0.8, Math.sin(angle) * 0.8, -1);
+                    camera.add(extraCube);
+                }
+            }
+            this.attachedCamera = camera;
+            this.attachmentFailed = false;
+        }
+        catch (error) {
+            this.attachmentFailed = true;
+        }
+    }
+    updateHeadTrackedPosition() {
+        if (!this.canvasUI?.mesh)
+            return;
+        const world = this.getWorld();
+        const camera = world?.getFirstPlayerPawn()?.getCamera();
+        if (!camera)
+            return;
+        // Attach to camera if not already attached
+        this.attachToCamera();
+    }
+    detachFromCamera() {
+        if (this.attachedCamera && this.canvasUI?.mesh) {
+            try {
+                if (this.canvasUI.mesh.parent === this.attachedCamera) {
+                    this.attachedCamera.remove(this.canvasUI.mesh);
+                }
+            }
+            catch (error) {
+                // Ignore cleanup errors
+            }
+            this.attachedCamera = null;
+            this.attachmentFailed = false;
+        }
+    }
+};
+Object.defineProperty(CanvasUIComponent, "EDITOR_CLASS_META", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: {
+        opacity: { number: { min: 0, max: 1, step: 0.1 } },
+    }
+});
+CanvasUIComponent = __decorate([
+    EngineClass('CanvasUIComponent'),
+    __metadata("design:paramtypes", [Object])
+], CanvasUIComponent);
+export { CanvasUIComponent };
+const DEBUG = true;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CanvasUIComponent.js","sourceRoot":"","sources":["../../../../src/xr/actor-components/CanvasUIComponent.ts"],"names":[],"mappings":"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"}

package/dist/src/xr/actor-components/VRBaseComponent.d.ts

@@ -0,0 +1,15 @@
+/**
+ * VRBaseComponent - common VR behavior hooks (e.g., hover) for actor components.
+ */
+import { SceneComponent } from '../../components/SceneComponent.js';
+import type { SceneComponentOptions } from '../../components/SceneComponent.js';
+import type { EditorClassMeta } from '../../utils/EditorClassMeta.js';
+import type * as THREE from 'three';
+export interface VRBaseComponentOptions extends SceneComponentOptions {
+}
+export declare class VRBaseComponent<TOptions extends VRBaseComponentOptions = VRBaseComponentOptions> extends SceneComponent<TOptions> {
+    static readonly EDITOR_CLASS_META: EditorClassMeta;
+    onVRHoverStart?(hand: 'left' | 'right', point: THREE.Vector3): void;
+    onVRHover?(hand: 'left' | 'right', point: THREE.Vector3): void;
+    onVRHoverEnd?(hand: 'left' | 'right'): void;
+}

package/dist/src/xr/actor-components/VRBaseComponent.js

@@ -0,0 +1,24 @@
+/**
+ * VRBaseComponent - common VR behavior hooks (e.g., hover) for actor components.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { SceneComponent } from '../../components/SceneComponent.js';
+import { EngineClass } from '../../systems/ClassRegistry.js';
+let VRBaseComponent = class VRBaseComponent extends SceneComponent {
+};
+Object.defineProperty(VRBaseComponent, "EDITOR_CLASS_META", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: {}
+});
+VRBaseComponent = __decorate([
+    EngineClass('VRBaseComponent')
+], VRBaseComponent);
+export { VRBaseComponent };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVlJCYXNlQ29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3hyL2FjdG9yLWNvbXBvbmVudHMvVlJCYXNlQ29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHOzs7Ozs7O0FBRUgsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBQ3BFLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQVN0RCxJQUFNLGVBQWUsR0FBckIsTUFBTSxlQUNYLFNBQVEsY0FBd0I7O0FBQ1A7Ozs7V0FBcUMsRUFDcEQ7RUFEZ0MsQ0FDL0I7QUFIQSxlQUFlO0lBRDNCLFdBQVcsQ0FBQyxpQkFBaUIsQ0FBQztHQUNsQixlQUFlLENBUzNCIn0=

package/dist/src/xr/actor-components/VRGrabbableComponent.d.ts

@@ -0,0 +1,31 @@
+/**
+ * VRGrabbableComponent - marks an actor as grabbable and defines grab behavior/options.
+ */
+import * as THREE from 'three';
+import { Delegate } from '../../utils/Delegate.js';
+import { VRBaseComponent } from './VRBaseComponent.js';
+import type { SceneComponentOptions } from '../../components/SceneComponent.js';
+import type { EditorClassMeta } from '../../utils/EditorClassMeta.js';
+import type { XRAxis, XRButton } from '../VRControllerManager.js';
+export interface VRGrabbableComponentOptions extends SceneComponentOptions {
+    vrAttachmentInputType?: 'grip' | 'select';
+    offsetPosition?: THREE.Vector3;
+    offsetRotation?: THREE.Euler;
+    offsetScale?: THREE.Vector3;
+    hideController?: boolean;
+    attachmentMode?: 'hand' | 'beam';
+    useBeamPickupDistance?: boolean;
+    beamPickupDistance?: number;
+}
+export declare class VRGrabbableComponent extends VRBaseComponent<VRGrabbableComponentOptions> {
+    static readonly EDITOR_CLASS_META: EditorClassMeta;
+    static get DEFAULT_OPTIONS(): VRGrabbableComponentOptions;
+    private grabEnabled;
+    getVRAttachmentInputType(): 'grip' | 'select';
+    getVRAttachmentOptions(): VRGrabbableComponentOptions;
+    setGrabEnabled(enabled: boolean): void;
+    canGrab(): boolean;
+    readonly onGrabStart: Delegate<[hand: 'left' | 'right'], void>;
+    readonly onGrabEnd: Delegate<[hand: 'left' | 'right', dropVelocity?: THREE.Vector3], void>;
+    readonly onVRInput: Delegate<[hand: 'left' | 'right', control: XRButton | XRAxis, pressed: boolean, value: number], boolean>;
+}