Needle Engine 3.32.13-alpha

Files changed (9) hide show

src/engine-components/AudioSource.ts +86 -32
src/engine-components/Collider.ts +6 -0
src/engine-components/Component.ts +2 -2
src/engine/engine_gameobject.ts +3 -7
src/engine/engine_physics_rapier.ts +5 -3
src/engine/xr/NeedleXRController.ts +1 -1
src/engine-components/RigidBody.ts +8 -0
src/engine-components/VideoPlayer.ts +5 -3
src/engine-components/webxr/WebXRImageTracking.ts +1 -1

src/engine-components/AudioSource.ts CHANGED Viewed

@@ -1,9 +1,11 @@
-import { Audio, AudioContext, AudioLoader, PositionalAudio } from "three";
+import { Audio, AudioContext, AudioLoader, PositionalAudio, Vector3 } from "three";
 import { PositionalAudioHelper } from 'three/examples/jsm/helpers/PositionalAudioHelper.js';
 import { isDevEnvironment } from "../engine/debug/index.js";
 import { ApplicationEvents } from "../engine/engine_application.js";
+import { Mathf } from "../engine/engine_math.js";
 import { serializable } from "../engine/engine_serialization_decorator.js";
+import { getTempVector } from "../engine/engine_three_utils.js";
 import * as utils from "../engine/engine_utils.js";
 import { AudioListener } from "./AudioListener.js";
 import { Behaviour, GameObject } from "./Component.js";
@@ -66,6 +68,9 @@
     playOnAwake: boolean = false;
     @serializable()
+    preload: boolean = false;
+    @serializable()
     get loop(): boolean {
         if (this.sound) this._loop = this.sound.getLoop();
         return this._loop;
@@ -142,19 +147,62 @@
             if (listener?.listener) {
                 this.sound = new PositionalAudio(listener.listener);
                 this.gameObject?.add(this.sound);
+                // this._listener = listener;
+                // this._originalSoundMatrixWorldFunction = this.sound.updateMatrixWorld;
+                // this.sound.updateMatrixWorld = this._onSoundMatrixWorld;
             }
             else if (debug) console.warn("No audio listener found in scene - can not play audio");
         }
         return this.sound;
     }
+    // This is a hacky workaround to get the PositionalAudio behave like a 2D audio source
+    // private _listener: AudioListener | null = null;
+    // private _originalSoundMatrixWorldFunction: Function | null = null;
+    // private _onSoundMatrixWorld = (force: boolean) => {
+    //     if (this._spatialBlend > .05) {
+    //         if (this._originalSoundMatrixWorldFunction) {
+    //             this._originalSoundMatrixWorldFunction.call(this.sound, force);
+    //         }
+    //     }
+    //     else {
+    //         // we use another object's matrix world function (but bound to the positional audio)
+    //         // this is just a little trick to prevent calling the PositionalAudio's updateMatrixWorld function
+    //         this.gameObject.updateMatrixWorld?.call(this.sound, force);
+    //         if (this.sound && this._listener) {
+    //             this.sound.gain.connect(this._listener.listener.getInput());
+    //             // const pos = getTempVector().setFromMatrixPosition(this._listener.gameObject.matrixWorld);
+    //             // const ctx = this.sound.context;
+    //             // const delay = this._listener.listener.timeDelta;
+    //             // const time = ctx.currentTime ;
+    //             // this.sound.panner.positionX.setValueAtTime(pos.x, time);
+    //             // this.sound.panner.positionY.setValueAtTime(pos.y, time);
+    //             // this.sound.panner.positionZ.setValueAtTime(pos.z, time);
+    //             // this.sound.panner.orientationX.setValueAtTime(0, time);
+    //             // this.sound.panner.orientationY.setValueAtTime(0, time);
+    //             // this.sound.panner.orientationZ.setValueAtTime(-1, time);
+    //         }
+    //     }
+    // }
     public get ShouldPlay(): boolean { return this.shouldPlay; }
+    /** Get the audio context from the Sound */
+    public get audioContext() {
+        return this.sound?.context;
+    }
     awake() {
-        if(debug) console.log(this);
+        if (debug) console.log(this);
         this.audioLoader = new AudioLoader();
         if (this.playOnAwake) this.shouldPlay = true;
+        if (this.preload) {
+            if (typeof this.clip === "string") {
+                this.audioLoader.load(this.clip, this.createAudio, () => { }, console.error);
+            }
+        }
     }
     onEnable(): void {
@@ -206,50 +254,56 @@
             this.sound?.setVolume(this.volume);
     }
