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

package/src/engine/engine_gizmos.ts

@@ -145,10 +145,9 @@ class Internal {
     }
 
     static getSphere(radius: number, duration: number, wireframe: boolean): Mesh {
-
         let sphere = this.spheresCache.pop();
         if (!sphere) {
-            sphere = new Mesh(new SphereGeometry(.5, 8, 8));
+            sphere = new Mesh(new SphereGeometry(1, 8, 8));
         }
         sphere.scale.set(radius, radius, radius);
         sphere.material["wireframe"] = wireframe;
@@ -176,6 +175,8 @@ class Internal {
             this.contextPostRenderCallbacks.set(context, cb);
             context.post_render_callbacks.push(cb);
         }
+        object.layers.disableAll();
+        object.layers.enable(2);
         object[$cacheSymbol] = cache;
         this.timedObjectsBuffer.push(object);
         this.timesBuffer.push(Context.Current.time.time + duration);

package/src/engine/engine_networking.ts

@@ -147,7 +147,7 @@ export class OwnershipModel {
         // console.log(res);
         if (res.guid === this.guid) {
             if (this._isWaitingForOwnershipResponseCallback) {
-                this.connection.stopListening(OwnershipEvent.ResponseHasOwner, this._isWaitingForOwnershipResponseCallback);
+                this.connection.stopListen(OwnershipEvent.ResponseHasOwner, this._isWaitingForOwnershipResponseCallback);
                 this._isWaitingForOwnershipResponseCallback = null;
             }
             this._isOwned = res.value;
@@ -185,18 +185,18 @@ export class OwnershipModel {
         // TODO: abort "requestOwnershipIfNotOwned"
         this.connection.send(OwnershipEvent.RemoveOwnership, { guid: this.guid });
         if (this._isWaitingForOwnershipResponseCallback) {
-            this.connection.stopListening(OwnershipEvent.ResponseHasOwner, this._isWaitingForOwnershipResponseCallback);
+            this.connection.stopListen(OwnershipEvent.ResponseHasOwner, this._isWaitingForOwnershipResponseCallback);
             this._isWaitingForOwnershipResponseCallback = null;
         }
         return this;
     }
 
     public destroy() {
-        this.connection.stopListening(OwnershipEvent.GainedOwnership, this._gainSubscription);
-        this.connection.stopListening(OwnershipEvent.LostOwnership, this._lostSubscription);
-        this.connection.stopListening(OwnershipEvent.ResponseHasOwner, this._hasOwnerResponse);
+        this.connection.stopListen(OwnershipEvent.GainedOwnership, this._gainSubscription);
+        this.connection.stopListen(OwnershipEvent.LostOwnership, this._lostSubscription);
+        this.connection.stopListen(OwnershipEvent.ResponseHasOwner, this._hasOwnerResponse);
         if (this._isWaitingForOwnershipResponseCallback) {
-            this.connection.stopListening(OwnershipEvent.ResponseHasOwner, this._isWaitingForOwnershipResponseCallback);
+            this.connection.stopListen(OwnershipEvent.ResponseHasOwner, this._isWaitingForOwnershipResponseCallback);
             this._isWaitingForOwnershipResponseCallback = null;
         }
     }
@@ -368,7 +368,9 @@ export class NetworkConnection implements INetworkConnection {
         return callback;
     }
 
-    public stopListening(key: string | OwnershipEvent, callback: Function | null) {
+    /**@deprecated please use stopListen instead (2.65.2-pre) */
+    public stopListening(key: string | OwnershipEvent, callback: Function | null) { return this.stopListen(key, callback); }
+    public stopListen(key: string | OwnershipEvent, callback: Function | null) {
         if (!callback) return;
         if (!this._listeners[key]) return;
         const index = this._listeners[key].indexOf(callback);
@@ -377,7 +379,7 @@ export class NetworkConnection implements INetworkConnection {
         }
     }
 
-    public beginListenBinrary(identifier: string, callback: BinaryCallback): BinaryCallback {
+    public beginListenBinary(identifier: string, callback: BinaryCallback): BinaryCallback {
         if (!this._listenersBinary[identifier])
             this._listenersBinary[identifier] = [];
         this._listenersBinary[identifier].push(callback);

package/src/engine/engine_physics.ts

@@ -15,7 +15,7 @@ import {
 import { InstancingUtil } from './engine_instancing';
 import { foreachComponent } from './engine_gameobject';
 
-import RAPIER, { ActiveEvents, CoefficientCombineRule, Collider, ColliderDesc, EventQueue, JointData, RigidBody, RigidBodyType, World } from '@dimforge/rapier3d-compat';
+import RAPIER, { ActiveEvents, CoefficientCombineRule, Collider, ColliderDesc, EventQueue, JointData, QueryFilterFlags, RigidBody, RigidBodyType, ShapeColliderTOI, World } from '@dimforge/rapier3d-compat';
 import { CollisionDetectionMode, PhysicsMaterialCombine } from '../engine/engine_physics.types';
 import { Gizmos } from './engine_gizmos';
 import { Mathf } from './engine_math';
@@ -83,12 +83,22 @@ export class SphereIntersection implements Intersection {
     }
 }
 
+export class SphereOverlapResult {
+    object: Object3D;
+    collider: ICollider;
+    constructor(object: Object3D, collider: ICollider) {
+        this.object = object;
+        this.collider = collider;
+    }
+}
+
 declare type PhysicsRaycastResult = {
     point: Vector3,
     normal?: Vector3,
     collider?: ICollider
 }
 
+
 export class Physics {
 
     // raycasting
@@ -107,6 +117,12 @@ export class Physics {
 
     private sphereResults: Array<Intersection> = new Array<Intersection>();
     private sphereMask: Layers = new Layers();
+    /** Test overlapping of a sphere with the threejs geometry. This does not use colliders. This does not return an exact intersection point (intersections returned contain the object and the world position of the object that is being hit)
+     * For a more accurate test use the physics engine's collider overlap test (see sphereOverlapPhysics)
+     * @param spherePos the center of the sphere in world space
+     * @param radius the radius of the sphere
+     * @param traverseChildsAfterHit if false it will stop after the first hit. If true it will continue to traverse and add all hits to the result array
+     */
     public sphereOverlap(spherePos: Vector3, radius: number, traverseChildsAfterHit: boolean = true): Array<Intersection> {
         this.sphereResults.length = 0;
         if (!this.context.scene) return this.sphereResults;
@@ -130,10 +146,9 @@ export class Physics {
                 if (mesh.matrixWorldNeedsUpdate) mesh.updateMatrixWorld();
                 const test = this.tempBoundingBox.copy(geo.boundingBox).applyMatrix4(mesh.matrixWorld);
                 if (sp.intersectsBox(test)) {
-                    // console.log(obj, obj.layers.test(mask), obj.layers.mask, mask.mask);
                     const wp = getWorldPosition(obj);
                     const dist = wp.distanceTo(sp.center);
-                    const int = new SphereIntersection(obj, dist, sp.center.clone());
+                    const int = new SphereIntersection(obj, dist, wp);
                     results.push(int);
                     if (!traverseChildsAfterHit) return;
                 }
@@ -157,6 +172,8 @@ export class Physics {
     /** raycast against rendered three objects. This might be very slow depending on your scene complexity.
      * We recommend setting objects to IgnoreRaycast layer (2) when you don't need them to be raycasted.
      * Raycasting SkinnedMeshes is specially expensive.
+     * Use raycastPhysics for raycasting against physic colliders only. Depending on your scenario this might be faster.
+     * @param options raycast options. If null, default options will be used.
      */
     public raycast(options: RaycastOptions | null = null): Array<Intersection> {
         if (!options) options = this.defaultRaycastOptions;
@@ -222,8 +239,12 @@ export class Physics {
 
     private rapierRay = new RAPIER.Ray({ x: 0, y: 0, z: 0 }, { x: 0, y: 0, z: 1 });
     private raycastVectorsBuffer = new CircularBuffer(() => new Vector3(), 10);
-
-    /** raycast against colliders */
+    /** Fast raycast against physics colliders
+     * @param origin ray origin in screen or worldspace
+     * @param direction ray direction in worldspace
+     * @param maxDistance max distance to raycast
+     * @param solid if true it will also hit the collider if origin is already inside it
+     */
     public raycastPhysicsFast(origin: Vec2 | Vec3, direction: Vec3 | undefined = undefined, maxDistance: number = Infinity, solid: boolean = true)
         : null | { point: Vector3, collider: ICollider } {
 
@@ -285,6 +306,72 @@ export class Physics {
         return ray;
     }
 
+
+    private rapierSphere: RAPIER.Ball | null = null;
+    private rapierColliderArray: Array<SphereOverlapResult> = [];
+    private readonly rapierIdentityRotation = { x: 0, y: 0, z: 0, w: 1 };
+    private readonly rapierForwardVector = { x: 0, y: 0, z: 1 };
+    /** Precice sphere overlap detection using rapier against colliders
+     * @param point center of the sphere in worldspace
+     * @param radius radius of the sphere
+     * @returns array of colliders that overlap with the sphere. Note: they currently only contain the collider and the gameobject
+     */
+    public sphereOverlapPhysics(point: Vector3, radius: number): Array<SphereOverlapResult> {
+        this.rapierColliderArray.length = 0;
+        if (!this.world) return this.rapierColliderArray;
+        if (!this.rapierSphere)
+            this.rapierSphere = new RAPIER.Ball(radius);
+        this.rapierSphere.radius = radius;
+
+        this.world.intersectionsWithShape(point, this.rapierIdentityRotation, this.rapierSphere, col => {
+            const collider = col[$componentKey] as ICollider
+            // if (collider.gameObject.layers.isEnabled(2)) return true;
+            const intersection = new SphereOverlapResult(collider.gameObject, collider);
+            this.rapierColliderArray.push(intersection);
+            return true; // Return `false` instead if we want to stop searching for other colliders that contain this point.
+        }, QueryFilterFlags.EXCLUDE_SENSORS, undefined, undefined, undefined,
+            col => {
+                const collider = col[$componentKey] as ICollider
+                return collider.gameObject.layers.isEnabled(2) == false
+            }
+        );
+        return this.rapierColliderArray;
+
+
+        // TODO: this only returns one hit
+        // let filterGroups = 0xffffffff;
+        // filterGroups &= ~(1 << 2);
+        // const hit: ShapeColliderTOI | null = this.world.castShape(point,
+        //     this.rapierIdentityRotation,
+        //     this.rapierForwardVector,
+        //     this.rapierSphere,
+        //     0,
+        //     QueryFilterFlags.EXCLUDE_SENSORS,
+        //     // filterGroups,
+        // );
+        // // console.log(hit);
+        // if (hit) {
+        //     const collider = hit.collider[$componentKey] as ICollider
+        //     const intersection = new SphereOverlapResult(collider.gameObject);
+        //     this.rapierColliderArray.push(intersection);
+        //     // const localpt = hit.witness2;
+        //     // // const normal = hit.normal2;
+        //     // const hitPoint = new Vector3(localpt.x, localpt.y, localpt.z);
+        //     // // collider.gameObject.localToWorld(hitPoint);
+        //     // // const normalPt = new Vector3(normal.x, normal.y, normal.z);
+        //     // // const mat = new Matrix4().setPosition(point).scale(new Vector3(radius, radius, radius));
+        //     // // hitPoint.applyMatrix4(mat);
+        //     // console.log(hit.witness2)
+        //     // // hitPoint.add(point);
+        //     // const dist = hitPoint.distanceTo(point);
+        // }
+
+        // return this.rapierColliderArray;
+    }
+
+
+
+
     // physics simulation
 
     enabled: boolean = true;
@@ -352,42 +439,58 @@ export class Physics {
 
     addBoxCollider(collider: ICollider, center: Vector3, size: Vector3) {
         if (!this.enabled) {
-            if(debugPhysics) console.warn("Physics is disabled");
+            if (debugPhysics) console.warn("Physics are disabled");
             return;
         }
         const obj = collider.gameObject;
         const scale = getWorldScale(obj, this._tempPosition).multiply(size);
         scale.multiplyScalar(0.5);
+
+        // prevent negative scale
+        if (scale.x < 0)
+            scale.x = Math.abs(scale.x);
+        if (scale.y < 0)
+            scale.y = Math.abs(scale.y);
+        if (scale.z < 0)
+            scale.z = Math.abs(scale.z);
+
         const desc = ColliderDesc.cuboid(scale.x, scale.y, scale.z);
+        // const objectLayerMask = collider.gameObject.layers.mask;
+        // const mask = objectLayerMask & ~2;
+        // desc.setCollisionGroups(objectLayerMask);
         this.createCollider(collider, desc, center);
     }
 
     addSphereCollider(collider: ICollider, center: Vector3, radius: number) {
         if (!this.enabled) {
-            if(debugPhysics) console.warn("Physics is disabled");
+            if (debugPhysics) console.warn("Physics are disabled");
             return;
         }
         const obj = collider.gameObject;
         const scale = getWorldScale(obj, this._tempPosition).multiplyScalar(radius);
+        // Prevent negative scales
+        scale.x = Math.abs(scale.x);
         const desc = ColliderDesc.ball(scale.x);
         this.createCollider(collider, desc, center);
     }
 
     addCapsuleCollider(collider: ICollider, center: Vector3, height: number, radius: number) {
         if (!this.enabled) {
-            if(debugPhysics) console.warn("Physics is disabled");
+            if (debugPhysics) console.warn("Physics are disabled");
             return;
         }
         const obj = collider.gameObject;
         const scale = getWorldScale(obj, this._tempPosition);
-        if (debugPhysics) console.log("capsule scale", scale, height, radius);
+        // Prevent negative scales
+        scale.x = Math.abs(scale.x);
+        scale.y = Math.abs(scale.y);
         const desc = ColliderDesc.capsule(height * .5 * scale.y - radius, radius * scale.x);
         this.createCollider(collider, desc, center);
     }
 
     addMeshCollider(collider: ICollider, mesh: Mesh, convex: boolean, scale: Vector3) {
         if (!this.enabled) {
-            if(debugPhysics) console.warn("Physics is disabled");
+            if (debugPhysics) console.warn("Physics are disabled");
             return;
         }
         const geo = mesh.geometry;

package/src/engine/engine_setup.ts

@@ -744,6 +744,10 @@ export class Context implements IContext {
 		this.connection.sendBufferedMessagesNow();
 
 		this._stats?.end();
+
+		if (this.time.frame === 1) {
+			this.domElement.dispatchEvent(new CustomEvent("ready"));
+		}
 	}
 
 	renderNow(camera?: Camera) {

package/src/engine/extensions/NEEDLE_render_objects.ts

@@ -23,7 +23,10 @@ import {
     DecrementWrapStencilOp,
     InvertStencilOp,
 } from "three";
-import { getParam } from "../engine_utils";
+import { getParam, isDebugMode } from "../engine_utils";
+import { showBalloonWarning } from "../debug";
+import { isUsingInstancing } from "../engine_gameobject";
+import { isLocalNetwork } from "../engine_networking_utils";
 
 const debug = getParam("debugstencil");
 
@@ -62,6 +65,12 @@ export class NEEDLE_render_objects implements GLTFLoaderPlugin {
             const stencil: StencilSettingsModel = settings[i];
             if (matchesLayer(stencil.layer, obj)) {
                 if (debug) console.log(stencil);
+                setTimeout(() => {
+                    if (isLocalNetwork() && isUsingInstancing(obj.gameObject)) {
+                        showBalloonWarning("Stencil not supported on instanced objects");
+                        console.warn("Stencil not supported on instanced objects", obj);
+                    }
+                }, 500)
                 for (let i = 0; i < obj.sharedMaterials.length; i++) {
                     let mat = obj.sharedMaterials[i];
                     if (mat) {

package/src/engine-components/Animator.ts

@@ -73,7 +73,6 @@ export class Animator extends Behaviour {
     /**@deprecated use getBool */
     GetBool(name: string | number) { return this.getBool(name); }
     getBool(name: string | number): boolean {
-        console.log("name", name);
         return this.runtimeAnimatorController?.getBool(name) ?? false;
     }
 

package/src/engine-components/CharacterController.ts

@@ -86,6 +86,9 @@ export class CharacterControllerInput extends Behaviour {
     @serializable()
     jumpForce: number = 1;
 
+    @serializable()
+    doubleJumpForce: number = 2;
+
     @serializable(Animator)
     animator?: Animator;
 
@@ -106,7 +109,7 @@ export class CharacterControllerInput extends Behaviour {
 
         if (this.controller?.isGrounded) {
             this._jumpCount = 0;
-            this.animator?.SetBool("doubleJump", false);
+            if (this.doubleJumpForce > 0) this.animator?.setBool("doubleJump", false);
         }
 
         const forward = this.context.input.isKeyPressed("w");
@@ -121,8 +124,8 @@ export class CharacterControllerInput extends Behaviour {
         this._currentSpeed.z += step * this.movementSpeed * this.context.time.deltaTime;
 
         // if (!this.controller || this.controller.isGrounded)
-        this.animator?.SetBool("running", step != 0);
-        this.animator?.SetBool("jumping", this.controller?.isGrounded === true && jump);
+        this.animator?.setBool("running", step != 0);
+        this.animator?.setBool("jumping", this.controller?.isGrounded === true && jump);
 
         this._temp.copy(this._currentSpeed);
         this._temp.applyQuaternion(this.gameObject.quaternion);
@@ -146,9 +149,9 @@ export class CharacterControllerInput extends Behaviour {
 
         if (this.controller && jump && this.jumpForce > 0) {
             let canJump = this.controller?.isGrounded;
-            if (!this.controller?.isGrounded && this._jumpCount === 1) {
+            if (this.doubleJumpForce > 0 && !this.controller?.isGrounded && this._jumpCount === 1) {
                 canJump = true;
-                this.animator?.SetBool("doubleJump", true);
+                this.animator?.setBool("doubleJump", true);
             }
 
             if (canJump) {
@@ -156,8 +159,8 @@ export class CharacterControllerInput extends Behaviour {
                 // TODO: factor in mass
                 const rb = this.controller.rigidbody;
                 // const fullJumpHoldLength = .1;
-                const factor = this._jumpCount === 2 ? 2 : 1;// Mathf.clamp((this.context.time.time - this._jumpDownTime), 0, fullJumpHoldLength) / fullJumpHoldLength;
-                rb.applyImpulse(new Vector3(0, 1, 0).multiplyScalar(this.jumpForce * factor));
+                const factor = this._jumpCount === 2 ? this.doubleJumpForce : this.jumpForce;// Mathf.clamp((this.context.time.time - this._jumpDownTime), 0, fullJumpHoldLength) / fullJumpHoldLength;
+                rb.applyImpulse(new Vector3(0, 1, 0).multiplyScalar(factor));
             }
         }
 
@@ -174,10 +177,10 @@ export class CharacterControllerInput extends Behaviour {
                 const hits = this.context.physics.raycast(this._raycastOptions);
                 this.gameObject.layers.set(currentLayer);
                 if ((hits.length && hits[0].distance > 2 || verticalSpeed < -10)) {
-                    this.animator?.SetBool("falling", true);
+                    this.animator?.setBool("falling", true);
                 }
             }
-            else this.animator?.SetBool("falling", false);
+            else this.animator?.setBool("falling", false);
         }
     }
 

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;