@needle-tools/engine 2.63.3-pre → 2.63.3-pre.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/engine",
-    "version": "2.63.3-pre",
+    "version": "2.63.3-pre.1",
     "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",
@@ -26,6 +26,7 @@
         "src",
         "dist",
         "lib",
+        "plugins",
         "license-2447137e.js"
     ],
     "keywords": [

package/src/engine/engine_application.ts

@@ -3,13 +3,24 @@ import { Context } from "./engine_setup";
 export enum ApplicationEvents {
     Visible = "application-visible",
     Hidden = "application-hidden",
+    MuteChanged = "application-mutechanged",
 }
 
 export class Application extends EventTarget {
 
-    private context : Context;
+    private _mute: boolean = false;
+    /** audio muted? */
+    get muted() { return this._mute; }
+    /** set global audio mute */
+    set muted(value) {
+        if (value === this._mute) return;
+        this._mute = value;
+        this.dispatchEvent(new Event(ApplicationEvents.MuteChanged));
+    }
+
+    private context: Context;
 
-    public get hasFocus() : boolean {
+    public get hasFocus(): boolean {
         return document.hasFocus();
     }
 
@@ -19,7 +30,7 @@ export class Application extends EventTarget {
 
     private _isVisible: boolean = true;
 
-    constructor(context : Context) {
+    constructor(context: Context) {
         super();
         this.context = context;
         // console.log("APP");

package/src/engine/engine_serialization_builtin_serializer.ts

@@ -206,6 +206,8 @@ declare type EventListCall = {
     enabled?: boolean,
 }
 
+const $eventListDebugInfo = Symbol("eventListDebugInfo");
+
 class EventListSerializer extends TypeSerializer {
     constructor() {
         super([EventList]);
@@ -238,13 +240,18 @@ class EventListSerializer extends TypeSerializer {
                     const hasMethod = call.method?.length > 0;
                     if (target && hasMethod) {
                         const printWarningMethodNotFound = () => console.warn(`Could not find method ${call.method} on object ${target.name}`, target, typeof target[call.method]);
-                        if (typeof target[call.method] !== "function") {
+                        const method = target[call.method];
+                        if (typeof method !== "function") {
                             let foundMethod = false;
+                            let currentPrototype = target;
                             // test if the target method is actually a property setter
-                            // in which case we want to remove the leading set prefix and see if the method or property exists
-                            if (call.method.startsWith("set_") && call.method.length > 4) {
-                                call.method = call.method.substring(4);
-                                if (target[call.method] !== undefined) foundMethod = true;
+                            while (currentPrototype) {
+                                const desc = Object.getOwnPropertyDescriptor(currentPrototype, call.method);
+                                if (desc && (desc.writable === true || desc.set)) {
+                                    foundMethod = true;
+                                    break;
+                                }
+                                currentPrototype = Object.getPrototypeOf(currentPrototype);
                             }
                             if (!foundMethod && (isDevEnvironment() || debugExtension))
                                 printWarningMethodNotFound();
@@ -252,38 +259,23 @@ class EventListSerializer extends TypeSerializer {
                     }
                     let fn: CallInfo | undefined;
                     let args = call.argument;
+
+                    // This is the final method we pass to the call info (or undefined if the method couldnt be resolved)
+                    const eventMethod = hasMethod ? this.createEventMethod(target, call.method, args) : undefined;
+
                     if (call.argument !== undefined) {
                         if (typeof args === "object") {
                             args = objectSerializer.onDeserialize(call.argument, context);
                             if (!args) args = componentSerializer.onDeserialize(call.argument, context);
                         }
-                        fn = new CallInfo(hasMethod ? (...args) => invokeFunction(...args) : undefined, call.enabled);
+                        fn = new CallInfo(eventMethod, call.enabled);
                     }
                     else
-                        fn = new CallInfo(hasMethod ? (...args) => invokeFunction(...args) : undefined, call.enabled);
+                        fn = new CallInfo(eventMethod, call.enabled);
 
 
-                    // TODO: move this into the event list directly 
-                    // this scope should not stay in the serializer.
-                    // the event list should be able to modify the args that were set in unity if necessary
-                    // and pass them on to the component
-                    const invokeFunction = (...forwardedArgs) => {
-                        const method = target[call.method];
-
-                        if (typeof method === "function") {
-                            if (args !== undefined)
-                                method?.call(target, args);
-                            else // support invoking EventList with any number of arguments (if none were declared in unity)
-                                method?.call(target, ...forwardedArgs);
-                        }
-                        else // the target "method" can be a property too
-                        {
-                            target[call.method] = args;
-                        }
-                    };
-
                     if (!fn.method)
-                        fn["__debuginfo"] = context.object?.name;
+                        fn[$eventListDebugInfo] = context.object?.name;
                     if (!target || !fn.method) {
                         const debugInfo = context.object ? "Current object: " + context.object.name + ", " + context.object["guid"] : null;
                         if (!target)
@@ -307,6 +299,23 @@ class EventListSerializer extends TypeSerializer {
         }
         return undefined;
     }
+
+    private createEventMethod(target : object, methodName: string, args?: any) : Function | undefined {
+        
+        return (...forwardedArgs) => {
+            const method = target[methodName];
+            if (typeof method === "function") {
+                if (args !== undefined)
+                    method?.call(target, args);
+                else // support invoking EventList with any number of arguments (if none were declared in unity)
+                    method?.call(target, ...forwardedArgs);
+            }
+            else // the target "method" can be a property too
+            {
+                target[methodName] = args;
+            }
+        };
+    }
 }
 export const eventListSerializer = new EventListSerializer();
 

package/src/engine/engine_serialization_core.ts

@@ -1,6 +1,6 @@
 import { GLTF } from "three/examples/jsm/loaders/GLTFLoader";
 import { getParam } from "./engine_utils";
-import { Object3D } from "three";
+import { AnimationClip, Material, Mesh, Object3D, Texture } from "three";
 import { Context } from "./engine_setup";
 import { isPersistentAsset } from "./extensions/NEEDLE_persistent_assets";
 import { SourceIdentifier } from "./engine_types";
@@ -545,6 +545,13 @@ function deserializeObjectWithType(data: any, typeOrConstructor: Constructor<any
     else {
         // happens when exporting e.g. Animation component with only clip assigned (clips array is marked as serialized but it might be undefined if no clips are assigned in e.g. blender)
         if (data === undefined) return undefined;
+        if (data === null) {
+            // Dont implictly create instances for three types that are not assigned
+            // see: https://github.com/needle-tools/needle-tiny/issues/637
+            if (type === Material || type === Texture || type === Mesh || type === AnimationClip) {
+                return null;
+            }
+        }
         // the fallback - this assumes that the type has a constructor that accepts the serialized arguments
         // made originally with THREE.Vector3 in mind but SHOULD actually not be used/called anymore
         instance = new type(...setBuffer(data));

package/src/engine-components/AudioListener.ts

@@ -16,6 +16,7 @@ export class AudioListener extends Behaviour {
 
     awake() {
         AudioSource.registerWaitForAllowAudio(() => {
+            if (this.destroyed) return;
             const listener = this.listener;
             if (listener == null) return;
             // if the listener is already parented to some object d0nt change it

package/src/engine-components/AudioSource.ts

@@ -133,7 +133,7 @@ export class AudioSource extends Behaviour {
     get volume(): number { return this._volume; }
     set volume(val: number) {
         this._volume = val;
-        if (this.sound) {
+        if (this.sound && !this.context.application.muted) {
             if (debug) console.log(this.name, "audio set volume", val);
             this.sound.setVolume(val);
         }
@@ -167,7 +167,9 @@ export class AudioSource extends Behaviour {
 
     public get ShouldPlay(): boolean { return this.shouldPlay; }
 
-    private _focusCallback?: any;
+
+    private _focusCallback: any;
+    private _muteChangedCallback: any;
 
     awake() {
         this.audioLoader = new THREE.AudioLoader();
@@ -189,13 +191,22 @@ export class AudioSource extends Behaviour {
             if (this.enabled && this.playOnAwake && !this.isPlaying && AudioSource._userInteractionRegistered) {
                 this.play();
             }
-        };
+        }
+
+        this._muteChangedCallback = () => {
+            if (this.context.application.muted)
+                this.sound?.setVolume(0);
+            else
+                this.sound?.setVolume(this.volume);
+        }
 
         this.context.application.addEventListener(ApplicationEvents.Visible, this._focusCallback);
+        this.context.application.addEventListener(ApplicationEvents.MuteChanged, this._muteChangedCallback);
     }
 
     onDestroy() {
         this.context.application.removeEventListener(ApplicationEvents.Visible, this._focusCallback);
+        this.context.application.removeEventListener(ApplicationEvents.MuteChanged, this._muteChangedCallback);
     }
 
 
@@ -233,7 +244,8 @@ export class AudioSource extends Behaviour {
 
             sound.setBuffer(buffer);
             sound.loop = this._loop;
-            sound.setVolume(this.volume);
+            if(this.context.application.muted) sound.setVolume(0);
+            else sound.setVolume(this.volume);
             sound.autoplay = this.shouldPlay;
             // sound.setDistanceModel('linear');
             // sound.setRolloffFactor(1);
@@ -313,7 +325,9 @@ export class AudioSource extends Behaviour {
         if (debug)
             console.log("play", this.sound?.getVolume(), this.sound);
         if (this.sound && !this.sound.isPlaying) {
-            this.sound.play();
+            const muted = this.context.application.muted;
+            if(muted) this.sound.setVolume(0);
+            this.sound.play(muted ? .1 : 0);
         }
     }
 

package/src/engine-components/GridHelper.ts

@@ -6,7 +6,7 @@ import { Color, GridHelper as _GridHelper } from "three";
 export class GridHelper extends Behaviour {
 
     @serializable()
-    public isGizmo:boolean = false;
+    public isGizmo: boolean = false;
     @serializable(Color)
     private color0!: THREE.Color;
     @serializable(Color)
@@ -23,10 +23,18 @@ export class GridHelper extends Behaviour {
         const size = this.size;
         const divisions = this.divisions;
         if (!this.gridHelper) {
-            this.gridHelper = new _GridHelper(size, divisions, this.color0 ?? new Color(.4, .4, .4), this.color1 ?? new Color(.6,.6,.6));
+            this.gridHelper = new _GridHelper(size, divisions, this.color0 ?? new Color(.4, .4, .4), this.color1 ?? new Color(.6, .6, .6));
             if (this.offset !== undefined)
                 this.gridHelper.position.y += this.offset;
+        }
+        if (this.gridHelper)
             this.gameObject.add(this.gridHelper);
+    }
+
+    onDisable(): void {
+        if (this.gridHelper) {
+            this.gameObject.remove(this.gridHelper);
+            this.gridHelper = null;
         }
     }
 }

package/src/engine-components/WebARSessionRoot.ts

@@ -45,6 +45,7 @@ export class WebARSessionRoot extends Behaviour {
     private _placementPose: Matrix4 | null = null;
     private _isTouching: boolean = false;
     private _rigStartPose: Matrix4 | undefined | null = null;
+    private _gotFirstHitTestResult: boolean = false;
 
     onBegin(session: XRSession) {
         this._placementPose = null;
@@ -52,6 +53,7 @@ export class WebARSessionRoot extends Behaviour {
         this.gameObject.matrixAutoUpdate = false;
         this._startPose = this.gameObject.matrix.clone();
         this._rigStartPose = this.rig?.matrix.clone();
+        this._gotFirstHitTestResult = false;
         session.addEventListener('selectstart', this._selectStartFn);
         session.addEventListener('selectend', this._selectEndFn);
         // setTimeout(() => this.gameObject.visible = false, 1000); // TODO test on phone AR and Hololens if this was still needed
@@ -66,12 +68,24 @@ export class WebARSessionRoot extends Behaviour {
             this.rig.matrixAutoUpdate = true;
             this._initalMatrix.decompose(this.rig.position, this.rig.quaternion, this.rig.scale);
         }
+
+        // TODO this is duplicate to WebXR events AND engine events, would be better in one place
+        this.dispatchEvent(new CustomEvent('onBeginSession'));
     }
 
     onUpdate(rig: Object3D | null, _session: XRSession, pose: XRPose | null | undefined): boolean {
 
         if (pose && !this._placementPose) {
+
+            if (!this._gotFirstHitTestResult) {
+                this._gotFirstHitTestResult = true;
+                this.dispatchEvent(new CustomEvent('canPlaceSession', { detail: { pose: pose } }));
+            }
+
             if (this._isTouching) {
+                // callbacks
+                this.dispatchEvent(new CustomEvent('placedSession', { detail: { pose: pose } }));
+
                 if (this.webAR) this.webAR.setReticleActive(false);
                 this.placeAt(rig, new Matrix4().fromArray(pose.transform.matrix).invert());
                 return true;

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

@@ -13,11 +13,13 @@ export function apply(object: Object3D) {
 }
 
 
-
-// do we still need this?
 Object3D.prototype["SetActive"] = function (active: boolean) {
     this.visible = active;
 }
+// e.g. when called via a UnityEvent
+Object3D.prototype["setActive"] = function (active: boolean) {
+    this.visible = active;
+}
 
 Object3D.prototype["addNewComponent"] = function <T extends Component>(type: ConstructorConcrete<T>) {
     return addNewComponent(this, new type());

package/src/engine-components/timeline/TimelineTracks.ts

@@ -524,6 +524,11 @@ export class AudioTrackHandler extends TrackHandler {
     evaluate(time: number) {
         if (muteAudioTracks) return;
         if (this.track.muted) return;
+        const isMuted = this.director.context.application.muted;
+        // this is just so that we dont hear the very first beat when the audio starts but is muted
+        // if we dont add a delay we hear a little bit of the audio before it shuts down
+        // MAYBE instead of doing it like this we should connect a custom audio node (or disconnect the output node?)
+        const playTimeOffset = isMuted ? .1 : 0;
         for (let i = 0; i < this.models.length; i++) {
             const model = this.models[i];
             const audio = this.audio[i];
@@ -535,7 +540,7 @@ export class AudioTrackHandler extends TrackHandler {
                 }
                 else if (!audio.isPlaying) {
                     audio.offset = model.clipIn + (time - model.start) * model.timeScale;
-                    audio.play();
+                    audio.play(playTimeOffset);
                 }
                 else {
                     const targetOffset = model.clipIn + (time - model.start) * model.timeScale;
@@ -547,10 +552,11 @@ export class AudioTrackHandler extends TrackHandler {
                     if (diff > 0.3) {
                         audio.offset = targetOffset;
                         audio.stop();
-                        audio.play();
+                        audio.play(playTimeOffset);
                     }
                 }
-                let vol = model.asset.volume;
+                let vol = model.asset.volume as number;
+                if(isMuted) vol = 0;
                 if (model.easeInDuration > 0) {
                     const easeIn = Math.min((time - model.start) / model.easeInDuration, 1);
                     vol *= easeIn;

package/src/tsconfig.json

@@ -0,0 +1,33 @@
+{
+  "compilerOptions": {   
+    "target": "ESNext", 
+    "module": "ESNext",
+    "outDir": "dist",
+    "useDefineForClassFields": true,
+    "lib": ["ESNext", "DOM"],
+    "moduleResolution": "Node",
+    "strict": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "noEmit": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noImplicitAny": false,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "experimentalDecorators": true,
+    "skipLibCheck": true,
+    "allowJs": true,
+    "types": [
+      "three",
+      "vite/client"
+    ]
+  },
+  "include": [
+    "**/*.ts"
+  ],
+  "exclude": ["node_modules", "dist"]
+}