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

package/dist/needle-engine.d.ts

@@ -100,8 +100,13 @@ declare module "engine/engine_types" {
         intensity: number;
         color: Color;
     }
+    export interface ISharedMaterials {
+        [num: number]: Material;
+        get length(): number;
+    }
     export interface IRenderer extends IComponent {
-        material: Material;
+        sharedMaterial: Material;
+        get sharedMaterials(): ISharedMaterials;
     }
     export interface ICollider extends IComponent {
         get isCollider(): any;
@@ -195,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" {
@@ -210,6 +216,45 @@ declare module "engine/extensions/NEEDLE_persistent_assets" {
         resolve(parser: GLTFParser, path: string): Promise<void> | null | any;
     }
 }
+declare module "engine/engine_networking_utils" {
+    export function isLocalNetwork(hostname?: string): boolean;
+    export function isHostedOnGlitch(): boolean;
+}
+declare module "engine/engine_element_overlay" {
+    import { Context } from "engine/engine_setup";
+    export const arContainerClassName = "ar";
+    export const quitARClassName = "quit-ar";
+    export class AROverlayHandler {
+        get ARContainer(): HTMLElement | null;
+        constructor();
+        private arContainer;
+        closeARCallback: any;
+        currentSession: THREE.XRSession | null;
+        registeredCloseEventElements: Element[];
+        private _createdAROnlyElements;
+        private _reparentedObjects;
+        requestEndAR(): void;
+        onBegin(context: Context, overlayContainer: HTMLElement, session: THREE.XRSession): void;
+        onEnd(_context: Context): void;
+        findOrCreateARContainer(element: HTMLElement): HTMLElement;
+        private onRequestedEndAR;
+        private createFallbackCloseARButton;
+    }
+}
+declare module "engine/debug/debug_overlay" {
+    export enum LogType {
+        Log = 0,
+        Warn = 1,
+        Error = 2
+    }
+    export function makeErrorsVisibleForDevelopment(): void;
+    export function addLog(type: LogType, message: string | any[], _file?: string | null, _line?: number | null): void;
+}
+declare module "engine/debug/debug" {
+    import { LogType } from "engine/debug/debug_overlay";
+    export { LogType };
+    export function showBalloonMessage(text: string, logType?: LogType): void;
+}
 declare module "engine/engine_serialization_core" {
     import { GLTF } from "three/examples/jsm/loaders/GLTFLoader";
     import { Object3D } from "three";
@@ -515,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" {
@@ -630,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;
@@ -639,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;
@@ -652,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;
@@ -681,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;
@@ -696,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;
@@ -723,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;
 }
@@ -731,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;
@@ -820,10 +868,6 @@ declare module "engine/engine_networking_peer" {
         private trySetupClient;
     }
 }
-declare module "engine/engine_networking_utils" {
-    export function isLocalNetwork(hostname?: string): boolean;
-    export function isHostedOnGlitch(): boolean;
-}
 declare module "engine/engine_networking" {
     import { Context } from "engine/engine_setup";
     import * as flatbuffers from 'flatbuffers';
@@ -1110,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;
@@ -1204,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;
@@ -1704,27 +1749,6 @@ declare module "engine/engine_setup" {
         private executeCoroutines;
     }
 }
