@needle-tools/engine 2.28.0-pre → 2.30.0-pre

package/CHANGELOG.md

@@ -4,6 +4,25 @@ All notable changes to this package will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [2.30.0-pre] - 2022-10-12
+- Add: Quest 2 passthrough support
+- Add: UI Graphic components now support ``raycastTarget`` again
+- Add: VideoPlayer now supports ``materialTarget`` option which allows for assigning any renderer in the scene that should be used as a video canvas
+- Changed: updated three-mesh-ui dependency version
+- Changed: updated needle-gltfTransform extensions package, fixing an issue with passthrough of texture json pointers
+- Changed: selecting SpectatorCam now requires click (instead of just listening to pointer up event)
+- Fix: Avatars using instanced materials should now update transforms correctly again
+
+## [2.29.0-pre] - 2022-10-10
+- Add: Context.removeCamera method
+- Add: SpectatorCam allows to follow other users across devices by clicking on respective avatar (e.g. clicking SyncedCam avatar or WebXR avatar, ESC or long press to stop spectating)
+- Add: ``Input`` events for pointerdown, pointerup, pointermove and keydown, keyup, keypress. Subscribe via ``this.context.input.addEventListener(InputEvents.pointerdown, evt => {...})`` 
+- Change: Default WebXR rig matches Unity forward
+- Fix: WebXRController raycast line being rendered as huge line before first world hit
+- Fix: SpectatorCam works again
+- Fix: ``serializable()`` does now not write undefined values if serialize data is undefined
+- Fix: exit VR lighting
+
 ## [2.28.0-pre] - 2022-10-06
 - Add: ``resolutionScaleFactor`` to context
 - Fix ``IsLocalNetwork`` regex

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;
@@ -424,7 +424,7 @@ declare module "engine-components/Component" {
         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, typeName: Constructor<T>): T | null;
+        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>;
@@ -517,6 +517,112 @@ declare module "engine-components/Component" {
     }
     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/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;
