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

package/src/engine-components/ParticleSystemModules.ts

@@ -1,11 +1,12 @@
 import { init } from "@dimforge/rapier3d-compat";
 import * as THREE from "three";
-import { Color, Matrix4, Object3D, Vector3 } from "three";
+import { Color, Matrix4, Object3D, PointLightShadow, Quaternion, Vector3 } from "three";
 import { Mathf } from "../engine/engine_math";
 import { serializeable } from "../engine/engine_serialization";
 import { RGBAColor } from "./js-extensions/RGBAColor";
 import { AnimationCurve } from "./AnimationCurve";
 import { Vec3 } from "../engine/engine_types";
+import { EmitterShape, FrameOverLife, Particle, ShapeJSON } from "three.quarks";
 
 declare type Color4 = { r: number, g: number, b: number, a: number };
 declare type ColorKey = { time: number, color: Color4 };
@@ -17,6 +18,9 @@ export interface IParticleSystem {
     get time(): number;
     get duration(): number;
     readonly main: MainModule;
+    get container(): Object3D;
+    get worldQuaternion(): Quaternion;
+    get worldQuaternionInverted(): Quaternion;
 }
 
 export enum ParticleSystemRenderMode {
@@ -165,14 +169,14 @@ export class MinMaxCurve {
             case ParticleSystemCurveMode.Constant:
                 return this.constant;
             case ParticleSystemCurveMode.Curve:
-                t01 %= this.curve!.duration;
-                return this.curve!.evaluate(t01);
+                t01 = Mathf.clamp01(t01);
+                return this.curve!.evaluate(t01) * this.curveMultiplier!;
             case ParticleSystemCurveMode.TwoCurves:
                 const t1 = t01 * this.curveMin!.duration;
                 const t2 = t01 * this.curveMax!.duration;
-                return Mathf.lerp(this.curveMin!.evaluate(t1), this.curveMax!.evaluate(t2), t % 1);
+                return Mathf.lerp(this.curveMin!.evaluate(t1), this.curveMax!.evaluate(t2), t % 1) * this.curveMultiplier!;
             case ParticleSystemCurveMode.TwoConstants:
-                return Mathf.lerp(this.constantMin, this.constantMax, t % 1);
+                return Mathf.lerp(this.constantMin, this.constantMax, t % 1)
             default:
                 this.curveMax!.evaluate(t01) * this.curveMultiplier!;
                 break;
@@ -208,7 +212,8 @@ export class MinMaxGradient {
                 this.gradient.evaluate(t01, MinMaxGradient._temp);
                 return MinMaxGradient._temp
             case ParticleSystemGradientMode.TwoColors:
-                return MinMaxGradient._temp.lerpColors(this.colorMin, this.colorMax, t);
+                const col1 = MinMaxGradient._temp.lerpColors(this.colorMin, this.colorMax, t);
+                return col1;
             case ParticleSystemGradientMode.TwoGradients:
                 const t2 = Math.random();
                 this.gradientMin.evaluate(t2, MinMaxGradient._temp);
@@ -374,23 +379,9 @@ export class EmissionModule {
     system!: IParticleSystem;
     get time() { return this.system.time; }
 
-    private _summed: number = 0;
-    // private _didEmit: boolean = false;
-
-    /** called by nebula */
-    init() {
-    }
-
-    /** called by nebula */
-    getValue(deltaTime: number) {
-        if (this.system.currentParticles >= this.system.maxParticles)
-            return 0;
-        if (!this.enabled) return 0;
-        let count = this.rateOverTime.evaluate(this.time / this.system.duration, Math.random());
-        this._summed += count * deltaTime;
-        let amount = Math.floor(this._summed);
-        this._summed -= amount;
 
+    getBurst() {
+        let amount = 0;
         if (this.burstCount > 0) {
             for (let i = 0; i < this.burstCount; i++) {
                 const burst = this.bursts[i];
@@ -401,9 +392,7 @@ export class EmissionModule {
                 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);
+        return amount;
     }
 }
 
@@ -420,18 +409,26 @@ export class SizeOverLifetimeModule {
     size!: MinMaxCurve;
     sizeMultiplier!: number;
     @serializeable(MinMaxCurve)
-    sizeX!: MinMaxCurve;
-    sizeXMultiplier!: number;
+    x!: MinMaxCurve;
+    xMultiplier!: number;
     @serializeable(MinMaxCurve)
-    sizeY!: MinMaxCurve;
-    sizeYMultiplier!: number;
+    y!: MinMaxCurve;
+    yMultiplier!: number;
     @serializeable(MinMaxCurve)
-    sizeZ!: MinMaxCurve;
-    sizeZMultiplier!: number;
+    z!: MinMaxCurve;
+    zMultiplier!: number;
 
     private _time: number = 0;
+    private _temp = new Vector3();
+
+    evaluate(t01: number, target?: Vec3) {
+        if (!target) target = this._temp;
+
+        if (!this.enabled) {
+            target.x = target.y = target.z = 1;
+            return target;
+        }
 
-    evaluate(t01: number, target: Vec3) {
         if (!this.separateAxes) {
             const scale = this.size.evaluate(t01) * this.sizeMultiplier;
             target.x = scale;
@@ -439,15 +436,31 @@ export class SizeOverLifetimeModule {
             // target.z = scale;
         }
         else {
-            target.x = this.sizeX.evaluate(this._time) * this.sizeXMultiplier;
-            // target.y = this.sizeY.evaluate(this._time) * this.sizeYMultiplier;
-            // target.z = this.sizeZ.evaluate(this._time) * this.sizeZMultiplier;
+            target.x = this.x.evaluate(t01) * this.xMultiplier;
+            target.y = this.y.evaluate(t01) * this.yMultiplier;
+            target.z = this.z.evaluate(t01) * this.zMultiplier;
         }
         return target;
     }
 }
 
-export class ShapeModule {
+export class ShapeModule implements EmitterShape {
+
+    get type(): string {
+        return ParticleSystemShapeType[this.shapeType];
+    }
+
+    initialize(particle: Particle): void {
+        this.getPosition();
+        particle.position.copy(this._vector);
+    }
+    toJSON(): ShapeJSON {
+        return this;
+    }
+    clone(): EmitterShape {
+        return new ShapeModule();
+    }
+
     @serializeable()
     shapeType: ParticleSystemShapeType = ParticleSystemShapeType.Box;
     @serializeable()
@@ -502,7 +515,6 @@ export class ShapeModule {
     get vector() {
         return this._vector;
     }
-    /** called by nebula */
     getPosition(): void {
         switch (this.shapeType) {
             case ParticleSystemShapeType.Box:
@@ -513,6 +525,9 @@ export class ShapeModule {
             case ParticleSystemShapeType.Sphere:
                 randomSpherePoint(this.position.x, this.position.y, this.position.z, this.radius, this.radiusThickness, this.arc, this._vector);
                 break;
+            default:
+                this._vector.set(0, 0, 0);
+                break;
             // case ParticleSystemShapeType.Hemisphere:
             //     randomSpherePoint(this.position.x, this.position.y, this.position.z, this.radius, this.radiusThickness, 180, this._vector);
             //     break;
@@ -559,6 +574,8 @@ function randomSpherePoint(x0: number, y0: number, z0: number, radius: number, t
 
 import { createNoise4D, NoiseFunction4D } from 'simplex-noise';
 import { Context } from "../engine/engine_setup";
+import { getWorldQuaternion } from "../engine/engine_three_utils";
+import { Gizmos } from "../engine/engine_gizmos";
 
 export class NoiseModule {
     @serializeable()
@@ -626,34 +643,229 @@ export class NoiseModule {
 
     /** nebula implementations: */
     private _temp: Vector3 = new Vector3();
-    applyNoise(index: number, pos: Vec3, vel: Vec3, deltaTime: number, age: number, life: number) {
+    apply(_index: number, pos: Vec3, vel: Vec3, _deltaTime: number, age: number, life: number) {
         if (!this.enabled) return;
         if (!this._noise) {
             this._noise = createNoise4D(() => 0);
         }
-        const t = age / life;
-        const dt = Context.Current.time.deltaTime;
         const temp = this._temp.set(pos.x, pos.y, pos.z).multiplyScalar(this.frequency);
         const nx = this._noise(temp.x, temp.y, temp.z, this._time);
-        const ny = this._noise(temp.x, temp.y, temp.z, this._time + .2);
-        const nz = this._noise(temp.x, temp.y, temp.z, this._time + .5);
-        this._temp.set(nx, ny, nz).normalize();
+        const ny = this._noise(temp.x, temp.y, temp.z, this._time + .3);
+        const nz = this._noise(temp.x, temp.y, temp.z, this._time + 1);
+        this._temp.set(nx, ny, nz).normalize()
 
+        const t = age / life;
         let strengthFactor = this.positionAmount.evaluate(t);
         if (!this.separateAxes) {
-            if (this.strengthX)
-                strengthFactor *= this.strengthX.evaluate(t, index * 1.1);
-            else strengthFactor *= this.strengthMultiplier;
-            strengthFactor *= deltaTime;
+            if (this.strengthX) {
+                strengthFactor *= this.strengthX.evaluate(t) * Math.PI;
+            }
+            // strengthFactor *= this.strengthMultiplier;
+            // strengthFactor *= deltaTime;
             this._temp.multiplyScalar(strengthFactor);
         }
-        if (this.separateAxes) {
-            this._temp.x *= strengthFactor * deltaTime * this.strengthXMultiplier
-            this._temp.y *= strengthFactor * deltaTime * this.strengthYMultiplier;
-            this._temp.z *= strengthFactor * deltaTime * this.strengthZMultiplier;
+        else {
+            this._temp.x *= strengthFactor * this.strengthXMultiplier
+            this._temp.y *= strengthFactor * this.strengthYMultiplier;
+            this._temp.z *= strengthFactor * this.strengthZMultiplier;
+        }
+        // this._temp.setLength(strengthFactor * deltaTime);
+        vel.x += this._temp.x;
+        vel.y += this._temp.y;
+        vel.z += this._temp.z;
+    }
+}
+
+export class TrailModule {
+
+    @serializeable()
+    enabled!: boolean;
+}
+
+export class VelocityOverLifetimeModule {
+    @serializeable()
+    enabled!: boolean;
+
+    /* orbital settings */
+
+
+    @serializeable()
+    space: ParticleSystemSimulationSpace = ParticleSystemSimulationSpace.Local;
+
+    @serializeable(MinMaxCurve)
+    speedModifier!: MinMaxCurve;
+    @serializeable()
+    speedModifierMultiplier!: number;
+    @serializeable(MinMaxCurve)
+    x!: MinMaxCurve;
+    @serializeable()
+    xMultiplier!: number;
+    @serializeable(MinMaxCurve)
+    y!: MinMaxCurve;
+    @serializeable()
+    yMultiplier!: number;
+    @serializeable(MinMaxCurve)
+    z!: MinMaxCurve;
+    @serializeable()
+    zMultiplier!: number;
+
+    private _system?: IParticleSystem;
+    // private _worldRotation: Quaternion = new Quaternion();
+
+    update(system: IParticleSystem) {
+        this._system = system;
+    }
+
+    private _temp: Vector3 = new Vector3();
+
+    apply(_index: number, _pos: Vec3, vel: Vec3, _dt: number, age: number, life: number) {
+        if (!this.enabled) return;
+        const t = age / life;
+
+        const speed = this.speedModifier.evaluate(t) * this.speedModifierMultiplier;
+        const x = this.x.evaluate(t) * speed;
+        const y = this.y.evaluate(t) * speed;
+        const z = this.z.evaluate(t) * speed;
+        this._temp.set(-x, y, z);
+        if (this._system) {
+            if (this.space === ParticleSystemSimulationSpace.World) {
+                this._temp.applyQuaternion(this._system.worldQuaternionInverted);
+            }
+            if (this._system.main.simulationSpace === ParticleSystemSimulationSpace.World) {
+                this._temp.applyQuaternion(this._system.worldQuaternion);
+            }
         }
         vel.x += this._temp.x;
         vel.y += this._temp.y;
         vel.z += this._temp.z;
     }
+}
+
+
+
+enum ParticleSystemAnimationTimeMode {
+    Lifetime,
+    Speed,
+    FPS,
+}
+
+enum ParticleSystemAnimationMode {
+    Grid,
+    Sprites,
+}
+
+enum ParticleSystemAnimationRowMode {
+    Custom,
+    Random,
+    MeshIndex,
+}
+
+enum ParticleSystemAnimationType {
+    WholeSheet,
+    SingleRow,
+}
+
+export class TextureSheetAnimationModule {
+
+    @serializeable()
+    animation!: ParticleSystemAnimationType;
+
+    @serializeable()
+    enabled!: boolean;
+
+    @serializeable()
+    cycleCount!: number;
+
+    @serializeable(MinMaxCurve)
+    frameOverTime!: MinMaxCurve;
+    @serializeable()
+    frameOverTimeMultiplier!: number;
+
+    @serializeable()
+    numTilesX!: number;
+    @serializeable()
+    numTilesY!: number;
+
+    @serializeable(MinMaxCurve)
+    startFrame!: MinMaxCurve;
+    @serializeable()
+    startFrameMultiplier!: number;
+
+    @serializeable()
+    rowMode!: ParticleSystemAnimationRowMode;
+    @serializeable()
+    rowIndex!: number;
+
+    @serializeable()
+    spriteCount!: number;
+
+    @serializeable()
+    timeMode!: ParticleSystemAnimationTimeMode;
+
+    private sampleOnceAtStart(): boolean {
+        if (this.timeMode === ParticleSystemAnimationTimeMode.Lifetime) {
+            switch (this.frameOverTime.mode) {
+                case ParticleSystemCurveMode.Constant:
+                case ParticleSystemCurveMode.TwoConstants:
+                    return true;
+            }
+        }
+        return false;
+    }
+
+    getStartIndex(): number {
+        if (this.sampleOnceAtStart()) {
+            return this.frameOverTime.evaluate(Math.random())
+        }
+        return 0;
+    }
+
+    evaluate(t01: number): number | undefined {
+        if (this.sampleOnceAtStart()) {
+            return;
+        }
+        return this.getIndex(t01);
+    }
+
+    private getIndex(t01: number): number {
+        const tiles = this.numTilesX * this.numTilesY;
+        // let pos = t01 * this.cycleCount;
+        let index = this.frameOverTime.evaluate(t01 % 1);
+        index *= this.frameOverTimeMultiplier;
+        index *= tiles;
+        index = index % tiles;
+        index = Math.floor(index);
+        // console.log(index);
+        return index;
+    }
+}
+
+
+export class RotationOverLifetimeModule {
+    @serializeable()
+    enabled!: boolean;
+
+    @serializeable()
+    separateAxes!: boolean;
+
+    @serializeable(MinMaxCurve)
+    x!: MinMaxCurve;
+    @serializeable()
+    xMultiplier!: number;
+    @serializeable(MinMaxCurve)
+    y!: MinMaxCurve;
+    @serializeable()
+    yMultiplier!: number;
+    @serializeable(MinMaxCurve)
+    z!: MinMaxCurve;
+    @serializeable()
+    zMultiplier!: number;
+
+    evaluate(t01: number): number {
+        if (!this.enabled) return 0;
+        if (!this.separateAxes) {
+            return this.z.evaluate(t01) * -1;
+        }
+        return 0;
+    }
 }

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

@@ -60,6 +60,10 @@ export { ColorOverLifetimeModule } from "../ParticleSystemModules";
 export { SizeOverLifetimeModule } from "../ParticleSystemModules";
 export { ShapeModule } from "../ParticleSystemModules";
 export { NoiseModule } from "../ParticleSystemModules";
+export { TrailModule } from "../ParticleSystemModules";
+export { VelocityOverLifetimeModule } from "../ParticleSystemModules";
+export { TextureSheetAnimationModule } from "../ParticleSystemModules";
+export { RotationOverLifetimeModule } from "../ParticleSystemModules";
 export { PlayerColor } from "../PlayerColor";
 export { ReflectionProbe } from "../ReflectionProbe";
 export { FieldWithDefault } from "../Renderer";

package/src/engine-components/js-extensions/RGBAColor.ts

@@ -32,6 +32,13 @@ export class RGBAColor extends Color {
         return super.lerp(color, alpha);
     }
 
+    lerpColors(color1: Color, color2: Color, alpha: number): this {
+        const rgba1 = color1 as RGBAColor;
+        const rgba2 = color2 as RGBAColor;
+        if(rgba1.alpha && rgba2.alpha) this.alpha = Mathf.lerp(rgba1.alpha, rgba2.alpha, alpha);
+        return super.lerpColors(color1, color2, alpha);
+    }
+
     multiply(color: Color): this {
         const rgba = color as RGBAColor;
         if(rgba.alpha) this.alpha = this.alpha * rgba.alpha;