@needle-tools/engine 3.2.1-alpha → 3.2.3-alpha

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/engine",
-    "version": "3.2.1-alpha",
+    "version": "3.2.3-alpha",
     "description": "Needle Engine is a web-based runtime for 3D apps. It runs on your machine for development with great integrations into editors like Unity or Blender - and can be deployed onto any device! It is flexible, extensible and networking and XR are built-in",
     "main": "dist/needle-engine.umd.cjs",
     "type": "module",

package/src/engine/codegen/register_types.js

@@ -1,5 +1,5 @@
 import { TypeStore } from "./../engine_typestore"
-
+
 // Import types
 import { __Ignore } from "../../engine-components/codegen/components";
 import { AlignmentConstraint } from "../../engine-components/AlignmentConstraint";
@@ -184,7 +184,7 @@ import { XRGrabModel } from "../../engine-components/WebXRGrabRendering";
 import { XRGrabRendering } from "../../engine-components/WebXRGrabRendering";
 import { XRRig } from "../../engine-components/WebXRRig";
 import { XRState } from "../../engine-components/XRFlag";
-
+
 // Register types
 TypeStore.add("__Ignore", __Ignore);
 TypeStore.add("AlignmentConstraint", AlignmentConstraint);

package/src/engine/engine_input.ts

@@ -243,28 +243,31 @@ export class Input extends EventTarget {
         return null;
     }
     isKeyDown(keyCode: KeyCode | string) {
+        if (!this.context.application.isVisible || !this.context.application.hasFocus) return false;
         const codes = this.getCodeForCommonKeyName(keyCode);
         if (codes !== null) {
             for (const code of codes) if (this.isKeyDown(code)) return true;
             return false;
         }
-        return this.context.application.isVisible && this.context.application.hasFocus && this.keysPressed[keyCode]?.startFrame === this.context.time.frameCount && this.keysPressed[keyCode].pressed;
+        return this.keysPressed[keyCode]?.startFrame === this.context.time.frameCount && this.keysPressed[keyCode].pressed;
     }
     isKeyUp(keyCode: KeyCode | string) {
+        if (!this.context.application.isVisible || !this.context.application.hasFocus) return false;
         const codes = this.getCodeForCommonKeyName(keyCode);
         if (codes !== null) {
             for (const code of codes) if (this.isKeyUp(code)) return true;
             return false;
         }
-        return this.context.application.isVisible && this.context.application.hasFocus && this.keysPressed[keyCode]?.frame === this.context.time.frameCount && !this.keysPressed[keyCode].pressed;
+        return this.keysPressed[keyCode]?.frame === this.context.time.frameCount && !this.keysPressed[keyCode].pressed;
     }
     isKeyPressed(keyCode: KeyCode | string) {
+        if (!this.context.application.isVisible || !this.context.application.hasFocus) return false;
         const codes = this.getCodeForCommonKeyName(keyCode);
         if (codes !== null) {
             for (const code of codes) if (this.isKeyPressed(code)) return true;
             return false;
         }
-        return this.context.application.isVisible && this.context.application.hasFocus && this.keysPressed[keyCode]?.pressed;// && time.frameCount - this.keysPressed[keyCode].frame < 100;
+        return this.keysPressed[keyCode]?.pressed;// && time.frameCount - this.keysPressed[keyCode].frame < 100;
     }
 
     // utility helper for mapping common names to actual codes; e.g. "Shift" -> "ShiftLeft" and "ShiftRight" or "a" -> "KeyA"

package/src/engine/engine_rendererdata.ts

@@ -136,7 +136,8 @@ export class RendererData {
         }
     }
 
