Needle Engine 3.10.6-beta

Changes between version 3.10.5-beta and 3.10.6-beta

src/engine-components/AnimationUtils.ts CHANGED Viewed

@@ -5,7 +5,33 @@
 import { Animation } from "./Animation";
 import { GameObject } from "./Component";
 import { PlayableDirector } from "./timeline/PlayableDirector";
+import { Object3D } from "three";
+const $objectAnimationKey = Symbol("objectIsAnimatedData");
+/** Internal method - This marks an object as being animated. Make sure to always call isAnimated=false if you stop animating the object
+ * @param obj The object to mark
+ * @param isAnimated Whether the object is animated or not
+ */
+export function setObjectAnimated(obj: Object3D, isAnimated: boolean) {
+    if (obj[$objectAnimationKey] === undefined) {
+        if (!isAnimated) return;
+        obj[$objectAnimationKey] = 1;
+    }
+    else {
+        if (isAnimated)
+            obj[$objectAnimationKey] += 1;
+        else if (obj[$objectAnimationKey] > 0)
+            obj[$objectAnimationKey] -= 1;
+    }
+}
+/** Get is the object is currently animated. Currently used by the Animator to check if a timeline animationtrack is actively animating an object */
+export function getObjectAnimated(obj: Object3D): boolean {
+    return obj[$objectAnimationKey] !== undefined && obj[$objectAnimationKey] > 0;
+}
 ContextRegistry.registerCallback(ContextEvent.ContextCreated, args => {
     const autoplay = args.context.domElement.getAttribute("autoplay");
     if (autoplay !== undefined && (autoplay === "" || autoplay === "true")) {

src/engine-components/Animator.ts CHANGED Viewed

@@ -5,6 +5,7 @@
 import { AnimatorController } from "./AnimatorController";
 import { serializable } from "../engine/engine_serialization_decorator";
 import { Mathf } from "../engine/engine_math";
+import { getObjectAnimated } from "./AnimationUtils";
 const debug = getParam("debuganimator");
@@ -102,7 +103,7 @@
     /**@deprecated use setTrigger */
     SetTrigger(name: string | number) { this.setTrigger(name); }
     setTrigger(name: string | number) {
-        if(debug) console.log("SetTrigger", name);
+        if (debug) console.log("SetTrigger", name);
         this.runtimeAnimatorController?.setTrigger(name);
     }
@@ -168,6 +169,8 @@
     }
     onBeforeRender() {
+        if (getObjectAnimated(this.gameObject)) return;
         if (this._animatorController) {
             this._animatorController.update();
         }

src/engine/engine_physics_rapier.ts CHANGED Viewed

@@ -24,7 +24,7 @@
 import { isDevEnvironment } from './debug/debug';
 const debugPhysics = getParam("debugphysics");
-const debugColliderPlacement = getParam("debugphysicscolliders");
+const debugColliderPlacement = getParam("debugcolliderplacement");
 const debugCollisions = getParam("debugcollisions");
 const showColliders = getParam("showcolliders");

src/engine/engine_scenelighting.ts CHANGED Viewed

@@ -49,6 +49,13 @@
     }
     private _timevec4: Vector4 = new Vector4();
+    /** Time data used for custom shaders
+     * x: time
+     * y: sin(time)
+     * z: cos(time)
+     * w: deltaTime
+     */
     get timeVec4(): Vector4 {
         return this._timevec4;
     }

src/engine/engine_serialization_builtin_serializer.ts CHANGED Viewed

@@ -74,6 +74,11 @@
     onDeserialize(data: ObjectData | string | null, context: SerializationContext) {
         if (typeof data === "string") {
+            if (data.endsWith(".glb") || data.endsWith(".gltf")) {
+                if (isDevEnvironment())
+                    showBalloonWarning("Detected wrong usage of @serializable with Object3D or GameObject. Instead you should use AssetReference here! Please see the console for details.");
+                console.warn("Wrong usage of @serializable detected:\n\nIt looks like you used @serializable(Object3D) or @serializable(GameObject) for a prefab or scene reference named \"" + context.path + "\" in your script \"" + context.target?.constructor?.name + "\". \nTo fix this replace it with @serializable(AssetReference). Make sure to replace the type with AssetReference too.\n\nIt should then look something like this:\n\n@serializable(AssetReference)\n" + context.path + "! : AssetReference;\n\0");
+            }
             // ACTUALLY: this is already handled by the extension_utils where we resolve json pointers recursively
             // if(data.startsWith("/nodes/")){
             //     const node = parseInt(data.substring("/nodes/".length));

src/engine/extensions/NEEDLE_techniques_webgl.ts CHANGED Viewed

@@ -212,9 +212,34 @@
         if (this.uniforms["_TimeParameters"]) {
             this.uniforms["_TimeParameters"].value = context.sceneLighting.timeVec4;
         }
-        else if (this.uniforms["_Time"]) {
-            this.uniforms["_Time"].value = context.sceneLighting.timeVec4;
+        if (this.uniforms["_Time"]) {
+            const _time = this.uniforms["_Time"].value as Vector4;
+            _time.x = context.sceneLighting.timeVec4.x / 20;
+            _time.y = context.sceneLighting.timeVec4.x;
+            _time.z = context.sceneLighting.timeVec4.x * 2;
+            _time.w = context.sceneLighting.timeVec4.x * 3;
         }
+        if (this.uniforms["_SinTime"]) {
+            const _time = this.uniforms["_SinTime"].value as Vector4;
+            _time.x = Math.sin(context.sceneLighting.timeVec4.x / 8);
+            _time.y = Math.sin(context.sceneLighting.timeVec4.x / 4);
+            _time.z = Math.sin(context.sceneLighting.timeVec4.x / 2);
+            _time.w = Math.sin(context.sceneLighting.timeVec4.x);
+        }
+        if (this.uniforms["_CosTime"]) {
+            const _time = this.uniforms["_CosTime"].value as Vector4;
+            _time.x = Math.cos(context.sceneLighting.timeVec4.x / 8);
+            _time.y = Math.cos(context.sceneLighting.timeVec4.x / 4);
+            _time.z = Math.cos(context.sceneLighting.timeVec4.x / 2);
+            _time.w = Math.cos(context.sceneLighting.timeVec4.x);
+        }
+        if (this.uniforms["unity_DeltaTime"]) {
+            const _time = this.uniforms["unity_DeltaTime"].value as Vector4;
+            _time.x = context.time.deltaTime;
+            _time.y = 1 / context.time.deltaTime;
+            _time.z = context.time.smoothedDeltaTime;
+            _time.w = 1 / context.time.smoothedDeltaTime;
+        }
         const mainLight: ILight | null = context.mainLight;
         if (mainLight) {
@@ -340,9 +365,17 @@
             const uniforms: {} = {};
             const techniqueUniforms = technique.uniforms;
-            if (vert.includes("_Time"))
+            // BiRP time uniforms
+            if (vert.includes("_Time") || frag.includes("_Time"))
                 uniforms["_Time"] = { value: new Vector4(0, 0, 0, 0) };
+            if (vert.includes("_SinTime") || frag.includes("_SinTime"))
+                uniforms["_SinTime"] = { value: new Vector4(0, 0, 0, 0) };
+            if (vert.includes("_CosTime") || frag.includes("_CosTime"))
+                uniforms["_CosTime"] = { value: new Vector4(0, 0, 0, 0) };
+            if (vert.includes("unity_DeltaTime") || frag.includes("unity_DeltaTime"))
+                uniforms["unity_DeltaTime"] = { value: new Vector4(0, 0, 0, 0) };
             for (const u in techniqueUniforms) {
                 const uniformName = u;
                 // const uniformValues = techniqueUniforms[u];

@@ -1,6 +1,6 @@
 import { Behaviour, GameObject } from "./Component";
 import * as THREE from "three";
-import { MainModule, EmissionModule, ShapeModule, ParticleSystemShapeType, MinMaxCurve, MinMaxGradient, ColorOverLifetimeModule, SizeOverLifetimeModule, NoiseModule, ParticleSystemSimulationSpace, ParticleBurst, IParticleSystem, ParticleSystemRenderMode, TrailModule, VelocityOverLifetimeModule, TextureSheetAnimationModule, RotationOverLifetimeModule, LimitVelocityOverLifetimeModule, RotationBySpeedModule, InheritVelocityModule, SizeBySpeedModule, ColorBySpeedModule } from "./ParticleSystemModules"
+import { MainModule, EmissionModule, ShapeModule, ParticleSystemShapeType, MinMaxCurve, MinMaxGradient, ColorOverLifetimeModule, SizeOverLifetimeModule, NoiseModule, ParticleSystemSimulationSpace, ParticleBurst, IParticleSystem, ParticleSystemRenderMode, TrailModule, VelocityOverLifetimeModule, TextureSheetAnimationModule, RotationOverLifetimeModule, LimitVelocityOverLifetimeModule, RotationBySpeedModule, InheritVelocityModule, SizeBySpeedModule, ColorBySpeedModule, ParticleSystemScalingMode } from "./ParticleSystemModules"
 import { getParam } from "../engine/engine_utils";
 // https://github.dev/creativelifeform/three-nebula
@@ -18,7 +18,7 @@
 import { ParticleSubEmitter } from "./ParticleSystemSubEmitter";
 import { NEEDLE_progressive } from "../engine/extensions/NEEDLE_progressive";
 import { Gizmos } from "../engine/engine_gizmos";
-import { isDevEnvironment } from "../engine/debug";
+import { isDevEnvironment, showBalloonWarning } from "../engine/debug";
 const debug = getParam("debugparticles");
 const suppressProgressiveLoading = getParam("noprogressive");
@@ -327,6 +327,7 @@
 }
 const $sizeLerpFactor = Symbol("sizeLerpFactor");
+const localScaleVec3 = new Vector3();
 class SizeBehaviour extends ParticleSystemBaseBehaviour {
     type: string = "NeedleSize";
@@ -347,6 +348,10 @@
             size *= this.system.sizeOverLifetime.evaluate(age01, undefined, particle[$sizeLerpFactor]).x;
         const scaleFactor = this.system.worldScale.x / this.system.cameraScale;
         particle.size = particle.startSize * size * scaleFactor;
+        if (this.system.localspace) {
+            const scale = getLocalSimulationScale(this.system, localScaleVec3);
+            particle.size *= scale.x;
+        }
         // in Unity this is viewport size, we don't really support this yet (and the renderer is logging a warning)
         // so for now it's disabled again
         // particle.size = Mathf.clamp(particle.size, this._minSize, this._maxSize);
@@ -770,6 +775,9 @@
     get worldspace() {
         return this.main.simulationSpace === ParticleSystemSimulationSpace.World;
     }
+    get localspace() {
+        return this.main.simulationSpace === ParticleSystemSimulationSpace.Local;
+    }
     private __worldQuaternion = new Quaternion();
     get worldQuaternion(): Quaternion {
@@ -999,11 +1007,7 @@
         // Handle LOCALSPACE
         if (isLocalSpace && this._container && this.gameObject?.parent) {
-            // TODO: there's probably a more efficient way to do this
-            const scale = getWorldScale(this.gameObject.parent);
-            scale.x = 1 / scale.x;
-            scale.y = 1 / scale.y;
-            scale.z = 1 / scale.z;
+            const scale = getLocalSimulationScale(this, temp3);
             this._container.matrix.makeScale(scale.x, scale.y, scale.z);
             this._container.matrix.makeRotationFromQuaternion(this.__worldQuaternion);
             this._container.matrix.setPosition(this.worldPos);
@@ -1063,4 +1067,30 @@
             console.warn("Could not find particle system for sub emitter", guid, gameObject, this);
         }
     }
+}
+function getLocalSimulationScale(system: ParticleSystem, vec: Vector3) {
+    vec.set(1, 1, 1);
+    if (system.gameObject.parent && system.localspace) {
+        switch (system.main.scalingMode) {
+            case ParticleSystemScalingMode.Local:
+                vec = getWorldScale(system.gameObject.parent, vec);
+                vec.x = 1 / vec.x;
+                vec.y = 1 / vec.y;
+                vec.z = 1 / vec.z;
+                break;
+            default:
+                if (!system["unsupported_scaling_mode"]) {
+                    system["unsupported_scaling_mode"] = true;
+                    const msg = "ParticleSystem scale mode " + ParticleSystemScalingMode[system.main.scalingMode] + " is not supported";
+                    if (isDevEnvironment())
+                        showBalloonWarning(msg);
+                    console.warn(msg, system.name, system);
+                }
+                vec = getWorldScale(system.gameObject, vec);
+                break;
+        }
+    }
+    return vec;
 }

src/engine-components/ParticleSystemModules.ts CHANGED Viewed

@@ -270,10 +270,10 @@
     }
 }
-declare type ParticleSystemScalingMode = {
-    Hierarchy: number;
-    Local: number;
-    Shape: number;
+export enum ParticleSystemScalingMode {
+    Hierarchy = 0,
+    Local = 1,
+    Shape = 2,
 }
 export class MainModule {

src/engine-components/timeline/PlayableDirector.ts CHANGED Viewed

@@ -110,6 +110,9 @@
         for (const track of this._customTracks) {
             track.onEnable?.();
         }
+        for (const track of this._animationTracks) {
+            track.onEnable?.();
+        }
         if (this.playOnAwake) {
             this.play();
         }
@@ -135,6 +138,9 @@
         for (const track of this._customTracks) {
             track.onDisable?.();
         }
+        for (const track of this._animationTracks) {
+            track.onDisable?.();
+        }
         if (this._visibilityChangeEvt)
             window.removeEventListener('visibilitychange', this._visibilityChangeEvt);
     }
@@ -296,6 +302,12 @@
             if (track.muted) continue;
             switch (track.type) {
                 case Models.TrackType.Activation:
+                    // when the timeline is being disabled or stopped
+                    // then we want to leave objects active state as they were
+                    // see NE-3241
+                    // TODO: support all "post-playback-state" settings an activation track has, this is just "Leave as is"
+                    if (!this._isPlaying) continue;
                     for (let i = 0; i < track.outputs.length; i++) {
                         const binding = track.outputs[i];
                         if (typeof binding === "object") {
@@ -306,8 +318,13 @@
                                 }
                             }
                             const obj = binding as THREE.Object3D;
-                            if (obj.visible !== undefined)
-                                obj.visible = isActive;
+                            if (obj.visible !== undefined) {
+                                if (obj.visible !== isActive) {
+                                    obj.visible = isActive;
+                                    if (debug)
+                                        console.warn(this.name, "set ActivationTrack-" + i, obj.name, isActive, time);
+                                }
+                            }
                         }
                     }
                     break;

src/engine-components/timeline/TimelineTracks.ts CHANGED Viewed

@@ -8,6 +8,7 @@
 import { getParam, resolveUrl } from "../../engine/engine_utils";
 import { AudioSource } from "../AudioSource";
 import { Animator } from "../Animator"
+import { setObjectAnimated } from "../AnimationUtils";
 const debug = getParam("debugtimeline");
@@ -140,16 +141,23 @@
     private _actionOffsets: Array<AnimationClipOffsetData> = [];
     private _didBind: boolean = false;
     private _animator: Animator | null = null;
-    private _animatorWasEnabled?: boolean = false;
     onPauseChanged() {
-        // When the timeline is paused the original animator will be enabled again if it was before
-        if (this._animator && this._animatorWasEnabled !== undefined) {
-            this._animator.enabled = this.director.isPlaying === false ? this._animatorWasEnabled : false;
-        }
+        if (this._animator)
+            setObjectAnimated(this._animator.gameObject, this.director.isPaused);
     }
+    onEnable() {
+        if (this._animator)
+            setObjectAnimated(this._animator.gameObject, true);
+    }
+    onDisable() {
+        if (this._animator)
+            setObjectAnimated(this._animator.gameObject, false);
+    }
     createHooks(clipModel: Models.AnimationClipModel, clip) {
         if (clip.tracks?.length <= 0) {
             console.warn("No tracks in AnimationClip", clip);
@@ -225,11 +233,6 @@
             // We need to disable the animator component in case it also animates
             // which overrides the timeline
             this._animator = GameObject.getComponent(this.target, Animator) ?? null;
-            if (this._animator) {
-                this._animatorWasEnabled = this._animator.enabled;
-                this._animator.enabled = false;
-            }
-            else this._animatorWasEnabled = false;
         }
         // Clip Offsets
@@ -285,7 +288,7 @@
         if (!this.mixer) return;
         this.bind();
-        if (this._animator && this.director.isPlaying && this.director.weight > 0) this._animator.enabled = false;
+        // if (this._animator && this.director.isPlaying && this.director.weight > 0) this._animator.enabled = false;
         this._totalOffsetPosition.set(0, 0, 0);
         this._totalOffsetRotation.set(0, 0, 0, 1);
@@ -731,6 +734,13 @@
     didTrigger: boolean[] = [];
     receivers: Array<SignalReceiver | null> = [];
+    // TODO: test when timeline signals are being reset in Unity
+    // onEnable() {
+    //     for (let i = 0; i < this.didTrigger?.length; i++) {
+    //         this.didTrigger[i] = false;
+    //     }
+    // }
     // private _lastTime: number = -1;
     evaluate(time: number) {
@@ -750,20 +760,21 @@
             if (model.retroActive) {
                 isActive = td <= 0.000001;
             }
-            // TODO: handle signal asset at time 0 (only trigger when time is 0)
-            // else if (model.time < .001) {
-            //     if (td <= 0.000001 && lastTime > time)
-            //         isActive = true;
-            // }
             else {
                 const abs = Math.abs(td);
-                if (abs >= .00001 && abs < estimatedFrameLengthWithPadding) {
+                // e.g. if the signal is at frame 0 and the timeline duration also 0 (no tracks, just a signal at frame 0)
+                if (abs === 0) {
                     isActive = true;
                 }
+                else if (abs >= .00001 && abs < estimatedFrameLengthWithPadding) {
+                    isActive = true;
+                }
             }
             // console.log(time, td, isActive);
             if (isActive) {
                 if (!wasTriggered) {
+                    if (debug)
+                        console.log("Trigger signal", time, model.time, model);
                     this.didTrigger[i] = true;
                     // If a signal doesnt have any explicit receivers it will invoke the signal globally
                     if (this.receivers?.length <= 0) {