@needle-tools/engine 2.66.1-pre → 2.67.0-pre

package/src/engine-components/Component.ts

@@ -23,6 +23,9 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
 
     guid: string | undefined;
 
+    // Added to the threejs Object3D prototype
+    abstract destroy();
+
     // The actual implementation / prototype of threejs is modified in js-extensions/Object3D
     abstract get transform(): THREE.Object3D;
 
@@ -33,15 +36,21 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
     public static setActive(go: THREE.Object3D, active: boolean, processStart: boolean = true) {
         if (!go) return;
         setActive(go, active);
+
+        // TODO: do we still need this?:
         main.updateIsActive(go);
         if (active && processStart)
             main.processStart(Context.Current, go);
     }
 
+    /** If the object is active (same as go.visible) */
     public static isActiveSelf(go: THREE.Object3D): boolean {
         return isActiveSelf(go);
     }
 
+    /** If the object is active in the hierarchy (e.g. if any parent is invisible or not in the scene it will be false) 
+     * @param go object to check
+    */
     public static isActiveInHierarchy(go: THREE.Object3D): boolean {
         return isActiveInHierarchy(go);
     }
@@ -52,19 +61,35 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
 
     public static isUsingInstancing(instance: THREE.Object3D): boolean { return isUsingInstancing(instance); }
 
+    /** Run a callback for all components of the provided type on the provided object and its children (if recursive is true)
+     * @param instance object to run the method on
+     * @param cb callback to run on each component
+     * @param recursive if true, the method will be run on all children as well
+     */
     public static foreachComponent(instance: THREE.Object3D, cb: (comp: Component) => any, recursive: boolean = true): any {
         return foreachComponent(instance, cb as (comp: IComponent) => any, recursive);
     }
 
+    /** Creates a new instance of the provided object. The new instance will be created on all connected clients 
+     * @param instance object to instantiate
+     * @param opts options for the instantiation
+     */
     public static instantiateSynced(instance: GameObject | Object3D | null, opts: InstantiateOptions): GameObject | null {
         if (!instance) return null;
         return syncInstantiate(instance as any, opts) as GameObject | null;
     }
 
+    /** Creates a new instance of the provided object (like cloning it including all components and children) 
+     * @param instance object to instantiate
+     * @param opts options for the instantiation (e.g. with what parent, position, etc.)
+    */
     public static instantiate(instance: GameObject | Object3D | null, opts: InstantiateOptions | null = null): GameObject | null {
         return instantiate(instance, opts) as GameObject | null;
     }
 
+    /** Destroys a object on all connected clients (if you are in a networked session) 
+     * @param instance object to destroy
+    */
     public static destroySynced(instance: THREE.Object3D | Component, context?: Context, recursive: boolean = true) {
         if (!instance) return;
         const go = instance as GameObject;
@@ -72,6 +97,10 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
         syncDestroy(go as any, context.connection, recursive);
     }
 
+    /** Destroys a object
+     * @param instance object to destroy
+     * @param recursive if true, all children will be destroyed as well
+     */
     public static destroy(instance: THREE.Object3D | Component, recursive: boolean = true, isRoot: boolean = true) {
         return destroy(instance, recursive, isRoot);
     }
@@ -94,7 +123,7 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
         if (context) {
             GameObject.foreachComponent(instance, (comp: Component) => {
                 main.addScriptToArrays(comp, context!);
-                if(comp.__internalDidAwakeAndStart) return;
+                if (comp.__internalDidAwakeAndStart) return;
                 if (context!.new_script_start.includes(comp) === false) {
                     context!.new_script_start.push(comp as Behaviour);
                 }
@@ -118,24 +147,31 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
         }, true);
     }
 
+    /** Invokes a method on all components including children (if a method with that name exists) */
     public static invokeOnChildren(go: THREE.Object3D | null | undefined, functionName: string, ...args: any) {
         this.invoke(go, functionName, true, args);
     }
 
+    /** Invokes a method on all components that have a method matching the provided name
+     * @param go object to invoke the method on all components
+     * @param functionName name of the method to invoke
+     */
     public static invoke(go: THREE.Object3D | null | undefined, functionName: string, children: boolean = false, ...args: any) {
         if (!go) return;
-
-        // console.log(go);
         this.foreachComponent(go, c => {
             const fn = c[functionName];
             if (fn && typeof fn === "function") {
-                const bound = fn.bind(c);
-                // console.log(c, bound)
-                bound(...args)
+                fn?.call(c, ...args)
             }
         }, children);
     }
 
