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

package/dist/needle-engine.d.ts

@@ -23,10 +23,35 @@ 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
+    }
+    export enum Axes {
+        None = 0,
+        X = 2,
+        Y = 4,
+        Z = 8,
+        All = -1
+    }
+}
 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 +93,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 +103,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;
@@ -114,33 +140,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;
+        readonly contacts: ContactPoint[];
+        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" {
@@ -164,7 +208,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;
@@ -254,6 +298,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";
@@ -323,6 +368,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;
 }
@@ -382,6 +430,7 @@ declare module "engine/engine_input" {
         getIsTouch(i: number): boolean;
         getTouchesPressedCount(): number;
         getMouseWheelChanged(i?: number): boolean;
+        getMouseWheelDeltaY(i?: number): number;
         getPointerEvent(i: number): Event | undefined;
         private context;
         private _pointerDown;
@@ -399,6 +448,7 @@ declare module "engine/engine_input" {
         private _pointerIds;
         private _pointerTypes;
         private _mouseWheelChanged;
+        private _mouseWheelDeltaY;
         private _pointerEvent;
         getKeyDown(): string | null;
         getKeyPressed(): string | null;
@@ -685,19 +735,11 @@ declare module "engine/engine_gameobject" {
     export function instantiate(instance: GameObject | Object3D | null, opts?: InstantiateOptions | null): GameObject | null;
 }
 declare module "engine/engine_physics" {
-    import { Body, Constraint } from 'cannon-es';
-    import { Camera, Intersection, Layers, Object3D, Ray, Raycaster, Vector2, Vector3 } 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";
-    import { Shape } from 'cannon-es';
-    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: Ray | undefined;
         cam: Camera | undefined | null;
@@ -733,46 +775,43 @@ declare module "engine/engine_physics" {
         private onSphereOverlap;
         raycastFromRay(ray: Ray, options?: RaycastOptions | null): Array<Intersection>;
         raycast(options?: RaycastOptions | null): Array<Intersection>;
-        get isUpdating(): boolean;
+        private _tempPosition;
+        private _tempQuaternion;
+        private _tempScale;
+        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: 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;
-        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;
+        addCapsuleCollider(collider: ICollider, center: Vector3, height: number, 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;
-    }
-    export interface IColliderProvider {
-        getCollider(obj: Object3D): ICollider;
+        /** sync rendered objects with physics world (except for colliders without rigidbody) */
+        private syncObjects;
+        private syncPhysicsBody;
+        private static _matricesBuffer;
+        private getRigidbodyRelativeMatrix;
     }
-    export function registerColliderProvider(prov: IColliderProvider): void;
 }
 declare module "engine/engine_time" {
     export class Time {
@@ -1150,7 +1189,7 @@ 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;
@@ -1226,6 +1265,7 @@ declare module "engine-components/Component" {
         onEnable(): void;
         onDisable(): void;
         onDestroy(): void;
+        onValidate?(prop?: string): void;
         start?(): void;
         earlyUpdate?(): void;
         update?(): void;
@@ -1234,11 +1274,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;
@@ -1249,6 +1288,7 @@ declare module "engine-components/Component" {
         protected __isEnabled: boolean | undefined;
         private __destroyed;
         get __internalDidAwakeAndStart(): boolean;
+        constructor();
         __internalNewInstanceCreated(): void;
         __internalAwake(): void;
         __internalStart(): void;
@@ -1257,16 +1297,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;
@@ -1540,9 +1570,11 @@ declare module "engine/engine_addressables" {
         private _glbRoot?;
         private _uri;
         private _progressListeners;
+        private _hash?;
+        private _hashedUri;
         private _isLoadingRawBinary;
         private _rawBinary?;
-        constructor(uri: string);
+        constructor(uri: string, hash?: string);
         private onResolvePrefab;
         private get mustLoad();
         isLoaded(): boolean | ArrayBuffer;
@@ -1643,6 +1675,7 @@ declare module "engine/engine_setup" {
         alias: string | undefined | null;
         domElement: HTMLElement | null;
         renderer?: THREE.WebGLRenderer;
+        hash?: string;
         constructor(domElement: HTMLElement | null);
     }
     export enum FrameEvent {
@@ -1651,7 +1684,8 @@ declare module "engine/engine_setup" {
         LateUpdate = 2,
         OnBeforeRender = 3,
         OnAfterRender = 4,
-        PhysicsStep = 10
+        PrePhysicsStep = 9,
+        PostPhysicsStep = 10
     }
     export enum XRSessionMode {
         ImmersiveVR = "immersive-vr",
@@ -1666,6 +1700,8 @@ declare module "engine/engine_setup" {
         name: string;
         alias: string | undefined | null;
         isManagedExternally: boolean;
+        /** used to append to loaded assets */
+        hash?: string;
         domElement: HTMLElement;
         get resolutionScaleFactor(): number;
         /** use to scale the resolution up or down of the renderer. default is 1 */
@@ -1677,6 +1713,8 @@ declare module "engine/engine_setup" {
         get domY(): number;
         get isInXR(): boolean;
         xrSessionMode: XRSessionMode | undefined;
+        get isInVR(): boolean;
+        get isInAR(): boolean;
         get xrSession(): THREE.XRSession | null;
         get arOverlayElement(): HTMLElement;
         scene: THREE.Scene;
@@ -2006,7 +2044,8 @@ declare module "engine-components/Animator" {
 declare module "engine-components/Animation" {
     import { Behaviour } from "engine-components/Component";
     import * as THREE from 'three';
-    import { AnimationAction, AnimationClip, Vector2 } from "three";
+    import { AnimationAction, AnimationClip } from "three";
+    import { Vec2 } from "engine/engine_types";
     export class PlayOptions {
         fadeDuration?: number;
         loop?: boolean;
@@ -2014,14 +2053,14 @@ declare module "engine-components/Animation" {
         startTime?: number;
         endTime?: number;
         clampWhenFinished?: boolean;
-        minMaxSpeed?: Vector2;
-        minMaxOffsetNormalized?: Vector2;
+        minMaxSpeed?: Vec2;
+        minMaxOffsetNormalized?: Vec2;
     }
     export class Animation extends Behaviour {
         playAutomatically: boolean;
         randomStartTime: boolean;
-        minMaxSpeed?: Vector2;
-        minMaxOffsetNormalized?: Vector2;
+        minMaxSpeed?: Vec2;
+        minMaxOffsetNormalized?: Vec2;
         private _tempAnimationClipBeforeGameObjectExisted;
         get clip(): AnimationClip | null;
         set clip(val: AnimationClip | null);
@@ -2046,6 +2085,7 @@ declare module "engine-components/Animation" {
         start(): void;
         update(): void;
         getAction(name: string): THREE.AnimationAction | undefined | null;
+        get isPlaying(): boolean;
         play(clipOrNumber: AnimationClip | number | string, options?: PlayOptions): Promise<AnimationAction> | void;
         internalOnPlay(action: AnimationAction, options?: PlayOptions): Promise<AnimationAction>;
         private tryFindHandle;
@@ -2313,6 +2353,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";
@@ -2320,6 +2367,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";
@@ -2447,6 +2495,7 @@ declare module "engine-components/Camera" {
         get cam(): THREE.PerspectiveCamera | THREE.OrthographicCamera;
         awake(): void;
         onEnable(): void;
+        onDisable(): void;
         buildCamera(): void;
         applyClearFlagsIfIsActiveCamera(): void;
         private environmentIsTransparent;
@@ -2529,65 +2578,84 @@ 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;
+        beforePhysics(): Generator<undefined, void, unknown>;
+        private get body();
+        teleport(pt: {
+            x: number;
+            y: number;
+            z: number;
+        }, localspace?: boolean): void;
+        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, Vector3 } 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;
@@ -2595,13 +2663,58 @@ declare module "engine-components/Collider" {
     }
     export class SphereCollider extends Collider {
         radius: number;
-        center: THREE.Vector3;
+        center: Vector3;
         onEnable(): void;
     }
     export class BoxCollider extends Collider {
-        size: THREE.Vector3;
-        center: THREE.Vector3;
+        size: Vector3;
+        center: Vector3;
+        onEnable(): void;
+    }
+    export class MeshCollider extends Collider {
+        sharedMesh?: Mesh;
+        convex: boolean;
+        awake(): void;
+        onEnable(): void;
+    }
+    export class CapsuleCollider extends Collider {
+        center: Vector3;
+        radius: number;
+        height: number;
+        onEnable(): void;
+    }
+}
+declare module "engine-components/CharacterController" {
+    import { Vector3 } from "three";
+    import { Collision } from "engine/engine_types";
+    import { Behaviour } from "engine-components/Component";
+    import { Rigidbody } from "engine-components/RigidBody";
+    import { Animator } from "engine-components/Animator";
+    export class CharacterController extends Behaviour {
+        center: Vector3;
+        radius: number;
+        height: number;
+        private _rigidbody;
+        get rigidbody(): Rigidbody;
         onEnable(): void;
+        move(vec: Vector3): void;
+        private _activeGroundCollisions;
+        onCollisionEnter(col: Collision): void;
+        onCollisionExit(col: Collision): void;
+        get isGrounded(): boolean;
+    }
+    export class CharacterControllerInput extends Behaviour {
+        controller?: CharacterController;
+        movementSpeed: number;
+        rotationSpeed: number;
+        jumpForce: number;
+        animator?: Animator;
+        private _currentSpeed;
+        private _currentAngularSpeed;
+        private _temp;
+        private _jumpCount;
+        update(): void;
+        private _raycastOptions;
     }
 }
 declare module "engine-components/ui/PointerEvents" {
@@ -3554,6 +3667,7 @@ declare module "engine-components/WebXR" {
         get webxr(): WebXR;
         private _webxr;
         private reticle;
+        private reticleParent;
         private hitTestSource;
         private reticleActive;
         private previousBackground;
@@ -3818,6 +3932,8 @@ declare module "engine-components/Light" {
         set shadowNormalBias(val: number);
         get shadowNormalBias(): number;
         private _shadowNormalBias;
+        /** when enabled this will remove the multiplication when setting the shadow bias settings initially */
+        private _overrideShadowBiasSettings;
         set shadows(val: LightShadows);
         get shadows(): LightShadows;
         private _shadows;
@@ -3882,13 +3998,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";
@@ -4262,14 +4371,15 @@ declare module "engine-components/Skybox" {
 declare module "engine-components/SmoothFollow" {
     import { Behaviour } from "engine-components/Component";
     import * as THREE from "three";
+    import { Axes } from "engine/engine_physics.types";
     export class SmoothFollow extends Behaviour {
         target: THREE.Object3D | null;
         followFactor: number;
         rotateFactor: number;
+        positionAxes: Axes;
         flipForward: boolean;
         private static _invertForward;
         private _firstUpdate;
-        onEnable(): void;
         onBeforeRender(): void;
         updateNow(hard: boolean): void;
     }
@@ -4323,6 +4433,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;
@@ -4347,21 +4458,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";
@@ -5300,9 +5396,13 @@ declare module "engine-components/codegen/components" {
     export { BasicIKConstraint } from "engine-components/BasicIKConstraint";
     export { BoxHelperComponent } from "engine-components/BoxHelperComponent";
     export { Camera } from "engine-components/Camera";
+    export { CharacterController } from "engine-components/CharacterController";
+    export { CharacterControllerInput } from "engine-components/CharacterController";
     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 { CapsuleCollider } from "engine-components/Collider";
     export { DeleteBox } from "engine-components/DeleteBox";
     export { Deletable } from "engine-components/DeleteBox";
     export { DeviceFlag } from "engine-components/DeviceFlag";
@@ -5325,8 +5425,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";
@@ -5351,7 +5449,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";