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

package/CHANGELOG.md

@@ -4,6 +4,16 @@ 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.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

@@ -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,
@@ -952,6 +1070,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 +1369,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";
@@ -1823,7 +1836,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 +2091,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 +2133,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 +2150,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;
@@ -2995,6 +3040,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>;
     };
@@ -3083,6 +3129,7 @@ declare module "engine/engine_setup" {
         rendererData: RendererData;
         addressables: Addressables;
         lightmaps: ILightDataRegistry;
+        players: PlayerViewManager;
         private _sizeChanged;
         private _isCreated;
         private _stats;
@@ -3096,6 +3143,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 +3711,6 @@ declare module "engine-components/ParticleSystem" {
         private tempQuat;
         awake(): void;
         onEnable(): void;
-        update(): void;
         emit(deltaTime: number): void;
         private initializeParticle;
         private updateOverLifetime;
@@ -3864,36 +3911,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 +4030,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 +4050,6 @@ declare module "engine-components/SyncedCamera" {
         private _camTimeoutInSeconds;
         private _receiveCallback;
         awake(): Promise<void>;
-        start(): void;
         onEnable(): void;
         onDisable(): void;
         update(): void;