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

package/src/engine-components/Collider.ts

@@ -1,7 +1,7 @@
 import { Behaviour } from "./Component";
 import { Rigidbody } from "./RigidBody";
 import { serializable } from "../engine/engine_serialization_decorator";
-import { Event, Mesh, Object3D, Vector3 } from "three"
+import { Event, Group, Mesh, Object3D, Vector3 } from "three"
 // import { IColliderProvider, registerColliderProvider } from "../engine/engine_physics";
 import { ICollider } from "../engine/engine_types";
 import { getWorldScale } from "../engine/engine_three_utils";
@@ -77,6 +77,7 @@ export class MeshCollider extends Collider {
 
 
     sharedMesh?: Mesh;
+
     @serializable()
     convex: boolean = false;
 
@@ -88,8 +89,21 @@ export class MeshCollider extends Collider {
                 this.sharedMesh = this.gameObject;
             }
         }
-        if (this.sharedMesh?.isMesh)
+        if (this.sharedMesh?.isMesh) {
             this.context.physics.addMeshCollider(this, this.sharedMesh, this.convex, getWorldScale(this.gameObject));
+        }
+        else {
+            const group = this.sharedMesh as any as Group;
+            if (group?.isGroup) {
+                console.warn(`MeshCollider mesh is a group \"${this.sharedMesh?.name}\", adding all children as colliders. This is currently not fully supported (colliders can not be removed from world again)`, this)
+                for (const ch in group.children) {
+                    const child = group.children[ch] as Mesh;
+                    if (child.isMesh) {
+                        this.context.physics.addMeshCollider(this, child, this.convex, getWorldScale(this.gameObject));
+                    }
+                }
+            }
+        }
     }
 }
 

package/src/engine-components/ParticleSystem.ts

@@ -330,7 +330,7 @@ class SizeBehaviour extends ParticleSystemBaseBehaviour {
     }
 }
 
-const $particleLife = Symbol("particleLife");
+export const $particleLife = Symbol("particleLife");
 const $trailLifetime = Symbol("trailLifetime");
 const $trailStartLength = Symbol("trailStartLength");
 