-    private lerp = (x, y, a) => x * (1 - a) + y * a;
     private createAudio = (buffer?: AudioBuffer) => {
-        if (debug) console.log("audio buffer loaded");
-        AudioSource.registerWaitForAllowAudio(() => {
-            if (debug)
-                console.log("finished loading", buffer);
+        if (debug) console.log("AudioBuffer finished loading", buffer);
-            const sound = this.Sound;
-            if (!sound) {
-                console.warn("Failed getting sound", this.name);
-                return;
-            }
-            if (sound.isPlaying)
-                sound.stop();
+        const sound = this.Sound;
+        if (!sound) {
+            if (debug) console.warn("Failed getting sound?", this.name);
+            return;
+        }
-            if (buffer)
-                sound.setBuffer(buffer);
-            sound.loop = this._loop;
-            if (this.context.application.muted) sound.setVolume(0);
-            else sound.setVolume(this.volume);
-            sound.autoplay = this.shouldPlay;
-            // sound.setDistanceModel('linear');
-            // sound.setRolloffFactor(1);
-            this.applySpatialDistanceSettings();
-            // sound.setDirectionalCone(180, 360, 0.1);
-            if (sound.isPlaying)
-                sound.stop();
+        if (sound.isPlaying)
+            sound.stop();
-            if (debug) console.log(this.name, this.shouldPlay, AudioSource.userInteractionRegistered, this);
+        if (buffer) sound.setBuffer(buffer);
+        sound.loop = this._loop;
+        if (this.context.application.muted) sound.setVolume(0);
+        else sound.setVolume(this.volume);
+        sound.autoplay = this.shouldPlay && AudioSource.userInteractionRegistered;
-            if (this.shouldPlay && AudioSource.userInteractionRegistered)
-                this.play();
-        });
+        this.applySpatialDistanceSettings();
+        if (sound.isPlaying)
+            sound.stop();
+        // const src = sound.context.createBufferSource();
+        // src.buffer = sound.buffer;
+        // src.connect(sound.panner);
+        // src.start(this.audioContext?.currentTime);
+        // const gain = sound.context.createGain();
+        // gain.gain.value = 1 - this.spatialBlend;
+        // src.connect(gain);
+        // make sure we only play the sound if the user has interacted with the page
+        AudioSource.registerWaitForAllowAudio(this.__onAllowAudioCallback);
     }