-declare module "engine/engine_element_overlay" {
-    import { Context } from "engine/engine_setup";
-    export const arContainerClassName = "ar";
-    export const quitARClassName = "quit-ar";
-    export class AROverlayHandler {
-        get ARContainer(): HTMLElement | null;
-        constructor();
-        private arContainer;
-        closeARCallback: any;
-        currentSession: THREE.XRSession | null;
-        registeredCloseEventElements: Element[];
-        private _createdAROnlyElements;
-        private _reparentedObjects;
-        requestEndAR(): void;
-        onBegin(context: Context, overlayContainer: HTMLElement, session: THREE.XRSession): void;
-        onEnd(_context: Context): void;
-        findOrCreateARContainer(element: HTMLElement): HTMLElement;
-        private onRequestedEndAR;
-        private createFallbackCloseARButton;
-    }
-}
 declare module "engine/engine_element_loading" {
     import { LoadingProgressArgs } from "engine/engine_setup";
     export class LoadingElementOptions {
@@ -1909,6 +1933,7 @@ declare module "engine-components/AnimatorController" {
         private updateActiveStates;
         private setStartTransition;
         private evaluateTransitions;
+        private getState;
         private transitionTo;
         private createAction;
         private evaluateCondition;
@@ -1981,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;
@@ -1989,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);
@@ -2081,10 +2110,10 @@ declare module "engine/extensions/NEEDLE_gameobject_data" {
 declare module "engine/extensions/NEEDLE_render_objects" {
     import { SourceIdentifier } from "engine/engine_types";
     import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
-    import { IRenderer as Renderer } from "engine/engine_types";
+    import { IRenderer } from "engine/engine_types";
     export class NEEDLE_render_objects implements GLTFLoaderPlugin {
         private static stencils;
-        static applyStencil(obj?: Renderer | null): void;
+        static applyStencil(obj?: IRenderer | null): void;
         private parser;
         private source;
         constructor(parser: GLTFParser, source: SourceIdentifier);
@@ -2288,6 +2317,9 @@ declare module "engine/api" {
     export { InstancingUtil } from "engine/engine_instancing";
     export * from "engine/engine_gameobject";
     export * from "engine/engine_components";
+    export { AssetReference } from "engine/engine_addressables";
+    export { FrameEvent } from "engine/engine_setup";
+    export * from "engine/debug/debug";
 }
 declare module "engine-components/AlignmentConstraint" {
     import { Behaviour } from "engine-components/Component";
@@ -2332,7 +2364,7 @@ declare module "engine-components/AudioSource" {
         static registerWaitForAllowAudio(cb: Function): void;
         private static _userInteractionRegistered;
         private static _beginWaitForUserInteraction;
-        private clip;
+        clip: string;
         playOnAwake: boolean;
         get loop(): boolean;
         set loop(val: boolean);
@@ -2482,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;
@@ -2707,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 {
@@ -2798,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;
@@ -2853,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";
@@ -2871,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;
@@ -2885,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;
@@ -3063,6 +3124,7 @@ declare module "engine-components/ui/EventSystem" {
         private objectsHoveredThisFrame;
         private objectsHoveredLastFrame;
         private raisedPointerDownEvents;
+        private raisedPointerDownObjects;
         private _didMove;
         onBeforeUpdate(): void;
         private _tempComponentsArray;
@@ -3108,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 { IRenderer } from "engine/engine_types";
+    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;
@@ -3124,7 +3216,8 @@ declare module "engine-components/Renderer" {
         Back = 1,
         Front = 2
     }
-    class SharedMaterialArray {
+    class SharedMaterialArray implements ISharedMaterials {
+        [num: number]: THREE.Material;
         private _renderer;
         private _targets;
         is(renderer: Renderer): boolean;
@@ -3141,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;
@@ -3167,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 {
     }
@@ -3225,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
@@ -3258,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;
@@ -3288,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;
@@ -3303,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;
@@ -3319,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",
@@ -3338,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;
@@ -3356,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;
@@ -3372,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 {
@@ -3409,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 {
@@ -3428,6 +3496,7 @@ declare module "engine-components/WebXR" {
         enableVR: boolean;
         enableAR: boolean;
         defaultAvatar?: AssetReference;
+        handModelPath: string;
         createVRButton: boolean;
         createARButton: boolean;
         private static _isInXr;
@@ -3442,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;
@@ -3463,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;
@@ -3500,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" {
@@ -3706,7 +3775,9 @@ declare module "engine-components/GroundProjection" {
         private env?;
         private _watcher?;
         onEnable(): void;
+        start(): void;
         onDisable(): void;
+        private updateAndCreate;
         updateProjection(): void;
     }
 }
@@ -4476,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 {
@@ -4494,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;
@@ -5266,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";
@@ -5364,9 +5436,6 @@ declare module "needle-engine" {
     export * from "engine-components/codegen/components";
     export * from "engine-components/js-extensions/Object3D";
 }
-declare module "engine/debug/error_overlay" {
-    export function makeErrorsVisibleForDevelopment(): void;
-}
 declare module "engine/engine" {
     import * as engine_setup from "engine/engine_setup";
     import * as engine_scenetools from "engine/engine_scenetools";