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

package/src/engine/engine_playerview.ts

@@ -0,0 +1,80 @@
+import { getParam } from "./engine_utils";
+import { Object3D } from "three";
+import { Context } from "./engine_setup";
+
+const debug = getParam("debugplayerview");
+
+export enum ViewDevice {
+    Browser = "browser",
+    Headset = "headset",
+    Handheld = "handheld",
+}
+
+export class PlayerView {
+    readonly userId: string;
+    readonly context: Context;
+
+    viewDevice: ViewDevice = ViewDevice.Browser;
+
+    get currentObject(): Object3D | undefined | null {
+        return this._object;
+    }
+    set currentObject(obj: Object3D | undefined | null) {
+        this._object = obj;
+    }
+
+    get isConnected(): boolean {
+        return this.context.connection.userIsInRoom(this.userId);
+    }
+
+    removed: boolean = false;
+
+    private _object: undefined | Object3D | null;
+
+    constructor(userId: string, context: Context) {
+        this.userId = userId;
+        this.context = context;
+    }
+}
+
+export class PlayerViewManager {
+
+    private readonly context: Context;
+    private readonly playerViews = new Map<string, PlayerView>();
+
+    constructor(context: Context) {
+        this.context = context;
+    }
+
+    setPlayerView(id: string, obj: Object3D | undefined | null, device: ViewDevice) {
+        let view = this.playerViews.get(id);
+        if (!view) {
+            view = new PlayerView(id, this.context);
+            this.playerViews.set(id, view);
+        }
+        view.viewDevice = device;
+        view.currentObject = obj;
+        view.removed = false;
+    }
+
+    getPlayerView(id: string | null | undefined): PlayerView | undefined {
+        if (!id) return undefined;
+        if (!this.context.connection.userIsInRoom(id)) {
+            this.playerViews.delete(id);
+            return undefined;
+        }
+        const view = this.playerViews.get(id);
+        return view;
+    }
+
+    removePlayerView(id: string, device: ViewDevice) {
+        const view = this.playerViews.get(id);
+        if (view?.viewDevice === device) {
+            if (debug)
+                console.log("REMOVE", id);
+            view.removed = true;
+            this.playerViews.delete(id);
+        }
+    }
+
+}

package/src/engine/engine_serialization_core.ts