+    }
+    export const TypeStore: _TypeStore;
+}
+declare module "engine/extensions/NEEDLE_persistent_assets" {
+    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 {
+        get name(): string;
+        private parser;
+        constructor(parser: GLTFParser);
+        afterRoot(_result: GLTF): Promise<void>;
+        resolve(parser: GLTFParser, path: string): Promise<void> | null | any;
+    }
+}
+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 const helper: SerializationHelper;
+    export interface ITypeSerializer {
+        onSerialize(data: any, context: SerializationContext): any;
+        onDeserialize(data: any, context: SerializationContext): any;
+    }
+    /**
+     * 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 interface ITypeInformation {
+        type?: Constructor<any>;
+    }
+    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 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_input" {
     import * as THREE from 'three';
     import { Context } from "engine/engine_setup";
@@ -528,8 +634,19 @@ declare module "engine/engine_input" {
         pointerType: string;
         source?: Event;
     };
+    export class KeyEventArgs {
+        key: string;
+        keyType: string;
+        source?: Event;
+        constructor(evt: KeyboardEvent);
+    }
     export enum InputEvents {
-        PointerDown = "pointerDown"
+        PointerDown = "pointerdown",
+        PointerUp = "pointerup",
+        PointerMove = "pointermove",
+        KeyDown = "keydown",
+        KeyUp = "keyup",
+        KeyPressed = "keypress"
     }
     export class Input extends EventTarget {
         _doubleClickTimeThreshold: number;
@@ -609,6 +726,7 @@ declare module "engine/engine_input" {
         private getPointerIndex;
         private setPointerState;
         private setPointerStateT;
+        private onDispatchEvent;
     }
     export enum KeyCode {
         BACKSPACE = 8,
@@ -842,7 +960,7 @@ declare module "engine/extensions/NEEDLE_deferred_texture" {
     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;
+        static assignTextureLOD(context: Context, source: SourceIdentifier | undefined, material: Material, level?: number): void;
         get name(): string;
         private parser;
         private sourceId;
@@ -900,6 +1018,7 @@ declare module "engine-components/Renderer" {
         private _isInstancingEnabled;
         private handles;
         private prevLayers;
+        private clearInstancingState;
         setInstancingEnabled(enabled: boolean): boolean;
         start(): void;
         onEnable(): void;
@@ -952,6 +1071,7 @@ declare module "engine/engine_physics" {
     }
     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;
@@ -1250,112 +1370,6 @@ declare module "engine/extensions/NEEDLE_animator_controller_model" {
         Trigger = 9
     }
 }
-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/extension_resolver" {
-    import { GLTFParser } from "three/examples/jsm/loaders/GLTFLoader";
-    export interface IExtensionReferenceResolver {
-        resolve(parser: GLTFParser, path: string): Promise<void> | null;
-    }
-}
-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/extensions/NEEDLE_persistent_assets" {
-    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 {
-        get name(): string;
-        private parser;
-        constructor(parser: GLTFParser);
-        afterRoot(_result: GLTF): Promise<void>;
-        resolve(parser: GLTFParser, path: string): Promise<void> | null | any;
-    }
-}
-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 const helper: SerializationHelper;
-    export interface ITypeSerializer {
-        onSerialize(data: any, context: SerializationContext): any;
-        onDeserialize(data: any, context: SerializationContext): any;
-    }
-    /**
-     * 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 interface ITypeInformation {
-        type?: Constructor<any>;
-    }
-    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 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-components/AnimatorController" {
     import { Animator } from "engine-components/Animator";
     import { AnimatorControllerModel, State } from "engine/extensions/NEEDLE_animator_controller_model";
@@ -1571,6 +1585,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";
@@ -1823,7 +1838,8 @@ declare module "engine-components/XRFlag" {
         AR = 2,
         VR = 4,
         FirstPerson = 8,
-        ThirdPerson = 16
+        ThirdPerson = 16,
+        All = 4294967295
     }
     export class XRState {
         static Global: XRState;
@@ -2077,6 +2093,34 @@ declare module "engine-components/WebXRSync" {
         private getAvatarId;
     }
 }
+declare module "engine/engine_playerview" {
+    import { Object3D } from "three";
+    import { Context } from "engine/engine_setup";
+    export enum ViewDevice {
+        Browser = "browser",
+        Headset = "headset",
+        Handheld = "handheld"
+    }
+    export class PlayerView {
+        readonly userId: string;
+        readonly context: Context;
+        viewDevice: ViewDevice;
+        get currentObject(): Object3D | undefined | null;
+        set currentObject(obj: Object3D | undefined | null);
+        get isConnected(): boolean;
+        removed: boolean;
+        private _object;
+        constructor(userId: string, context: Context);
+    }
+    export class PlayerViewManager {
+        private readonly context;
+        private readonly playerViews;
+        constructor(context: Context);
+        setPlayerView(id: string, obj: Object3D | undefined | null, device: ViewDevice): void;
+        getPlayerView(id: string | null | undefined): PlayerView | undefined;
+        removePlayerView(id: string, device: ViewDevice): void;
+    }
+}
 declare module "engine-components/WebXRAvatar" {
     import { Behaviour } from "engine-components/Component";
     import { WebXR } from "engine-components/WebXR";
@@ -2091,6 +2135,7 @@ declare module "engine-components/WebXRAvatar" {
         gameObject: Object3D;
     };
     export class AvatarMarker extends Behaviour {
+        static getAvatar(index: number): AvatarMarker | null;
         static instances: AvatarMarker[];
         static onAvatarMarkerCreated(cb: (args: AvatarMarkerEventArgs) => void): Function;
         static onAvatarMarkerDestroyed(cb: (args: AvatarMarkerEventArgs) => void): Function;
@@ -2107,6 +2152,8 @@ declare module "engine-components/WebXRAvatar" {
         private static loader;
         private _isVisible;
         setVisible(visible: boolean): void;
+        get isWebXRAvatar(): boolean;
+        /** the user id */
         guid: string;
         private root;
         head: THREE.Object3D | null;
@@ -2366,20 +2413,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;
@@ -2426,7 +2480,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;
@@ -2466,7 +2520,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;
@@ -2479,9 +2534,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;
     }
@@ -2820,10 +2877,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;
     }
 }
