@needle-tools/engine 2.35.5-pre → 2.36.0-pre

package/CHANGELOG.md

@@ -4,6 +4,25 @@ All notable changes to this package will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [2.36.0-pre] - 2022-10-26
+- Add: Expose WebXR hand model path
+- Add: Animation component can now be configured with random time scale and offset
+- Change: allow blocking overlay errors using the ``?noerrors`` query parameter
+- Change: don't use Composer for postprocessing in XR (see [issue](https://github.com/needle-tools/needle-engine-support/issues/101)) 
+- Change: physics intersections causing NaN's are now reported prominently and physics bodies are removed from physics world as an interim solution, this provides more information about problematic colliders for debugging
+- Fix: bug that caused component events for onEnable and onDisable not being called anymore in some cases
+- Fix: cases where loading overlay using old project template wouldnt be removed/hidden anymore
+- Fix: WebXR hide large hand grab sphere
+- Fix: onPointerUp event not firing using WebXR controllers when grabbing an object for the second time
+- Fix: GroundProjection can now be removed again
+- Fix: Custom shaders exported using builtin RP can now use  _Time property
+- Fix: Only create two controllers when in AR on oculus browser
+- Fix: BoxHelperComponent can now handle multi-material objects (groups) 
+
+## [2.35.6-pre] - 2022-10-24
+- Add: warning balloon when unknown components are detected and have been most likely forgot to be installed, linking to npmdef docs 
+- Fix: dont show serialization warning for builtin components where specific fields are not deserialized on purpose (since right now the serializer does not check which fields are actually implemented) 
+
 ## [2.35.5-pre] - 2022-10-24
 - Change: AudioSource exposes ``clip`` field
 - Change: improve error and messaging overlay

package/dist/needle-engine.d.ts

