@needle-tools/engine 4.16.6 → 4.16.7-beta.1

package/plugins/vite/build-pipeline.js

@@ -112,14 +112,14 @@ export async function needleBuildPipeline(command, config, userSettings) {
     }
 
     let shouldRun = false;
-    const productionArgument = process.argv.indexOf("--production");
-    if (productionArgument >= 0) {
+    // Check env var (set by Unity/Blender integrations) or CLI arg (for manual invocation)
+    if (process.env.NEEDLE_BUILD_PRODUCTION === "true" || process.argv.indexOf("--production") >= 0) {
         shouldRun = true;
     }
 
     if (!shouldRun) {
         if (command === "build") {
-            log("Skipping build pipeline because this is a development build.\n- Invoke with `--production` to run the build pipeline.\n- For example \"vite build -- --production\".");
+            log("Skipping build pipeline because this is a development build.\n- Invoke with `--production` to run the build pipeline.\n- For example \"vite build -- --production\" or set NEEDLE_BUILD_PRODUCTION=true.");
         }
         await new Promise((resolve, _) => setTimeout(resolve, 1000));
         return null;
@@ -387,12 +387,21 @@ async function invokeBuildPipeline(opts, options = {}) {
     else {
         // First check if the user passed in a specific version to use via the vite config
         let version = opts.buildPipeline?.version;
-        // If not then see if we have a commandline argument
+        let versionSource = version ? "vite" : "";
+        // If not, check env var (set by Unity/Blender integrations)
+        if (!version && process.env.NEEDLE_BUILD_PIPELINE_VERSION) {
+            version = process.env.NEEDLE_BUILD_PIPELINE_VERSION;
+            versionSource = "env";
+        }
+        // Fallback: check CLI arg for backwards compatibility
         if (!version) {
             for (let i = 0; i < process.argv.length; i++) {
                 if (process.argv[i] === "--build-pipeline-version" && i < process.argv.length - 1) {
                     const value = process.argv[i + 1]?.replace(/['"]+/g, '').trim();
-                    if (value) version = value;
+                    if (value) {
+                        version = value;
+                        versionSource = "arg";
+                    }
                     break;
                 }
             }
@@ -400,8 +409,9 @@ async function invokeBuildPipeline(opts, options = {}) {
         // Otherwise we default to the stable version on npm
         if (!version) version = "stable";
 
+        const versionInfo = versionSource ? `'${version}' (${versionSource})` : `'${version}'`;
         const cmd = `npx --yes @needle-tools/gltf-build-pipeline@${version} transform "${outputDirectory}" \"${tempOutputPath}\"`;
-        log(`Running compression locally using version '${version}'`);
+        log(`Running compression locally using version ${versionInfo}`);
         proc = exec(cmd, { env: commandEnv });
     }
     let pipelineSpinnerIndex = 0;

package/src/engine/xr/NeedleXRSession.ts

@@ -1017,6 +1017,8 @@ export class NeedleXRSession implements INeedleXRSession {
     private readonly _xr_update_scripts: INeedleXRSessionEventReceiver[] = [];
     /** scripts that are in the scene but inactive (e.g. disabled parent gameObject) */
     private readonly _inactive_scripts: INeedleXRSessionEventReceiver[] = [];
+    /** tracks scripts that have received onEnterXR — prevents spurious onLeaveXR calls */
+    private readonly _scripts_in_xr = new Set<INeedleXRSessionEventReceiver>();
     private readonly _controllerAdded: ControllerChangedEvt[];
     private readonly _controllerRemoved: ControllerChangedEvt[];
     private readonly _originalCameraWorldPosition?: Vector3 | null;
@@ -1295,8 +1297,10 @@ export class NeedleXRSession implements INeedleXRSession {
         // even if they might already be destroyed e.g. by the WebXR component (it destroys the default controller scripts)
         // they should still receive this callback to be properly cleaned up
         for (const listener of this._xr_scripts) {
+            this._scripts_in_xr.delete(listener);
             listener?.onLeaveXR?.({ xr: this });
         }
+        this._scripts_in_xr.clear();
 
         this.sync?.onExitXR(this);
 
@@ -1498,8 +1502,12 @@ export class NeedleXRSession implements INeedleXRSession {
         }
 
         //performance.mark('NeedleXRSession update scripts start');
-        // invoke update on all scripts
-        for (const script of this._xr_update_scripts) {
+        // check all XR scripts for destroyed or inactive state
+        // this must cover _xr_scripts (not just _xr_update_scripts) so that scripts
+        // without onUpdateXR are also detected as inactive when removed from the scene
+        // iterate backwards since markInactive/removeScript modifies the array
+        for (let i = this._xr_scripts.length - 1; i >= 0; i--) {
+            const script = this._xr_scripts[i];
             if (script.destroyed === true) {
                 this._script_to_remove.push(script);
                 continue;
@@ -1508,6 +1516,10 @@ export class NeedleXRSession implements INeedleXRSession {
                 this.markInactive(script);
                 continue;
             }
+        }
+        // invoke update on scripts that have onUpdateXR
+        for (const script of this._xr_update_scripts) {
+            if (script.destroyed || script.activeAndEnabled === false) continue;
             if (script.onUpdateXR) script.onUpdateXR(args);
         }
         //performance.mark('NeedleXRSession update scripts end');
@@ -1630,9 +1642,11 @@ export class NeedleXRSession implements INeedleXRSession {
                 const script = this._inactive_scripts[i];
                 if (script.activeAndEnabled) {
                     this._inactive_scripts.splice(i, 1);
-                    this.addScript(script);
-                    this.invokeCallback_EnterXR(script);
-                    for (const ctrl of this.controllers) this.invokeCallback_ControllerAdded(script, ctrl);
+                    // addScript returns false if already re-added (e.g. via new_scripts_xr processing)
+                    if (this.addScript(script)) {
+                        this.invokeCallback_EnterXR(script);
+                        for (const ctrl of this.controllers) this.invokeCallback_ControllerAdded(script, ctrl);
+                    }
                 }
             }
         }
@@ -1653,6 +1667,7 @@ export class NeedleXRSession implements INeedleXRSession {
     }
 
     private invokeCallback_EnterXR(script: INeedleXRSessionEventReceiver) {
+        this._scripts_in_xr.add(script);
         if (script.onEnterXR) {
             script.onEnterXR({ xr: this });
         }
@@ -1668,6 +1683,7 @@ export class NeedleXRSession implements INeedleXRSession {
         }
     }
     private invokeCallback_LeaveXR(script: INeedleXRSessionEventReceiver) {
+        if (!this._scripts_in_xr.delete(script)) return;
         if (script.onLeaveXR && !script.destroyed) {
             script.onLeaveXR({ xr: this });
         }

package/src/engine-components/ReflectionProbe.ts

@@ -286,6 +286,8 @@ export class ReflectionProbe extends Behaviour {
             const current = block.getOverride("envMap")?.value;
             if (current === this.texture) {
                 block.removeOveride("envMap");
+                block.removeOveride("envMapRotation");
+                block.removeOveride("envMapIntensity");
             }
         }
     }

package/src/engine-components/VideoPlayer.ts

@@ -428,6 +428,8 @@ export class VideoPlayer extends Behaviour {
         }
     }
 
+    private _playErrors: number = 0;
+
     /** start playing the video source */
     play() {
         if (!this._videoElement) this.create(false);
@@ -448,7 +450,8 @@ export class VideoPlayer extends Behaviour {
         if (debug) console.log("Video Play()", this.clip, this._videoElement, this.time);
         this._videoElement.currentTime = this.time;
         this._videoElement.play().catch(err => {
-            console.log(err);
+            if (this._playErrors++ < 10) console.error(err);
+            else if (this._playErrors === 10) console.error("Multiple errors playing video, further errors will be suppressed. Use 'debugvideo' param to see all errors.");
             // https://developer.chrome.com/blog/play-request-was-interrupted/
             if (debug)
                 console.error("Error playing video", err, "CODE=" + err.code, this.videoElement?.src, this);

package/src/engine-components/ui/Canvas.ts

@@ -4,7 +4,7 @@ import * as ThreeMeshUI from 'three-mesh-ui'
 import { Mathf } from "../../engine/engine_math.js";
 import { serializable } from "../../engine/engine_serialization_decorator.js";
 import { FrameEvent } from "../../engine/engine_setup.js";
-import { delayForFrames, getParam } from "../../engine/engine_utils.js";
+import { getParam } from "../../engine/engine_utils.js";
 import { type NeedleXREventArgs } from "../../engine/xr/api.js";
 import { Camera } from "../Camera.js";
 import { GameObject } from "../Component.js";
@@ -236,19 +236,13 @@ export class Canvas extends UIRootComponent implements ICanvas {
         }
     }
 
-    async onEnterXR(args: NeedleXREventArgs) {
+    onEnterXR(args: NeedleXREventArgs) {
         // workaround for https://linear.app/needle/issue/NE-4114
         if (this.screenspace) {
             if (args.xr.isVR || args.xr.isPassThrough) {
                 this.gameObject.visible = false;
             }
         }
-        else {
-            this.gameObject.visible = false;
-            await delayForFrames(1).then(()=>{
-                this.gameObject.visible = true;
-            });
-        }
     }
     onLeaveXR(args: NeedleXREventArgs): void {
         if (this.screenspace) {