@needle-tools/engine 2.59.1-pre → 2.59.2-pre

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/engine",
-    "version": "2.59.1-pre",
+    "version": "2.59.2-pre",
     "description": "Needle Engine is a web-based runtime for 3D apps. It runs on your machine for development, and can be deployed anywhere. It is flexible, extensible, and collaboration and XR come naturally.",
     "main": "dist/needle-engine.umd.cjs",
     "module": "dist/needle-engine.js",

package/src/engine/engine_input.ts

@@ -343,10 +343,10 @@ export class Input extends EventTarget {
 
     private canReceiveInput(evt : Event) {
         // If the user has HTML objects ontop of the canvas
-        if(evt.target instanceof HTMLCanvasElement) return true;
-        const css = window.getComputedStyle(evt.target as HTMLElement);
-        if(css.pointerEvents === "all") return false;
-        return true;
+        // if(evt.target === this.context.renderer.domElement) return true;
+        // const css = window.getComputedStyle(evt.target as HTMLElement);
+        // if(css.pointerEvents === "all") return false;
+        return evt.target === this.context.renderer.domElement;
     }
 
     private keysPressed: { [key: number]: { pressed: boolean, frame: number, startFrame: number, key: string } } = {};

package/src/engine-components/ParticleSystem.ts

@@ -16,15 +16,26 @@ import { createFlatTexture } from "../engine/engine_shaders";
 import { Mathf } from "../engine/engine_math";
 import { Context } from "../engine/engine_setup";
 import { ParticleSubEmitter } from "./ParticleSystemSubEmitter";
+import { copyFile } from "fs";
 
 const debug = getParam("debugparticles");
 
-
+export enum SubEmitterType {
+    Birth = 0,
+    Collision = 1,
+    Death = 2,
+    Trigger = 3,
+    Manual = 4,
+}
 
 export class SubEmitterSystem {
 
     particleSystem?: ParticleSystem;
 
+    emitProbability: number = 1;
+    properties?: number;
+    type?: SubEmitterType;
+
     _deserialize(context: Context) {
         const ps = this.particleSystem;
         if (ps && !(ps instanceof ParticleSystem) && typeof ps["guid"] === "string") {
@@ -726,6 +737,9 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
                 arr[i] = instance;
             }
         }
+        if (debug && arr.length > 0) {
+            console.log("SubEmitters: ", arr, this)
+        }
         this._subEmitterSystems = arr;
     }
     private _subEmitterSystems?: SubEmitterSystem[];
@@ -839,11 +853,15 @@ export class ParticleSystem extends Behaviour implements IParticleSystem {
     private addSubParticleSystems() {
         if (this._subEmitterSystems && this._particleSystem) {
             for (const sys of this._subEmitterSystems) {
+                // Make sure the particle system is created
+                if (sys.particleSystem) sys.particleSystem.__internalAwake();
                 const system = sys.particleSystem?._particleSystem;
                 if (system) {
                     sys.particleSystem!._isUsedAsSubsystem = true;
                     // sys.particleSystem!.main.simulationSpace = ParticleSystemSimulationSpace.World;
                     const sub = new ParticleSubEmitter(this, this._particleSystem, sys.particleSystem!, system);
+                    sub.emitterType = sys.type;
+                    sub.emitterProbability = sys.emitProbability;
                     this._particleSystem.addBehavior(sub);
                 }
             }

package/src/engine-components/ParticleSystemSubEmitter.ts

@@ -2,6 +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";
 
 const VECTOR_ONE = new Vector3(1, 1, 1);
 const VECTOR_Z = new Vector3(0, 0, 1);
@@ -11,6 +12,9 @@ export class ParticleSubEmitter implements Behavior {
 
     type = "NeedleParticleSubEmitter";
 
+    emitterType?: SubEmitterType;
+    emitterProbability?: number;
+
     //private matrix_ = new Matrix4();
     private q_ = new Quaternion();
     private v_ = new Vector3();
@@ -47,14 +51,41 @@ export class ParticleSubEmitter implements Behavior {
         } as EmissionState;
         // particle[$emitterMatrix] = new Matrix4();
         this._emitterMatrix.copy(this.subSystem.matrixWorld).invert().premultiply(this.system.matrixWorld)
+
+        if (this.emitterType === SubEmitterType.Birth) {
+            this.run(particle);
+        }
+    }
+
+    update(particle: Particle, _delta: number): void {
+        this.run(particle);
+    }
+
+    frameUpdate(_delta: number): void {
+    }
+
+    toJSON(): any {
     }
 
-    update(particle: Particle, delta: number): void {
+    private run(particle: Particle) {
         if (this.subSystem.currentParticles >= this.subSystem.main.maxParticles)
             return;
         if (!this.subParticleSystem || !particle.emissionState)
             return;
 
+        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;
+            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;
+            particle.emissionState.waitEmiting = maxAmount;
+        }
+
         // TODO: figure out how to re-use matrices
         const m = new Matrix4();// this._circularBuffer.get();// new Matrix4();// particle[$emitterMatrix];
 
@@ -71,10 +102,4 @@ export class ParticleSubEmitter implements Behavior {
 
         this.subParticleSystem!.emit(delta, particle.emissionState!, m);
     }
-
-    frameUpdate(_delta: number): void {
-    }
-
-    toJSON(): any {
-    }
 }