@@ -2995,6 +3054,7 @@ declare module "engine/engine_setup" {
     import { Addressables } from "engine/engine_addressables";
     import { Application } from "engine/engine_application";
     import { ILightDataRegistry } from "engine/engine_lightdata";
+    import { PlayerViewManager } from "engine/engine_playerview";
     export const build_scene_functions: {
         [name: string]: (context: Context) => Promise<void>;
     };
@@ -3027,6 +3087,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;
@@ -3045,6 +3109,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;
@@ -3083,6 +3148,7 @@ declare module "engine/engine_setup" {
         rendererData: RendererData;
         addressables: Addressables;
         lightmaps: ILightDataRegistry;
+        players: PlayerViewManager;
         private _sizeChanged;
         private _isCreated;
         private _stats;
@@ -3096,6 +3162,7 @@ declare module "engine/engine_setup" {
         stopAllCoroutinesFrom(script: Component): void;
         private _cameraStack;
         setCurrentCamera(cam: Camera): void;
+        removeCamera(cam?: Camera | null): void;
         private _onBeforeRenderListeners;
         /** use this to subscribe to onBeforeRender events on threejs objects */
         addBeforeRenderListener(target: THREE.Object3D, callback: OnBeforeRenderCallback): void;
@@ -3663,7 +3730,6 @@ declare module "engine-components/ParticleSystem" {
         private tempQuat;
         awake(): void;
         onEnable(): void;
-        update(): void;
         emit(deltaTime: number): void;
         private initializeParticle;
         private updateOverLifetime;
@@ -3708,11 +3774,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;
@@ -3761,6 +3836,7 @@ declare module "engine-components/ScreenCapture" {
         private captureStream;
         open(force?: boolean): Promise<void>;
         close(): void;
+        private handleNetworkedVideo;
     }
 }
 declare module "engine-components/ShadowCatcher" {
@@ -3864,36 +3940,43 @@ declare module "engine-components/SpatialTrigger" {
 declare module "engine-components/SpectatorCamera" {
     import { Behaviour } from "engine-components/Component";
     import { Camera } from "engine-components/Camera";
+    import { PlayerView } from "engine/engine_playerview";
+    export enum SpectatorMode {
+        FirstPerson = 0,
+        ThirdPerson = 1
+    }
     export class SpectatorCamera extends Behaviour {
         cam: Camera | null;
-        private _firstPersonMode;
-        get firstPersonMode(): boolean;
-        set firstPersonMode(val: boolean);
-        enableFirstPersonMode(): void;
-        enableThirdPersonMode(): void;
+        private _mode;
+        get mode(): SpectatorMode;
+        set mode(val: SpectatorMode);
+        /** if this user is currently spectating someone else */
+        get isSpectating(): boolean;
+        isSpectatingUser(userId: string): boolean;
+        isFollowedBy(userId: string): boolean;
+        /** list of other users that are following me */
+        get followers(): string[];
+        stopSpectating(): void;
+        /** player view to follow */
+        set target(target: PlayerView | undefined);
+        get target(): PlayerView | undefined;
+        requestAllFollowMe(): void;
+        private get isSpectatingSelf();
         private orbit;
-        private firstPersonFollow;
-        private spectatorUIDomElement;
+        private _handler?;
         private eventSub_WebXRRequestStartEvent;
         private eventSub_WebXRStartEvent;
         private eventSub_WebXREndEvent;
+        private _debug?;
+        private _networking;
         awake(): void;
         onDestroy(): void;
-        private toggleView;
-        private updateUI;
         private isSupportedPlatform;
         private onXRSessionRequestStart;
         private onXRSessionStart;
         private onXRSessionEnded;
-        private _sessionHasStarted;
-        private _firstPersonIsSetup;
-        private _orbitStartPos;
-        private _orbitStartRot;
-        private _orbitStartPos2;
-        private _orbitStartRot2;
+        private followSelf;
         onAfterRender(): void;
-        private setupFollowMode;
-        private updateFollowSettings;
         private setAvatarFlagsBeforeRender;
         private resetAvatarFlags;
     }
@@ -3976,11 +4059,15 @@ declare module "engine-schemes/synced-camera-model" {
 }
 declare module "engine-components/SyncedCamera" {
     import { Behaviour } from "engine-components/Component";
-    import { Camera } from "engine-components/Camera";
     import { AssetReference } from "engine/engine_addressables";
+    type UserCamInfo = {
+        obj: THREE.Object3D;
+        lastUpdate: number;
+        userId: string;
+    };
     export class SyncedCamera extends Behaviour {
-        getUserCamera(userId: string): THREE.Object3D | null;
-        cam: Camera | null;
+        static instances: UserCamInfo[];
+        getCameraObject(userId: string): THREE.Object3D | null;
         cameraPrefab: THREE.Object3D | null | AssetReference;
         private _lastWorldPosition;
         private _lastWorldQuaternion;
@@ -3992,7 +4079,6 @@ declare module "engine-components/SyncedCamera" {
         private _camTimeoutInSeconds;
         private _receiveCallback;
         awake(): Promise<void>;
-        start(): void;
         onEnable(): void;
         onDisable(): void;
         update(): void;
@@ -4083,10 +4169,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" {
@@ -4518,6 +4608,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;
@@ -4669,6 +4760,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;
@@ -5003,6 +5095,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 };