@@ -248,6 +248,14 @@ export function deserializeObject(obj: ISerializable, serializedData: object, co
             for (const key in typeInfo) {
                 const serializedEntryInfo = typeInfo[key];
                 const data = serializedData[key];
+
+
+                if (obj[key] !== undefined && data === undefined) {
+                    // if a field is marked as serialized and has some default value
+                    // but no data was serialized do not override the default value with undefined
+                    continue;
+                }
+
                 context.path = key;
 
                 if (serializedEntryInfo === null) {

package/src/engine/engine_setup.ts

@@ -26,6 +26,7 @@ import { RendererData } from './engine_rendererdata';
 import { Addressables } from './engine_addressables';
 import { Application } from './engine_application';
 import { LightDataRegistry, ILightDataRegistry } from './engine_lightdata';
+import { PlayerViewManager } from './engine_playerview';
 
 
 const debug = utils.getParam("debugSetup");
@@ -90,13 +91,26 @@ export class Context {
 	isManagedExternally: boolean = false;
 
 	domElement: HTMLElement;
+	get resolutionScaleFactor() { return this._resolutionScaleFactor; }
+	/** use to scale the resolution up or down of the renderer. default is 1 */
+	set resolutionScaleFactor(val: number) { 
+		if(val === this._resolutionScaleFactor) return;
+		if(typeof val !== "number") return;
+		if(val <= 0) {
+			console.error("Invalid resolution scale factor", val);
+			return;
+		}
+		this._resolutionScaleFactor = val;
+		this.updateSize();
+	}
+	private _resolutionScaleFactor: number = 1;
 	get domWidth(): number { return this.domElement.clientWidth; }
 	get domHeight(): number { return this.domElement.clientHeight; }
 	get domX(): number { return this.domElement.offsetLeft; }
 	get domY(): number { return this.domElement.offsetTop; }
 	get isInXR() { return this.renderer.xr?.isPresenting || false; }
 	get xrSession() { return this.renderer.xr?.getSession(); }
-	get AROverlayElement(): HTMLElement {
+	get arOverlayElement(): HTMLElement {
 		const el = this.domElement as any;
 		if (typeof el.getAROverlayContainer === "function")
 			return el.getAROverlayContainer();
@@ -152,6 +166,7 @@ export class Context {
 	rendererData: RendererData;
 	addressables: Addressables;
 	lightmaps: ILightDataRegistry;
+	players : PlayerViewManager;
 
 	private _sizeChanged: boolean = false;
 	private _isCreated: boolean = false;
@@ -199,6 +214,7 @@ export class Context {
 		this.rendererData = new RendererData(this);
 		this.addressables = new Addressables(this);
 		this.lightmaps = new LightDataRegistry(this);
+		this.players = new PlayerViewManager(this);
 
 		window.addEventListener('resize', this.updateSize.bind(this));
 		const ro = new ResizeObserver(_ => this._sizeChanged = true);
@@ -208,12 +224,15 @@ export class Context {
 	private updateSize() {
 		if (!this.isManagedExternally && !this.renderer.xr.isPresenting) {
 			this._sizeChanged = false;
-			const width = this.domWidth;
-			const height = this.domHeight;
+			const scaleFactor = this.resolutionScaleFactor;
+			const width = this.domWidth * scaleFactor;
+			const height = this.domHeight * scaleFactor;
 			const camera = this.mainCamera as PerspectiveCamera;
 			this.updateAspect(camera);
 			this.renderer.setSize(width, height);
 			this.renderer.setPixelRatio(window.devicePixelRatio);
+			this.renderer.domElement.style.width = this.domWidth + "px";
+			this.renderer.domElement.style.height = this.domHeight + "px";
 			if (this.composer) {
 				this.composer.setSize(width, height);
 				this.composer.setPixelRatio(window.devicePixelRatio);
@@ -294,6 +313,21 @@ export class Context {
 		(this.mainCameraComponent as Camera)?.applyClearFlagsIfIsActiveCamera();
 	}
 
+	removeCamera(cam?: Camera | null) {
+		if(!cam) return;
+		const index = this._cameraStack.indexOf(cam);
+		if (index >= 0) this._cameraStack.splice(index, 1);
+
+		if (this.mainCameraComponent === cam) {
+			this.mainCameraComponent = undefined;
+		
+			if (this._cameraStack.length > 0) {
+				const last = this._cameraStack[this._cameraStack.length - 1];
+				this.setCurrentCamera(last);
+			}
+		}
+	}
+
 	private _onBeforeRenderListeners: { [key: string]: OnBeforeRenderCallback[] } = {};
 
 	/** use this to subscribe to onBeforeRender events on threejs objects */

package/src/engine/extensions/NEEDLE_lighting_settings.ts

@@ -99,13 +99,14 @@ export class SceneLightSettings extends Behaviour {
     onEnable() {
         const isActive = this.context.mainCameraComponent?.sourceId === this.sourceId;
         if (debug)
-            console.log("enable", this.sourceId, isActive, this, this.context.mainCameraComponent?.sourceId);
+            console.log("Enable scene lighting", this.sourceId, isActive, this, this.context.mainCameraComponent?.sourceId);
         if (!isActive) {
+            if(debug) console.warn("This is no active?!", this.context.mainCameraComponent?.sourceId)
             // this.enabled = false;
             // return;
         }
         if (this.ambientMode == AmbientMode.Flat) {
-            if (this.ambientLight) {
+            if (this.ambientLight && !this._ambientLightObj) {
                 this._ambientLightObj = new AmbientLight(this.ambientLight, Math.PI * this.ambientIntensity);
             }
             if (this._ambientLightObj) {
@@ -155,6 +156,7 @@ export class SceneLightSettings extends Behaviour {
         if (debug)
             console.log("disable", this.sourceId, this);
         if (this._lightProbeObj) this._lightProbeObj.removeFromParent();
+        if(this._ambientLightObj) this._ambientLightObj.removeFromParent();
         if (this.sourceId)
             this.context.rendererData.disableReflection();
     }

package/src/engine/extensions/NEEDLE_techniques_webgl.ts

@@ -393,7 +393,7 @@ export class NEEDLE_techniques_webgl implements GLTFLoaderPlugin {
                         const val = materialExtension.values[key];
                         if (typeof val === "string") {
                             if (val.startsWith("/textures/")) {
-                                const indexString = val.substring(9);
+                                const indexString = val.substring("/textures/".length);
                                 const texIndex = Number.parseInt(indexString);
                                 if (texIndex >= 0) {
                                     const tex = await this.parser.getDependency("texture", texIndex);

package/src/engine-components/Component.ts

@@ -644,7 +644,7 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D {
         return object.getComponentsInChildren(typeName, go, arr);
     }
 
-    public static getComponentInParent<T>(go: GameObject | THREE.Object3D, typeName: Constructor<T>): T | null {
+    public static getComponentInParent<T>(go: GameObject | THREE.Object3D | Array<Object3D>, typeName: Constructor<T>): T | null {
         return object.getComponentInParent(typeName, go);
     }
 

package/src/engine-components/Light.ts

@@ -334,7 +334,10 @@ export class Light extends Behaviour {
             }
         }
 
+
         if (this.light !== undefined) {
+            this._intensity = this.light.intensity;
+            
             if (this.shadows !== LightShadows.None) {
                 this.light.castShadow = true;
             }

package/src/engine-components/OrbitControls.ts

@@ -9,7 +9,6 @@ import { serializeable } from "../engine/engine_serialization_decorator";
 import { Vector3 } from "three";
 
 export class OrbitControls extends Behaviour {
-
     public get controls() {
         return this._controls;
     }
@@ -31,7 +30,7 @@ export class OrbitControls extends Behaviour {
     minZoom: number = 0;
     maxZoom: number = Infinity;
     enablePan: boolean = true;
-    @serializeable(LookAtConstraint)
+    @serializeable()
     lookAtConstraint: LookAtConstraint | null = null;
     lookAtConstraint01: number = 1;
     middleClickToFocus: boolean = true;

package/src/engine-components/ParticleSystem.ts

@@ -61,7 +61,7 @@ export class ParticleSystem extends Behaviour {
 
     awake(): void {
         this.renderer = GameObject.getComponent(this.gameObject, ParticleSystemRenderer)!;
-        if (debug)
+        // if (debug)
             console.log(this);
     }
 
@@ -108,31 +108,30 @@ export class ParticleSystem extends Behaviour {
         this.activeCount = this.main.prewarm ? this.main.maxParticles : 0;
     }
 
-    update() {
-        if (!this.geometry) return;
-
-        const t = this.context.time.deltaTime;
-        this.emit(t);
-
-        for (let i = 0; i < this.activeCount; i += 1) {
-            const ps = this.particleStates[i];
-            if (!ps) continue;
-            const vx = ps.velocity.x * t;
-            const vy = ps.velocity.y * t;
-            const vz = ps.velocity.z * t;
-            ps.position.x += vx;
-            ps.position.y += vy;
-            ps.position.z += vz;
-            this.updateOverLifetime(i, ps);
-            this.geometry.attributes.position.setXYZ(i, ps.position.x, ps.position.y, ps.position.z);
-            this.geometry.attributes.color.setXYZ(i, ps.color.r, ps.color.g, ps.color.b);
-        }
-        if (this.geometry) {
-            this.geometry.attributes.position.needsUpdate = true;
-            this.geometry.setDrawRange(0, this.activeCount);
-        }
-        // console.log(this.activeCount);
-    }
+    // update() {
+    //     if (!this.geometry) return;
+
+    //     const t = this.context.time.deltaTime;
+    //     this.emit(t);
+
+    //     for (let i = 0; i < this.activeCount; i += 1) {
+    //         const ps = this.particleStates[i];
+    //         if (!ps) continue;
+    //         const vx = ps.velocity.x * t;
+    //         const vy = ps.velocity.y * t;
+    //         const vz = ps.velocity.z * t;
+    //         ps.position.x += vx;
+    //         ps.position.y += vy;
+    //         ps.position.z += vz;
+    //         this.updateOverLifetime(i, ps);
+    //         this.geometry.attributes.position.setXYZ(i, ps.position.x, ps.position.y, ps.position.z);
+    //         this.geometry.attributes.color.setXYZ(i, ps.color.r, ps.color.g, ps.color.b);
+    //     }
+    //     if (this.geometry) {
+    //         this.geometry.attributes.position.needsUpdate = true;
+    //         this.geometry.setDrawRange(0, this.activeCount);
+    //     }
+    // }
 
     emit(deltaTime: number) {
         const count = this.activeCount;

package/src/engine-components/PlayerColor.ts

@@ -68,7 +68,7 @@ export class PlayerColor extends Behaviour {
             mesh.material = mat;
             // console.log("CLONE", mat);
         }
-        else console.log("DONT CLONE", mat);
+        // else console.log("DONT CLONE", mat);
         mat["color"] = col;
     }