@needle-tools/engine 2.41.0-pre → 2.42.0-pre

package/src/engine-components/ParticleSystemModules.ts

@@ -11,6 +11,24 @@ declare type Color4 = { r: number, g: number, b: number, a: number };
 declare type ColorKey = { time: number, color: Color4 };
 declare type AlphaKey = { time: number, alpha: number };
 
+export interface IParticleSystem {
+    get currentParticles(): number;
+    get maxParticles(): number;
+    get time(): number;
+    get duration(): number;
+    readonly main: MainModule;
+}
+
+export enum ParticleSystemRenderMode {
+    Billboard = 0,
+    //   Stretch = 1,
+    //   HorizontalBillboard = 2,
+    //   VerticalBillboard = 3,
+    Mesh = 4,
+    //   None = 5,
+}
+
+
 export class Gradient {
     @serializeable()
     alphaKeys!: Array<AlphaKey>;
@@ -178,7 +196,8 @@ export class MinMaxGradient {
     @serializeable(Gradient)
     gradientMax!: Gradient;
 
-    private _temp: RGBAColor = new RGBAColor(0, 0, 0, 1);
+    private static _temp: RGBAColor = new RGBAColor(0, 0, 0, 1);
+    private static _temp2: RGBAColor = new RGBAColor(0, 0, 0, 1);
 
     evaluate(t01: number, lerpFactor?: number): RGBAColor {
         const t = lerpFactor === undefined ? Math.random() : lerpFactor;
@@ -186,15 +205,21 @@ export class MinMaxGradient {
             case ParticleSystemGradientMode.Color:
                 return this.color;
             case ParticleSystemGradientMode.Gradient:
-                this.gradient.evaluate(t01, this._temp);
-                return this._temp
+                this.gradient.evaluate(t01, MinMaxGradient._temp);
+                return MinMaxGradient._temp
             case ParticleSystemGradientMode.TwoColors:
-                return this._temp.lerpColors(this.colorMin, this.colorMax, t);
+                return MinMaxGradient._temp.lerpColors(this.colorMin, this.colorMax, t);
+            case ParticleSystemGradientMode.TwoGradients:
+                const t2 = Math.random();
+                this.gradientMin.evaluate(t2, MinMaxGradient._temp);
+                this.gradientMax.evaluate(t2, MinMaxGradient._temp2);
+                return MinMaxGradient._temp.lerp(MinMaxGradient._temp2, t);
+
         }
         // console.warn("Not implemented", ParticleSystemGradientMode[this.mode]);
-        this._temp.set(0xff00ff)
-        this._temp.alpha = 1;
-        return this._temp;
+        MinMaxGradient._temp.set(0xff00ff)
+        MinMaxGradient._temp.alpha = 1;
+        return MinMaxGradient._temp;
     }
 }
 
@@ -262,23 +287,93 @@ export class MainModule {
     useUnscaledTime!: boolean;
 }
 
+
+export class ParticleBurst {
+    cycleCount!: number;
+    maxCount!: number;
+    minCount!: number;
+    probability!: number;
+    repeatInterval!: number;
+    time!: number;
+    count!: {
+        constant: number;
+        constantMax: number;
+        constantMin: number;
+        curve?: AnimationCurve;
+        curveMax?: AnimationCurve;
+        curveMin?: AnimationCurve;
+        curveMultiplier?: number;
+        mode: ParticleSystemCurveMode;
+    }
+
+
+    private _performed: number = 0;
+
+
+    reset() {
+        this._performed = 0;
+    }
+    run(time: number): number {
+        if (time <= this.time) {
+            this.reset();
+            return 0;
+        }
+        let amount = 0;
+        if (this.cycleCount === 0 || this._performed < this.cycleCount) {
+            const nextTime = this.time + this.repeatInterval * this._performed;
+            if (time >= nextTime) {
+                this._performed += 1;
+                if (Math.random() < this.probability) {
+                    switch (this.count.mode) {
+                        case ParticleSystemCurveMode.Constant:
+                            amount = this.count.constant;
+                            break;
+                        case ParticleSystemCurveMode.TwoConstants:
+                            amount = Mathf.lerp(this.count.constantMin, this.count.constantMax, Math.random());
+                            break;
+                        case ParticleSystemCurveMode.Curve:
+                            amount = this.count.curve!.evaluate(Math.random());
+                            break;
+                        case ParticleSystemCurveMode.TwoCurves:
+                            const t = Math.random();
+                            amount = Mathf.lerp(this.count.curveMin!.evaluate(t), this.count.curveMax!.evaluate(t), Math.random());
+                            break;
+                    }
+                }
+            }
+        }
+        return amount;
+    }
+}
+
 export class EmissionModule {
-    burstCount!: number;
+
+    @serializeable()
     enabled!: boolean;
 
+
+    get burstCount() {
+        return this.bursts?.length ?? 0;
+    }
+
+    @serializeable()
+    bursts!: ParticleBurst[];
+
     @serializeable(MinMaxCurve)
     rateOverTime!: MinMaxCurve;
+    @serializeable()
     rateOverTimeMultiplier!: number;
 
     @serializeable(MinMaxCurve)
     rateOverDistance!: MinMaxCurve;
+    @serializeable()
     rateOverDistanceMultiplier!: number;
 
 
-    currentParticles: number = 0;
-    maxParticles: number = Infinity;
+    /** set from system */
+    system!: IParticleSystem;
+    get time() { return this.system.time; }
 
-    private _time: number = 0;
     private _summed: number = 0;
     // private _didEmit: boolean = false;
 
@@ -288,19 +383,27 @@ export class EmissionModule {
 
     /** called by nebula */
     getValue(deltaTime: number) {
-        if (this.currentParticles >= this.maxParticles)
+        if (this.system.currentParticles >= this.system.maxParticles)
             return 0;
-        // if (this._didEmit) return 0;
-        // this._didEmit = true;
-        // return 1;
-
         if (!this.enabled) return 0;
-        const time = this._time += deltaTime;
-        let count = this.rateOverTime.evaluate(time, Math.random());
+        let count = this.rateOverTime.evaluate(this.time / this.system.duration, Math.random());
         this._summed += count * deltaTime;
-        const amount = Math.floor(this._summed);
+        let amount = Math.floor(this._summed);
         this._summed -= amount;
-        return amount;
+
+        if (this.burstCount > 0) {
+            for (let i = 0; i < this.burstCount; i++) {
+                const burst = this.bursts[i];
+                if (burst.time >= this.time) {
+                    burst.reset();
+                    continue;
+                }
+                amount += Math.round(burst.run(this.time));
+            }
+        }
+
+        // dont emit more than we are allowed to
+        return amount;//Mathf.clamp(amount, 0, this.system.maxParticles - this.system.currentParticles);
     }
 }
 
@@ -414,7 +517,7 @@ export class ShapeModule {
             //     randomSpherePoint(this.position.x, this.position.y, this.position.z, this.radius, this.radiusThickness, 180, this._vector);
             //     break;
         }
-        if(this._space === ParticleSystemSimulationSpace.World) {
+        if (this._space === ParticleSystemSimulationSpace.World) {
             this._vector.applyMatrix4(this._worldSpacePosition);
         }
     }
@@ -422,7 +525,7 @@ export class ShapeModule {
 
 
     private _dir: Vector3 = new Vector3();
-    getDirection(position): Vec3 {
+    getDirection(position): Vector3 {
         switch (this.shapeType) {
             case ParticleSystemShapeType.Box:
                 return this._dir.set(0, 0, 1);
@@ -540,8 +643,8 @@ export class NoiseModule {
         if (!this.separateAxes) {
             if (this.strengthX)
                 strengthFactor *= this.strengthX.evaluate(t, index * 1.1);
-            strengthFactor *= this.strengthMultiplier;
-            strengthFactor *= .1;
+            else strengthFactor *= this.strengthMultiplier;
+            strengthFactor *= deltaTime;
             this._temp.multiplyScalar(strengthFactor);
         }
         if (this.separateAxes) {

package/src/engine-components/ReflectionProbe.ts

@@ -10,11 +10,14 @@ import { getParam } from "../engine/engine_utils";
 export const debug = getParam("debugreflectionprobe");
 const disable = getParam("noreflectionprobe");
 
+const $reflectionProbeKey = Symbol("reflectionProbeKey");
+const $originalMaterial = Symbol("original material");
+
 export class ReflectionProbe extends Behaviour {
 
     private static _probes: Map<Context, ReflectionProbe[]> = new Map();
 
-    public static get(object: Object3D | null | undefined, context: Context, isAnchor:boolean): ReflectionProbe | null {
+    public static get(object: Object3D | null | undefined, context: Context, isAnchor: boolean): ReflectionProbe | null {
         if (!object || object.isObject3D !== true) return null;
         if (disable) return null;
         const probes = ReflectionProbe._probes.get(context);
@@ -91,7 +94,7 @@ export class ReflectionProbe extends Behaviour {
     // and some need reflection probe and some don't
     // we need to make sure we don't override the material but use a copy
 
-    private static _rendererMaterialsCache: Map<IRenderer, Array<{ orig: Material, copy: Material }>> = new Map();
+    private static _rendererMaterialsCache: Map<IRenderer, Array<{ material: Material, copy: Material }>> = new Map();
 
     onSet(_rend: IRenderer) {
         if (disable) return;
@@ -109,22 +112,43 @@ export class ReflectionProbe extends Behaviour {
         // need to make sure materials are not shared when using reflection probes
         // otherwise some renderers outside of the probe will be affected or vice versa
         for (let i = 0; i < _rend.sharedMaterials.length; i++) {
-            const orig = _rend.sharedMaterials[i];
-            if (!orig) continue;
-            if (orig["envMap"] === undefined) continue;
+            const material = _rend.sharedMaterials[i];
+            if (!material) continue;
+            if (material["envMap"] === undefined) continue;
+            if (material["envMap"] === this.texture) {
+                continue;
+            }
             let cached = rendererCache[i];
-            let copy = cached?.copy;
-            if (!cached) {
-                const clone = orig.clone();
-                copy = clone;
-                rendererCache.push({ orig, copy });
 
-                copy["__reflection_probe"] = this;
-                copy["envMap"] = this.texture;
+            // 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) {
+                const clone = material.clone();
+
+                if (cached) {
+                    cached.copy = clone;
+                    cached.material = material;
+                }
+                else {
+                    cached = {
+                        material: material,
+                        copy: clone
+                    };
+                    rendererCache.push(cached);
+                }
+
+                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);
             }
+
+            /** this is the material that we copied and that has the reflection probe */
+            const copy = cached?.copy;
+
             _rend.sharedMaterials[i] = copy;
         }
     }
@@ -134,7 +158,7 @@ export class ReflectionProbe extends Behaviour {
         if (rendererCache) {
             for (let i = 0; i < rendererCache.length; i++) {
                 const cached = rendererCache[i];
-                _rend.sharedMaterials[i] = cached.orig;
+                _rend.sharedMaterials[i] = cached.material;
             }
         }
     }

package/src/engine-components/Renderer.ts

@@ -219,6 +219,8 @@ export class Renderer extends Behaviour implements IRenderer {
         return lm !== null && lm !== undefined;
     }
 
+    allowProgressiveLoading : boolean = true;
+
     awake() {
         this.clearInstancingState();
 
@@ -457,7 +459,7 @@ export class Renderer extends Behaviour implements IRenderer {
     onBeforeRenderThree(_renderer, _scene, _camera, _geometry, material, _group) {
 
         // progressive load before rendering so we only load textures for visible materials
-        if (!suppressProgressiveLoading && material._didRequestTextureLOD === undefined) {
+        if (!suppressProgressiveLoading && material._didRequestTextureLOD === undefined && this.allowProgressiveLoading) {
             material._didRequestTextureLOD = 0;
             if (debugProgressiveLoading) {
                 console.log("Load material LOD (with delay)", material.name);
@@ -542,7 +544,7 @@ export class Renderer extends Behaviour implements IRenderer {
         // handle reflection probe
         this._reflectionProbe = null;
         if (this.reflectionProbeUsage !== ReflectionProbeUsage.Off) {
-            // if(this.gameObject.name.includes("Tank_Case_Jewlery") === false) return;
+            if(!this.probeAnchor) return;
             const obj = this.probeAnchor || this.gameObject;
             const isAnchor = this.probeAnchor ? true : false;
             this._reflectionProbe = ReflectionProbe.get(obj, this.context, isAnchor);

package/src/engine-components/codegen/components.ts

@@ -54,6 +54,7 @@ export { Gradient } from "../ParticleSystemModules";
 export { MinMaxCurve } from "../ParticleSystemModules";
 export { MinMaxGradient } from "../ParticleSystemModules";
 export { MainModule } from "../ParticleSystemModules";
+export { ParticleBurst } from "../ParticleSystemModules";
 export { EmissionModule } from "../ParticleSystemModules";
 export { ColorOverLifetimeModule } from "../ParticleSystemModules";
 export { SizeOverLifetimeModule } from "../ParticleSystemModules";