+    /**
+     * Adds a new component to the provided object
+     * @param go object to add the component to
+     * @param type type of the component to add
+     * @param callAwake if true, the component will be added and awake will be called immediately
+     */
     public static addNewComponent<T>(go: GameObject | THREE.Object3D, type: ConstructorConcrete<T>, callAwake: boolean = true): T {
         const instance = new type();
         //@ts-ignore
@@ -143,13 +179,31 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
         return instance
     }
 
+    /**
+     * Moves a component to a new object  
+     * BEWARE: this does MOVE a component. If you want to add a new component use `addNewComponent`  
+     * @param go component to move the component to
+     * @param instance component to move to the GO
+     */
     public static addComponent(go: GameObject, instance: Component): void {
+        return this.moveComponent(go, instance);
+    }
+
+    /**
+     * Moves a component to a new object  
+     * @param go component to move the component to
+     * @param instance component to move to the GO
+     */
+    public static moveComponent(go: GameObject, instance: Component): void {
         if (instance.gameObject == null) {
             throw new Error("Did you mean to create a new component? Use addNewComponent");
         }
         moveComponentInstance(go, instance as any);
     }
 
+    /** Removes a component from its object
+     * @param instance component to remove
+     */
     public static removeComponent(instance: Component): Component {
         removeComponent(instance.gameObject, instance as any);
         return instance;
@@ -159,6 +213,7 @@ abstract class GameObject extends THREE.Object3D implements THREE.Object3D, IGam
         return getOrAddComponent<any>(go, typeName);
     }
 
