@needle-tools/engine 2.29.0-pre → 2.31.0-pre

package/dist/needle-engine.d.ts

@@ -57,7 +57,7 @@ declare module "engine/engine_utils" {
     type deepClonePredicate = (owner: any, propertyName: string, current: any) => boolean;
     export function deepClone(obj: any, predicate?: deepClonePredicate): any;
     export function delay(milliseconds: number): Promise<void>;
-    export function getPath(glbLocation: SourceIdentifier | undefined, path: string): string;
+    export function getPath(source: SourceIdentifier | undefined, uri: string): string;
     export type WriteCallback = (data: any) => void;
     export class Watch {
         subscribeWrite(callback: WriteCallback): void;
@@ -350,789 +350,833 @@ declare module "engine/engine_networking_instantiate" {
     export type PrefabProviderCallback = (guid: string) => Promise<GameObject | null>;
     export function registerPrefabProvider(key: string, fn: PrefabProviderCallback): void;
 }
-declare module "engine-components/Component" {
-    import * as THREE from "three";
-    import { Context, FrameEvent } from "engine/engine_setup";
-    import { Object3D } from "three";
-    import { SourceIdentifier } from "engine/engine_gltf";
-    export interface UIDProvider {
-        seed: number;
-        generateUUID(): string;
-    }
-    export enum HideFlags {
-        None = 0,
-        HideInHierarchy = 1,
-        HideInInspector = 2,
-        DontSaveInEditor = 4,
-        NotEditable = 8,
-        DontSaveInBuild = 16,
-        DontUnloadUnusedAsset = 32,
-        DontSave = 52,
-        HideAndDontSave = 61
-    }
-    export type Constructor<T> = abstract new (...args: any[]) => T;
-    export type ConstructorConcrete<T> = new (...args: any[]) => T;
-    export type GuidsMap = {
-        [key: string]: string;
+declare module "engine-components/ui/Utils" {
+    import { FrameEvent } from "engine/engine_setup";
+    import { Behaviour } from "engine-components/Component";
+    export function isUIObject(obj: THREE.Object3D): boolean;
+    export type RenderSettings = {
+        renderOnTop?: boolean;
+        doubleSided?: boolean;
+        depthWrite?: boolean;
+        castShadows?: boolean;
+        receiveShadows?: boolean;
     };
-    type FunctionName = string;
-    export class InstantiateOptions {
-        idProvider?: UIDProvider | undefined;
-        parent?: string | undefined | Object3D;
-        /** for duplicatable parenting */
-        keepWorldPosition?: boolean;
-        position?: THREE.Vector3 | undefined;
-        rotation?: THREE.Quaternion | undefined;
-        scale?: THREE.Vector3 | undefined;
-        visible?: boolean | undefined;
-        context?: Context | undefined;
-    }
-    abstract class GameObject extends THREE.Object3D implements THREE.Object3D {
-        guid: string | undefined;
-        static setActive(go: THREE.Object3D, active: boolean): void;
-        static isActiveSelf(go: THREE.Object3D): boolean;
-        static isActiveInHierarchy(go: THREE.Object3D): boolean;
-        static markAsInstancedRendered(go: THREE.Object3D, instanced: boolean): void;
-        static isUsingInstancing(instance: THREE.Object3D): boolean;
-        static foreachComponent(instance: THREE.Object3D, cb: (comp: Component) => any, recursive?: boolean): any;
-        static instantiateSynced(instance: GameObject | THREE.Object3D | null, opts: InstantiateOptions): GameObject | null;
-        static instantiate(instance: GameObject | THREE.Object3D | null, opts?: InstantiateOptions | null): GameObject | null;
-        private static internalInstantiate;
-        private static resolveAndBindSkinnedMeshBones;
-        private static resolveReferences;
-        private static postProcessNewInstance;
-        static destroySynced(instance: THREE.Object3D | Component, context?: Context, recursive?: boolean): void;
-        static destroy(instance: THREE.Object3D | Component, recursive?: boolean, isRoot?: boolean): void;
-        /**
-         * Add an object to parent and also ensure all components are being registered
-         */
-        static add(instance: THREE.Object3D | null | undefined, parent: THREE.Object3D, context?: Context): void;
-        /**
-         * Removes the object from its parent and deactivates all of its components
-         */
-        static remove(instance: THREE.Object3D | null | undefined): void;
-        static invokeOnChildren(go: THREE.Object3D | null | undefined, functionName: string | FunctionName, ...args: any): void;
-        static invoke(go: THREE.Object3D | null | undefined, functionName: string | FunctionName, children?: boolean, ...args: any): void;
-        static addNewComponent<T extends Behaviour>(go: GameObject | THREE.Object3D, type: ConstructorConcrete<T>, callAwake?: boolean): T;
-        static addComponent(go: GameObject, instance: Component): void;
-        static removeComponent(instance: Component): Component;
-        static getOrAddComponent<T>(go: GameObject | THREE.Object3D, typeName: Constructor<T> | null): T;
-        static getComponent<T>(go: GameObject | THREE.Object3D | null, typeName: Constructor<T> | null): T | null;
-        static getComponents<T>(go: GameObject | THREE.Object3D | null, typeName: Constructor<T> | null, arr?: T[] | null): T[];
-        static findByGuid(guid: string, hierarchy: THREE.Object3D): GameObject | Behaviour | null | undefined;
-        static findObjectOfType<T>(typeName: Constructor<T> | string, context?: Context | THREE.Object3D, includeInactive?: boolean): T | null;
-        static findObjectsOfType<T>(typeName: Constructor<T>, context?: Context | THREE.Object3D): Array<T>;
-        static getComponentInChildren<T>(go: GameObject | THREE.Object3D, typeName: Constructor<T> | null): T | null;
-        static getComponentsInChildren<T>(go: GameObject | THREE.Object3D, typeName: Constructor<T> | null, arr?: T[] | null): Array<T>;
-        static getComponentInParent<T>(go: GameObject | THREE.Object3D | Array<Object3D>, typeName: Constructor<T>): T | null;
-        static getComponentsInParent<T>(go: GameObject | THREE.Object3D, typeName: Constructor<T>, arr?: Array<T> | null): Array<T>;
-        static getAllComponents(go: GameObject | THREE.Object3D): Behaviour[];
-        static iterateComponents(go: GameObject | THREE.Object3D): Generator<any, void, unknown>;
-        abstract addNewComponent<T>(type: Constructor<T>): T | null;
-        abstract removeComponent(comp: Component): Component;
-        abstract getOrAddComponent<T>(go: GameObject | THREE.Object3D, typeName: Constructor<T> | null): T;
-        abstract getComponent<T>(type: Constructor<T>): T | null;
-        abstract getComponents<T>(type: Constructor<T>, arr?: T[]): Array<T>;
-        abstract getComponentInChildren<T>(type: Constructor<T>): T | null;
-        abstract getComponentsInChildren<T>(type: Constructor<T>, arr?: T[]): Array<T>;
-        abstract getComponentInParent<T>(type: Constructor<T>): T | null;
-        abstract getComponentsInParent<T>(type: Constructor<T>, arr?: T[]): Array<T>;
-    }
-    class Component implements EventTarget {
-        get isComponent(): boolean;
-        private __context;
-        get context(): Context;
-        set context(context: Context);
-        get scene(): THREE.Scene;
-        get layer(): number;
-        get name(): string;
-        private __name?;
-        set name(str: string);
-        get tag(): string;
-        set tag(str: string);
-        get static(): any;
-        get hideFlags(): HideFlags;
-        get activeAndEnabled(): boolean;
-        private get __isActive();
-        private get __isActiveInHierarchy();
-        gameObject: GameObject;
-        guid: string;
-        sourceId?: SourceIdentifier;
-        /** called on a component with a map of old to new guids (e.g. when instantiate generated new guids and e.g. timeline track bindings needs to remape them) */
-        resolveGuids?(guidsMap: GuidsMap): void;
+    export function updateRenderSettings(shadowComponent: THREE.Object3D, settings: RenderSettings): void;
+    export type RevocableProxy = {
+        proxy: any;
+        revoke: () => void;
+    };
+    /** internal method to proxy a field to detect changes */
+    export function onChange<T extends object>(caller: T, field: string, callback: (newValue: any, oldValue: any) => void): RevocableProxy;
+    /** internal method to schedula a function at a specific moment in the update loop */
+    export function scheduleAction(caller: Behaviour, action: Function, timing?: FrameEvent): void;
+}
+declare module "engine/engine_serialization_decorator" {
+    import { Constructor } from "engine-components/Component";
+    export type TypeResolver<T> = (data: any) => Constructor<T> | null;
+    export const serializeable: <T>(type?: Constructor<T> | TypeResolver<T> | (Constructor<any> | TypeResolver<T>)[] | null | undefined) => (_target: any, _propertyKey: string) => void;
+    export const ALL_PROPERTIES_MARKER = "__NEEDLE__ALL_PROPERTIES";
+    /** @deprecated current not used */
+    export function allProperties(constructor: Function): void;
+    export const STRICT_MARKER = "__NEEDLE__STRICT";
+    /** @deprecated  current not used */
+    export function strict(constructor: Function): void;
+}
+declare module "engine-components/Rigidbody" {
+    import { Behaviour } from "engine-components/Component";
+    import * as CANNON from 'cannon-es';
+    import * as THREE from 'three';
+    export class Rigidbody extends Behaviour {
+        mass: number;
+        set isKinematic(kinematic: boolean);
+        get isKinematic(): boolean;
+        private _isKinematic;
+        drag: number;
+        angularDrag: number;
+        detectCollisions: boolean;
+        sleepThreshold: number;
+        get body(): CANNON.Body | null;
+        private static tempPosition;
+        private _body;
+        private currentVelocity;
+        private _smoothedVelocity;
+        private lastWorldPosition;
+        private dirty;
+        private transformProxy?;
         awake(): void;
+        start(): void;
         onEnable(): void;
         onDisable(): void;
         onDestroy(): void;
-        start?(): void;
-        earlyUpdate?(): void;
-        update?(): void;
-        lateUpdate?(): void;
-        onBeforeRender?(frame: THREE.XRFrame | null): void;
-        onAfterRender?(): void;
-        startCoroutine(routine: Generator, evt?: FrameEvent): Generator;
-        stopCoroutine(routine: Generator, evt?: FrameEvent): void;
-        get destroyed(): boolean;
-        destroy(): void;
-        protected __didAwake: boolean;
-        private __didStart;
-        protected __didEnable: boolean;
-        protected __isEnabled: boolean | undefined;
-        private __destroyed;
-        __internalNewInstanceCreated(): void;
-        __internalAwake(): void;
-        __internalStart(): void;
-        __internalEnable(): void;
-        __internalDisable(): void;
-        constructor();
-        private static _worldPositionBuffer;
-        private static _worldQuaternionBuffer;
-        private static _worldEulerBuffer;
-        private _worldPosition;
-        private _worldQuaternion;
-        private static _tempQuaternionBuffer2;
-        private _worldEuler;
-        private _worldRotation;
-        get worldPosition(): THREE.Vector3;
-        set worldPosition(val: THREE.Vector3);
-        setWorldPosition(x: number, y: number, z: number): void;
-        get worldQuaternion(): THREE.Quaternion;
-        set worldQuaternion(val: THREE.Quaternion);
-        setWorldQuaternion(x: number, y: number, z: number, w: number): void;
-        get worldEuler(): THREE.Euler;
-        set worldEuler(val: THREE.Euler);
-        get worldRotation(): THREE.Vector3;
-        set worldRotation(val: THREE.Vector3);
-        setWorldRotation(x: number, y: number, z: number, degrees?: boolean): void;
-        private static _forward;
-        get forward(): THREE.Vector3;
-        private _eventListeners;
-        addEventListener(type: string, listener: EventListener): void;
-        removeEventListener(type: string, listener: EventListener): void;
-        dispatchEvent(evt: Event): boolean;
-    }
-    class Behaviour extends Component {
-        get enabled(): boolean;
-        set enabled(val: boolean);
+        earlyUpdate(): void;
+        onBeforeRender(): void;
+        initialize(): void;
+        wakeUp(): void;
+        applyForce(vec: THREE.Vector3, rel: THREE.Vector3 | undefined): void;
+        getVelocity(): THREE.Vector3;
+        setVelocity(x: number, 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 | {
+            x: number;
+            y: number;
+            z: number;
+        }): void;
+        private updateVelocity;
     }
-    export { Behaviour, Component, GameObject };
 }
-declare module "engine/extensions/extension_resolver" {
-    import { GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
-    export interface IExtensionReferenceResolver {
-        resolve(parser: GLTFParser, path: string): Promise<void> | null;
+declare module "engine-components/RendererLightmap" {
+    import { GameObject } from "engine-components/Component";
+    import * as THREE from "three";
+    import { Texture } from "three";
+    import { Context } from "engine/engine_setup";
+    export class RendererLightmap {
+        get lightmap(): Texture | null;
+        set lightmap(tex: Texture | null);
+        lightmapIndex: number;
+        lightmapScaleOffset: THREE.Vector4;
+        private context;
+        private gameObject;
+        private lightmapTexture;
+        private lightmapScaleOffsetUniform;
+        private lightmapUniform;
+        private beforeRenderCallback?;
+        constructor(gameObject: GameObject, context: Context);
+        init(lightmapIndex: number, lightmapScaleOffset: THREE.Vector4, lightmapTexture: THREE.Texture, debug?: boolean): void;
+        bindOnBeforeRender(): void;
+        private onBeforeRenderThreeComplete;
+        private setupLightmap;
+        onBeforeRenderThree(material: THREE.Material): void;
+        private setLightmapDebugMaterial;
     }
 }
-declare module "engine/engine_default_parameters" {
-    export const showGizmos: string | boolean;
-    export const debugExtension: string | boolean;
-}
-declare module "engine/extensions/extension_utils" {
-    import { GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
-    export function resolveReferences(parser: GLTFParser, obj: any): Promise<void | void[]>;
-}
-declare module "engine/engine_typestore" {
-    class _TypeStore {
-        private _types;
-        add(key: any, type: any): void;
-        get(key: any): any;
+declare module "engine/extensions/NEEDLE_render_objects" {
+    import { SourceIdentifier } from "engine/engine_gltf";
+    import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
+    import { Renderer } from "engine-components/Renderer";
+    export class NEEDLE_render_objects implements GLTFLoaderPlugin {
+        private static stencils;
+        static applyStencil(obj?: Renderer | null): void;
+        private parser;
+        private source;
+        constructor(parser: GLTFParser, source: SourceIdentifier);
+        afterRoot(_result: GLTF): Promise<void> | null;
     }
-    export const TypeStore: _TypeStore;
+    export const EXTENSION_NAME = "NEEDLE_render_objects";
 }
-declare module "engine/extensions/NEEDLE_persistent_assets" {
+declare module "engine/engine_loaders" {
+    import { Context } from "engine/engine_setup";
+    import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+    export function setDracoDecoderPath(path: string | undefined): void;
+    export function setDracoDecoderType(type: string | undefined): void;
+    export function setKtx2TranscoderPath(path: string): void;
+    export function addDracoAndKTX2Loaders(loader: GLTFLoader, context: Context): void;
+}
+declare module "engine/extensions/NEEDLE_deferred_texture" {
+    import { Material } from "three";
     import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
-    import { IExtensionReferenceResolver } from "engine/extensions/extension_resolver";
-    export const EXTENSION_NAME = "NEEDLE_persistent_assets";
-    export function isPersistentAsset(asset: any): boolean;
-    export class NEEDLE_persistent_assets implements GLTFLoaderPlugin, IExtensionReferenceResolver {
+    import { SourceIdentifier } from "engine/engine_gltf";
+    import { Context } from "engine/engine_setup";
+    export const EXTENSION_NAME = "NEEDLE_deferred_texture";
+    export class NEEDLE_deferred_texture implements GLTFLoaderPlugin {
+        static assignTextureLOD(context: Context, source: SourceIdentifier | undefined, material: Material, level?: number): void;
         get name(): string;
         private parser;
-        constructor(parser: GLTFParser);
-        afterRoot(_result: GLTF): Promise<void>;
-        resolve(parser: GLTFParser, path: string): Promise<void> | null | any;
+        private sourceId;
+        private context;
+        constructor(parser: GLTFParser, sourceId: SourceIdentifier, context: Context);
+        private _loading;
+        afterRoot(gltf: GLTF): null;
+        private static cache;
+        private static resolved;
+        private static getOrLoadTexture;
     }
 }
-declare module "engine/engine_serialization_core" {
-    import { GLTF } from "three/examples/jsm/loaders/GLTFLoader";
-    import { Object3D } from "three";
-    import { Context } from "engine/engine_setup";
-    import { SourceIdentifier } from "engine/engine_gltf";
-    export type Constructor<T> = {
-        new (...args: any[]): T;
-    };
-    export type NodeToObjectMap = {
-        [nodeId: string]: Object3D;
-    };
-    export type ObjectToNodeMap = {
-        [uuid: string]: number;
-    };
-    class SerializationHelper {
-        register(type: string, ser: ITypeSerializer): void;
-        typeMap: {
-            [type: string]: ITypeSerializer;
-        };
-        getSerializer(type: string): ITypeSerializer | undefined;
-        getSerializerForConstructor(type: any, level?: number): ITypeSerializer | undefined;
+declare module "engine-components/Renderer" {
+    import { Behaviour } from "engine-components/Component";
+    import * as THREE from "three";
+    import { Texture } from "three";
+    export class FieldWithDefault {
+        path: string | null;
+        asset: object | null;
+        default: any;
     }
-    export const helper: SerializationHelper;
-    export interface ITypeSerializer {
-        onSerialize(data: any, context: SerializationContext): any;
-        onDeserialize(data: any, context: SerializationContext): any;
+    export enum RenderState {
+        Both = 0,
+        Back = 1,
+        Front = 2
     }
-    /**
-     * implement and call super(<type string or array>) with the type names this serializer can handle
-     * for example:
-     * class ColorSerializer extends TypeSerializer {
-     *  constructor() {
-     *      super("Color")
-     *  }
-     * }
-    */
-    export abstract class TypeSerializer implements ITypeSerializer {
-        constructor(type: Constructor<any> | Constructor<any>[]);
-        abstract onSerialize(data: any, context: SerializationContext): any | void;
-        abstract onDeserialize(data: any, context: SerializationContext): any | void;
+    class SharedMaterialArray {
+        private _renderer;
+        private _targets;
+        is(renderer: Renderer): boolean;
+        constructor(renderer: Renderer);
+        get length(): number;
+        private setMaterial;
+        private getMaterial;
     }
-    export interface ITypeInformation {
-        type?: Constructor<any>;
+    export class Renderer extends Behaviour {
+        receiveShadows: boolean;
+        shadowCastingMode: ShadowCastingMode;
+        lightmapIndex: number;
+        lightmapScaleOffset: THREE.Vector4;
+        enableInstancing: boolean[] | undefined;
+        renderOrder: number[] | undefined;
+        allowOcclusionWhenDynamic: boolean;
+        private _lightmaps?;
+        get material(): THREE.Material;
+        set material(mat: THREE.Material);
+        private _sharedMaterials;
+        get sharedMaterials(): SharedMaterialArray;
+        static get shouldSuppressInstancing(): string | boolean;
+        private _lightmapTextureOverride;
+        get lightmap(): Texture | null;
+        set lightmap(tex: Texture | null | undefined);
+        get hasLightmap(): boolean;
+        awake(): void;
+        private _isInstancingEnabled;
+        private handles;
+        private prevLayers;
+        private clearInstancingState;
+        setInstancingEnabled(enabled: boolean): boolean;
+        start(): void;
+        onEnable(): void;
+        onDisable(): void;
+        onDestroy(): void;
+        applyStencil(): void;
+        onBeforeRenderThree(_renderer: any, _scene: any, _camera: any, _geometry: any, material: any, _group: any): void;
+        onBeforeRender(): void;
+        onAfterRender(): void;
+        private applySettings;
     }
-    export class SerializationContext {
-        root: THREE.Object3D;
-        gltf?: GLTF;
-        gltfId?: SourceIdentifier;
-        object: THREE.Object3D;
-        target?: object;
-        nodeId?: number;
-        nodeToObject?: NodeToObjectMap;
-        objectToNode?: ObjectToNodeMap;
-        context?: Context;
-        path?: string;
-        constructor(root: THREE.Object3D);
+    export class MeshRenderer extends Renderer {
     }
-    export interface ISerializable {
-        $serializedTypes?: {
-            [key: string]: Constructor<any> | ITypeInformation | null;
-        };
-        onBeforeDeserialize?(data: any, context: SerializationContext): void | undefined | boolean;
-        onBeforeDeserializeMember?(key: string, data: any, context: SerializationContext): void | undefined | boolean;
-        onAfterDeserializeMember?(key: string, data: any, context: SerializationContext): void;
-        onAfterDeserialize?(data: any, context: SerializationContext): void;
+    export class SkinnedMeshRenderer extends MeshRenderer {
+        awake(): void;
+    }
+    export enum ShadowCastingMode {
+        Off = 0,
+        On = 1,
+        TwoSided = 2,
+        ShadowsOnly = 3
+    }
+    export class InstancingUtil {
+        static markDirty(go: THREE.Object3D | null, recursive?: boolean): void;
     }
-    export function serializeObject(obj: ISerializable, context: SerializationContext): object | null;
-    export function deserializeObject(obj: ISerializable, serializedData: object, context: SerializationContext): boolean;
-    /** Object.assign behaviour but check if property is writeable (e.g. getter only properties are skipped) */
-    export function assign(target: any, source: any): void;
 }
-declare module "engine/engine_input" {
+declare module "engine-components/Collider" {
+    import { Behaviour } from "engine-components/Component";
+    import { Rigidbody } from "engine-components/Rigidbody";
+    import { Shape } from "cannon-es";
+    export class Collider extends Behaviour {
+        attachedRigidbody: Rigidbody | null;
+        isTrigger: boolean;
+        protected _shape: Shape | null;
+        awake(): void;
+        onEnable(): void;
+        onDisable(): void;
+    }
+    export class SphereCollider extends Collider {
+        radius: number;
+        center: THREE.Vector3;
+        onEnable(): void;
+    }
+    export class BoxCollider extends Collider {
+        size: THREE.Vector3;
+        center: THREE.Vector3;
+        onEnable(): void;
+    }
+}
+declare module "engine/engine_physics" {
+    import * as CANNON from 'cannon-es';
     import * as THREE from 'three';
     import { Context } from "engine/engine_setup";
-    export type PointerEventArgs = {
-        button: number;
-        clientX: number;
-        clientY: number;
-        pointerId?: number;
-        pointerType: string;
-        source?: Event;
+    import { Rigidbody } from "engine-components/Rigidbody";
+    import { GameObject } from "engine-components/Component";
+    import { Object3D, Vector3 } from 'three';
+    import { Collider } from "engine-components/Collider";
+    export class BodyOptions {
+        mass: number;
+        kinematic: boolean;
+        physicsEvents: boolean;
+        drag: number;
+        angularDrag: number;
+        sleepThreshold: number;
+    }
+    type CannonCollision = {
+        body: CANNON.Body;
+        contact: CANNON.ContactEquation;
+        target: CANNON.Body;
+        type: string;
     };
-    export class KeyEventArgs {
-        key: string;
-        keyType: string;
-        source?: Event;
-        constructor(evt: KeyboardEvent);
+    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;
+        recursive: boolean | undefined;
+        minDistance: number | undefined;
+        maxDistance: number | undefined;
+        lineThreshold: number | undefined;
+        layerMask: THREE.Layers | number | undefined;
+        ignore: THREE.Object3D[] | undefined;
+        screenPointFromOffset(ox: number, oy: number): void;
+        setMask(mask: number): void;
+        static AllLayers: number;
     }
-    export enum InputEvents {
-        PointerDown = "pointerdown",
-        PointerUp = "pointerup",
-        PointerMove = "pointermove",
-        KeyDown = "keydown",
-        KeyUp = "keyup",
-        KeyPressed = "keypress"
+    export class SphereIntersection implements THREE.Intersection {
+        distance: number;
+        point: THREE.Vector3;
+        object: THREE.Object3D;
+        constructor(object: THREE.Object3D, distance: number, point: THREE.Vector3);
     }
-    export class Input extends EventTarget {
-        _doubleClickTimeThreshold: number;
-        _longPressTimeThreshold: number;
-        get mousePosition(): THREE.Vector2;
-        get mousePositionRC(): THREE.Vector2;
-        get mouseDown(): boolean;
-        get mouseUp(): boolean;
-        get mouseClick(): boolean;
-        get mouseDoubleClick(): boolean;
-        get mousePressed(): boolean;
-        get mouseWheelChanged(): boolean;
-        private _specialCursorTrigger;
-        setCursorPointer(): void;
-        setCursorNormal(): void;
-        getPointerPressedCount(): number;
-        getPointerPosition(i: number): THREE.Vector2 | null;
-        getPointerPositionLastFrame(i: number): THREE.Vector2 | null;
-        getPointerPositionDelta(i: number): THREE.Vector2 | null;
-        getPointerPositionRC(i: number): THREE.Vector2 | null;
-        getPointerDown(i: number): boolean;
-        getPointerUp(i: number): boolean;
-        getPointerPressed(i: number): boolean;
-        getPointerClicked(i: number): boolean;
-        getPointerDoubleClicked(i: number): boolean;
-        getPointerDownTime(i: number): number;
-        getPointerUpTime(i: number): number;
-        getPointerLongPress(i: number): boolean;
-        getIsMouse(i: number): boolean;
-        getIsTouch(i: number): boolean;
-        getTouchesPressedCount(): number;
-        getMouseWheelChanged(i?: number): boolean;
-        getPointerEvent(i: number): Event | undefined;
+    export class Physics {
+        private readonly raycaster;
+        private readonly defaultRaycastOptions;
+        private readonly targetBuffer;
+        private readonly defaultThresholds;
+        private sphereResults;
+        private sphereMask;
+        sphereOverlap(spherePos: THREE.Vector3, radius: number): Array<THREE.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;
+        private _isUpdatingPhysicsWorld;
         private context;
-        private _pointerDown;
-        private _pointerUp;
-        private _pointerClick;
-        private _pointerDoubleClick;
-        private _pointerPressed;
-        private _pointerPositions;
-        private _pointerPositionsLastFrame;
-        private _pointerPositionsDelta;
-        private _pointerPositionsRC;
-        private _pointerPositionDown;
-        private _pointerDownTime;
-        private _pointerUpTime;
-        private _pointerIds;
-        private _pointerTypes;
-        private _mouseWheelChanged;
-        private _pointerEvent;
-        getKeyDown(): string | null;
-        getKeyPressed(): string | null;
-        isKeyDown(keyCode: number): boolean;
-        isKeyUp(keyCode: number): boolean;
-        isKeyPressed(keyCode: number): boolean;
-        createPointerDown(args: PointerEventArgs): void;
-        createPointerMove(args: PointerEventArgs): void;
-        createPointerUp(args: PointerEventArgs): void;
+        private world;
+        private objects;
+        private tempPosition;
+        private tempQuaternion;
         constructor(context: Context);
-        private onLostFocus;
-        private onEndOfFrame;
-        private keysPressed;
-        private onKeyDown;
-        private onKeyPressed;
-        private onKeyUp;
-        private onMouseWheel;
-        private onTouchMove;
-        private onTouchUp;
-        private onPointerDown;
-        private onPointerMove;
-        private onPointerUp;
-        private isInRect;
-        private onDown;
-        private onMove;
-        private onUp;
-        private updatePointerPosition;
-        private getPointerIndex;
-        private setPointerState;
-        private setPointerStateT;
-        private onDispatchEvent;
+        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 addShape;
+        step(deltaTime: number): void;
+        private temp;
+        private tempQuat;
+        postStep(): void;
+        private internalCreateBody;
+        private registerCollisionEvents;
+        private unregisterCollisionEvents;
+        private onBeginContact;
+        private raiseCollisionEvents;
+        private onEndContact;
     }
-    export enum KeyCode {
-        BACKSPACE = 8,
-        TAB = 9,
-        ENTER = 13,
-        SHIFT = 16,
-        CTRL = 17,
-        ALT = 18,
-        PAUSE = 19,
-        CAPS_LOCK = 20,
-        ESCAPE = 27,
-        SPACE = 32,
-        PAGE_UP = 33,
-        PAGE_DOWN = 34,
-        END = 35,
-        HOME = 36,
-        LEFT_ARROW = 37,
-        UP_ARROW = 38,
-        RIGHT_ARROW = 39,
-        DOWN_ARROW = 40,
-        INSERT = 45,
-        DELETE = 46,
-        KEY_0 = 48,
-        KEY_1 = 49,
-        KEY_2 = 50,
-        KEY_3 = 51,
-        KEY_4 = 52,
-        KEY_5 = 53,
-        KEY_6 = 54,
-        KEY_7 = 55,
-        KEY_8 = 56,
-        KEY_9 = 57,
-        KEY_A = 65,
-        KEY_B = 66,
-        KEY_C = 67,
-        KEY_D = 68,
-        KEY_E = 69,
-        KEY_F = 70,
-        KEY_G = 71,
-        KEY_H = 72,
-        KEY_I = 73,
-        KEY_J = 74,
-        KEY_K = 75,
-        KEY_L = 76,
-        KEY_M = 77,
-        KEY_N = 78,
-        KEY_O = 79,
-        KEY_P = 80,
-        KEY_Q = 81,
-        KEY_R = 82,
-        KEY_S = 83,
-        KEY_T = 84,
-        KEY_U = 85,
-        KEY_V = 86,
-        KEY_W = 87,
-        KEY_X = 88,
-        KEY_Y = 89,
-        KEY_Z = 90,
-        LEFT_META = 91,
-        RIGHT_META = 92,
-        SELECT = 93,
-        NUMPAD_0 = 96,
-        NUMPAD_1 = 97,
-        NUMPAD_2 = 98,
-        NUMPAD_3 = 99,
-        NUMPAD_4 = 100,
-        NUMPAD_5 = 101,
-        NUMPAD_6 = 102,
-        NUMPAD_7 = 103,
-        NUMPAD_8 = 104,
-        NUMPAD_9 = 105,
-        MULTIPLY = 106,
-        ADD = 107,
-        SUBTRACT = 109,
-        DECIMAL = 110,
-        DIVIDE = 111,
-        F1 = 112,
-        F2 = 113,
-        F3 = 114,
-        F4 = 115,
-        F5 = 116,
-        F6 = 117,
-        F7 = 118,
-        F8 = 119,
-        F9 = 120,
-        F10 = 121,
-        F11 = 122,
-        F12 = 123,
-        NUM_LOCK = 144,
-        SCROLL_LOCK = 145,
-        SEMICOLON = 186,
-        EQUALS = 187,
-        COMMA = 188,
-        DASH = 189,
-        PERIOD = 190,
-        FORWARD_SLASH = 191,
-        GRAVE_ACCENT = 192,
-        OPEN_BRACKET = 219,
-        BACK_SLASH = 220,
-        CLOSE_BRACKET = 221,
-        SINGLE_QUOTE = 222
+    export class Collision {
+        private readonly collision;
+        readonly me: Object3D;
+        private _normal?;
+        get normal(): Vector3;
+        private _collider?;
+        get collider(): Collider;
+        get gameObject(): Object3D;
+        constructor(obj: Object3D, collision: CannonCollision);
     }
 }
-declare module "engine-components/ui/Utils" {
-    import { FrameEvent } from "engine/engine_setup";
-    import { Behaviour } from "engine-components/Component";
-    export function isUIObject(obj: THREE.Object3D): boolean;
-    export type RenderSettings = {
-        renderOnTop?: boolean;
-        doubleSided?: boolean;
-        depthWrite?: boolean;
-        castShadows?: boolean;
-        receiveShadows?: boolean;
-    };
-    export function updateRenderSettings(shadowComponent: THREE.Object3D, settings: RenderSettings): void;
-    export type RevocableProxy = {
-        proxy: any;
-        revoke: () => void;
+declare module "engine-components/Component" {
+    import * as THREE from "three";
+    import { Context, FrameEvent } from "engine/engine_setup";
+    import { Object3D } from "three";
+    import { SourceIdentifier } from "engine/engine_gltf";
+    import { Collision } from "engine/engine_physics";
+    export interface UIDProvider {
+        seed: number;
+        generateUUID(): string;
+    }
+    export enum HideFlags {
+        None = 0,
+        HideInHierarchy = 1,
+        HideInInspector = 2,
+        DontSaveInEditor = 4,
+        NotEditable = 8,
+        DontSaveInBuild = 16,
+        DontUnloadUnusedAsset = 32,
+        DontSave = 52,
+        HideAndDontSave = 61
+    }
+    export type Constructor<T> = abstract new (...args: any[]) => T;
+    export type ConstructorConcrete<T> = new (...args: any[]) => T;
+    export type GuidsMap = {
+        [key: string]: string;
     };
-    /** internal method to proxy a field to detect changes */
-    export function onChange<T extends object>(caller: T, field: string, callback: (newValue: any, oldValue: any) => void): RevocableProxy;
-    /** internal method to schedula a function at a specific moment in the update loop */
-    export function scheduleAction(caller: Behaviour, action: Function, timing?: FrameEvent): void;
-}
-declare module "engine/engine_serialization_decorator" {
-    import { Constructor } from "engine-components/Component";
-    export type TypeResolver<T> = (data: any) => Constructor<T> | null;
-    export const serializeable: <T>(type?: Constructor<T> | TypeResolver<T> | (Constructor<any> | TypeResolver<T>)[] | null | undefined) => (_target: any, _propertyKey: string) => void;
-    export const ALL_PROPERTIES_MARKER = "__NEEDLE__ALL_PROPERTIES";
-    /** @deprecated current not used */
-    export function allProperties(constructor: Function): void;
-    export const STRICT_MARKER = "__NEEDLE__STRICT";
-    /** @deprecated  current not used */
-    export function strict(constructor: Function): void;
-}
-declare module "engine-components/Rigidbody" {
-    import { Behaviour } from "engine-components/Component";
-    import * as CANNON from 'cannon-es';
-    import * as THREE from 'three';
-    export class Rigidbody extends Behaviour {
-        mass: number;
-        set isKinematic(kinematic: boolean);
-        get isKinematic(): boolean;
-        private _isKinematic;
-        drag: number;
-        angularDrag: number;
-        detectCollision: boolean;
-        sleepThreshold: number;
-        get body(): CANNON.Body | null;
-        private static tempPosition;
-        private _body;
-        private currentVelocity;
-        private _smoothedVelocity;
-        private lastWorldPosition;
-        private dirty;
-        private transformProxy?;
+    type FunctionName = string;
+    export class InstantiateOptions {
+        idProvider?: UIDProvider | undefined;
+        parent?: string | undefined | Object3D;
+        /** for duplicatable parenting */
+        keepWorldPosition?: boolean;
+        position?: THREE.Vector3 | undefined;
+        rotation?: THREE.Quaternion | undefined;
+        scale?: THREE.Vector3 | undefined;
+        visible?: boolean | undefined;
+        context?: Context | undefined;
+    }
+    abstract class GameObject extends THREE.Object3D implements THREE.Object3D {
+        guid: string | undefined;
+        static setActive(go: THREE.Object3D, active: boolean): void;
+        static isActiveSelf(go: THREE.Object3D): boolean;
+        static isActiveInHierarchy(go: THREE.Object3D): boolean;
+        static markAsInstancedRendered(go: THREE.Object3D, instanced: boolean): void;
+        static isUsingInstancing(instance: THREE.Object3D): boolean;
+        static foreachComponent(instance: THREE.Object3D, cb: (comp: Component) => any, recursive?: boolean): any;
+        static instantiateSynced(instance: GameObject | THREE.Object3D | null, opts: InstantiateOptions): GameObject | null;
+        static instantiate(instance: GameObject | THREE.Object3D | null, opts?: InstantiateOptions | null): GameObject | null;
+        private static internalInstantiate;
+        private static resolveAndBindSkinnedMeshBones;
+        private static resolveReferences;
+        private static postProcessNewInstance;
+        static destroySynced(instance: THREE.Object3D | Component, context?: Context, recursive?: boolean): void;
+        static destroy(instance: THREE.Object3D | Component, recursive?: boolean, isRoot?: boolean): void;
+        /**
+         * Add an object to parent and also ensure all components are being registered
+         */
+        static add(instance: THREE.Object3D | null | undefined, parent: THREE.Object3D, context?: Context): void;
+        /**
+         * Removes the object from its parent and deactivates all of its components
+         */
+        static remove(instance: THREE.Object3D | null | undefined): void;
+        static invokeOnChildren(go: THREE.Object3D | null | undefined, functionName: string | FunctionName, ...args: any): void;
+        static invoke(go: THREE.Object3D | null | undefined, functionName: string | FunctionName, children?: boolean, ...args: any): void;
+        static addNewComponent<T extends Behaviour>(go: GameObject | THREE.Object3D, type: ConstructorConcrete<T>, callAwake?: boolean): T;
+        static addComponent(go: GameObject, instance: Component): void;
+        static removeComponent(instance: Component): Component;
+        static getOrAddComponent<T>(go: GameObject | THREE.Object3D, typeName: Constructor<T> | null): T;
+        static getComponent<T>(go: GameObject | THREE.Object3D | null, typeName: Constructor<T> | null): T | null;
+        static getComponents<T>(go: GameObject | THREE.Object3D | null, typeName: Constructor<T> | null, arr?: T[] | null): T[];
+        static findByGuid(guid: string, hierarchy: THREE.Object3D): GameObject | Behaviour | null | undefined;
+        static findObjectOfType<T>(typeName: Constructor<T> | string, context?: Context | THREE.Object3D, includeInactive?: boolean): T | null;
+        static findObjectsOfType<T>(typeName: Constructor<T>, context?: Context | THREE.Object3D): Array<T>;
+        static getComponentInChildren<T>(go: GameObject | THREE.Object3D, typeName: Constructor<T> | null): T | null;
+        static getComponentsInChildren<T>(go: GameObject | THREE.Object3D, typeName: Constructor<T> | null, arr?: T[] | null): Array<T>;
+        static getComponentInParent<T>(go: GameObject | THREE.Object3D | Array<Object3D>, typeName: Constructor<T>): T | null;
+        static getComponentsInParent<T>(go: GameObject | THREE.Object3D, typeName: Constructor<T>, arr?: Array<T> | null): Array<T>;
+        static getAllComponents(go: GameObject | THREE.Object3D): Behaviour[];
+        static iterateComponents(go: GameObject | THREE.Object3D): Generator<any, void, unknown>;
+        abstract addNewComponent<T>(type: Constructor<T>): T | null;
+        abstract removeComponent(comp: Component): Component;
+        abstract getOrAddComponent<T>(go: GameObject | THREE.Object3D, typeName: Constructor<T> | null): T;
+        abstract getComponent<T>(type: Constructor<T>): T | null;
+        abstract getComponents<T>(type: Constructor<T>, arr?: T[]): Array<T>;
+        abstract getComponentInChildren<T>(type: Constructor<T>): T | null;
+        abstract getComponentsInChildren<T>(type: Constructor<T>, arr?: T[]): Array<T>;
+        abstract getComponentInParent<T>(type: Constructor<T>): T | null;
+        abstract getComponentsInParent<T>(type: Constructor<T>, arr?: T[]): Array<T>;
+    }
+    class Component implements EventTarget {
+        get isComponent(): boolean;
+        private __context;
+        get context(): Context;
+        set context(context: Context);
+        get scene(): THREE.Scene;
+        get layer(): number;
+        get name(): string;
+        private __name?;
+        set name(str: string);
+        get tag(): string;
+        set tag(str: string);
+        get static(): any;
+        get hideFlags(): HideFlags;
+        get activeAndEnabled(): boolean;
+        private get __isActive();
+        private get __isActiveInHierarchy();
+        gameObject: GameObject;
+        guid: string;
+        sourceId?: SourceIdentifier;
+        /** called on a component with a map of old to new guids (e.g. when instantiate generated new guids and e.g. timeline track bindings needs to remape them) */
+        resolveGuids?(guidsMap: GuidsMap): void;
         awake(): void;
-        start(): void;
         onEnable(): void;
         onDisable(): void;
         onDestroy(): void;
-        earlyUpdate(): void;
-        onBeforeRender(): void;
-        initialize(): void;
-        wakeUp(): void;
-        applyForce(vec: THREE.Vector3, rel: THREE.Vector3 | undefined): void;
-        getVelocity(): THREE.Vector3;
-        setVelocity(x: number, 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 | {
-            x: number;
-            y: number;
-            z: number;
-        }): void;
-        private updateVelocity;
-    }
-}
-declare module "engine-components/RendererLightmap" {
-    import { GameObject } from "engine-components/Component";
-    import * as THREE from "three";
-    import { Texture } from "three";
-    import { Context } from "engine/engine_setup";
-    export class RendererLightmap {
-        get lightmap(): Texture | null;
-        set lightmap(tex: Texture | null);
-        lightmapIndex: number;
-        lightmapScaleOffset: THREE.Vector4;
-        private context;
-        private gameObject;
-        private lightmapTexture;
-        private lightmapScaleOffsetUniform;
-        private lightmapUniform;
-        private beforeRenderCallback?;
-        constructor(gameObject: GameObject, context: Context);
-        init(lightmapIndex: number, lightmapScaleOffset: THREE.Vector4, lightmapTexture: THREE.Texture, debug?: boolean): void;
-        bindOnBeforeRender(): void;
-        private onBeforeRenderThreeComplete;
-        private setupLightmap;
-        onBeforeRenderThree(material: THREE.Material): void;
-        private setLightmapDebugMaterial;
+        start?(): void;
+        earlyUpdate?(): void;
+        update?(): void;
+        lateUpdate?(): void;
+        onBeforeRender?(frame: THREE.XRFrame | null): void;
+        onAfterRender?(): void;
+        onCollisionEnter?(col: Collision): any;
+        onCollisionExit?(col: Collision): any;
+        onCollisionStay?(col: Collision): any;
+        startCoroutine(routine: Generator, evt?: FrameEvent): Generator;
+        stopCoroutine(routine: Generator, evt?: FrameEvent): void;
+        get destroyed(): boolean;
+        destroy(): void;
+        protected __didAwake: boolean;
+        private __didStart;
+        protected __didEnable: boolean;
+        protected __isEnabled: boolean | undefined;
+        private __destroyed;
+        __internalNewInstanceCreated(): void;
+        __internalAwake(): void;
+        __internalStart(): void;
+        __internalEnable(): void;
+        __internalDisable(): void;
+        constructor();
+        private _collisionExitRoutine;
+        private _collisions;
+        private __internalResetsCachedPhysicsData;
+        __internalHandleCollision(col: Collision): void;
+        sendExitCollisionEvent(obj: Object3D): void;
+        private __waitForCollisionExit;
+        private static _worldPositionBuffer;
+        private static _worldQuaternionBuffer;
+        private static _worldEulerBuffer;
+        private _worldPosition;
+        private _worldQuaternion;
+        private static _tempQuaternionBuffer2;
+        private _worldEuler;
+        private _worldRotation;
+        get worldPosition(): THREE.Vector3;
+        set worldPosition(val: THREE.Vector3);
+        setWorldPosition(x: number, y: number, z: number): void;
+        get worldQuaternion(): THREE.Quaternion;
+        set worldQuaternion(val: THREE.Quaternion);
+        setWorldQuaternion(x: number, y: number, z: number, w: number): void;
+        get worldEuler(): THREE.Euler;
+        set worldEuler(val: THREE.Euler);
+        get worldRotation(): THREE.Vector3;
+        set worldRotation(val: THREE.Vector3);
+        setWorldRotation(x: number, y: number, z: number, degrees?: boolean): void;
+        private static _forward;
+        get forward(): THREE.Vector3;
+        private _eventListeners;
+        addEventListener(type: string, listener: EventListener): void;
+        removeEventListener(type: string, listener: EventListener): void;
+        dispatchEvent(evt: Event): boolean;
+    }
+    class Behaviour extends Component {
+        get enabled(): boolean;
+        set enabled(val: boolean);
     }
+    export { Behaviour, Component, GameObject };
 }
-declare module "engine/extensions/NEEDLE_render_objects" {
-    import { SourceIdentifier } from "engine/engine_gltf";
-    import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
-    import { Renderer } from "engine-components/Renderer";
-    export class NEEDLE_render_objects implements GLTFLoaderPlugin {
-        private static stencils;
-        static applyStencil(obj?: Renderer | null): void;
-        private parser;
-        private source;
-        constructor(parser: GLTFParser, source: SourceIdentifier);
-        afterRoot(_result: GLTF): Promise<void> | null;
+declare module "engine/extensions/extension_resolver" {
+    import { GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
+    export interface IExtensionReferenceResolver {
+        resolve(parser: GLTFParser, path: string): Promise<void> | null;
     }
-    export const EXTENSION_NAME = "NEEDLE_render_objects";
 }
-declare module "engine/engine_loaders" {
-    import { Context } from "engine/engine_setup";
-    import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
-    export function setDracoDecoderPath(path: string | undefined): void;
-    export function setDracoDecoderType(type: string | undefined): void;
-    export function setKtx2TranscoderPath(path: string): void;
-    export function addDracoAndKTX2Loaders(loader: GLTFLoader, context: Context): void;
+declare module "engine/engine_default_parameters" {
+    export const showGizmos: string | boolean;
+    export const debugExtension: string | boolean;
 }
-declare module "engine/extensions/NEEDLE_deferred_texture" {
-    import { Material } from "three";
+declare module "engine/extensions/extension_utils" {
+    import { GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
+    export function resolveReferences(parser: GLTFParser, obj: any): Promise<void | void[]>;
+}
+declare module "engine/engine_typestore" {
+    class _TypeStore {
+        private _types;
+        add(key: any, type: any): void;
+        get(key: any): any;
+    }
+    export const TypeStore: _TypeStore;
+}
+declare module "engine/extensions/NEEDLE_persistent_assets" {
     import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
-    import { SourceIdentifier } from "engine/engine_gltf";
-    import { Context } from "engine/engine_setup";
-    export const EXTENSION_NAME = "NEEDLE_deferred_texture";
-    export class NEEDLE_deferred_texture implements GLTFLoaderPlugin {
-        static assignTextureLOD(context: Context, material: Material, level?: number): void;
+    import { IExtensionReferenceResolver } from "engine/extensions/extension_resolver";
+    export const EXTENSION_NAME = "NEEDLE_persistent_assets";
+    export function isPersistentAsset(asset: any): boolean;
+    export class NEEDLE_persistent_assets implements GLTFLoaderPlugin, IExtensionReferenceResolver {
         get name(): string;
         private parser;
-        private sourceId;
-        private context;
-        constructor(parser: GLTFParser, sourceId: SourceIdentifier, context: Context);
-        private _loading;
-        afterRoot(gltf: GLTF): null;
-        private static cache;
-        private static resolved;
-        private static getOrLoadTexture;
+        constructor(parser: GLTFParser);
+        afterRoot(_result: GLTF): Promise<void>;
+        resolve(parser: GLTFParser, path: string): Promise<void> | null | any;
     }
 }
-declare module "engine-components/Renderer" {
-    import { Behaviour } from "engine-components/Component";
-    import * as THREE from "three";
-    import { Texture } from "three";
-    export class FieldWithDefault {
-        path: string | null;
-        asset: object | null;
-        default: any;
-    }
-    export enum RenderState {
-        Both = 0,
-        Back = 1,
-        Front = 2
-    }
-    class SharedMaterialArray {
-        private _renderer;
-        private _targets;
-        is(renderer: Renderer): boolean;
-        constructor(renderer: Renderer);
-        get length(): number;
-        private setMaterial;
-        private getMaterial;
+declare module "engine/engine_serialization_core" {
+    import { GLTF } from "three/examples/jsm/loaders/GLTFLoader";
+    import { Object3D } from "three";
+    import { Context } from "engine/engine_setup";
+    import { SourceIdentifier } from "engine/engine_gltf";
+    export type Constructor<T> = {
+        new (...args: any[]): T;
+    };
+    export type NodeToObjectMap = {
+        [nodeId: string]: Object3D;
+    };
+    export type ObjectToNodeMap = {
+        [uuid: string]: number;
+    };
+    class SerializationHelper {
+        register(type: string, ser: ITypeSerializer): void;
+        typeMap: {
+            [type: string]: ITypeSerializer;
+        };
+        getSerializer(type: string): ITypeSerializer | undefined;
+        getSerializerForConstructor(type: any, level?: number): ITypeSerializer | undefined;
     }
-    export class Renderer extends Behaviour {
-        receiveShadows: boolean;
-        shadowCastingMode: ShadowCastingMode;
-        lightmapIndex: number;
-        lightmapScaleOffset: THREE.Vector4;
-        enableInstancing: boolean[] | undefined;
-        renderOrder: number[] | undefined;
-        allowOcclusionWhenDynamic: boolean;
-        private _lightmaps?;
-        get material(): THREE.Material;
-        set material(mat: THREE.Material);
-        private _sharedMaterials;
-        get sharedMaterials(): SharedMaterialArray;
-        static get shouldSuppressInstancing(): string | boolean;
-        private _lightmapTextureOverride;
-        get lightmap(): Texture | null;
-        set lightmap(tex: Texture | null | undefined);
-        get hasLightmap(): boolean;
-        awake(): void;
-        private _isInstancingEnabled;
-        private handles;
-        private prevLayers;
-        setInstancingEnabled(enabled: boolean): boolean;
-        start(): void;
-        onEnable(): void;
-        onDisable(): void;
-        onDestroy(): void;
-        applyStencil(): void;
-        onBeforeRenderThree(_renderer: any, _scene: any, _camera: any, _geometry: any, material: any, _group: any): void;
-        onBeforeRender(): void;
-        onAfterRender(): void;
-        private applySettings;
+    export const helper: SerializationHelper;
+    export interface ITypeSerializer {
+        onSerialize(data: any, context: SerializationContext): any;
+        onDeserialize(data: any, context: SerializationContext): any;
     }
-    export class MeshRenderer extends Renderer {
+    /**
+     * implement and call super(<type string or array>) with the type names this serializer can handle
+     * for example:
+     * class ColorSerializer extends TypeSerializer {
+     *  constructor() {
+     *      super("Color")
+     *  }
+     * }
+    */
+    export abstract class TypeSerializer implements ITypeSerializer {
+        constructor(type: Constructor<any> | Constructor<any>[]);
+        abstract onSerialize(data: any, context: SerializationContext): any | void;
+        abstract onDeserialize(data: any, context: SerializationContext): any | void;
     }
-    export class SkinnedMeshRenderer extends MeshRenderer {
-        awake(): void;
+    export interface ITypeInformation {
+        type?: Constructor<any>;
     }
-    export enum ShadowCastingMode {
-        Off = 0,
-        On = 1,
-        TwoSided = 2,
-        ShadowsOnly = 3
+    export class SerializationContext {
+        root: THREE.Object3D;
+        gltf?: GLTF;
+        gltfId?: SourceIdentifier;
+        object: THREE.Object3D;
+        target?: object;
+        nodeId?: number;
+        nodeToObject?: NodeToObjectMap;
+        objectToNode?: ObjectToNodeMap;
+        context?: Context;
+        path?: string;
+        constructor(root: THREE.Object3D);
     }
-    export class InstancingUtil {
-        static markDirty(go: THREE.Object3D | null, recursive?: boolean): void;
+    export interface ISerializable {
+        $serializedTypes?: {
+            [key: string]: Constructor<any> | ITypeInformation | null;
+        };
+        onBeforeDeserialize?(data: any, context: SerializationContext): void | undefined | boolean;
+        onBeforeDeserializeMember?(key: string, data: any, context: SerializationContext): void | undefined | boolean;
+        onAfterDeserializeMember?(key: string, data: any, context: SerializationContext): void;
+        onAfterDeserialize?(data: any, context: SerializationContext): void;
     }
+    export function serializeObject(obj: ISerializable, context: SerializationContext): object | null;
+    export function deserializeObject(obj: ISerializable, serializedData: object, context: SerializationContext): boolean;
+    /** Object.assign behaviour but check if property is writeable (e.g. getter only properties are skipped) */
+    export function assign(target: any, source: any): void;
 }
-declare module "engine/engine_physics" {
-    import * as CANNON from 'cannon-es';
+declare module "engine/engine_input" {
     import * as THREE from 'three';
     import { Context } from "engine/engine_setup";
-    import { Rigidbody } from "engine-components/Rigidbody";
-    import { GameObject } from "engine-components/Component";
-    export interface ICollisionEventReceiver {
-        onCollision(data: CollisionData): any;
-    }
-    export class BodyOptions {
-        mass: number;
-        kinematic: boolean;
-        physicsEvents: boolean;
-        drag: number;
-        angularDrag: number;
-        sleepThreshold: number;
-    }
-    export class CollisionData {
-        obj: THREE.Object3D | null;
-        contact: CANNON.ContactEquation;
-        target: THREE.Object3D | null;
-        type: string;
-        constructor(contact: CANNON.ContactEquation, type: string);
-    }
-    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;
-        recursive: boolean | undefined;
-        minDistance: number | undefined;
-        maxDistance: number | undefined;
-        lineThreshold: number | undefined;
-        layerMask: THREE.Layers | number | undefined;
-        ignore: THREE.Object3D[] | undefined;
-        screenPointFromOffset(ox: number, oy: number): void;
-        setMask(mask: number): void;
-        static AllLayers: number;
+    export type PointerEventArgs = {
+        button: number;
+        clientX: number;
+        clientY: number;
+        pointerId?: number;
+        pointerType: string;
+        source?: Event;
+    };
+    export class KeyEventArgs {
+        key: string;
+        keyType: string;
+        source?: Event;
+        constructor(evt: KeyboardEvent);
     }
-    export class SphereIntersection implements THREE.Intersection {
-        distance: number;
-        point: THREE.Vector3;
-        object: THREE.Object3D;
-        constructor(object: THREE.Object3D, distance: number, point: THREE.Vector3);
+    export enum InputEvents {
+        PointerDown = "pointerdown",
+        PointerUp = "pointerup",
+        PointerMove = "pointermove",
+        KeyDown = "keydown",
+        KeyUp = "keyup",
+        KeyPressed = "keypress"
     }
-    export class Physics {
-        private readonly raycaster;
-        private readonly defaultRaycastOptions;
-        private readonly targetBuffer;
-        private readonly defaultThresholds;
-        private sphereResults;
-        private sphereMask;
-        sphereOverlap(spherePos: THREE.Vector3, radius: number): Array<THREE.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;
-        private _isUpdatingPhysicsWorld;
+    export class Input extends EventTarget {
+        _doubleClickTimeThreshold: number;
+        _longPressTimeThreshold: number;
+        get mousePosition(): THREE.Vector2;
+        get mousePositionRC(): THREE.Vector2;
+        get mouseDown(): boolean;
+        get mouseUp(): boolean;
+        get mouseClick(): boolean;
+        get mouseDoubleClick(): boolean;
+        get mousePressed(): boolean;
+        get mouseWheelChanged(): boolean;
+        private _specialCursorTrigger;
+        setCursorPointer(): void;
+        setCursorNormal(): void;
+        getPointerPressedCount(): number;
+        getPointerPosition(i: number): THREE.Vector2 | null;
+        getPointerPositionLastFrame(i: number): THREE.Vector2 | null;
+        getPointerPositionDelta(i: number): THREE.Vector2 | null;
+        getPointerPositionRC(i: number): THREE.Vector2 | null;
+        getPointerDown(i: number): boolean;
+        getPointerUp(i: number): boolean;
+        getPointerPressed(i: number): boolean;
+        getPointerClicked(i: number): boolean;
+        getPointerDoubleClicked(i: number): boolean;
+        getPointerDownTime(i: number): number;
+        getPointerUpTime(i: number): number;
+        getPointerLongPress(i: number): boolean;
+        getIsMouse(i: number): boolean;
+        getIsTouch(i: number): boolean;
+        getTouchesPressedCount(): number;
+        getMouseWheelChanged(i?: number): boolean;
+        getPointerEvent(i: number): Event | undefined;
         private context;
-        private world;
-        private objects;
-        private tempPosition;
-        private tempQuaternion;
+        private _pointerDown;
+        private _pointerUp;
+        private _pointerClick;
+        private _pointerDoubleClick;
+        private _pointerPressed;
+        private _pointerPositions;
+        private _pointerPositionsLastFrame;
+        private _pointerPositionsDelta;
+        private _pointerPositionsRC;
+        private _pointerPositionDown;
+        private _pointerDownTime;
+        private _pointerUpTime;
+        private _pointerIds;
+        private _pointerTypes;
+        private _mouseWheelChanged;
+        private _pointerEvent;
+        getKeyDown(): string | null;
+        getKeyPressed(): string | null;
+        isKeyDown(keyCode: number): boolean;
+        isKeyUp(keyCode: number): boolean;
+        isKeyPressed(keyCode: number): boolean;
+        createPointerDown(args: PointerEventArgs): void;
+        createPointerMove(args: PointerEventArgs): void;
+        createPointerUp(args: PointerEventArgs): void;
         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 addShape;
-        step(deltaTime: number): void;
-        private temp;
-        private tempQuat;
-        postStep(): void;
-        private internalCreateBody;
-        private registerCollisionEvents;
-        private unregisterCollisionEvents;
-        private raiseCollisionEvents;
+        private onLostFocus;
+        private onEndOfFrame;
+        private keysPressed;
+        private onKeyDown;
+        private onKeyPressed;
+        private onKeyUp;
+        private onMouseWheel;
+        private onTouchMove;
+        private onTouchUp;
+        private onPointerDown;
+        private onPointerMove;
+        private onPointerUp;
+        private isInRect;
+        private onDown;
+        private onMove;
+        private onUp;
+        private updatePointerPosition;
+        private getPointerIndex;
+        private setPointerState;
+        private setPointerStateT;
+        private onDispatchEvent;
+    }
+    export enum KeyCode {
+        BACKSPACE = 8,
+        TAB = 9,
+        ENTER = 13,
+        SHIFT = 16,
+        CTRL = 17,
+        ALT = 18,
+        PAUSE = 19,
+        CAPS_LOCK = 20,
+        ESCAPE = 27,
+        SPACE = 32,
+        PAGE_UP = 33,
+        PAGE_DOWN = 34,
+        END = 35,
+        HOME = 36,
+        LEFT_ARROW = 37,
+        UP_ARROW = 38,
+        RIGHT_ARROW = 39,
+        DOWN_ARROW = 40,
+        INSERT = 45,
+        DELETE = 46,
+        KEY_0 = 48,
+        KEY_1 = 49,
+        KEY_2 = 50,
+        KEY_3 = 51,
+        KEY_4 = 52,
+        KEY_5 = 53,
+        KEY_6 = 54,
+        KEY_7 = 55,
+        KEY_8 = 56,
+        KEY_9 = 57,
+        KEY_A = 65,
+        KEY_B = 66,
+        KEY_C = 67,
+        KEY_D = 68,
+        KEY_E = 69,
+        KEY_F = 70,
+        KEY_G = 71,
+        KEY_H = 72,
+        KEY_I = 73,
+        KEY_J = 74,
+        KEY_K = 75,
+        KEY_L = 76,
+        KEY_M = 77,
+        KEY_N = 78,
+        KEY_O = 79,
+        KEY_P = 80,
+        KEY_Q = 81,
+        KEY_R = 82,
+        KEY_S = 83,
+        KEY_T = 84,
+        KEY_U = 85,
+        KEY_V = 86,
+        KEY_W = 87,
+        KEY_X = 88,
+        KEY_Y = 89,
+        KEY_Z = 90,
+        LEFT_META = 91,
+        RIGHT_META = 92,
+        SELECT = 93,
+        NUMPAD_0 = 96,
+        NUMPAD_1 = 97,
+        NUMPAD_2 = 98,
+        NUMPAD_3 = 99,
+        NUMPAD_4 = 100,
+        NUMPAD_5 = 101,
+        NUMPAD_6 = 102,
+        NUMPAD_7 = 103,
+        NUMPAD_8 = 104,
+        NUMPAD_9 = 105,
+        MULTIPLY = 106,
+        ADD = 107,
+        SUBTRACT = 109,
+        DECIMAL = 110,
+        DIVIDE = 111,
+        F1 = 112,
+        F2 = 113,
+        F3 = 114,
+        F4 = 115,
+        F5 = 116,
+        F6 = 117,
+        F7 = 118,
+        F8 = 119,
+        F9 = 120,
+        F10 = 121,
+        F11 = 122,
+        F12 = 123,
+        NUM_LOCK = 144,
+        SCROLL_LOCK = 145,
+        SEMICOLON = 186,
+        EQUALS = 187,
+        COMMA = 188,
+        DASH = 189,
+        PERIOD = 190,
+        FORWARD_SLASH = 191,
+        GRAVE_ACCENT = 192,
+        OPEN_BRACKET = 219,
+        BACK_SLASH = 220,
+        CLOSE_BRACKET = 221,
+        SINGLE_QUOTE = 222
     }
 }
 declare module "engine/engine_time" {
@@ -1584,6 +1628,7 @@ declare module "engine/engine_serialization" {
     import { serializeObject, deserializeObject } from "engine/engine_serialization_core";
     import * as builtin from "engine/engine_serialization_builtin_serializer";
     export { serializeObject, deserializeObject, builtin };
+    export { serializeable } from "engine/engine_serialization_decorator";
 }
 declare module "engine/extensions/NEEDLE_components" {
     import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
@@ -2411,20 +2456,27 @@ declare module "engine-components/WebXRController" {
 declare module "engine-components/WebARSessionRoot" {
     import { Behaviour } from "engine-components/Component";
     import * as THREE from 'three';
-    import { XRPose } 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): 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;
@@ -2471,7 +2523,7 @@ declare module "engine-components/WebXR" {
         static createARButton(webXR: WebXR, opts?: CreateButtonOptions): HTMLButtonElement;
         static resetButtonStyles(button: any): void;
         endSession(): void;
-        get Rig(): THREE.Object3D | null;
+        get Rig(): THREE.Object3D;
         private controllers;
         get Controllers(): WebXRController[];
         get LeftController(): WebXRController | null;
@@ -2511,7 +2563,8 @@ declare module "engine-components/WebXR" {
         private onEnterXR_HandleMirrorWindow;
     }
     export class WebAR {
-        private webxr;
+        get webxr(): WebXR;
+        private _webxr;
         private reticle;
         private hitTestSource;
         private reticleActive;
@@ -2524,9 +2577,11 @@ declare module "engine-components/WebXR" {
         constructor(webxr: WebXR);
         private arDomOverlay;
         private arOverlayElement;
+        private noHitTestAvailable;
+        private didPlaceARSessionRoot;
         getAROverlayContainer(): HTMLElement | null;
         setReticleActive(active: boolean): void;
-        onBegin(session: THREE.XRSession): void;
+        onBegin(session: THREE.XRSession): Promise<void>;
         onEnd(_session: THREE.XRSession): void;
         onUpdate(session: THREE.XRSession, frame: THREE.XRFrame): void;
     }
@@ -2865,10 +2920,12 @@ declare module "engine-components/DragControls" {
 }
 declare module "engine-components/ui/Interfaces" {
     export interface ICanvasGroup {
+        get isCanvasGroup(): boolean;
         blocksRaycasts: boolean;
         interactable: boolean;
     }
     export interface IGraphic {
+        get isGraphic(): boolean;
         raycastTarget: boolean;
     }
 }
@@ -3073,6 +3130,10 @@ declare module "engine/engine_setup" {
         OnAfterRender = 4,
         PhysicsStep = 10
     }
+    export enum XRSessionMode {
+        ImmersiveVR = "immersive-vr",
+        ImmersiveAR = "immersive-ar"
+    }
     export type OnBeforeRenderCallback = (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera, geometry: THREE.BufferGeometry, material: THREE.Material, group: THREE.Group) => void;
     export class Context {
         private static _current;
@@ -3091,6 +3152,7 @@ declare module "engine/engine_setup" {
         get domX(): number;
         get domY(): number;
         get isInXR(): boolean;
+        xrSessionMode: XRSessionMode | undefined;
         get xrSession(): THREE.XRSession | null;
         get arOverlayElement(): HTMLElement;
         scene: THREE.Scene;
@@ -3325,29 +3387,6 @@ declare module "engine-components/BoxHelperComponent" {
         showHelper(col?: THREE.ColorRepresentation | null, force?: boolean): void;
     }
 }
-declare module "engine-components/Collider" {
-    import { Behaviour } from "engine-components/Component";
-    import { Rigidbody } from "engine-components/Rigidbody";
-    import { Shape } from "cannon-es";
-    export class Collider extends Behaviour {
-        attachedRigidbody: Rigidbody | null;
-        isTrigger: boolean;
-        protected _shape: Shape | null;
-        awake(): void;
-        onEnable(): void;
-        onDisable(): void;
-    }
-    export class SphereCollider extends Collider {
-        radius: number;
-        center: THREE.Vector3;
-        onEnable(): void;
-    }
-    export class BoxCollider extends Collider {
-        size: THREE.Vector3;
-        center: THREE.Vector3;
-        onEnable(): void;
-    }
-}
 declare module "engine-components/ComponentExtensions" {
     export class UnityObject {
     }
@@ -3745,6 +3784,7 @@ declare module "engine/engine_input_utils" {
 declare module "engine-components/VideoPlayer" {
     import { Behaviour } from "engine-components/Component";
     import * as THREE from "three";
+    import { Object3D } from "three";
     export enum VideoSource {
         VideoClip = 0,
         Url = 1
@@ -3755,11 +3795,20 @@ declare module "engine-components/VideoPlayer" {
         Direct = 2,
         APIOnly = 3
     }
+    export enum VideoRenderMode {
+        CameraFarPlane = 0,
+        CameraNearPlane = 1,
+        RenderTexture = 2,
+        MaterialOverride = 3
+    }
     export class VideoPlayer extends Behaviour {
         renderer: THREE.Object3D | null;
         playOnAwake: boolean;
         playOnEnable?: boolean;
-        targetMaterialProperty?: string;
+        private renderMode?;
+        private targetMaterialProperty?;
+        private targetMaterialRenderer?;
+        private targetTexture?;
         private time;
         private _playbackSpeed;
         get playbackSpeed(): number;
@@ -3782,6 +3831,7 @@ declare module "engine-components/VideoPlayer" {
         private videoMaterial;
         private _isPlaying;
         private wasPlaying;
+        setVideo(video: MediaStream): void;
         setClipURL(url: string): void;
         awake(): void;
         onEnable(): void;
@@ -3793,6 +3843,8 @@ declare module "engine-components/VideoPlayer" {
         stop(): void;
         pause(): void;
         create(playAutomatically: boolean): void;
+        private _targetObjects;
+        getTargetObjects(): Array<Object3D>;
         private createVideoElement;
         private handleBeginPlaying;
         private updateVideoElementSettings;
@@ -3801,13 +3853,43 @@ declare module "engine-components/VideoPlayer" {
 }
 declare module "engine-components/ScreenCapture" {
     import { Behaviour } from "engine-components/Component";
-    export class ScreenCapture extends Behaviour {
-        streamOnAwake: boolean;
+    import { IPointerClickHandler } from "engine-components/ui/PointerEvents";
+    export enum ScreenCaptureDevice {
+        Screen = 0,
+        Camera = 1
+    }
+    export enum ScreenCaptureMode {
+        Idle = 0,
+        Sending = 1,
+        Receiving = 2
+    }
+    export enum AspectMode {
+        None = 0,
+        AdjustHeight = 1,
+        AdjustWidth = 2
+    }
+    export class ScreenCapture extends Behaviour implements IPointerClickHandler {
+        onPointerClick(): void;
+        device: ScreenCaptureDevice;
+        aspectMode: AspectMode;
+        get isSending(): boolean | null;
+        get isReceiving(): boolean | null;
+        private _net?;
+        private _video?;
+        private _requestOpen;
+        private _currentStream;
+        private _currentMode;
+        awake(): void;
         start(): void;
-        private requestOpen;
-        private captureStream;
-        open(force?: boolean): Promise<void>;
+        share(): Promise<void>;
         close(): void;
+        private setVideo;
+        private onReceiveVideo;
+        private tryShareUserCamera;
+        private _targetObjects?;
+        private updateAspect;
+        private _updateAspectRoutineId;
+        private updateAspectImpl;
     }
 }
 declare module "engine-components/ShadowCatcher" {
@@ -4140,10 +4222,14 @@ declare module "engine-components/Volume" {
     export class VolumeProfile {
         components?: VolumeComponent[];
         apply(context: Context): void;
+        unapply(context: Context): void;
+        private onUpdate;
     }
     export class Volume extends Behaviour {
         sharedProfile?: VolumeProfile;
+        awake(): void;
         onEnable(): void;
+        onDisable(): void;
     }
 }
 declare module "engine-components/WebXRGrabRendering" {
@@ -4575,6 +4661,7 @@ declare module "engine-components/ui/Graphic" {
     import { Texture } from 'three';
     import { RectTransform } from "engine-components/ui/RectTransform";
     export class Graphic extends BaseUIComponent implements IGraphic {
+        get isGraphic(): boolean;
         get color(): RGBAColor;
         set color(col: RGBAColor);
         protected onColorChanged(): void;
@@ -4726,6 +4813,7 @@ declare module "engine-components/ui/CanvasGroup" {
     export class CanvasGroup extends Behaviour implements ICanvasGroup {
         get alpha(): number;
         set alpha(val: number);
+        get isCanvasGroup(): boolean;
         private _alpha;
         interactable: boolean;
         blocksRaycasts: boolean;
@@ -5030,6 +5118,7 @@ declare module "needle-engine" {
     import "engine/engine_setup";
     export { GameObject, Behaviour } from "engine-components/Component";
     export { serializeable } from "engine/engine_serialization_decorator";
+    export { Collision } from "engine/engine_physics";
     export * from "engine-components/codegen/exports";
 }
 declare module "engine/debug/error_overlay" {
@@ -5060,6 +5149,7 @@ declare module "engine/engine" {
         LoadingOptions: typeof engine_setup.LoadingOptions;
         ContextArgs: typeof engine_setup.ContextArgs;
         FrameEvent: typeof engine_setup.FrameEvent;
+        XRSessionMode: typeof engine_setup.XRSessionMode;
         Context: typeof engine_setup.Context;
     };
     export { engine as engine };