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

package/dist/needle-engine.d.ts

@@ -23,10 +23,28 @@ declare module "engine-components/js-extensions/RGBAColor" {
         multiply(color: Color): this;
     }
 }
+declare module "engine/engine_physics.types" {
+    export enum CollisionDetectionMode {
+        Discrete = 0,
+        Continuous = 1
+    }
+    export enum RigidbodyConstraints {
+        None = 0,
+        FreezePositionX = 2,
+        FreezePositionY = 4,
+        FreezePositionZ = 8,
+        FreezePosition = 14,
+        FreezeRotationX = 16,
+        FreezeRotationY = 32,
+        FreezeRotationZ = 64,
+        FreezeRotation = 112,
+        FreezeAll = 126
+    }
+}
 declare module "engine/engine_types" {
-    import { Camera, Color, Material, Object3D, Vector3 } from "three";
-    import { Body, ContactEquation } from "cannon-es";
+    import { Camera, Color, Material, Object3D, Vector3, Quaternion } from "three";
     import { RGBAColor } from "engine-components/js-extensions/RGBAColor";
+    import { CollisionDetectionMode, RigidbodyConstraints } from "engine/engine_physics.types";
     /** used to find data registered via gltf files e.g. find lightmaps for a Renderer component that were shipped inside a gltf */
     export type SourceIdentifier = string;
     export type Constructor<T> = abstract new (...args: any[]) => T;
@@ -68,6 +86,8 @@ declare module "engine/engine_types" {
         onEnable(): any;
         onDisable(): any;
         onDestroy(): any;
+        /** called for properties decorated with the @validate decorator */
+        onValidate?(property?: string): any;
         start?(): void;
         earlyUpdate?(): void;
         update?(): void;
@@ -76,14 +96,13 @@ declare module "engine/engine_types" {
         onAfterRender?(): void;
         onCollisionEnter?(col: Collision): any;
         onCollisionExit?(col: Collision): any;
-        onCollisionExitRaw?(col: Collision): any;
         onCollisionStay?(col: Collision): any;
-        onTriggerEnter?(col: Collision): any;
-        onTriggerStay?(col: Collision): any;
-        onTriggerExit?(col: Collision): any;
-        __internalHandleCollision(col: Collision, isTriggerCollision: boolean): any;
-        __internalHandleExitCollisionEvent(obj: Object3D, isTriggerCollision: boolean): any;
+        onTriggerEnter?(col: ICollider): any;
+        onTriggerStay?(col: ICollider): any;
+        onTriggerExit?(col: ICollider): any;
         get forward(): Vector3;
+        get worldPosition(): Vector3;
+        get worldQuaternion(): Quaternion;
     }
     export interface ICamera extends IComponent {
         applyClearFlagsIfIsActiveCamera(): unknown;
@@ -102,6 +121,7 @@ declare module "engine/engine_types" {
     }
     export interface ISharedMaterials {
         [num: number]: Material;
+        get length(): number;
     }
     export interface IRenderer extends IComponent {
         sharedMaterial: Material;
@@ -113,33 +133,51 @@ declare module "engine/engine_types" {
         isTrigger: boolean;
     }
     export interface IRigidbody extends IComponent {
-        initialize(): void;
-        body: any;
+        constraints: RigidbodyConstraints;
+        isKinematic: boolean;
+        mass: number;
+        drag: number;
+        angularDrag: number;
+        useGravity: boolean;
+        collisionDetectionMode: CollisionDetectionMode;
+        lockPositionX: boolean;
+        lockPositionY: boolean;
+        lockPositionZ: boolean;
+        lockRotationX: boolean;
+        lockRotationY: boolean;
+        lockRotationZ: boolean;
     }
     export const $physicsKey: unique symbol;
-    export type CannonCollision = {
-        body: Body;
-        contact: ContactEquation;
-        target: Body;
-        type: string;
-    };
     export type ICollisionContext = {
         getCollider(obj: Object3D): ICollider;
     };
+    export type Vec3 = {
+        x: number;
+        y: number;
+        z: number;
+    };
+    export type Vec2 = {
+        x: number;
+        y: number;
+    };
+    export class ContactPoint {
+        readonly localPoint: Vec3;
+        readonly distance: number;
+        readonly normal: Vec3;
+        constructor(localPt: Vec3, dist: number, normal: Vec3);
+    }
     export class Collision {
-        get __internalCollision(): CannonCollision;
-        get __internalInvertedSourceReceiver(): boolean;
-        private readonly invert;
-        private readonly collision;
-        private readonly targetBody;
-        private readonly context;
+        private readonly contacts;
+        constructor(obj: Object3D, otherCollider: ICollider, contacts: ContactPoint[]);
         readonly me: Object3D;
-        private _normal?;
-        get normal(): Vector3;
-        private _collider?;
+        private _collider;
+        /** the collider the collision happened with */
         get collider(): ICollider;
+        /** the object the collision happened with */
+        private _gameObject;
         get gameObject(): Object3D;
-        constructor(obj: Object3D, collision: CannonCollision, context: ICollisionContext, invert?: boolean);
+        /** the rigidbody we hit, null if none attached */
+        get rigidBody(): IRigidbody | null;
     }
 }
 declare module "engine/engine_utils" {
@@ -163,7 +201,7 @@ declare module "engine/engine_utils" {
     export function deepClone(obj: any, predicate?: deepClonePredicate): any;
     export function delay(milliseconds: number): Promise<void>;
     export function getPath(source: SourceIdentifier | undefined, uri: string): string;
-    export type WriteCallback = (data: any) => void;
+    export type WriteCallback = (data: any, prop: string) => void;
     export interface IWatch {
         subscribeWrite(callback: WriteCallback): any;
         apply(): any;
@@ -199,6 +237,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" {
@@ -252,6 +291,7 @@ declare module "engine/debug/debug" {
     import { LogType } from "engine/debug/debug_overlay";
     export { LogType };
     export function showBalloonMessage(text: string, logType?: LogType): void;
+    export function showBalloonWarning(text: string): void;
 }
 declare module "engine/engine_serialization_core" {
     import { GLTF } from "three/examples/jsm/loaders/GLTFLoader";
@@ -321,6 +361,9 @@ declare module "engine/engine_serialization_core" {
     }
     export function serializeObject(obj: ISerializable, context: SerializationContext): object | null;
     export function deserializeObject(obj: ISerializable, serializedData: object, context: SerializationContext): boolean;
+    /** set to true while assigning properties during instantiation.
+     * Used for validate decorator to not invoke callbacks on components that are currently in the process of being built */
+    export const $isAssigningProperties: unique symbol;
     /** Object.assign behaviour but check if property is writeable (e.g. getter only properties are skipped) */
     export function assign(target: any, source: any): void;
 }
@@ -558,7 +601,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 +716,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,40 +726,33 @@ 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 { Camera, Intersection, Layers, Mesh, 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";
-    export class BodyOptions {
-        mass: number;
-        kinematic: boolean;
-        physicsEvents: boolean;
-        drag: number;
-        angularDrag: number;
-        sleepThreshold: number;
-    }
+    import { IComponent, ICollider, IRigidbody } from "engine/engine_types";
+    import RAPIER, { RigidBody } from '@dimforge/rapier3d-compat';
+    export type Rapier = typeof RAPIER;
     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,49 +761,48 @@ 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>;
-        get isUpdating(): boolean;
+        raycastFromRay(ray: Ray, options?: RaycastOptions | null): Array<Intersection>;
+        raycast(options?: RaycastOptions | null): Array<Intersection>;
+        private _tempPosition;
+        private _tempQuaternion;
+        private _tempMatrix;
+        private static _didLoadPhysicsEngine;
         private _isUpdatingPhysicsWorld;
+        get isUpdating(): boolean;
         private context;
-        private world;
+        private world?;
+        private _hasCreatedWorld;
+        private eventQueue?;
+        private collisionHandler?;
         private objects;
-        private tempPosition;
-        private tempQuaternion;
+        private bodies;
         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;
-        private isAlreadyRegistered;
-        private readonly tempMat1;
-        private readonly tempMat2;
-        private addShape;
-        step(deltaTime: number): void;
-        private temp;
-        private tempQuat;
+        createWorld(): Promise<void>;
+        addBoxCollider(collider: ICollider, center: Vector3, size: Vector3): void;
+        addSphereCollider(collider: ICollider, center: Vector3, radius: number): void;
+        addMeshCollider(collider: ICollider, mesh: Mesh, convex: boolean): void;
+        private createCollider;
+        private getRigidbody;
+        removeBody(obj: IComponent): void;
+        updateBody(comp: ICollider | IRigidbody, translation: boolean, rotation: boolean): void;
+        updateProperties(rigidbody: IRigidbody): void;
+        internal_getRigidbody(rb: IRigidbody): RigidBody | null;
+        private internalUpdateProperties;
+        private lines?;
+        step(_deltaTime?: number): void;
+        private updateDebugRendering;
         postStep(): void;
-        private internalCreateBody;
-        private registerCollisionEvents;
-        private unregisterCollisionEvents;
-        private onBeginContact;
-        private readonly collisionContext;
-        private raiseCollisionEvents;
-        private onEndContact;
+        /** sync rendered objects with physics world (except for colliders without rigidbody) */
+        private syncObjects;
+        private syncPhysicsBody;
+        private static _matricesBuffer;
+        private getRigidbodyRelativeMatrix;
     }
     export interface IColliderProvider {
-        getCollider(obj: THREE.Object3D): ICollider;
+        getCollider(obj: Object3D): ICollider;
     }
     export function registerColliderProvider(prov: IColliderProvider): void;
 }
@@ -774,6 +810,7 @@ declare module "engine/engine_time" {
     export class Time {
         deltaTime: number;
         time: number;
+        /** same as frameCount */
         frame: number;
         get realtimeSinceStartup(): number;
         get frameCount(): number;
@@ -1145,11 +1182,11 @@ declare module "engine-components/Component" {
     import * as THREE from "three";
     import { Context, FrameEvent } from "engine/engine_setup";
     import { Object3D } from "three";
-    import { ConstructorConcrete, SourceIdentifier, IComponent, IGameObject, Constructor, GuidsMap, Collision } from "engine/engine_types";
+    import { ConstructorConcrete, SourceIdentifier, IComponent, IGameObject, Constructor, GuidsMap, Collision, ICollider } from "engine/engine_types";
     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;
@@ -1221,6 +1258,7 @@ declare module "engine-components/Component" {
         onEnable(): void;
         onDisable(): void;
         onDestroy(): void;
+        onValidate?(prop?: string): void;
         start?(): void;
         earlyUpdate?(): void;
         update?(): void;
@@ -1229,11 +1267,10 @@ declare module "engine-components/Component" {
         onAfterRender?(): void;
         onCollisionEnter?(col: Collision): any;
         onCollisionExit?(col: Collision): any;
-        onCollisionExitRaw?(col: Collision): any;
         onCollisionStay?(col: Collision): any;
-        onTriggerEnter?(col: Collision): any;
-        onTriggerStay?(col: Collision): any;
-        onTriggerExit?(col: Collision): any;
+        onTriggerEnter?(col: ICollider): any;
+        onTriggerStay?(col: ICollider): any;
+        onTriggerExit?(col: ICollider): any;
         startCoroutine(routine: Generator, evt?: FrameEvent): Generator;
         stopCoroutine(routine: Generator, evt?: FrameEvent): void;
         get destroyed(): boolean;
@@ -1243,6 +1280,8 @@ declare module "engine-components/Component" {
         protected __didEnable: boolean;
         protected __isEnabled: boolean | undefined;
         private __destroyed;
+        get __internalDidAwakeAndStart(): boolean;
+        constructor();
         __internalNewInstanceCreated(): void;
         __internalAwake(): void;
         __internalStart(): void;
@@ -1251,16 +1290,6 @@ declare module "engine-components/Component" {
         __internalDestroy(): void;
         get enabled(): boolean;
         set enabled(val: boolean);
-        constructor();
-        private _collisionExitRoutine;
-        private _collisions;
-        private _triggerExitRoutine;
-        private _triggerCollisions;
-        get collisionsCount(): number;
-        private __internalResetsCachedPhysicsData;
-        __internalHandleCollision(col: Collision, isTriggerCollision: boolean): void;
-        __internalHandleExitCollisionEvent(obj: Object3D, isTriggerCollision: boolean): void;
-        private __waitForCollisionExit;
         private static _worldPositionBuffer;
         private static _worldQuaternionBuffer;
         private static _worldEulerBuffer;
@@ -1927,6 +1956,7 @@ declare module "engine-components/AnimatorController" {
         private updateActiveStates;
         private setStartTransition;
         private evaluateTransitions;
+        private getState;
         private transitionTo;
         private createAction;
         private evaluateCondition;
@@ -2000,6 +2030,7 @@ declare module "engine-components/Animation" {
     import { Behaviour } from "engine-components/Component";
     import * as THREE from 'three';
     import { AnimationAction, AnimationClip } from "three";
+    import { Vec2 } from "engine/engine_types";
     export class PlayOptions {
         fadeDuration?: number;
         loop?: boolean;
@@ -2007,10 +2038,14 @@ declare module "engine-components/Animation" {
         startTime?: number;
         endTime?: number;
         clampWhenFinished?: boolean;
+        minMaxSpeed?: Vec2;
+        minMaxOffsetNormalized?: Vec2;
     }
     export class Animation extends Behaviour {
         playAutomatically: boolean;
         randomStartTime: boolean;
+        minMaxSpeed?: Vec2;
+        minMaxOffsetNormalized?: Vec2;
         private _tempAnimationClipBeforeGameObjectExisted;
         get clip(): AnimationClip | null;
         set clip(val: AnimationClip | null);
@@ -2302,6 +2337,13 @@ declare module "engine/engine_element" {
         private onBeforeBeginLoading;
     }
 }
+declare module "engine/engine_util_decorator" {
+    import { IComponent } from "engine/engine_types";
+    type setter = (v: any) => void;
+    type getter = () => any;
+    /** create accessor callbacks for a field */
+    export const validate: (set?: setter, get?: getter) => (target: IComponent | any, propertyKey: string, descriptor?: undefined) => void;
+}
 declare module "engine/api" {
     export { InstancingUtil } from "engine/engine_instancing";
     export * from "engine/engine_gameobject";
@@ -2309,6 +2351,7 @@ declare module "engine/api" {
     export { AssetReference } from "engine/engine_addressables";
     export { FrameEvent } from "engine/engine_setup";
     export * from "engine/debug/debug";
+    export { validate } from "engine/engine_util_decorator";
 }
 declare module "engine-components/AlignmentConstraint" {
     import { Behaviour } from "engine-components/Component";
@@ -2503,11 +2546,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;
@@ -2518,65 +2561,79 @@ declare module "engine-components/BoxHelperComponent" {
 }
 declare module "engine-components/RigidBody" {
     import { Behaviour } from "engine-components/Component";
-    import * as CANNON from 'cannon-es';
     import * as THREE from 'three';
     import { Vector3 } from "three";
     import { IRigidbody } from "engine/engine_types";
+    import { CollisionDetectionMode, RigidbodyConstraints } from "engine/engine_physics.types";
     export class Rigidbody extends Behaviour implements IRigidbody {
         mass: number;
-        set isKinematic(kinematic: boolean);
-        get isKinematic(): boolean;
-        private _isKinematic;
+        useGravity: boolean;
+        constraints: RigidbodyConstraints;
+        isKinematic: boolean;
         drag: number;
         angularDrag: number;
         detectCollisions: boolean;
         sleepThreshold: number;
-        get body(): CANNON.Body | null;
+        collisionDetectionMode: CollisionDetectionMode;
+        get lockPositionX(): boolean;
+        get lockPositionY(): boolean;
+        get lockPositionZ(): boolean;
+        get lockRotationX(): boolean;
+        get lockRotationY(): boolean;
+        get lockRotationZ(): boolean;
+        set lockPositionX(v: boolean);
+        set lockPositionY(v: boolean);
+        set lockPositionZ(v: boolean);
+        set lockRotationX(v: boolean);
+        set lockRotationY(v: boolean);
+        set lockRotationZ(v: boolean);
+        private _propertiesChanged;
         private static tempPosition;
-        private _body;
-        private currentVelocity;
+        private _currentVelocity;
         private _smoothedVelocity;
-        private lastWorldPosition;
-        private _ignoreChange;
-        private _dirty;
-        private _positionWatch?;
-        private _matrixWatch?;
-        private _setMatrix;
-        constructor();
+        private _smoothedVelocityGetter;
+        private _lastPosition;
+        private _watch?;
         awake(): void;
         onEnable(): void;
         onDisable(): void;
         onDestroy(): void;
-        onBeforeRender(): void;
-        initialize(): void;
+        onValidate(): void;
+        earlyUpdate(): void;
+        private get body();
+        resetForces(): void;
+        resetTorques(): void;
+        resetVelocities(): void;
+        resetForcesAndTorques(): void;
         wakeUp(): void;
-        applyForce(vec: THREE.Vector3, rel?: THREE.Vector3): void;
+        applyForce(vec: Vector3, _rel?: THREE.Vector3): void;
+        applyImpulse(vec: Vector3): void;
         setForce(x: number, y: number, z: number): void;
-        getVelocity(): THREE.Vector3;
-        setVelocity(x: number | Vector3, y: number, z: number): void;
-        getTorque(): THREE.Vector3;
+        getVelocity(): Vector3;
+        setVelocity(x: number | Vector3, y?: number, z?: number): void;
+        setAngularVelocity(x: number | Vector3, y?: number, z?: number): void;
         setTorque(x: number | Vector3, y: number, z: number): void;
-        get smoothedVelocity(): THREE.Vector3;
-        setAngularVelocity(x: number, y: number, z: number): void;
-        private static copyVector3;
-        setBodyFromGameObject(velocity?: THREE.Vector3 | null | {
+        get smoothedVelocity(): Vector3;
+        /**d
+         * @deprecated not used anymore
+         */
+        setBodyFromGameObject(_velocity?: THREE.Vector3 | null | {
             x: number;
             y: number;
             z: number;
         }): void;
-        private updateVelocity;
+        private captureVelocity;
     }
 }
 declare module "engine-components/Collider" {
     import { Behaviour } from "engine-components/Component";
     import { Rigidbody } from "engine-components/RigidBody";
-    import { Shape } from "cannon-es";
+    import { Mesh } from "three";
     import { ICollider } from "engine/engine_types";
     export class Collider extends Behaviour implements ICollider {
         get isCollider(): any;
         attachedRigidbody: Rigidbody | null;
         isTrigger: boolean;
-        protected _shape: Shape | null;
         awake(): void;
         start(): void;
         onEnable(): void;
@@ -2592,6 +2649,12 @@ declare module "engine-components/Collider" {
         center: THREE.Vector3;
         onEnable(): void;
     }
+    export class MeshCollider extends Collider {
+        sharedMesh?: Mesh;
+        convex: boolean;
+        awake(): void;
+        onEnable(): void;
+    }
 }
 declare module "engine-components/ui/PointerEvents" {
     export interface IInputEventArgs {
@@ -2728,6 +2791,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 +2912,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 +2967,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 +2984,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 +2998,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 +3176,7 @@ declare module "engine-components/ui/EventSystem" {
         private objectsHoveredThisFrame;
         private objectsHoveredLastFrame;
         private raisedPointerDownEvents;
+        private raisedPointerDownObjects;
         private _didMove;
         onBeforeUpdate(): void;
         private _tempComponentsArray;
@@ -3129,12 +3222,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 +3286,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 +3314,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 +3375,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 +3407,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 +3437,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 +3452,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 +3468,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 +3488,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 +3506,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 +3522,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 +3529,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 +3548,7 @@ declare module "engine-components/WebXR" {
         enableVR: boolean;
         enableAR: boolean;
         defaultAvatar?: AssetReference;
+        handModelPath: string;
         createVRButton: boolean;
         createARButton: boolean;
         private static _isInXr;
@@ -3464,7 +3563,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 +3584,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;
@@ -3507,6 +3606,7 @@ declare module "engine-components/WebXR" {
         get webxr(): WebXR;
         private _webxr;
         private reticle;
+        private reticleParent;
         private hitTestSource;
         private reticleActive;
         private previousBackground;
@@ -3522,9 +3622,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 +3828,9 @@ declare module "engine-components/GroundProjection" {
         private env?;
         private _watcher?;
         onEnable(): void;
+        start(): void;
         onDisable(): void;
+        private updateAndCreate;
         updateProjection(): void;
     }
 }
@@ -3833,13 +3935,6 @@ declare module "engine-components/LODGroup" {
         distanceFactor(factor: number): void;
     }
 }
-declare module "engine-components/NavMesh" {
-    import { Behaviour } from "engine-components/Component";
-    export class NavMesh extends Behaviour {
-    }
-    export class NavMeshAgent extends Behaviour {
-    }
-}
 declare module "engine-components/NestedGltf" {
     import { Behaviour } from "engine-components/Component";
     import { AssetReference, ProgressCallback } from "engine/engine_addressables";
@@ -4274,6 +4369,7 @@ declare module "engine-components/SpectatorCamera" {
         /** list of other users that are following me */
         get followers(): string[];
         stopSpectating(): void;
+        private get localId();
         /** player view to follow */
         set target(target: PlayerView | undefined);
         get target(): PlayerView | undefined;
@@ -4298,21 +4394,6 @@ declare module "engine-components/SpectatorCamera" {
         private resetAvatarFlags;
     }
 }
-declare module "engine-components/SpringJoint" {
-    import { Behaviour } from "engine-components/Component";
-    import { Rigidbody } from "engine-components/RigidBody";
-    import { Vector3 } from "three";
-    export class SpringJoint extends Behaviour {
-        anchor: Vector3 | null;
-        connectedBody: Rigidbody | null;
-        connectedAnchor: Vector3 | null;
-        spring: number;
-        damper: number;
-        private rb;
-        awake(): void;
-        update(): void;
-    }
-}
 declare module "engine-components/SpriteRenderer" {
     import { Behaviour } from "engine-components/Component";
     import * as THREE from "three";
@@ -4498,7 +4579,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 +4597,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;
@@ -5254,6 +5335,7 @@ declare module "engine-components/codegen/components" {
     export { Collider } from "engine-components/Collider";
     export { SphereCollider } from "engine-components/Collider";
     export { BoxCollider } from "engine-components/Collider";
+    export { MeshCollider } from "engine-components/Collider";
     export { DeleteBox } from "engine-components/DeleteBox";
     export { Deletable } from "engine-components/DeleteBox";
     export { DeviceFlag } from "engine-components/DeviceFlag";
@@ -5276,8 +5358,6 @@ declare module "engine-components/codegen/components" {
     export { LODModel } from "engine-components/LODGroup";
     export { LODGroup } from "engine-components/LODGroup";
     export { LookAtConstraint } from "engine-components/LookAtConstraint";
-    export { NavMesh } from "engine-components/NavMesh";
-    export { NavMeshAgent } from "engine-components/NavMesh";
     export { NestedGltf } from "engine-components/NestedGltf";
     export { Networking } from "engine-components/Networking";
     export { OffsetConstraint } from "engine-components/OffsetConstraint";
@@ -5288,6 +5368,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";
@@ -5301,7 +5382,6 @@ declare module "engine-components/codegen/components" {
     export { SpatialTriggerReceiver } from "engine-components/SpatialTrigger";
     export { SpatialTrigger } from "engine-components/SpatialTrigger";
     export { SpectatorCamera } from "engine-components/SpectatorCamera";
-    export { SpringJoint } from "engine-components/SpringJoint";
     export { Sprite } from "engine-components/SpriteRenderer";
     export { SpriteRenderer } from "engine-components/SpriteRenderer";
     export { SyncedCamera } from "engine-components/SyncedCamera";