+    private __onAllowAudioCallback = () => {
+        if (this.shouldPlay)
+            this.play();
+    }
     private applySpatialDistanceSettings() {
         const sound = this.sound;
         if (!sound) return;
         this._needUpdateSpatialDistanceSettings = false;
-        const dist = this.lerp(10 * this._maxDistance / Math.max(0.0001, this.spatialBlend), this._minDistance, this.spatialBlend);
+        const dist = Mathf.lerp(10 * this._maxDistance / Math.max(0.0001, this.spatialBlend), this._minDistance, this.spatialBlend);
         if (debug) console.log(this.name, this._minDistance, this._maxDistance, this.spatialBlend, "Ref distance=" + dist);
         sound.setRefDistance(dist);
         sound.setMaxDistance(Math.max(0.01, this._maxDistance));
+        // sound.setRolloffFactor(this.spatialBlend);
+        // sound.panner.positionZ.automationRate
         // https://developer.mozilla.org/en-US/docs/Web/API/PannerNode/distanceModel
         switch (this.rollOffMode) {
             case AudioRolloffMode.Logarithmic:

src/engine-components/Collider.ts CHANGED Viewed

@@ -106,8 +106,14 @@
     onEnable() {
         super.onEnable();
         this.context.physics.engine?.addBoxCollider(this, this.size);
+        watchWrite(this.gameObject.scale, this.updateProperties);
     }
+    onDisable(): void {
+        super.onDisable();
+        unwatchWrite(this.gameObject.scale, this.updateProperties);
+    }
     onValidate(): void {
         this.updateProperties();
     }

src/engine-components/Component.ts CHANGED Viewed

@@ -83,8 +83,8 @@
      * @param instance object to instantiate
      * @param opts options for the instantiation (e.g. with what parent, position, etc.)
     */
-    public static instantiate(instance: GameObject | Object3D | null, opts: IInstantiateOptions | null = null): GameObject | null {
-        return instantiate(instance, opts) as GameObject | null;
+    public static instantiate(instance: GameObject | Object3D, opts: IInstantiateOptions | null = null): GameObject {
+        return instantiate(instance, opts) as GameObject;
     }
     /** Destroys a object on all connected clients (if you are in a networked session)

src/engine/engine_gameobject.ts CHANGED Viewed

@@ -33,9 +33,11 @@
     idProvider?: UIDProvider;
     //** parent guid or object */
     parent?: string | Object3D;
+    /** position in local space. Set `keepWorldPosition` to true if this is world space */
     position?: Vector3;
     /** for duplicatable parenting */
     keepWorldPosition?: boolean;
+    /** rotation in local space. Set `keepWorldPosition` to true if this is world space */
     rotation?: Quaternion;
     scale?: Vector3;
     /** if the instantiated object should be visible */
@@ -279,9 +281,7 @@
     clone: Object3D;
 }
-export function instantiate(instance: GameObject | Object3D | null, opts: IInstantiateOptions | null = null): GameObject | null {
-    if (instance === null) return null;
+export function instantiate(instance: GameObject | Object3D, opts: IInstantiateOptions | null = null): GameObject {
     let options: InstantiateOptions | null = null;
     if (opts !== null) {
         // if x is defined assume this is a vec3 - this is just to not break everything at once and stay a little bit backwards compatible
@@ -292,10 +292,6 @@
         else {
             // if (opts instanceof InstantiateOptions)
             options = opts as InstantiateOptions;
-            // else {
-            //     options = new InstantiateOptions();
-            //     Object.assign(options, opts);
-            // }
         }
     }

src/engine/engine_physics_rapier.ts CHANGED Viewed

@@ -898,9 +898,11 @@
             case ShapeType.Cuboid:
                 const cuboid = shape as Cuboid;
                 const sc = col as IBoxCollider;
-                const newX = sc.size.x * 0.5;
-                const newY = sc.size.y * 0.5;
-                const newZ = sc.size.z * 0.5;
+                const obj = col.gameObject;
+                const scale = getWorldScale(obj, this._tempPosition);
+                const newX = sc.size.x * 0.5 * scale.x;
+                const newY = sc.size.y * 0.5 * scale.y;
+                const newZ = sc.size.z * 0.5 * scale.z;
                 sizeHasChanged = cuboid.halfExtents.x !== newX || cuboid.halfExtents.y !== newY || cuboid.halfExtents.z !== newZ;
                 cuboid.halfExtents.x = newX;
                 cuboid.halfExtents.y = newY;

src/engine/xr/NeedleXRController.ts CHANGED Viewed

@@ -189,7 +189,7 @@
     /** returns the URL of the default controller model */
     async getModelUrl(): Promise<string | null> {
-        return this.getMotionController?.then(res => res.assetUrl || null);
+        return this.getMotionController?.then(res => res?.assetUrl || null);
     }
     constructor(session: NeedleXRSession, device: XRInputSource, index: number) {

src/engine-components/RigidBody.ts CHANGED Viewed

@@ -362,10 +362,17 @@
         return this.context.physics.engine?.isSleeping(this);
     }
+    /** Call to force an update of the rigidbody properties in the physics engine */
+    public updateProperties() {
+        this._propertiesChanged = false;
+        return this.context.physics.engine?.updateProperties(this);
+    }
     /** Forces affect the rigid-body's acceleration whereas impulses affect the rigid-body's velocity
      * the acceleration change is equal to the force divided by the mass:
      * @link see https://rapier.rs/docs/user_guides/javascript/rigid_bodies#forces-and-impulses */
     public applyForce(vec: Vector3 | Vec3, _rel?: THREE.Vector3, wakeup: boolean = true) {
+        if (this._propertiesChanged) this.updateProperties();
         this.context.physics.engine?.addForce(this, vec, wakeup);
     }
@@ -373,6 +380,7 @@
      * the velocity change is equal to the impulse divided by the mass
      * @link see https://rapier.rs/docs/user_guides/javascript/rigid_bodies#forces-and-impulses */
     public applyImpulse(vec: Vector3 | Vec3, wakeup: boolean = true) {
+        if (this._propertiesChanged) this.updateProperties();
         this.context.physics.engine?.applyImpulse(this, vec, wakeup);
     }

src/engine-components/VideoPlayer.ts CHANGED Viewed

@@ -185,11 +185,13 @@
     private _isPlaying: boolean = false;
     private wasPlaying: boolean = false;
-    /** ensure's the video elemnent has been created and will start loading the clip */
-    preload() {
+    /** ensure's the video element has been created and will start loading the clip */
+    preloadVideo() {
         if (debug) console.log("Video Preload: " + this.name, this.clip);
         this.create(false);
     }
+    /** @deprecated use `preloadVideo()` */
+    preload() { this.preloadVideo(); }
     /** Set a new video stream
      * starts to play automatically if the videoplayer hasnt been active before and playOnAwake is true */
@@ -235,7 +237,7 @@
             this.create(true);
         }
         else {
-            this.preload();
+            this.preloadVideo();
         }
         if (this.screenspace) {

src/engine-components/webxr/WebXRImageTracking.ts CHANGED Viewed

@@ -307,7 +307,7 @@
                 this.imageToObjectMap.set(model, trackedData);
                 model.object.loadAssetAsync().then((asset: GameObject | null) => {
-                    if (model.createObjectInstance) {
+                    if (model.createObjectInstance && asset) {
                         asset = GameObject.instantiate(asset);
                     }