@@ -340,7 +340,6 @@ class TrailBehaviour extends ParticleSystemBaseBehaviour {
     initialize(particle: Particle) {
         if (particle instanceof TrailParticle) {
             particle[$particleLife] = particle.life;
-            particle[$trailLifetime] = particle.life;
             if (this.system.trails.enabled && this.system.trails.dieWithParticles === false) {
                 particle[$trailLifetime] = this.system.trails.lifetime.evaluate(Math.random(), Math.random());
                 particle.life += particle[$trailLifetime];
@@ -418,7 +417,7 @@ class VelocityBehaviour extends ParticleSystemBaseBehaviour {
         if (gravityFactor !== 0) {
             // gravityFactor *= -1;
             temp3.copy(this._gravityDirection).multiplyScalar(gravityFactor);
-            if(debug) Gizmos.DrawDirection(particle.position, temp3, 0x0000ff, 0, false, 10);
+            if (debug) Gizmos.DrawDirection(particle.position, temp3, 0x0000ff, 0, false, 10);
             baseVelocity.add(temp3);
         }
         particle.velocity.copy(baseVelocity);
@@ -747,6 +746,7 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
     private _time: number = 0;
     private _isPlaying: boolean = true;
     private _isUsedAsSubsystem: boolean = false;
+    private _didPreWarm: boolean = false;
 
     /** called from deserialization */
     private set bursts(arr: ParticleBurst[]) {
@@ -779,7 +779,8 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
     }
     private _subEmitterSystems?: SubEmitterSystem[];
 
-    onAfterDeserialize(_){
+    onAfterDeserialize(_) {
+        // doing this here to get a chance to resolve the subemitter guid
         if (this._subEmitterSystems && Array.isArray(this._subEmitterSystems)) {
             for (const sub of this._subEmitterSystems) {
                 sub._deserialize(this.context, this.gameObject);
@@ -788,7 +789,6 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
     }
 
     awake(): void {
-
         this._renderer = this.gameObject.getComponent(ParticleSystemRenderer) as ParticleSystemRenderer;
 
         this._container = new Object3D();
@@ -837,16 +837,42 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
     onEnable() {
         if (this.inheritVelocity)
             this.inheritVelocity.system = this;
+        if (this._batchSystem)
+            this._batchSystem.visible = true;
         this.play();
     }
 
     onDisable() {
+        if (this._batchSystem)
+            this._batchSystem.visible = false;
     }
 
     onBeforeRender() {
+        if (this._didPreWarm === false && this.main?.prewarm === true) {
+            this._didPreWarm = true;
+            this.preWarm();
+        }
         this.onUpdate();
-        const dt = this.deltaTime;
+        this.onSimulate(this.deltaTime);
+    }
+
+    private preWarm() {
+        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);
+        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;
+            this.onUpdate();
+            this.onSimulate(dt);
+        }
+    }
 
+    private onSimulate(dt: number) {
         if (this._batchSystem) {
             // Updating layers on batches
             // TODO: figure out a better way to do this
@@ -942,10 +968,20 @@ export class SubEmitterSystem {
     properties?: number;
     type?: SubEmitterType;
 
-    _deserialize(context: Context, _gameObject: GameObject) {
+    _deserialize(_context: Context, gameObject: GameObject) {
         const ps = this.particleSystem;
-        if (ps && !(ps instanceof ParticleSystem) && typeof ps["guid"] === "string") {
-            this.particleSystem = GameObject.findByGuid(ps["guid"], context.scene) as ParticleSystem;
+        if (ps instanceof ParticleSystem) return;
+
+        let guid = "";
+
+        if (ps && typeof ps["guid"] === "string") {
+            guid = ps["guid"];
+            // subemitter MUST be a child of the particle system
+            this.particleSystem = GameObject.findByGuid(guid, gameObject) as ParticleSystem;
+        }
+
+        if (debug && !(this.particleSystem instanceof ParticleSystem)) {
+            console.warn("Could not find particle system for sub emitter", guid, gameObject, this);
         }
     }
 }

package/src/engine-components/ParticleSystemModules.ts

@@ -199,6 +199,33 @@ export class MinMaxCurve {
         }
         return 0;
     }
+
+    getMax(): number {
+        switch (this.mode) {
+            case ParticleSystemCurveMode.Constant:
+                return this.constant;
+            case ParticleSystemCurveMode.Curve:
+                return this.getMaxFromCurve(this.curve!) * this.curveMultiplier!;
+            case ParticleSystemCurveMode.TwoCurves:
+                return Math.max(this.getMaxFromCurve(this.curveMin), this.getMaxFromCurve(this.curveMax)) * this.curveMultiplier!;
+            case ParticleSystemCurveMode.TwoConstants:
+                return Math.max(this.constantMin, this.constantMax);
+            default:
+                return 0;
+        }
+    }
+
+    private getMaxFromCurve(curve?: AnimationCurve) {
+        if (!curve) return 0;
+        let maxNumber = Number.MIN_VALUE;
+        for (let i = 0; i < curve!.keys.length; i++) {
+            const key = curve!.keys[i];
+            if (key.value > maxNumber) {
+                maxNumber = key.value;
+            }
+        }
+        return maxNumber;
+    }
 }
 
 export class MinMaxGradient {
@@ -571,7 +598,7 @@ export class ShapeModule implements EmitterShape {
         if (this.enabled) {
             switch (this.shapeType) {
                 case ParticleSystemShapeType.Box:
-                    if(debug) Gizmos.DrawBox(this.position, this.scale, 0xdddddd, 1);
+                    if (debug) Gizmos.DrawBox(this.position, this.scale, 0xdddddd, 1);
                     this._vector.x = Math.random() * this.scale.x - this.scale.x / 2;
                     this._vector.y = Math.random() * this.scale.y - this.scale.y / 2;
                     this._vector.z = Math.random() * this.scale.z - this.scale.z / 2;

package/src/engine-components/ParticleSystemSubEmitter.ts

@@ -2,7 +2,7 @@ import { Behavior, Particle, EmissionState, ParticleSystem, ParticleEmitter } fr
 import { Vector3, Quaternion, Matrix4 } from "three";
 import { IParticleSystem } from "./ParticleSystemModules";
 import { CircularBuffer } from "../engine/engine_utils";
-import { SubEmitterType } from "./ParticleSystem";
+import { $particleLife, SubEmitterType } from "./ParticleSystem";
 
 const VECTOR_ONE = new Vector3(1, 1, 1);
 const VECTOR_Z = new Vector3(0, 0, 1);
@@ -73,13 +73,15 @@ export class ParticleSubEmitter implements Behavior {
         if (!this.subParticleSystem || !particle.emissionState)
             return;
 
-        if(this.emitterProbability && Math.random() > this.emitterProbability)
+        if (this.emitterProbability && Math.random() > this.emitterProbability)
             return;
 
         const delta = this.system.deltaTime;
 
         if (this.emitterType === SubEmitterType.Death) {
-            const willDie = particle.age + delta * 1.2 >= particle.life;
+            let lifeTime = particle.life;
+            if (particle[$particleLife] !== undefined) lifeTime = particle[$particleLife];
+            const willDie = particle.age + delta * 1.2 >= lifeTime;
             if (!willDie) return;
             // Just emit all for now, we should probably add a way to get the amount from the subsystem emission module
             const maxAmount = this.subSystem.main.maxParticles - this.subSystem.currentParticles;

package/src/engine-components/Renderer.ts

@@ -90,6 +90,8 @@ class SharedMaterialArray implements ISharedMaterials {
             if (!target) continue;
             const mat = target.material as Material;
             if (!mat) continue;
+            // set the shadow side to the same as the side of the material, three flips this for some reason
+            mat.shadowSide = mat.side;
             for (let k = 0; k < originalMaterials.length; k++) {
                 const orig = originalMaterials[k];
                 if (!orig) {
@@ -110,7 +112,7 @@ class SharedMaterialArray implements ISharedMaterials {
             this._indexMap = indexMap;
             const warningMessage = `Renderer ${renderer.name} was initialized with missing materials - this may lead to unexpected behaviour when trying to access sharedMaterials by index.`;
             console.warn(warningMessage);
-            if(isLocalNetwork()) showBalloonWarning("Found renderer with missing materials: please check the console for details.");
+            if (isLocalNetwork()) showBalloonWarning("Found renderer with missing materials: please check the console for details.");
         }
 
         // this lets us override the javascript indexer, only works in ES6 tho
@@ -503,7 +505,7 @@ export class Renderer extends Behaviour implements IRenderer {
             //     console.log(this.name, this.gameObject.matrixWorldNeedsUpdate);
             const needsUpdate: boolean = this.gameObject[NEED_UPDATE_INSTANCE_KEY] === true;// || this.gameObject.matrixWorldNeedsUpdate;
             if (needsUpdate) {
-                if(debugInstancing)
+                if (debugInstancing)
                     console.log("UPDATE INSTANCED MATRICES", this.context.time.frame);
                 this.gameObject[NEED_UPDATE_INSTANCE_KEY] = false;
                 const remove = false;// Math.random() < .01;
@@ -712,7 +714,7 @@ class InstancingHandler {
 
     public objs: InstancedMeshRenderer[] = [];
 
-    public setup(renderer:Renderer, obj: THREE.Object3D, context: Context, handlesArray: InstanceHandle[] | null, args: InstancingSetupArgs, level: number = 0)
+    public setup(renderer: Renderer, obj: THREE.Object3D, context: Context, handlesArray: InstanceHandle[] | null, args: InstancingSetupArgs, level: number = 0)
         : InstanceHandle[] | null {
 
         const res = this.tryCreateOrAddInstance(obj, context, args);
@@ -729,6 +731,14 @@ class InstancingHandler {
                 handlesArray = this.setup(renderer, ch, context, handlesArray, args, nextLevel);
             }
         }
+
+        if (level === 0) {
+            // For multi material objects we only want to track the root object's matrix
+            if (args.useMatrixWorldAutoUpdate && handlesArray && handlesArray.length >= 0) {
+                this.autoUpdateInstanceMatrix(obj);
+            }
+        }
+
         return handlesArray;
     }
 
@@ -755,8 +765,6 @@ class InstancingHandler {
                 if (i.isFull()) continue;
                 if (i.geo === geo && i.material === mat) {
                     const handle = i.addInstance(mesh);
-                    if (args.useMatrixWorldAutoUpdate && handle)
-                        this.autoUpdateInstanceMatrix(mesh, i, handle);
                     return handle;
                 }
             }
@@ -764,17 +772,14 @@ class InstancingHandler {
             const i = new InstancedMeshRenderer(obj.name, geo, mat, 200, context);
             this.objs.push(i);
             const handle = i.addInstance(mesh);
-            if (args.useMatrixWorldAutoUpdate && handle)
-                this.autoUpdateInstanceMatrix(mesh, i, handle);
             return handle;
         }
         return null;
     }
 
-    private autoUpdateInstanceMatrix(obj: Object3D, _renderer: InstancedMeshRenderer, _handle: InstanceHandle) {
+    private autoUpdateInstanceMatrix(obj: Object3D) {
         const original = obj.matrixWorld["multiplyMatrices"].bind(obj.matrixWorld);
         let previousMatrix: THREE.Matrix4 = obj.matrixWorld.clone();
-
         const matrixChangeWrapper = (a: Matrix4, b: Matrix4) => {
             const newMatrixWorld = original(a, b);
             // console.warn("MULT", obj.matrixWorldNeedsUpdate);
@@ -786,7 +791,6 @@ class InstancingHandler {
             return newMatrixWorld;
         };
         obj.matrixWorld["multiplyMatrices"] = matrixChangeWrapper;
-
         // wrap matrixWorldNeedsUpdate
         // let originalMatrixWorldNeedsUpdate = obj.matrixWorldNeedsUpdate;
         // Object.defineProperty(obj, "matrixWorldNeedsUpdate", {
@@ -798,7 +802,6 @@ class InstancingHandler {
         //         originalMatrixWorldNeedsUpdate = value;
         //     }
         // });
-
     }
 }
 const instancing: InstancingHandler = new InstancingHandler();

package/src/engine-components/ScreenCapture.ts

@@ -409,9 +409,9 @@ class PeerHandle extends EventDispatcher {
     disable() {
         if (!this._enabled) return;
         this._enabled = false;
-        this.context.connection.stopListening(RoomEvents.JoinedRoom, this.onConnectRoomFn);
-        this.context.connection.stopListening(RoomEvents.UserJoinedRoom, this.onUserJoinedOrLeftRoomFn);
-        this.context.connection.stopListening(RoomEvents.UserLeftRoom, this.onUserJoinedOrLeftRoomFn);
+        this.context.connection.stopListen(RoomEvents.JoinedRoom, this.onConnectRoomFn);
+        this.context.connection.stopListen(RoomEvents.UserJoinedRoom, this.onUserJoinedOrLeftRoomFn);
+        this.context.connection.stopListen(RoomEvents.UserLeftRoom, this.onUserJoinedOrLeftRoomFn);
         this.unsubscribePeerEvents();
     }
 

package/src/engine-components/SpectatorCamera.ts

@@ -562,9 +562,9 @@ class SpectatorCamNetworking {
     }
 
     destroy() {
-        this.context.connection.stopListening("spectator-follower-changed", this._followerEventMethod);
-        this.context.connection.stopListening("spectator-request-follow", this._requestFollowMethod);
-        this.context.connection.stopListening(RoomEvents.JoinedRoom, this._joinedRoomMethod);
+        this.context.connection.stopListen("spectator-follower-changed", this._followerEventMethod);
+        this.context.connection.stopListen("spectator-request-follow", this._requestFollowMethod);
+        this.context.connection.stopListen(RoomEvents.JoinedRoom, this._joinedRoomMethod);
     }
 
     onSpectatedObjectChanged(target: PlayerView | undefined, _prevId?: string) {

package/src/engine-components/SyncedCamera.ts

@@ -102,7 +102,7 @@ export class SyncedCamera extends Behaviour {
     }
 
     onEnable(): void {
-        this._receiveCallback = this.context.connection.beginListenBinrary(SyncedCameraModelIdentifier, this.onReceivedRemoteCameraInfoBin.bind(this));
+        this._receiveCallback = this.context.connection.beginListenBinary(SyncedCameraModelIdentifier, this.onReceivedRemoteCameraInfoBin.bind(this));
     }
 
     onDisable(): void {

package/src/engine-components/SyncedTransform.ts

@@ -105,7 +105,7 @@ export class SyncedTransform extends Behaviour {
         this.joinedRoomCallback = this.tryGetLastState.bind(this);
         this.context.connection.beginListen(RoomEvents.JoinedRoom, this.joinedRoomCallback);
         this.receivedDataCallback = this.onReceivedData.bind(this);
-        this.context.connection.beginListenBinrary(SyncedTransformIdentifier, this.receivedDataCallback);
+        this.context.connection.beginListenBinary(SyncedTransformIdentifier, this.receivedDataCallback);
     }
 
     onDestroy(): void {
@@ -113,7 +113,7 @@ export class SyncedTransform extends Behaviour {
         if (this.syncDestroy)
             sendDestroyed(this.guid, this.context.connection);
         this._model = null;
-        this.context.connection.stopListening(RoomEvents.JoinedRoom, this.joinedRoomCallback);
+        this.context.connection.stopListen(RoomEvents.JoinedRoom, this.joinedRoomCallback);
         this.context.connection.stopListenBinary(SyncedTransformIdentifier, this.receivedDataCallback);
     }
 

package/src/engine-components/TestRunner.ts

@@ -21,7 +21,7 @@ export class TestSimulateUserData extends Behaviour {
 
     awake(): void {
         if (this.useFlatbuffers) {
-            this.context.connection.beginListenBinrary(SyncedTransformIdentifier, (_mod: SyncedTransformModel) => {
+            this.context.connection.beginListenBinary(SyncedTransformIdentifier, (_mod: SyncedTransformModel) => {
                 // console.log("Received transform");
                 // const sc = SyncedTransformModel.getRootAsSyncedTransformModel(bin);
                 // console.log(mod.guid());

package/src/engine-components/WebARSessionRoot.ts

@@ -84,10 +84,11 @@ export class WebARSessionRoot extends Behaviour {
 
             if (this._isTouching) {
                 // callbacks
-                this.dispatchEvent(new CustomEvent('placedSession', { detail: { pose: pose } }));
+                const poseMatrix = new Matrix4().fromArray(pose.transform.matrix).invert();
+                this.dispatchEvent(new CustomEvent('placedSession', { detail: { pose, poseMatrix } }));
 
                 if (this.webAR) this.webAR.setReticleActive(false);
-                this.placeAt(rig, new Matrix4().fromArray(pose.transform.matrix).invert());
+                this.placeAt(rig, poseMatrix);
                 return true;
             }
         }

package/src/engine-components/WebXRAvatar.ts

@@ -9,7 +9,6 @@ import { AssetReference } from "../engine/engine_addressables";
 import { Object3D } from "three";
 import { VRUserState } from "./WebXRSync";
 import { getParam } from "../engine/engine_utils";
-import { serializable } from "../engine/engine_serialization_decorator";
 import { ViewDevice } from "../engine/engine_playerview";
 import { InstancingUtil } from "../engine/engine_instancing";
 

package/src/engine-components/WebXRGrabRendering.ts

@@ -54,8 +54,8 @@ export class XRGrabRendering extends Behaviour {
     }
 
     onDisable(): void {
-        this.context.connection.stopListening(XRGrabEvent.StartOrUpdate, this._addOrUpdateSub);
-        this.context.connection.stopListening(XRGrabEvent.End, this._endSub);
+        this.context.connection.stopListen(XRGrabEvent.StartOrUpdate, this._addOrUpdateSub);
+        this.context.connection.stopListen(XRGrabEvent.End, this._endSub);
         AttachedObject.RemoveEventListener(AttachedObjectEvents.WillFree, this._freeSub);
     }
 

package/src/engine-components/WebXRSync.ts

@@ -253,7 +253,7 @@ export class WebXRSync extends Behaviour {
                 this.avatars[evt.id] = undefined;
             }
         });
-        this.context.connection.beginListenBinrary(VRUserStateBufferIdentifier, (state: VrUserStateBuffer) => {
+        this.context.connection.beginListenBinary(VRUserStateBufferIdentifier, (state: VrUserStateBuffer) => {
             // console.log("BUFFER", state);
             const guid = state.guid();
             if (!guid) return;
@@ -299,7 +299,7 @@ export class WebXRSync extends Behaviour {
 
     onDisable() {
         if (this.eventSub_ConnectionEvent)
-            this.context.connection.stopListening(RoomEvents.JoinedRoom, this.eventSub_ConnectionEvent);
+            this.context.connection.stopListen(RoomEvents.JoinedRoom, this.eventSub_ConnectionEvent);
         WebXR.removeEventListener(WebXREvent.XRStarted, this.eventSub_WebXRStartEvent);
         WebXR.removeEventListener(WebXREvent.XRUpdate, this.eventSub_WebXRUpdateEvent);
         WebXR.removeEventListener(WebXREvent.XRStopped, this.eventSub_WebXREndEvent);

package/src/engine-components-experimental/networking/PlayerSync.ts

@@ -24,7 +24,7 @@ export class PlayerSync extends Behaviour {
         this.context.connection.beginListen(RoomEvents.JoinedRoom, this.joinedRoomFunction!)
     }
     onDisable(): void {
-        this.context.connection.stopListening(RoomEvents.JoinedRoom, this.joinedRoomFunction!)
+        this.context.connection.stopListen(RoomEvents.JoinedRoom, this.joinedRoomFunction!)
     }
 
     private async onUserJoined(_model) {