+    /** Gets a component on the provided object */
     public static getComponent<T>(go: GameObject | THREE.Object3D | null, typeName: Constructor<T> | null): T | null {
         if (go === null) return null;
         // if names are minified we could also use the type store and work with strings everywhere
@@ -339,7 +394,7 @@ class Component implements IComponent, EventTarget {
     onCollisionEnter?(col: Collision);
     onCollisionExit?(col: Collision);
     onCollisionStay?(col: Collision);
-    
+
     onTriggerEnter?(col: ICollider);
     onTriggerStay?(col: ICollider);
     onTriggerExit?(col: ICollider);
@@ -361,34 +416,33 @@ class Component implements IComponent, EventTarget {
         this.__internalDestroy();
     }
 
-    
-    
+
+
     /** @internal */
     protected __didAwake: boolean = false;
-    
+
     /** @internal */
     private __didStart: boolean = false;
-    
+
     /** @internal */
     protected __didEnable: boolean = false;
-    
+
     /** @internal */
     protected __isEnabled: boolean | undefined = undefined;
-    
+
     /** @internal */
     private __destroyed: boolean = false;
-    
+
     /** @internal */
     get __internalDidAwakeAndStart() { return this.__didAwake && this.__didStart; }
 
-    
+
     /** @internal */
     constructor() {
-        // super();
         this.__internalNewInstanceCreated();
     }
 
-    
+
     /** @internal */
     __internalNewInstanceCreated() {
         this.__didAwake = false;
@@ -396,21 +450,17 @@ class Component implements IComponent, EventTarget {
         this.__didEnable = false;
         this.__isEnabled = undefined;
         this.__destroyed = false;
-        // this.__internalResetsCachedPhysicsData();
     }
 
-    
+
     /** @internal */
     __internalAwake() {
         if (this.__didAwake) return;
-        // console.log("__internalAwake");
         this.__didAwake = true;
-        // this.gameObject.test();
-
         this.awake();
     }
 
-    
+
     /** @internal */
     __internalStart() {
         if (this.__didStart) return;
@@ -418,14 +468,13 @@ class Component implements IComponent, EventTarget {
         if (this.start) this.start();
     }
 
-    
+
     /** @internal */
     __internalEnable(): boolean {
         if (this.__didEnable) return false;
         // console.trace("INTERNAL ENABLE");
         this.__didEnable = true;
         this.onEnable();
-        // if we do this after processing the callback
         this.__isEnabled = true;
         return true;
     }
@@ -434,10 +483,7 @@ class Component implements IComponent, EventTarget {
     __internalDisable() {
         if (!this.__didEnable) return;
         this.__didEnable = false;
-        // this._collisionExitRoutine = undefined;
         this.onDisable();
-        // this._collisions?.clear();
-        // if we do this after processing the callback
         this.__isEnabled = false;
     }
 
@@ -446,11 +492,9 @@ class Component implements IComponent, EventTarget {
         if (this.__destroyed) return;
         this.__destroyed = true;
         this.destroy?.call(this);
-        // console.log("destroy", this);
         destroyComponentInstance(this as any);
     }
 
-    // isActiveAndEnabled: boolean = false;
 
     get enabled(): boolean {
         return this.__isEnabled ?? true; // if it has no enabled field it is always enabled

package/src/engine-components/Networking.ts

@@ -1,17 +1,25 @@
+import { serializable } from "../engine/engine_serialization";
 import { INetworkingWebsocketUrlProvider } from "../engine/engine_networking";
 import { isLocalNetwork } from "../engine/engine_networking_utils";
 import { getParam } from "../engine/engine_utils";
 import { Behaviour } from "./Component";
 
+const debug = getParam("debugnet");
+
 export class Networking extends Behaviour implements INetworkingWebsocketUrlProvider {
 
+    @serializable()
     url: string | null = null;
+    @serializable()
     urlParameterName: string | null = null;
 
     // used when local host is detected
+    @serializable()
     localhost: string | null = null;
 
-    awake(){
+    awake() {
+        if (debug)
+            console.log(this);
         this.context.connection.registerProvider(this);
     }
 

package/src/engine-components/OrbitControls.ts

@@ -11,6 +11,7 @@ import { OrbitControls as ThreeOrbitControls } from "three/examples/jsm/controls
 import { EventSystem, EventSystemEvents } from "./ui/EventSystem";
 import { ICameraController } from "../engine/engine_types";
 import { setCameraController } from "../engine/engine_camera";
+import { SyncedTransform } from "./SyncedTransform";
 
 const freeCam = getParam("freecam");
 
@@ -70,7 +71,8 @@ export class OrbitControls extends Behaviour implements ICameraController {
 
     private _eventSystem?: EventSystem;
     private _afterHandleInputFn?: any;
-    private _camera : Camera | null = null;
+    private _camera: Camera | null = null;
+    private _syncedTransform?: SyncedTransform;
 
     targetElement: HTMLElement | null = null;
 
@@ -133,6 +135,7 @@ export class OrbitControls extends Behaviour implements ICameraController {
             this._controls.autoRotate = this.autoRotate;
             this._controls.autoRotateSpeed = this.autoRotateSpeed;
             this._controls.enableZoom = this.enableZoom;
+            this._controls.addEventListener("start", this.onControlsChangeStarted.bind(this));
             if (cam?.type === "PerspectiveCamera") {
                 if (freeCam) {
                     // dont set limits
@@ -158,7 +161,7 @@ export class OrbitControls extends Behaviour implements ICameraController {
                 this._controls.listenToKeyEvents(window.document.body);
             }
         }
-
+        this._syncedTransform = GameObject.getComponent(this.gameObject, SyncedTransform) ?? undefined;
     }
 
     onDisable() {
@@ -172,6 +175,12 @@ export class OrbitControls extends Behaviour implements ICameraController {
         }
     }
 
+    private onControlsChangeStarted() {
+        if(this._syncedTransform) {
+            this._syncedTransform.requestOwnership();
+        }
+    }
+
     private _shouldDisable: boolean = false;
     private afterHandleInput() {
         if (this._controls && this._eventSystem) {

package/src/engine-components/ParticleSystem.ts

@@ -17,7 +17,8 @@ import { Mathf } from "../engine/engine_math";
 import { Context } from "../engine/engine_setup";
 import { ParticleSubEmitter } from "./ParticleSystemSubEmitter";
 import { NEEDLE_progressive } from "../engine/extensions/NEEDLE_progressive";
-import { Gizmos, isDevEnvironment } from "../engine/api";
+import { Gizmos } from "../engine/engine_gizmos";
+import { isDevEnvironment } from "../engine/debug";
 
 const debug = getParam("debugparticles");
 const suppressProgressiveLoading = getParam("noprogressive");
@@ -857,16 +858,23 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
     }
 
     private preWarm() {
+        if (!this.emission?.enabled) return;
+        const emission = this.emission.rateOverTime.getMax();
+        if (emission <= 0) return;
         const dt = 1 / 60;
         const duration = this.main.duration;
         const lifetime = this.main.startLifetime.getMax();
         const maxDurationToPrewarm = 1000;
         const timeToSimulate = Math.min(duration, lifetime, maxDurationToPrewarm);
         const framesToSimulate = Math.ceil(timeToSimulate / dt);
+        const startTime = Date.now();
         if (debug)
             console.log(`Particles ${this.name} - Prewarm for ${framesToSimulate} frames (${timeToSimulate} sec). Duration: ${duration}, Lifetime: ${lifetime}`);
         for (let i = 0; i < framesToSimulate; i++) {
             if (this.currentParticles >= this.maxParticles) break;
+            if (Date.now() - startTime > 2) {
+                console.warn(`Particles ${this.name} - Prewarm took too long. Aborting.`);
+            }
             this.onUpdate();
             this.onSimulate(dt);
         }

package/src/engine-components/ReflectionProbe.ts

@@ -1,5 +1,5 @@
 import { Behaviour } from "./Component";
-import { Box3, Color, EquirectangularReflectionMapping, LineBasicMaterial, Material, MeshStandardMaterial, Object3D, sRGBEncoding, Texture, Vector3, WebGLCubeRenderTarget, WebGLRenderTarget } from "three";
+import { Box3, Color, EquirectangularReflectionMapping, LinearEncoding, LineBasicMaterial, Material, MeshStandardMaterial, Object3D, SrcAlphaFactor, sRGBEncoding, Texture, Vector3, WebGLCubeRenderTarget, WebGLRenderTarget } from "three";
 import { serializable } from "../engine/engine_serialization";
 import { Context } from "../engine/engine_setup";
 import { getWorldPosition, getWorldScale } from "../engine/engine_three_utils";
@@ -47,7 +47,16 @@ export class ReflectionProbe extends Behaviour {
 
     private _texture!: Texture;
     set texture(tex: Texture) {
+        if (tex && !(tex instanceof Texture)) {
+            console.error("ReflectionProbe.texture must be a Texture", tex);
+            return;
+        }
         this._texture = tex;
+        if (tex) {
+            tex.mapping = EquirectangularReflectionMapping;
+            tex.encoding = sRGBEncoding;
+            tex.needsUpdate = true;
+        }
     }
     get texture(): Texture {
         return this._texture;
@@ -81,8 +90,6 @@ export class ReflectionProbe extends Behaviour {
         if (this.texture) {
             this.texture.mapping = EquirectangularReflectionMapping;
             this.texture.encoding = sRGBEncoding;
-            // this.texture.rotation = Math.PI;
-            // this.texture.flipY = true;
             this.texture.needsUpdate = true;
         }
     }
@@ -106,6 +113,7 @@ export class ReflectionProbe extends Behaviour {
 
     onSet(_rend: IRenderer) {
         if (disable) return;
+        if (!this.enabled) return;
         if (_rend.sharedMaterials?.length <= 0) return;
         if (!this.texture) return;
 
@@ -129,8 +137,10 @@ export class ReflectionProbe extends Behaviour {
             let cached = rendererCache[i];
 
             // make sure we have the currently assigned material cached (and an up to date clone of that)
-            if (!cached || cached.material !== material || cached.material.version !== material.version) {
+            if (!cached || cached.material !== material || cached.copy.version !== material.version) {
+                if(debug) console.log("Cloning material", material.name, material.version);
                 const clone = material.clone();
+                clone.version = material.version;
 
                 if (cached) {
                     cached.copy = clone;
@@ -147,9 +157,6 @@ export class ReflectionProbe extends Behaviour {
                 clone[$reflectionProbeKey] = this;
                 clone[$originalMaterial] = material;
 
-                // make sure the reflection probe is assigned
-                clone["envMap"] = this.texture;
-
                 if (debug)
                     console.log("Set reflection", _rend.name, _rend.guid);
             }
@@ -157,6 +164,9 @@ export class ReflectionProbe extends Behaviour {
             /** this is the material that we copied and that has the reflection probe */
             const copy = cached?.copy;
 
+            // make sure the reflection probe is assigned
+            copy["envMap"] = this.texture;
+
             _rend.sharedMaterials[i] = copy;
         }
     }

package/src/engine-components/Renderer.ts

@@ -245,18 +245,37 @@ export class Renderer extends Behaviour implements IRenderer {
     }
 
     private _sharedMaterials!: SharedMaterialArray;
-    private _originalMaterials: Material[] = [];
+    private _originalMaterials?: Material[];
 
     // this is just available during deserialization
     private set sharedMaterials(_val: Array<Material | null>) {
         // TODO: elements in the array might be missing at the moment which leads to problems if an index is serialized
-        this._originalMaterials = _val as Material[];
+        if (!this._originalMaterials) {
+            this._originalMaterials = _val as Material[];
+        }
+        else if (_val) {
+            let didWarn = false;
+            for (let i = 0; i < this._sharedMaterials.length; i++) {
+                const mat = i < _val.length ? _val[i] : null;
+                if (mat && mat instanceof Material) {
+                    this.sharedMaterials[i] = mat as Material;
+                }
+                else {
+                    if (!didWarn) {
+                        didWarn = true;
+                        console.warn("Can not assign null as material: " + this.name, mat);
+                    }
+                }
+            }
+        }
     }
 
     //@ts-ignore
     get sharedMaterials(): SharedMaterialArray {
-        if (!this._sharedMaterials || !this._sharedMaterials.is(this))
+        if (!this._sharedMaterials || !this._sharedMaterials.is(this)) {
+            if (!this._originalMaterials) this._originalMaterials = [];
             this._sharedMaterials = new SharedMaterialArray(this, this._originalMaterials);
+        }
         return this._sharedMaterials!;
     }
 
@@ -609,8 +628,6 @@ export class Renderer extends Behaviour implements IRenderer {
     loadProgressiveTextures(material: THREE.Material) {
         // progressive load before rendering so we only load textures for visible materials
         if (!suppressProgressiveLoading && material) {
-            if (debugProgressiveLoading && material["_didRequestTextureLOD"] === undefined)
-                console.warn("Progressive?", this)
 
             if (material["_didRequestTextureLOD"] === undefined && this.allowProgressiveLoading) {
                 material["_didRequestTextureLOD"] = 0;

package/src/engine-components/Skybox.ts

@@ -43,6 +43,8 @@ export class RemoteSkybox extends Behaviour {
             this._prevLoadedEnvironment = undefined;
         }
         this.unregisterDropEvents();
+        // Re-apply the skybox/background settings of the main camera
+        this.context.mainCameraComponent?.applyClearFlags();
     }
 
     async setSkybox(url: string | undefined | null) {

package/src/engine-components/SmoothFollow.ts

@@ -20,15 +20,11 @@ export class SmoothFollow extends Behaviour {
     @serializable()
     positionAxes : Axes = Axes.All;
 
-    // @serializable()
-    // rotationAxes : Axes = Axes.All;
-
     flipForward: boolean = false;
 
     private static _invertForward: THREE.Quaternion = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI);
     private _firstUpdate = true;
 
-
     onBeforeRender(): void {
         this.updateNow(false);
     }
@@ -39,9 +35,13 @@ export class SmoothFollow extends Behaviour {
             const wp = getWorldPosition(this.target);
             const fpos = this._firstUpdate || hard ? 1 : Mathf.clamp01(this.context.time.deltaTime * this.followFactor);
             const currentPosition = this.worldPosition;
+
             if(this.positionAxes & Axes.X) currentPosition.x = Mathf.lerp(currentPosition.x, wp.x, fpos);
             if(this.positionAxes & Axes.Y) currentPosition.y = Mathf.lerp(currentPosition.y, wp.y, fpos);
             if(this.positionAxes & Axes.Z) currentPosition.z = Mathf.lerp(currentPosition.z, wp.z, fpos);
+            
+            // TODO lerp distance from target as well
+
             this.worldPosition = currentPosition;
         }
         if (this.rotateFactor > 0) {