-    disableReflection() {
+    disableReflection(sourceId? : SourceIdentifier) {
+        if(sourceId && sourceId !== this._currentReflectionId) return;
         const scene = this.context.scene;
         scene.environment = null;
     }

package/src/engine/extensions/NEEDLE_lighting_settings.ts

@@ -160,6 +160,6 @@ export class SceneLightSettings extends Behaviour {
         if (this._lightProbeObj) this._lightProbeObj.removeFromParent();
         if(this._ambientLightObj) this._ambientLightObj.removeFromParent();
         if (this.sourceId)
-            this.context.rendererData.disableReflection();
+            this.context.rendererData.disableReflection(this.sourceId);
     }
 }

package/src/engine-components/ParticleSystem.ts

@@ -414,6 +414,7 @@ class VelocityBehaviour extends ParticleSystemBaseBehaviour {
         particle[$gravitySpeed] = 1;
 
         particle[$velocityLerpFactor] = Math.random();
+        this.system.velocityOverLifetime?.init(particle);
 
         this._gravityDirection.set(0, -1, 0);
         if (this.system.main.simulationSpace === ParticleSystemSimulationSpace.Local)
@@ -463,7 +464,7 @@ class VelocityBehaviour extends ParticleSystemBaseBehaviour {
         // limit or modify speed
         const velocity = this.system.velocityOverLifetime;
         if (velocity.enabled) {
-            velocity.apply(0, particle.position, particle.velocity, delta, particle.age, particle.life);
+            velocity.apply(particle, 0, particle.position, particle.velocity, delta, particle.age, particle.life);
         }
 
         const limitVelocityOverLifetime = this.system.limitVelocityOverLifetime;

package/src/engine-components/ParticleSystemModules.ts

@@ -567,12 +567,24 @@ export class ShapeModule implements EmitterShape {
         }
     }
 
-    private updateRotation() {
+    private applyRotation(vector: Vector3) {
         const isRotated = this.rotation.x !== 0 || this.rotation.y !== 0 || this.rotation.z !== 0;
         if (isRotated) {
+            // console.log(this._rotation);
+            // TODO: we need to convert this to threejs euler
             this._rotation.x = Mathf.toRadians(this.rotation.x);
-            this._rotation.y = -Mathf.toRadians(this.rotation.y);
-            this._rotation.z = -Mathf.toRadians(this.rotation.z);
+            this._rotation.y = Mathf.toRadians(this.rotation.y);
+            this._rotation.z = Mathf.toRadians(this.rotation.z);
+            this._rotation.order = 'ZYX';
+            vector.applyEuler(this._rotation);
+            // this._quat.setFromEuler(this._rotation);
+            // // this._quat.invert();
+            // this._quat.x *= -1;
+            // // this._quat.y *= -1;
+            // // this._quat.z *= -1;
+            // this._quat.w *= -1;
+            // vector.applyQuaternion(this._quat);
+
         }
         return isRotated;
     }
@@ -624,8 +636,7 @@ export class ShapeModule implements EmitterShape {
             this.randomizePosition(this._vector, this.randomPositionAmount);
         }
 
-        if (this.updateRotation())
-            this._vector.applyEuler(this._rotation);
+        this.applyRotation(this._vector);
 
         if (isWorldSpace) {
             this._vector.applyQuaternion(this.system.worldQuaternion);
@@ -663,6 +674,8 @@ export class ShapeModule implements EmitterShape {
                 this._dir.set(rx, ry, rz)
                 if (this.system?.worldspace)
                     this._dir.sub(this.system.worldPos)
+                else
+                    this._dir.sub(this.position)
                 break;
             default:
                 this._dir.set(0, 0, 1);
@@ -671,8 +684,7 @@ export class ShapeModule implements EmitterShape {
         if (this._space === ParticleSystemSimulationSpace.World) {
             this._dir.applyQuaternion(this.system.worldQuaternion);
         }
-        if (this.updateRotation())
-            this._dir.applyEuler(this._rotation);
+        this.applyRotation(this._dir);
         this._dir.normalize();
         this.spherizeDirection(this._dir, this.sphericalDirectionAmount);
         this.randomizeDirection(this._dir, this.randomDirectionAmount);
@@ -982,11 +994,29 @@ export class VelocityOverLifetimeModule {
     @serializable()
     enabled!: boolean;
 
-    /* orbital settings */
+    @serializable()
+    space: ParticleSystemSimulationSpace = ParticleSystemSimulationSpace.Local;
 
+    @serializable(MinMaxCurve)
+    orbitalX!: MinMaxCurve;
+    @serializable(MinMaxCurve)
+    orbitalY!: MinMaxCurve;
+    @serializable(MinMaxCurve)
+    orbitalZ!: MinMaxCurve;
 
     @serializable()
-    space: ParticleSystemSimulationSpace = ParticleSystemSimulationSpace.Local;
+    orbitalXMultiplier!: number;
+    @serializable()
+    orbitalYMultiplier!: number;
+    @serializable()
+    orbitalZMultiplier!: number;
+
+    @serializable()
+    orbitalOffsetX!: number;
+    @serializable()
+    orbitalOffsetY!: number;
+    @serializable()
+    orbitalOffsetZ!: number;
 
     @serializable(MinMaxCurve)
     speedModifier!: MinMaxCurve;
@@ -1013,8 +1043,23 @@ export class VelocityOverLifetimeModule {
     }
 
     private _temp: Vector3 = new Vector3();
+    private _temp2: Vector3 = new Vector3();
+    private _temp3: Vector3 = new Vector3();
+    private _hasOrbital = false;
+    private _index = 0;
+    private _orbitalMatrix: Matrix4 = new Matrix4();
+
+    init(particle: object) {
+        if (this._index == 0) particle["debug"] = true;
+        this._index += 1;
+        particle["orbitx"] = this.orbitalX.evaluate(Math.random());
+        particle["orbity"] = this.orbitalY.evaluate(Math.random());
+        particle["orbitz"] = this.orbitalZ.evaluate(Math.random());
+        // console.log(particle["orbitx"], particle["orbity"], particle["orbitz"])
+        this._hasOrbital = particle["orbitx"] != 0 || particle["orbity"] != 0 || particle["orbitz"] != 0;
+    }
 
-    apply(_index: number, _pos: Vec3, vel: Vec3, _dt: number, age: number, life: number) {
+    apply(_particle: object, _index: number, _pos: Vec3, vel: Vec3, _dt: number, age: number, life: number) {
         if (!this.enabled) return;
         const t = age / life;
 
@@ -1024,13 +1069,51 @@ export class VelocityOverLifetimeModule {
         const z = this.z.evaluate(t);
         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);
+            // if (this.space === ParticleSystemSimulationSpace.World) {
+            //     this._temp.applyQuaternion(this._system.worldQuaternionInverted);
+            // }
+            // if (this._system.main.simulationSpace === ParticleSystemSimulationSpace.World) {
+            //     this._temp.applyQuaternion(this._system.worldQuaternion);
+            // }
+        }
+
+        if (this._hasOrbital) {
+            const position = this._system?.worldPos;
+            if (position) {
+
+                // TODO: we absolutely need to fix this, this is a hack for a specific usecase and doesnt work yet correctly
+                // https://github.com/needle-tools/needle-tiny/issues/710
+
+                const pos = this._temp2.set(_pos.x, _pos.y, _pos.z);
+
+                const ox = this.orbitalXMultiplier;// particle["orbitx"];
+                const oy = this.orbitalYMultiplier;// particle["orbity"];
+                const oz = this.orbitalZMultiplier;// particle["orbitz"];
+                const angle = speed * Math.PI * 2 * 10; // < Oh god
+
+                const cosX = Math.cos(angle * ox);
+                const sinX = Math.sin(angle * ox);
+                const cosY = Math.cos(angle * oy);
+                const sinY = Math.sin(angle * oy);
+                const cosZ = Math.cos(angle * oz);
+                const sinZ = Math.sin(angle * oz);
+
+                const newX = pos.x * (cosY * cosZ) + pos.y * (cosY * sinZ) + pos.z * (-sinY);
+                const newY = pos.x * (sinX * sinY * cosZ - cosX * sinZ) + pos.y * (sinX * sinY * sinZ + cosX * cosZ) + pos.z * (sinX * cosY);
+                const newZ = pos.x * (cosX * sinY * cosZ + sinX * sinZ) + pos.y * (cosX * sinY * sinZ - sinX * cosZ) + pos.z * (cosX * cosY);
+
+                // pos.x += this.orbitalOffsetX;
+                // pos.y += this.orbitalOffsetY;
+                // pos.z += this.orbitalOffsetZ;
+                const v = this._temp3.set(pos.x - newX, pos.y - newY, pos.z - newZ);
+                v.normalize();
+                v.multiplyScalar(.2 / _dt * (Math.max(this.orbitalXMultiplier, this.orbitalYMultiplier, this.orbitalZMultiplier)));
+                vel.x += v.x;
+                vel.y += v.y;
+                vel.z += v.z;
             }
         }
+
         vel.x += this._temp.x;
         vel.y += this._temp.y;
         vel.z += this._temp.z;

package/src/engine-components/SceneSwitcher.ts

@@ -47,14 +47,16 @@ export class SceneSwitcher extends Behaviour {
     private _currentScene: AssetReference | undefined = undefined;
     private _engineElementOverserver: MutationObserver | undefined = undefined;
 
-    start() {
-        if (!this.tryLoadFromQueryParam()) {
+    async start() {
+        if (this._currentIndex === -1 && !await this.tryLoadFromQueryParam()) {
             const value = this.context.domElement.getAttribute(ENGINE_ELEMENT_SCENE_ATTRIBUTE_NAME);
             // let locked = this.lock;
             try {
                 // this.lock = false;
-                if (value === null || !this.trySelectSceneFromValue(value))
-                    this.select(0);
+                if (value === null || !await this.trySelectSceneFromValue(value)) {
+                    if (this._currentIndex === -1)
+                        this.select(0);
+                }
             }
             finally {
                 // this.lock = locked;
@@ -202,10 +204,10 @@ export class SceneSwitcher extends Behaviour {
     }
 
     private tryLoadFromQueryParam() {
-        if (!this.queryParameterName?.length) return false;
+        if (!this.queryParameterName?.length) return couldNotLoadScenePromise;
         // try restore the scene from the url
         const value = getParam(this.queryParameterName);
-        if (typeof value === "boolean") return false;
+        if (typeof value === "boolean") return couldNotLoadScenePromise;
         return this.trySelectSceneFromValue(value);
     }
 
@@ -233,7 +235,7 @@ export class SceneSwitcher extends Behaviour {
             }
         }
 
-        if (isLocalNetwork()) console.warn("Unknown scene value or index: \"" + value + "\"", this)
+        if (isLocalNetwork()) console.warn("Can not find scene: \"" + value + "\"", this)
 
         return couldNotLoadScenePromise;
     }

package/src/engine-components/SpriteRenderer.ts

@@ -217,6 +217,10 @@ export class SpriteRenderer extends Behaviour {
                 this.gameObject.add(this._currentSprite);
         }
 
+        if(this._currentSprite){
+            this._currentSprite.layers.set(this.layer)
+        }
+
         this._spriteSheet?.update();
     }
 }

package/src/engine-components/VideoPlayer.ts

@@ -424,7 +424,7 @@ export class VideoPlayer extends Behaviour {
         this._videoElement.playbackRate = this._playbackSpeed;
         // dont open in fullscreen on ios
         this._videoElement.playsInline = true;
-        let muted = !this._receivedInput && this.audioOutputMode !== VideoAudioOutputMode.None;
+        let muted = !this._receivedInput || this.audioOutputMode === VideoAudioOutputMode.None;
         if (!muted && this._muted) muted = true;
         this._videoElement.muted = muted;
         if (this.playOnAwake)