@@ -102,6 +102,7 @@ declare module "engine/engine_types" {
     }
     export interface ISharedMaterials {
         [num: number]: Material;
+        get length(): number;
     }
     export interface IRenderer extends IComponent {
         sharedMaterial: Material;
@@ -199,6 +200,7 @@ declare module "engine/engine_typestore" {
         add(key: any, type: any): void;
         get(key: any): any;
     }
+    export const $BuiltInTypeFlag: unique symbol;
     export const TypeStore: _TypeStore;
 }
 declare module "engine/extensions/NEEDLE_persistent_assets" {
@@ -558,7 +560,7 @@ declare module "engine/engine_mainloop_utils" {
     export function processStart(context: Context, object?: Object3D): void;
     export function addScriptToArrays(script: any, context: Context): void;
     export function removeScriptFromContext(script: any, context: Context): void;
-    export function updateIsActive(): void;
+    export function updateIsActive(obj?: Object3D): void;
     export function updateActiveInHierarchyWithoutEventCall(go: THREE.Object3D): void;
 }
 declare module "engine/engine_networking_types" {
@@ -673,6 +675,7 @@ declare module "engine/engine_gameobject" {
         context?: Context | undefined;
     }
     export function isActiveSelf(go: Object3D): boolean;
+    export function setActive(go: Object3D, active: boolean, setVisible?: boolean): void;
     export function isActiveInHierarchy(go: Object3D): boolean;
     export function markAsInstancedRendered(go: THREE.Object3D, instanced: boolean): void;
     export function isUsingInstancing(instance: THREE.Object3D): boolean;
@@ -682,10 +685,11 @@ declare module "engine/engine_gameobject" {
     export function instantiate(instance: GameObject | Object3D | null, opts?: InstantiateOptions | null): GameObject | null;
 }
 declare module "engine/engine_physics" {
-    import * as CANNON from 'cannon-es';
-    import * as THREE from 'three';
+    import { Body, Constraint } from 'cannon-es';
+    import { Camera, Intersection, Layers, Object3D, Ray, Raycaster, Vector2, Vector3 } from 'three';
     import { Context } from "engine/engine_setup";
     import { IGameObject as GameObject, ICollider, IRigidbody as Rigidbody } from "engine/engine_types";
+    import { Shape } from 'cannon-es';
     export class BodyOptions {
         mass: number;
         kinematic: boolean;
@@ -695,27 +699,27 @@ declare module "engine/engine_physics" {
         sleepThreshold: number;
     }
     export class RaycastOptions {
-        ray: THREE.Ray | undefined;
-        cam: THREE.Camera | undefined | null;
-        screenPoint: THREE.Vector2 | undefined;
-        raycaster: THREE.Raycaster | undefined;
-        results: Array<THREE.Intersection> | undefined;
-        targets: Array<THREE.Object3D> | undefined;
+        ray: Ray | undefined;
+        cam: Camera | undefined | null;
+        screenPoint: Vector2 | undefined;
+        raycaster: Raycaster | undefined;
+        results: Array<Intersection> | undefined;
+        targets: Array<Object3D> | undefined;
         recursive: boolean | undefined;
         minDistance: number | undefined;
         maxDistance: number | undefined;
         lineThreshold: number | undefined;
-        layerMask: THREE.Layers | number | undefined;
-        ignore: THREE.Object3D[] | undefined;
+        layerMask: Layers | number | undefined;
+        ignore: Object3D[] | undefined;
         screenPointFromOffset(ox: number, oy: number): void;
         setMask(mask: number): void;
         static AllLayers: number;
     }
-    export class SphereIntersection implements THREE.Intersection {
+    export class SphereIntersection implements Intersection {
         distance: number;
-        point: THREE.Vector3;
-        object: THREE.Object3D;
-        constructor(object: THREE.Object3D, distance: number, point: THREE.Vector3);
+        point: Vector3;
+        object: Object3D;
+        constructor(object: Object3D, distance: number, point: Vector3);
     }
     export class Physics {
         private readonly raycaster;
@@ -724,11 +728,11 @@ declare module "engine/engine_physics" {
         private readonly defaultThresholds;
         private sphereResults;
         private sphereMask;
-        sphereOverlap(spherePos: THREE.Vector3, radius: number): Array<THREE.Intersection>;
+        sphereOverlap(spherePos: Vector3, radius: number, traverseChildsAfterHit?: boolean): Array<Intersection>;
         private tempBoundingBox;
         private onSphereOverlap;
-        raycastFromRay(ray: THREE.Ray, options?: RaycastOptions | null): Array<THREE.Intersection>;
-        raycast(options?: RaycastOptions | null): Array<THREE.Intersection>;
+        raycastFromRay(ray: Ray, options?: RaycastOptions | null): Array<Intersection>;
+        raycast(options?: RaycastOptions | null): Array<Intersection>;
         get isUpdating(): boolean;
         private _isUpdatingPhysicsWorld;
         private context;
@@ -739,16 +743,16 @@ declare module "engine/engine_physics" {
         constructor(context: Context);
         addPreStepListener(listener: (evt: any) => void): void;
         addPostStepListener(listener: (evt: any) => void): void;
-        addConstraint(constraint: CANNON.Constraint): void;
-        setGravity(vec: THREE.Vector3): void;
-        multiplyGravity(vec: THREE.Vector3): void;
-        addBody(go: GameObject, body: CANNON.Body): void;
-        removeBody(go: GameObject, body: CANNON.Body, removeCompletely?: boolean): void;
-        removeShape(obj: THREE.Object3D, shape: CANNON.Shape): void;
-        createBody(obj: THREE.Object3D, settings: BodyOptions): CANNON.Body;
-        addBoxCollider(obj: THREE.Object3D, trigger: boolean, center: THREE.Vector3, size: THREE.Vector3, rb: Rigidbody | null): CANNON.Shape;
-        addSphereCollider(obj: THREE.Object3D, center: THREE.Vector3, radius: number, rb: Rigidbody | null): CANNON.Shape;
-        addMeshCollider(_obj: THREE.Object3D): void;
+        addConstraint(constraint: Constraint): void;
+        setGravity(vec: Vector3): void;
+        multiplyGravity(vec: Vector3): void;
+        addBody(go: GameObject, body: Body): void;
+        removeBody(go: GameObject, body: Body, removeCompletely?: boolean): void;
+        removeShape(obj: Object3D, shape: Shape): void;
+        createBody(obj: Object3D, settings: BodyOptions): Body;
+        addBoxCollider(obj: Object3D, trigger: boolean, center: Vector3, size: Vector3, rb: Rigidbody | null): Shape;
+        addSphereCollider(obj: Object3D, center: Vector3, radius: number, rb: Rigidbody | null): Shape;
+        addMeshCollider(_obj: Object3D): void;
         private isAlreadyRegistered;
         private readonly tempMat1;
         private readonly tempMat2;
@@ -766,7 +770,7 @@ declare module "engine/engine_physics" {
         private onEndContact;
     }
     export interface IColliderProvider {
-        getCollider(obj: THREE.Object3D): ICollider;
+        getCollider(obj: Object3D): ICollider;
     }
     export function registerColliderProvider(prov: IColliderProvider): void;
 }
@@ -774,6 +778,7 @@ declare module "engine/engine_time" {
     export class Time {
         deltaTime: number;
         time: number;
+        /** same as frameCount */
         frame: number;
         get realtimeSinceStartup(): number;
         get frameCount(): number;
@@ -1149,7 +1154,7 @@ declare module "engine-components/Component" {
     import { InstantiateOptions, HideFlags } from "engine/engine_gameobject";
     abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGameObject {
         guid: string | undefined;
-        static setActive(go: THREE.Object3D, active: boolean, processStart?: boolean): void;
+        static setActive(go: THREE.Object3D, active: boolean, processStart?: boolean, setVisible?: boolean): void;
         static isActiveSelf(go: THREE.Object3D): boolean;
         static isActiveInHierarchy(go: THREE.Object3D): boolean;
         static markAsInstancedRendered(go: THREE.Object3D, instanced: boolean): void;
@@ -1243,6 +1248,7 @@ declare module "engine-components/Component" {
         protected __didEnable: boolean;
         protected __isEnabled: boolean | undefined;
         private __destroyed;
+        get __internalDidAwakeAndStart(): boolean;
         __internalNewInstanceCreated(): void;
         __internalAwake(): void;
         __internalStart(): void;
@@ -1927,6 +1933,7 @@ declare module "engine-components/AnimatorController" {
         private updateActiveStates;
         private setStartTransition;
         private evaluateTransitions;
+        private getState;
         private transitionTo;
         private createAction;
         private evaluateCondition;
@@ -1999,7 +2006,7 @@ declare module "engine-components/Animator" {
 declare module "engine-components/Animation" {
     import { Behaviour } from "engine-components/Component";
     import * as THREE from 'three';
-    import { AnimationAction, AnimationClip } from "three";
+    import { AnimationAction, AnimationClip, Vector2 } from "three";
     export class PlayOptions {
         fadeDuration?: number;
         loop?: boolean;
@@ -2007,10 +2014,14 @@ declare module "engine-components/Animation" {
         startTime?: number;
         endTime?: number;
         clampWhenFinished?: boolean;
+        minMaxSpeed?: Vector2;
+        minMaxOffsetNormalized?: Vector2;
     }
     export class Animation extends Behaviour {
         playAutomatically: boolean;
         randomStartTime: boolean;
+        minMaxSpeed?: Vector2;
+        minMaxOffsetNormalized?: Vector2;
         private _tempAnimationClipBeforeGameObjectExisted;
         get clip(): AnimationClip | null;
         set clip(val: AnimationClip | null);
@@ -2503,11 +2514,11 @@ declare module "engine-components/BoxHelperComponent" {
     import * as THREE from "three";
     export class BoxHelperComponent extends Behaviour {
         private box;
-        private testBox;
+        private static testBox;
         private _lastMatrixUpdateFrame;
         private static _position;
         private static _size;
-        isInBox(obj: THREE.Object3D): boolean | undefined;
+        isInBox(obj: THREE.Object3D, scaleFactor?: number): boolean | undefined;
         intersects(box: THREE.Box3): boolean;
         updateBox(force?: boolean): THREE.Box3;
         private _helper;
@@ -2728,6 +2739,36 @@ declare module "engine-components/Voip" {
         static HasMicrophonePermissions(): Promise<boolean>;
     }
 }
+declare module "engine-components/WebARSessionRoot" {
+    import { Behaviour } from "engine-components/Component";
+    import { XRSession } from 'three';
+    import { Matrix4, Object3D, XRPose } from "three";
+    import { WebAR } from "engine-components/WebXR";
+    export class WebARSessionRoot extends Behaviour {
+        webAR: WebAR | null;
+        get rig(): Object3D | undefined;
+        invertForward: boolean;
+        get arScale(): number;
+        set arScale(val: number);
+        private readonly _initalMatrix;
+        private readonly _selectStartFn;
+        private readonly _selectEndFn;
+        start(): void;
+        private _arScale;
+        private _rig;
+        private _startPose;
+        private _placementPose;
+        private _isTouching;
+        private _rigStartPose;
+        onBegin(session: XRSession): void;
+        onUpdate(rig: Object3D | null, _session: XRSession, pose: XRPose | null | undefined): boolean;
+        placeAt(rig: Object3D | null, mat: Matrix4): void;
+        onEnd(rig: Object3D | null, _session: XRSession): void;
+        private onSelectStart;
+        private onSelectEnd;
+        private setScale;
+    }
+}
 declare module "engine-components/XRFlag" {
     import { Behaviour } from "engine-components/Component";
     export enum XRStateFlag {
@@ -2819,23 +2860,23 @@ declare module "engine-components/WebXRSync" {
     import { Behaviour } from "engine-components/Component";
     import { NetworkConnection } from "engine/engine_networking";
     import { WebXR } from "engine-components/WebXR";
-    import * as THREE from "three";
+    import { Group, Quaternion, Vector3, Vector4 } from "three";
     import { Builder } from "flatbuffers";
     import { VrUserStateBuffer } from "engine-schemes/vr-user-state-buffer";
     export class VRUserState {
         guid: string;
         time: number;
         avatarId: string;
-        position: THREE.Vector3;
-        rotation: THREE.Vector4;
+        position: Vector3;
+        rotation: Vector4;
         scale: number;
-        posLeftHand: THREE.Vector3;
-        posRightHand: THREE.Vector3;
-        rotLeftHand: THREE.Quaternion;
-        rotRightHand: THREE.Quaternion;
+        posLeftHand: Vector3;
+        posRightHand: Vector3;
+        rotLeftHand: Quaternion;
+        rotRightHand: Quaternion;
         constructor(guid: string);
         private static invertRotation;
-        update(rig: THREE.Group, pos: DOMPointReadOnly, rot: DOMPointReadOnly, webXR: WebXR, avatarId: string): void;
+        update(rig: Group, pos: DOMPointReadOnly, rot: DOMPointReadOnly, webXR: WebXR, avatarId: string): void;
         private static quat0;
         private static quat1;
         sendAsBuffer(builder: Builder, net: NetworkConnection): void;
@@ -2874,7 +2915,6 @@ declare module "engine-components/WebXRSync" {
 declare module "engine-components/WebXRAvatar" {
     import { Behaviour } from "engine-components/Component";
     import { WebXR } from "engine-components/WebXR";
-    import * as THREE from "three";
     import { XRFlag } from "engine-components/XRFlag";
     import { Context } from "engine/engine_setup";
     import { Object3D } from "three";
@@ -2892,7 +2932,7 @@ declare module "engine-components/WebXRAvatar" {
         private static _onNewAvatarMarkerAdded;
         private static _onAvatarMarkerDestroyed;
         connectionId: string;
-        avatar?: WebXRAvatar | THREE.Object3D;
+        avatar?: WebXRAvatar | Object3D;
         awake(): void;
         onDestroy(): void;
         isLocalAvatar(): boolean;
@@ -2906,9 +2946,9 @@ declare module "engine-components/WebXRAvatar" {
         /** the user id */
         guid: string;
         private root;
-        head: THREE.Object3D | null;
-        handLeft: THREE.Object3D | null;
-        handRight: THREE.Object3D | null;
+        head: Object3D | null;
+        handLeft: Object3D | null;
+        handRight: Object3D | null;
         lastUpdate: number;
         isLocalAvatar: boolean;
         flags: XRFlag[] | null;
@@ -3084,6 +3124,7 @@ declare module "engine-components/ui/EventSystem" {
         private objectsHoveredThisFrame;
         private objectsHoveredLastFrame;
         private raisedPointerDownEvents;
+        private raisedPointerDownObjects;
         private _didMove;
         onBeforeUpdate(): void;
         private _tempComponentsArray;
@@ -3129,12 +3170,42 @@ declare module "engine-components/RendererLightmap" {
         private setLightmapDebugMaterial;
     }
 }
+declare module "engine-components/ReflectionProbe" {
+    import { Behaviour } from "engine-components/Component";
+    import { Object3D, Texture, Vector3 } from "three";
+    import { Context } from "engine/engine_setup";
+    import { IRenderer } from "engine/engine_types";
+    export const debug: string | boolean;
+    export class ReflectionProbe extends Behaviour {
+        private static _probes;
+        static get(object: Object3D | null | undefined, context: Context, isAnchor: boolean): ReflectionProbe | null;
+        private _texture;
+        set texture(tex: Texture);
+        get texture(): Texture;
+        center?: Vector3;
+        size?: Vector3;
+        private _boxHelper?;
+        private isInBox;
+        constructor();
+        awake(): void;
+        onDestroy(): void;
+        private static _rendererMaterialsCache;
+        onSet(_rend: IRenderer): void;
+        onUnset(_rend: IRenderer): void;
+    }
+}
 declare module "engine-components/Renderer" {
     import { Behaviour } from "engine-components/Component";
     import * as THREE from "three";
-    import { Mesh, Texture } from "three";
+    import { Mesh, Object3D, Texture } from "three";
     import { IRenderer, ISharedMaterials } from "engine/engine_types";
     export { InstancingUtil } from "engine/engine_instancing";
+    export enum ReflectionProbeUsage {
+        Off = 0,
+        BlendProbes = 1,
+        BlendProbesAndSkybox = 2,
+        Simple = 3
+    }
     export class FieldWithDefault {
         path: string | null;
         asset: object | null;
@@ -3163,6 +3234,8 @@ declare module "engine-components/Renderer" {
         enableInstancing: boolean[] | undefined;
         renderOrder: number[] | undefined;
         allowOcclusionWhenDynamic: boolean;
+        probeAnchor?: Object3D;
+        reflectionProbeUsage: ReflectionProbeUsage;
         private _lightmaps?;
         get sharedMesh(): Mesh | undefined;
         get sharedMaterial(): THREE.Material;
@@ -3189,10 +3262,13 @@ declare module "engine-components/Renderer" {
         onDisable(): void;
         onDestroy(): void;
         applyStencil(): void;
-        onBeforeRenderThree(_renderer: any, _scene: any, _camera: any, _geometry: any, material: any, _group: any): void;
+        static envmap: THREE.Texture | null;
         onBeforeRender(): void;
+        onBeforeRenderThree(_renderer: any, _scene: any, _camera: any, _geometry: any, material: any, _group: any): void;
         onAfterRender(): void;
         private applySettings;
+        private _reflectionProbe;
+        private updateReflectionProbe;
     }
     export class MeshRenderer extends Renderer {
     }
@@ -3247,13 +3323,12 @@ declare module "engine-components/ui/RaycastUtils" {
     }
 }
 declare module "engine-components/WebXRController" {
+    import { Group, Intersection, Mesh, Object3D, Quaternion, Ray, Vector3, XRInputSource, XRSession } from "three";
+    import { OculusHandPointerModel } from 'three/examples/jsm/webxr/OculusHandPointerModel.js';
+    import { XRControllerModel, XRControllerModelFactory } from 'three/examples/jsm/webxr/XRControllerModelFactory.js';
     import { Behaviour, GameObject } from "engine-components/Component";
-    import { WebXR } from "engine-components/WebXR";
-    import * as THREE from "three";
     import { SyncedTransform } from "engine-components/SyncedTransform";
-    import { XRControllerModel, XRControllerModelFactory } from 'three/examples/jsm/webxr/XRControllerModelFactory.js';
-    import { OculusHandPointerModel } from 'three/examples/jsm/webxr/OculusHandPointerModel.js';
-    import { XRSession } from "three";
+    import { WebXR } from "engine-components/WebXR";
     export enum ControllerType {
         PhysicalDevice = 0,
         Touch = 1
@@ -3280,17 +3355,17 @@ declare module "engine-components/WebXRController" {
         webXR: WebXR;
         index: number;
         controllerModel: XRControllerModel;
-        controller: THREE.Group;
-        controllerGrip: THREE.Group;
-        hand: THREE.Group;
+        controller: Group;
+        controllerGrip: Group;
+        hand: Group;
         handPointerModel: OculusHandPointerModel;
         grabbed: AttachedObject | null;
-        input: THREE.XRInputSource | null;
+        input: XRInputSource | null;
         type: ControllerType;
         get isUsingHands(): boolean;
-        get wrist(): THREE.Object3D | null;
+        get wrist(): Object3D | null;
         private _wristQuaternion;
-        getWristQuaternion(): THREE.Quaternion | null;
+        getWristQuaternion(): Quaternion | null;
         private movementVector;
         private worldRot;
         private joystick;
@@ -3310,7 +3385,7 @@ declare module "engine-components/WebXRController" {
         get selectionUp(): boolean;
         get selectionPressed(): boolean;
         get selectionClick(): boolean;
-        get raycastHitPoint(): THREE.Object3D | null;
+        get raycastHitPoint(): Object3D | null;
         private _selectionPressed;
         private _selectionPressedLastFrame;
         private _selectionStartTime;
@@ -3325,7 +3400,7 @@ declare module "engine-components/WebXRController" {
         private onSourceConnected;
         private onSourceDisconnected;
         private createPointerEvent;
-        rayRotation: THREE.Quaternion;
+        rayRotation: Quaternion;
         update(): void;
         private _pinchStartTime;
         onUpdate(session: XRSession): void;
@@ -3341,9 +3416,10 @@ declare module "engine-components/WebXRController" {
         private onSelectEnd;
         private testIsVisible;
         private setControllerLayers;
-        getRay(): THREE.Ray;
-        overlap(): THREE.Intersection[];
-        raycast(): THREE.Intersection[];
+        getRay(): Ray;
+        private closeGrabBoundingBoxHelper?;
+        overlap(): Intersection[];
+        raycast(): Intersection[];
     }
     export enum AttachedObjectEvents {
         WillTake = "WillTake",
@@ -3360,11 +3436,11 @@ declare module "engine-components/WebXRController" {
         static Current: AttachedObject[];
         private static Register;
         private static Remove;
-        static TryTake(controller: WebXRController, candidate: THREE.Object3D, intersection: THREE.Intersection, closeGrab: boolean): AttachedObject | null;
+        static TryTake(controller: WebXRController, candidate: Object3D, intersection: Intersection, closeGrab: boolean): AttachedObject | null;
         sync: SyncedTransform | null;
-        selected: THREE.Object3D | null;
-        selectedParent: THREE.Object3D | null;
-        selectedMesh: THREE.Mesh | null;
+        selected: Object3D | null;
+        selectedParent: Object3D | null;
+        selectedMesh: Mesh | null;
         controller: WebXRController | null;
         grabTime: number;
         grabUUID: string;
@@ -3378,7 +3454,7 @@ declare module "engine-components/WebXRController" {
         private positionSource;
         private Take;
         free(): void;
-        grabPoint: THREE.Vector3;
+        grabPoint: Vector3;
         private localPositionOffsetToGrab;
         private localPositionOffsetToGrab_worldSpace;
         private localQuaternionToGrab;
@@ -3394,36 +3470,6 @@ declare module "engine-components/WebXRController" {
         update(): void;
     }
 }
-declare module "engine-components/WebARSessionRoot" {
-    import { Behaviour } from "engine-components/Component";
-    import * as THREE from 'three';
-    import { Matrix4, XRPose } from "three";
-    import { WebAR } from "engine-components/WebXR";
-    export class WebARSessionRoot extends Behaviour {
-        webAR: WebAR | null;
-        get rig(): THREE.Object3D | undefined;
-        invertForward: boolean;
-        get arScale(): number;
-        set arScale(val: number);
-        private readonly _initalMatrix;
-        private readonly _selectStartFn;
-        private readonly _selectEndFn;
-        start(): void;
-        private _arScale;
-        private _rig;
-        private _startPose;
-        private _placementPose;
-        private _isTouching;
-        private _rigStartPose;
-        onBegin(session: THREE.XRSession): void;
-        onUpdate(rig: THREE.Object3D | null, _session: THREE.XRSession, pose: XRPose | null | undefined): boolean;
-        placeAt(rig: THREE.Object3D | null, mat: Matrix4): void;
-        onEnd(rig: THREE.Object3D | null, _session: THREE.XRSession): void;
-        private onSelectStart;
-        private onSelectEnd;
-        private setScale;
-    }
-}
 declare module "engine-components/WebXRRig" {
     import { Behaviour } from "engine-components/Component";
     export class XRRig extends Behaviour {
@@ -3431,10 +3477,10 @@ declare module "engine-components/WebXRRig" {
     }
 }
 declare module "engine-components/WebXR" {
+    import { Object3D, Quaternion, XRFrame, XRSession, XRViewerPose } from 'three';
+    import { AssetReference } from "engine/engine_addressables";
     import { Behaviour } from "engine-components/Component";
-    import * as THREE from 'three';
     import { WebXRController } from "engine-components/WebXRController";
-    import { AssetReference } from "engine/engine_addressables";
     export function detectARSupport(): Promise<boolean>;
     export function detectVRSupport(): Promise<boolean>;
     export enum WebXREvent {
@@ -3450,6 +3496,7 @@ declare module "engine-components/WebXR" {
         enableVR: boolean;
         enableAR: boolean;
         defaultAvatar?: AssetReference;
+        handModelPath: string;
         createVRButton: boolean;
         createARButton: boolean;
         private static _isInXr;
@@ -3464,7 +3511,7 @@ declare module "engine-components/WebXR" {
         static createARButton(webXR: WebXR, opts?: CreateButtonOptions): HTMLButtonElement;
         static resetButtonStyles(button: any): void;
         endSession(): void;
-        get Rig(): THREE.Object3D;
+        get Rig(): Object3D;
         private controllers;
         get Controllers(): WebXRController[];
         get LeftController(): WebXRController | null;
@@ -3485,9 +3532,9 @@ declare module "engine-components/WebXR" {
         awake(): void;
         onEnable(): void;
         private _transformOrientation;
-        get TransformOrientation(): THREE.Quaternion;
+        get TransformOrientation(): Quaternion;
         private _currentHeadPose;
-        get HeadPose(): THREE.XRViewerPose | null;
+        get HeadPose(): XRViewerPose | null;
         onBeforeRender(frame: any): void;
         private onClickedARButton;
         private onClickedVRButton;
@@ -3522,9 +3569,9 @@ declare module "engine-components/WebXR" {
         private didPlaceARSessionRoot;
         getAROverlayContainer(): HTMLElement | null;
         setReticleActive(active: boolean): void;
-        onBegin(session: THREE.XRSession): Promise<void>;
-        onEnd(session: THREE.XRSession): void;
-        onUpdate(session: THREE.XRSession, frame: THREE.XRFrame): void;
+        onBegin(session: XRSession): Promise<void>;
+        onEnd(session: XRSession): void;
+        onUpdate(session: XRSession, frame: XRFrame): void;
     }
 }
 declare module "engine-components/DragControls" {
@@ -3728,7 +3775,9 @@ declare module "engine-components/GroundProjection" {
         private env?;
         private _watcher?;
         onEnable(): void;
+        start(): void;
         onDisable(): void;
+        private updateAndCreate;
         updateProjection(): void;
     }
 }
@@ -4498,7 +4547,7 @@ declare module "engine-components/Volume" {
 }
 declare module "engine-components/WebXRGrabRendering" {
     import { Behaviour } from "engine-components/Component";
-    import * as THREE from "three";
+    import { Object3D, Vector3 } from "three";
     import { Context } from "engine/engine_setup";
     import { IModel } from "engine/engine_networking_types";
     export class XRGrabModel implements IModel {
@@ -4516,10 +4565,10 @@ declare module "engine-components/WebXRGrabRendering" {
             z: number;
         };
         target: string | undefined;
-        update(context: Context, point: THREE.Vector3, source: THREE.Vector3, target?: string | undefined): void;
+        update(context: Context, point: Vector3, source: Vector3, target?: string | undefined): void;
     }
     export class XRGrabRendering extends Behaviour {
-        prefab: THREE.Object3D | null;
+        prefab: Object3D | null;
         private _grabModels;
         private _grabModelsUpdateTime;
         private _addOrUpdateSub;
@@ -5288,6 +5337,7 @@ declare module "engine-components/codegen/components" {
     export { EmissionModule } from "engine-components/ParticleSystemModules";
     export { ShapeModule } from "engine-components/ParticleSystemModules";
     export { PlayerColor } from "engine-components/PlayerColor";
+    export { ReflectionProbe } from "engine-components/ReflectionProbe";
     export { FieldWithDefault } from "engine-components/Renderer";
     export { Renderer } from "engine-components/Renderer";
     export { MeshRenderer } from "engine-components/Renderer";