@needle-tools/engine 2.35.2-pre → 2.35.3-pre

package/dist/needle-engine.d.ts

@@ -38,6 +38,11 @@ declare module "engine/engine_types" {
         seed: number;
         generateUUID(): string;
     }
+    export interface INeedleEngineComponent extends HTMLElement {
+        getAROverlayContainer(): HTMLElement;
+        onEnterAR(session: THREE.XRSession, overlayContainer: HTMLElement): any;
+        onExitAR(session: THREE.XRSession): any;
+    }
     export interface IGameObject extends Object3D {
         guid: string | undefined;
     }
@@ -568,7 +573,9 @@ declare module "engine/engine_networking_instantiate" {
     export function registerPrefabProvider(key: string, fn: PrefabProviderCallback): void;
 }
 declare module "engine-components/js-extensions/ExtensionUtils" {
-    export function applyPrototypeExtensions(obj: any): void;
+    import { Constructor } from "engine/engine_types";
+    export function applyPrototypeExtensions<T>(obj: any, prototype: Constructor<T>): void;
+    export function registerPrototypeExtensions<T>(type: Constructor<T>): void;
     export interface IApplyPrototypeExtension {
         apply(object: object): void;
     }
@@ -997,7 +1004,7 @@ declare module "engine/extensions/NEEDLE_components" {
     }
 }
 declare module "engine/engine_gltf" {
-    import { SourceIdentifier, UIDProvider } from "engine/engine_types";
+    import { ConstructorConcrete, SourceIdentifier, UIDProvider } from "engine/engine_types";
     import { Context } from "engine/engine_setup";
     import { NEEDLE_components } from "engine/extensions/NEEDLE_components";
     import { SerializationContext } from "engine/engine_serialization_core";
@@ -1009,7 +1016,7 @@ declare module "engine/engine_gltf" {
         loadSync(context: Context, url: string, seed: number | UIDProvider | null, _allowAddingAnimator: boolean, prog?: (ProgressEvent: any) => void): Promise<GLTF | undefined>;
     }
     export function getLoader(): INeedleGltfLoader;
-    export function registerLoader(loader: INeedleGltfLoader): void;
+    export function registerLoader<T extends INeedleGltfLoader>(loader: ConstructorConcrete<T>): void;
 }
 declare module "engine/engine_networking_files" {
     import { Context } from "engine/engine_setup";
@@ -1755,70 +1762,6 @@ declare module "engine/engine_loaders" {
     export function setKtx2TranscoderPath(path: string): void;
     export function addDracoAndKTX2Loaders(loader: GLTFLoader, context: Context): void;
 }
-declare module "engine/engine_element" {
-    import { Context } from "engine/engine_setup";
-    export class EngineElement extends HTMLElement {
-        get loadingProgress01(): number;
-        get loadingFinished(): boolean;
-        getContext(): Promise<Context>;
-        get Context(): Context | null;
-        /**@obsolete use GameObject */
-        private gameObject;
-        private GameObject;
-        private _context;
-        private _overlay_ar;
-        private _loadingProgress01;
-        private _watcher?;
-        private _loadingView?;
-        constructor();
-        connectedCallback(): Promise<void>;
-        disconnectedCallback(): void;
-        static get observedAttributes(): string[];
-        attributeChangedCallback(name: string, _oldValue: string, newValue: string): void;
-        private registerEventFromAttribute;
-        getAROverlayContainer(): HTMLElement;
-        getVROverlayContainer(): HTMLElement | null;
-        onEnterAR(session: THREE.XRSession, overlayContainer: HTMLElement): void;
-        onExitAR(session: THREE.XRSession): void;
-        onEnterVR(session: THREE.XRSession): void;
-        onExitVR(session: THREE.XRSession): void;
-        private onElementsChanged;
-        private onSetupAR;
-        private onSetupVR;
-        private onSetupDesktop;
-        private setupElementsForMode;
-        private foreachHtmlElement;
-        private onBeforeBeginLoading;
-    }
-}
-declare module "engine/engine_serialization_decorator" {
-    import { Constructor } from "engine/engine_types";
-    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/api" {
-    export { InstancingUtil } from "engine/engine_instancing";
-    export * from "engine/engine_gameobject";
-    export * from "engine/engine_components";
-}
-declare module "engine-components/AlignmentConstraint" {
-    import { Behaviour } from "engine-components/Component";
-    export class AlignmentConstraint extends Behaviour {
-        private from;
-        private to;
-        private width;
-        private centered;
-        private _centerPos;
-        awake(): void;
-        update(): void;
-    }
-}
 declare module "engine/extensions/NEEDLE_animator_controller_model" {
     import { Animator } from "engine-components/Animator";
     import { AnimationAction, AnimationClip, Object3D } from "three";
@@ -1970,6 +1913,17 @@ declare module "engine-components/AnimatorController" {
         private rootMotionHandler?;
     }
 }
+declare module "engine/engine_serialization_decorator" {
+    import { Constructor } from "engine/engine_types";
+    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/Animator" {
     import { Behaviour } from "engine-components/Component";
     import * as THREE from 'three';
@@ -2055,15 +2009,292 @@ declare module "engine-components/Animation" {
         private _currentActions;
         private _handles;
         awake(): void;
-        onEnable(): void;
-        start(): void;
+        onEnable(): void;
+        start(): void;
+        update(): void;
+        getAction(name: string): THREE.AnimationAction | undefined | null;
+        play(clipOrNumber: AnimationClip | number | string, options?: PlayOptions): Promise<AnimationAction> | void;
+        internalOnPlay(action: AnimationAction, options?: PlayOptions): Promise<AnimationAction>;
+        private tryFindHandle;
+        private _didInit;
+        init(): void;
+    }
+}
+declare module "engine/extensions/NEEDLE_techniques_webgl" {
+    import { GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
+    import * as THREE from 'three';
+    import { RawShaderMaterial } from 'three';
+    import { SourceIdentifier } from "engine/engine_types";
+    export const NEEDLE_TECHNIQUES_WEBGL_NAME = "NEEDLE_techniques_webgl";
+    export class CustomShader extends RawShaderMaterial {
+        private identifier;
+        private onBeforeRenderSceneCallback;
+        clone(): this;
+        constructor(identifier: SourceIdentifier, ...args: any[]);
+        dispose(): void;
+        waitForLighting(): Promise<void>;
+        private _sphericalHarmonicsName;
+        private _objToWorldName;
+        private _worldToObjectName;
+        private static viewProjection;
+        private static _viewProjectionValues;
+        private _viewProjectionName;
+        private static viewMatrix;
+        private static _viewMatrixValues;
+        private _viewMatrixName;
+        private static _worldSpaceCameraPosName;
+        private static _worldSpaceCameraPos;
+        private static _mainLightColor;
+        private static _mainLightPosition;
+        private static _lightData;
+        private _rendererData;
+        private get depthTextureUniform();
+        private get opaqueTextureUniform();
+        private onBeforeRenderScene;
+        onBeforeRender(_renderer: any, _scene: any, camera: any, _geometry: any, obj: any, _group: any): void;
+        onUpdateUniforms(camera?: THREE.Camera, obj?: any): void;
+    }
+    export class NEEDLE_techniques_webgl implements GLTFLoaderPlugin {
+        get name(): string;
+        private parser;
+        private identifier;
+        constructor(loader: GLTFParser, identifier: SourceIdentifier);
+        loadMaterial(index: number): Promise<THREE.Material> | null;
+    }
+}
+declare module "engine/extensions/NEEDLE_gameobject_data" {
+    import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
+    export const EXTENSION_NAME = "NEEDLE_gameobject_data";
+    export class NEEDLE_gameobject_data implements GLTFLoaderPlugin {
+        get name(): string;
+        private parser;
+        constructor(parser: GLTFParser);
+        afterRoot(_result: GLTF): Promise<void> | null;
+        private findAndApplyExtensionData;
+        private applyExtensionData;
+    }
+}
+declare module "engine/extensions/NEEDLE_render_objects" {
+    import { SourceIdentifier } from "engine/engine_types";
+    import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
+    import { IRenderer as Renderer } from "engine/engine_types";
+    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 EXTENSION_NAME = "NEEDLE_render_objects";
+}
+declare module "engine/extensions/NEEDLE_deferred_texture" {
+    import { Material } from "three";
+    import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
+    import { SourceIdentifier } from "engine/engine_types";
+    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;
+        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/extensions/extensions" {
+    import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader";
+    import { NEEDLE_components } from "engine/extensions/NEEDLE_components";
+    import { SourceIdentifier } from "engine/engine_types";
+    import { Context } from "engine/engine_setup";
+    export function registerComponentExtension(loader: GLTFLoader): NEEDLE_components;
+    export function registerExtensions(loader: GLTFLoader, context: Context, sourceId: SourceIdentifier): void;
+}
+declare module "engine-components/EventList" {
+    export class CallInfo {
+        method?: Function;
+        enabled: boolean;
+        constructor(method?: Function, enabled?: boolean);
+        invoke(...args: any): void;
+    }
+    export class EventListEvent extends Event {
+        args?: [];
+    }
+    export class EventList {
+        private target?;
+        private key?;
+        /** set an event target to try invoke the EventTarget dispatchEvent when this EventList is invoked */
+        setEventTarget(key: string, target: object): void;
+        private _isInvoking;
+        private methods;
+        constructor(evts?: CallInfo[]);
+        invoke(...args: any): void;
+        addEventListener(cb: Function): Function;
+        removeEventListener(cb: Function | null | undefined): void;
+        removeAllEventListeners(): void;
+    }
+}
+declare module "engine/engine_serialization_builtin_serializer" {
+    import * as THREE from "three";
+    import { RGBAColor } from "engine-components/js-extensions/RGBAColor";
+    import { SerializationContext, TypeSerializer } from "engine/engine_serialization_core";
+    import { Behaviour, GameObject } from "engine-components/Component";
+    import { EventList } from "engine-components/EventList";
+    class ColorSerializer extends TypeSerializer {
+        constructor();
+        onDeserialize(data: any): THREE.Color | RGBAColor | void;
+        onSerialize(data: any): any | void;
+    }
+    export const colorSerializer: ColorSerializer;
+    type ObjectData = {
+        node?: number;
+        guid?: string;
+    };
+    class ObjectSerializer extends TypeSerializer {
+        constructor();
+        onSerialize(data: any, context: SerializationContext): {
+            node: number;
+        } | undefined;
+        onDeserialize(data: ObjectData, context: SerializationContext): THREE.Object3D<THREE.Event> | GameObject | Behaviour | null | undefined;
+    }
+    export const objectSerializer: ObjectSerializer;
+    class ComponentSerializer extends TypeSerializer {
+        constructor();
+        onSerialize(data: any, _context: SerializationContext): {
+            guid: any;
+        } | undefined;
+        onDeserialize(data: any, context: SerializationContext): any;
+        findObjectForGuid(guid: string, root: THREE.Object3D): any;
+    }
+    export const componentSerializer: ComponentSerializer;
+    class EventListData {
+        type: string;
+        calls: Array<EventListCall>;
+    }
+    type EventListCall = {
+        method: string;
+        target: string;
+        argument?: any;
+        enabled?: boolean;
+    };
+    class EventListSerializer extends TypeSerializer {
+        constructor();
+        onSerialize(_data: EventList, _context: SerializationContext): EventListData | undefined;
+        onDeserialize(data: EventListData, context: SerializationContext): EventList | undefined | null;
+    }
+    export const eventListSerializer: EventListSerializer;
+}
+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/engine_gltf_builtin_components" {
+    import "./codegen/register_types";
+    import { Component } from "engine-components/Component";
+    import { Context } from "engine/engine_setup";
+    import { SerializationContext } from "engine/engine_serialization_core";
+    import { NEEDLE_components } from "engine/extensions/NEEDLE_components";
+    import { SourceIdentifier } from "engine/engine_types";
+    import { UIDProvider } from "engine/engine_types";
+    export function writeBuiltinComponentData(comp: Component, context: SerializationContext): object | null;
+    export function createBuiltinComponents(context: Context, gltfId: SourceIdentifier, gltf: any, seed?: number | null | UIDProvider, extension?: NEEDLE_components): Promise<void>;
+}
+declare module "engine/engine_scenetools" {
+    import { Context } from "engine/engine_setup";
+    import { GLTF, GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+    import { INeedleGltfLoader } from "engine/engine_gltf";
+    import { UIDProvider } from "engine/engine_types";
+    import { SerializationContext } from "engine/engine_serialization_core";
+    import { NEEDLE_components } from "engine/extensions/NEEDLE_components";
+    export class NeedleGltfLoader implements INeedleGltfLoader {
+        createBuiltinComponents(context: Context, gltfId: string, gltf: any, seed: number | UIDProvider | null, extension?: NEEDLE_components | undefined): Promise<void>;
+        writeBuiltinComponentData(comp: any, context: SerializationContext): object | null;
+        parseSync(context: Context, data: any, path: string, seed: number | UIDProvider | null): Promise<GLTF | undefined>;
+        loadSync(context: Context, url: string, seed: number | UIDProvider | null, _allowAddingAnimator: boolean, prog?: ((ProgressEvent: any) => void) | undefined): Promise<GLTF | undefined>;
+    }
+    export enum GltfLoadEventType {
+        BeforeLoad = 0,
+        AfterLoaded = 1,
+        FinishedSetup = 10
+    }
+    export class GltfLoadEvent {
+        context: Context;
+        loader: GLTFLoader;
+        path: string;
+        gltf?: GLTF;
+        constructor(context: Context, path: string, loader: GLTFLoader, gltf?: GLTF);
+    }
+    export type GltfLoadEventCallback = (event: GltfLoadEvent) => void;
+    export function addGltfLoadEventListener(type: GltfLoadEventType, listener: GltfLoadEventCallback): void;
+    export function removeGltfLoadEventListener(type: GltfLoadEventType, listener: GltfLoadEventCallback): void;
+    export function parseSync(context: Context, data: any, path: string, seed: number | UIDProvider | null): Promise<GLTF | undefined>;
+    export function loadSync(context: Context, url: string, seed: number | UIDProvider | null, _allowAddingAnimator?: boolean, prog?: (ProgressEvent: any) => void): Promise<GLTF | undefined>;
+    export function findAnimationsLate(_context: Context, gltf: any, callbackarray: any, allowAddingAnimator?: boolean): void;
+    export function findAnimations(gltf: GLTF, allowAddingAnimator?: boolean): void;
+    export function tryFindObjectByName(name: any, obj: any, recursive?: boolean): any;
+    export function tryFindObject(globalObjectIdentifier: any, obj: any, recursive?: boolean): any;
+    export function tryFindScript(globalObjectIdentifier: any, list?: null): import("engine/engine_types").IComponent | null;
+}
+declare module "engine/engine_element" {
+    import { Context } from "engine/engine_setup";
+    import { INeedleEngineComponent } from "engine/engine_types";
+    export class EngineElement extends HTMLElement implements INeedleEngineComponent {
+        get loadingProgress01(): number;
+        get loadingFinished(): boolean;
+        getContext(): Promise<Context>;
+        get Context(): Context | null;
+        /**@obsolete use GameObject */
+        private gameObject;
+        private GameObject;
+        private _context;
+        private _overlay_ar;
+        private _loadingProgress01;
+        private _watcher?;
+        private _loadingView?;
+        constructor();
+        connectedCallback(): Promise<void>;
+        disconnectedCallback(): void;
+        static get observedAttributes(): string[];
+        attributeChangedCallback(name: string, _oldValue: string, newValue: string): void;
+        private registerEventFromAttribute;
+        getAROverlayContainer(): HTMLElement;
+        getVROverlayContainer(): HTMLElement | null;
+        onEnterAR(session: THREE.XRSession, overlayContainer: HTMLElement): void;
+        onExitAR(session: THREE.XRSession): void;
+        onEnterVR(session: THREE.XRSession): void;
+        onExitVR(session: THREE.XRSession): void;
+        private onElementsChanged;
+        private onSetupAR;
+        private onSetupVR;
+        private onSetupDesktop;
+        private setupElementsForMode;
+        private foreachHtmlElement;
+        private onBeforeBeginLoading;
+    }
+}
+declare module "engine/api" {
+    export { InstancingUtil } from "engine/engine_instancing";
+    export * from "engine/engine_gameobject";
+    export * from "engine/engine_components";
+}
+declare module "engine-components/AlignmentConstraint" {
+    import { Behaviour } from "engine-components/Component";
+    export class AlignmentConstraint extends Behaviour {
+        private from;
+        private to;
+        private width;
+        private centered;
+        private _centerPos;
+        awake(): void;
         update(): void;
-        getAction(name: string): THREE.AnimationAction | undefined | null;
-        play(clipOrNumber: AnimationClip | number | string, options?: PlayOptions): Promise<AnimationAction> | void;
-        internalOnPlay(action: AnimationAction, options?: PlayOptions): Promise<AnimationAction>;
-        private tryFindHandle;
-        private _didInit;
-        init(): void;
     }
 }
 declare module "engine-components/AnimationCurve" {
@@ -2708,80 +2939,6 @@ declare module "engine-components/avatar/Avatar_Brain_LookAt" {
         private selectTarget;
     }
 }
-declare module "engine-components/EventList" {
-    export class CallInfo {
-        method?: Function;
-        enabled: boolean;
-        constructor(method?: Function, enabled?: boolean);
-        invoke(...args: any): void;
-    }
-    export class EventListEvent extends Event {
-        args?: [];
-    }
-    export class EventList {
-        private target?;
-        private key?;
-        /** set an event target to try invoke the EventTarget dispatchEvent when this EventList is invoked */
-        setEventTarget(key: string, target: object): void;
-        private _isInvoking;
-        private methods;
-        constructor(evts?: CallInfo[]);
-        invoke(...args: any): void;
-        addEventListener(cb: Function): Function;
-        removeEventListener(cb: Function | null | undefined): void;
-        removeAllEventListeners(): void;
-    }
-}
-declare module "engine/engine_serialization_builtin_serializer" {
-    import * as THREE from "three";
-    import { RGBAColor } from "engine-components/js-extensions/RGBAColor";
-    import { SerializationContext, TypeSerializer } from "engine/engine_serialization_core";
-    import { Behaviour, GameObject } from "engine-components/Component";
-    import { EventList } from "engine-components/EventList";
-    class ColorSerializer extends TypeSerializer {
-        constructor();
-        onDeserialize(data: any): THREE.Color | RGBAColor | void;
-        onSerialize(data: any): any | void;
-    }
-    export const colorSerializer: ColorSerializer;
-    type ObjectData = {
-        node?: number;
-        guid?: string;
-    };
-    class ObjectSerializer extends TypeSerializer {
-        constructor();
-        onSerialize(data: any, context: SerializationContext): {
-            node: number;
-        } | undefined;
-        onDeserialize(data: ObjectData, context: SerializationContext): THREE.Object3D<THREE.Event> | GameObject | Behaviour | null | undefined;
-    }
-    export const objectSerializer: ObjectSerializer;
-    class ComponentSerializer extends TypeSerializer {
-        constructor();
-        onSerialize(data: any, _context: SerializationContext): {
-            guid: any;
-        } | undefined;
-        onDeserialize(data: any, context: SerializationContext): any;
-        findObjectForGuid(guid: string, root: THREE.Object3D): any;
-    }
-    export const componentSerializer: ComponentSerializer;
-    class EventListData {
-        type: string;
-        calls: Array<EventListCall>;
-    }
-    type EventListCall = {
-        method: string;
-        target: string;
-        argument?: any;
-        enabled?: boolean;
-    };
-    class EventListSerializer extends TypeSerializer {
-        constructor();
-        onSerialize(_data: EventList, _context: SerializationContext): EventListData | undefined;
-        onDeserialize(data: EventListData, context: SerializationContext): EventList | undefined | null;
-    }
-    export const eventListSerializer: EventListSerializer;
-}
 declare module "engine-components/LookAtConstraint" {
     import { Behaviour } from "engine-components/Component";
     import * as THREE from "three";
@@ -2947,40 +3104,6 @@ declare module "engine-components/RendererLightmap" {
         private setLightmapDebugMaterial;
     }
 }
-declare module "engine/extensions/NEEDLE_render_objects" {
-    import { SourceIdentifier } from "engine/engine_types";
-    import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
-    import { IRenderer as Renderer } from "engine/engine_types";
-    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 EXTENSION_NAME = "NEEDLE_render_objects";
-}
-declare module "engine/extensions/NEEDLE_deferred_texture" {
-    import { Material } from "three";
-    import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
-    import { SourceIdentifier } from "engine/engine_types";
-    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;
-        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-components/Renderer" {
     import { Behaviour } from "engine-components/Component";
     import * as THREE from "three";
@@ -3370,7 +3493,7 @@ declare module "engine-components/WebXR" {
         getAROverlayContainer(): HTMLElement | null;
         setReticleActive(active: boolean): void;
         onBegin(session: THREE.XRSession): Promise<void>;
-        onEnd(_session: THREE.XRSession): void;
+        onEnd(session: THREE.XRSession): void;
         onUpdate(session: THREE.XRSession, frame: THREE.XRFrame): void;
     }
 }
@@ -3395,6 +3518,7 @@ declare module "engine-components/DragControls" {
         private static _active;
         static get HasAnySelected(): boolean;
         transformSelf: boolean;
+        private orbit;
         private selectStartEventListener;
         private selectEndEventListener;
         constructor();
@@ -3965,12 +4089,6 @@ declare module "engine-components/VideoPlayer" {
         private updateAspectImpl;
     }
 }
-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-components/ScreenCapture" {
     import { Behaviour } from "engine-components/Component";
     import { VideoPlayer } from "engine-components/VideoPlayer";
@@ -3985,6 +4103,11 @@ declare module "engine-components/ScreenCapture" {
         Sending = 1,
         Receiving = 2
     }
+    type ScreenCaptureOptions = {
+        device?: ScreenCaptureDevice;
+        deviceId?: string;
+        constraints?: MediaTrackConstraints;
+    };
     export class ScreenCapture extends Behaviour implements IPointerClickHandler {
         onPointerClick(): void;
         videoPlayer?: VideoPlayer;
@@ -3999,7 +4122,7 @@ declare module "engine-components/ScreenCapture" {
         private _currentMode;
         awake(): void;
         start(): void;
-        share(): Promise<void>;
+        share(opts?: ScreenCaptureOptions): Promise<void>;
         close(): void;
         private setVideo;
         private onReceiveVideo;
@@ -5236,106 +5359,6 @@ declare module "needle-engine" {
     export * from "engine-components/codegen/components";
     export * from "engine-components/js-extensions/Object3D";
 }
-declare module "engine/extensions/NEEDLE_techniques_webgl" {
-    import { GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
-    import * as THREE from 'three';
-    import { RawShaderMaterial } from 'three';
-    import { SourceIdentifier } from "engine/engine_types";
-    export const NEEDLE_TECHNIQUES_WEBGL_NAME = "NEEDLE_techniques_webgl";
-    export class CustomShader extends RawShaderMaterial {
-        private identifier;
-        private onBeforeRenderSceneCallback;
-        clone(): this;
-        constructor(identifier: SourceIdentifier, ...args: any[]);
-        dispose(): void;
-        waitForLighting(): Promise<void>;
-        private _sphericalHarmonicsName;
-        private _objToWorldName;
-        private _worldToObjectName;
-        private static viewProjection;
-        private static _viewProjectionValues;
-        private _viewProjectionName;
-        private static viewMatrix;
-        private static _viewMatrixValues;
-        private _viewMatrixName;
-        private static _worldSpaceCameraPosName;
-        private static _worldSpaceCameraPos;
-        private static _mainLightColor;
-        private static _mainLightPosition;
-        private static _lightData;
-        private _rendererData;
-        private get depthTextureUniform();
-        private get opaqueTextureUniform();
-        private onBeforeRenderScene;
-        onBeforeRender(_renderer: any, _scene: any, camera: any, _geometry: any, obj: any, _group: any): void;
-        onUpdateUniforms(camera?: THREE.Camera, obj?: any): void;
-    }
-    export class NEEDLE_techniques_webgl implements GLTFLoaderPlugin {
-        get name(): string;
-        private parser;
-        private identifier;
-        constructor(loader: GLTFParser, identifier: SourceIdentifier);
-        loadMaterial(index: number): Promise<THREE.Material> | null;
-    }
-}
-declare module "engine/extensions/NEEDLE_gameobject_data" {
-    import { GLTF, GLTFLoaderPlugin, GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
-    export const EXTENSION_NAME = "NEEDLE_gameobject_data";
-    export class NEEDLE_gameobject_data implements GLTFLoaderPlugin {
-        get name(): string;
-        private parser;
-        constructor(parser: GLTFParser);
-        afterRoot(_result: GLTF): Promise<void> | null;
-        private findAndApplyExtensionData;
-        private applyExtensionData;
-    }
-}
-declare module "engine/extensions/extensions" {
-    import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader";
-    import { NEEDLE_components } from "engine/extensions/NEEDLE_components";
-    import { SourceIdentifier } from "engine/engine_types";
-    import { Context } from "engine/engine_setup";
-    export function registerComponentExtension(loader: GLTFLoader): NEEDLE_components;
-    export function registerExtensions(loader: GLTFLoader, context: Context, sourceId: SourceIdentifier): void;
-}
-declare module "engine/engine_gltf_builtin_components" {
-    import "./codegen/register_types";
-    import { Component } from "engine-components/Component";
-    import { Context } from "engine/engine_setup";
-    import { SerializationContext } from "engine/engine_serialization_core";
-    import { NEEDLE_components } from "engine/extensions/NEEDLE_components";
-    import { SourceIdentifier } from "engine/engine_types";
-    import { UIDProvider } from "engine/engine_types";
-    export function writeBuiltinComponentData(comp: Component, context: SerializationContext): object | null;
-    export function createBuiltinComponents(context: Context, gltfId: SourceIdentifier, gltf: any, seed?: number | null | UIDProvider, extension?: NEEDLE_components): Promise<void>;
-}
-declare module "engine/engine_scenetools" {
-    import { Context } from "engine/engine_setup";
-    import { GLTF, GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
-    import { UIDProvider } from "engine/engine_types";
-    export enum GltfLoadEventType {
-        BeforeLoad = 0,
-        AfterLoaded = 1,
-        FinishedSetup = 10
-    }
-    export class GltfLoadEvent {
-        context: Context;
-        loader: GLTFLoader;
-        path: string;
-        gltf?: GLTF;
-        constructor(context: Context, path: string, loader: GLTFLoader, gltf?: GLTF);
-    }
-    export type GltfLoadEventCallback = (event: GltfLoadEvent) => void;
-    export function addGltfLoadEventListener(type: GltfLoadEventType, listener: GltfLoadEventCallback): void;
-    export function removeGltfLoadEventListener(type: GltfLoadEventType, listener: GltfLoadEventCallback): void;
-    export function parseSync(context: Context, data: any, path: string, seed: number | UIDProvider | null): Promise<GLTF | undefined>;
-    export function loadSync(context: Context, url: string, seed: number | UIDProvider | null, _allowAddingAnimator?: boolean, prog?: (ProgressEvent: any) => void): Promise<GLTF | undefined>;
-    export function findAnimationsLate(_context: Context, gltf: any, callbackarray: any, allowAddingAnimator?: boolean): void;
-    export function findAnimations(gltf: GLTF, allowAddingAnimator?: boolean): void;
-    export function tryFindObjectByName(name: any, obj: any, recursive?: boolean): any;
-    export function tryFindObject(globalObjectIdentifier: any, obj: any, recursive?: boolean): any;
-    export function tryFindScript(globalObjectIdentifier: any, list?: null): import("engine/engine_types").IComponent | null;
-}
 declare module "engine/debug/error_overlay" {
     export function makeErrorsVisibleForDevelopment(): void;
 }
@@ -5355,6 +5378,7 @@ declare module "engine/engine" {
         tryFindObjectByName(name: any, obj: any, recursive?: boolean): any;
         tryFindObject(globalObjectIdentifier: any, obj: any, recursive?: boolean): any;
         tryFindScript(globalObjectIdentifier: any, list?: null): import("engine/engine_types").IComponent | null;
+        NeedleGltfLoader: typeof engine_scenetools.NeedleGltfLoader;
         GltfLoadEventType: typeof engine_scenetools.GltfLoadEventType;
         GltfLoadEvent: typeof engine_scenetools.GltfLoadEvent;
         registerComponent(script: import("engine/engine_types").IComponent, context?: engine_setup.Context | undefined): void;