@needle-tools/engine 4.4.0-ci.1 → 4.4.2

package/src/engine/engine_license.ts

@@ -11,7 +11,7 @@ const _licenseCheckResultChangedCallbacks: ((result: boolean) => void)[] = [];
 // This is modified by a bundler (e.g. vite)
 // Do not edit manually
 let NEEDLE_ENGINE_LICENSE_TYPE: string = "basic";
-if (debug) 
+if (debug)
     console.log("License Type: " + NEEDLE_ENGINE_LICENSE_TYPE)
 
 /** @internal */
@@ -33,15 +33,24 @@ export function hasIndieLicense() {
     return false;
 }
 
+/** @internal */
+export function hasEduLicense() {
+    switch (NEEDLE_ENGINE_LICENSE_TYPE) {
+        case "edu":
+            return true;
+    }
+    return false;
+}
+
 /** @internal */
 export function hasCommercialLicense() {
-    return hasProLicense() || hasIndieLicense();
+    return hasProLicense() || hasIndieLicense() || hasEduLicense();
 }
 
 
 /** @internal */
 export function onLicenseCheckResultChanged(cb: (result: boolean) => void) {
-    if (hasProLicense() || hasIndieLicense())
+    if (hasProLicense() || hasIndieLicense() || hasEduLicense())
         return cb(true);
     _licenseCheckResultChangedCallbacks.push(cb);
 }
@@ -85,14 +94,17 @@ async function checkLicense() {
                 invokeLicenseCheckResultChanged(true);
             }
             else if (res?.status === 403) {
+                invokeLicenseCheckResultChanged(false);
                 applicationIsForbidden = true;
                 applicationForbiddenText = await res.text();
             }
             else {
+                invokeLicenseCheckResultChanged(false);
                 if (debug) console.log("License check failed with status " + res?.status);
             }
         }
         catch (err) {
+            invokeLicenseCheckResultChanged(false);
             if (debug) console.error("License check failed", err);
         }
     }
@@ -167,7 +179,9 @@ async function handleForbidden(ctx: IContext) {
 
 async function showLicenseInfo(ctx: IContext) {
     try {
-        if (hasCommercialLicense() !== true) return onNonCommercialVersionDetected(ctx);
+        if (!hasProLicense() && !hasIndieLicense()) {
+            return onNonCommercialVersionDetected(ctx);
+        }
     }
     catch (err) {
         if (debug) console.log("License check failed", err)
@@ -179,85 +193,120 @@ async function showLicenseInfo(ctx: IContext) {
 
 
 async function onNonCommercialVersionDetected(ctx: IContext) {
+
     // if the engine loads faster than the license check, we need to capture the ready event here
     let isReady = false;
     ctx.domElement.addEventListener("ready", () => isReady = true);
 
     await runtimeLicenseCheckPromise?.catch(() => { });
-    if (hasCommercialLicense()) return;
-    logNonCommercialUse();
+
+
+    if (hasProLicense() || hasIndieLicense()) return;
+    if (hasCommercialLicense() === false) logNonCommercialUse();
 
     // check if the engine is already ready (meaning has finished loading)
-    // if (isReady) {
-    //     insertNonCommercialUseHint(ctx);
-    // }
-    // else {
-    //     ctx.domElement.addEventListener("ready", () => {
-    //         insertNonCommercialUseHint(ctx);
-    //     });
-    // }
+    if (isReady) {
+        insertNonCommercialUseHint(ctx);
+    }
+    else {
+        ctx.domElement.addEventListener("ready", () => {
+            insertNonCommercialUseHint(ctx);
+        });
+    }
 }
 
 // const licenseElementIdentifier = "needle-license-element";
 // const licenseDuration = 10000;
 // const licenseDelay = 1200;
-// function insertNonCommercialUseHint(ctx: IContext) {
-
-//     return;
-//     const banner = LicenseBanner.create();
-//     ctx.domElement.shadowRoot?.appendChild(banner);
-//     let bannerStyle = `
-//         position: absolute;
-//         bottom: 20px;
-//         right: 20px;
-//         opacity: 0;
-//         transform: translateY(10px);
-//         transition: all .5s ease-in-out 1s;
-//         pointer: cursor;
-//     `;
-//     banner.style.cssText = bannerStyle;
-//     let expectedBannerStyle = banner.style.cssText;
-//     setTimeout(() => {
-//         bannerStyle = bannerStyle.replace("opacity: 0", "opacity: 1");
-//         bannerStyle = bannerStyle.replace("transform: translateY(10px)", "transform: translateY(0)");
-//         banner.style.cssText = bannerStyle;
-//         expectedBannerStyle = banner.style.cssText;
-//     }, 100);
-
-//     // ensure the banner is always visible
-//     const interval = setInterval(() => {
-//         const parent = ctx.domElement.shadowRoot || ctx.domElement;
-//         if (banner.parentNode !== parent) {
-//             parent.appendChild(banner);
-//         }
-//         if (expectedBannerStyle != banner.style.cssText) {
-//             banner.style.cssText = bannerStyle;
-//             expectedBannerStyle = banner.style.cssText;
-//             showBalloonError("This website violates the Needle Engine License! Please contact hi@needle.tools");
-//         }
-//     }, 1000);
-
-//     if (hasIndieLicense()) {
-//         const removeDelay = licenseDuration + licenseDelay;
-//         setTimeout(() => {
-//             clearInterval(interval);
-//             banner?.remove();
-//             // show the logo every x minutes
-//             const intervalInMinutes = 5;
-//             setTimeout(() => {
-//                 if (ctx.domElement.parentNode)
-//                     insertNonCommercialUseHint(ctx);
-//             }, 1000 * 60 * intervalInMinutes)
-//         }, removeDelay);
-//     }
-
-// }
+function insertNonCommercialUseHint(ctx: IContext) {
+
+    const style = `
+        position: relative;
+        display: block;
+        background-size: 20px;
+        background-position: 10px 5px;
+        background-repeat:no-repeat;
+        background-image:url('${base64Logo}');
+        background-max-size: 40px;
+        padding: 10px;
+        padding-left: 30px;
+    `;
+    if (NEEDLE_ENGINE_LICENSE_TYPE === "edu") {
+        console.log("%c " + "Supported by Needle for Education – https://needle.tools", style);
+    }
+    else {
+        // if the user has a basic license we already show the logo in the menu and log a license message
+        return;
+    }
+
+    const banner = document.createElement("div");
+    banner.className = "needle-non-commercial-use";
+    banner.innerHTML = "Made with Needle for Education";
+    ctx.domElement.shadowRoot?.appendChild(banner);
+    let bannerStyle = `
+        position: absolute;
+        font-family: system-ui, Avenir, Helvetica, Arial, sans-serif;
+        font-size: 12px;
+        color: rgb(100, 100, 100);
+        /*mix-blend-mode: difference;*/
+        background-color: transparent;
+        z-index: 10000;
+
+        cursor: pointer;
+        user-select: none;
+        opacity: 0;
+
+        bottom: 6px;
+        right: 12px;
+        transform: translateY(0px);
+        transition: all .5s ease-in-out 1s;
+    `;
+    banner.style.cssText = bannerStyle;
+    banner.addEventListener("click", () => { window.open("https://needle.tools", "_blank") });
+    let expectedBannerStyle = banner.style.cssText;
+    setTimeout(() => {
+        bannerStyle = bannerStyle.replace("opacity: 0", "opacity: 1");
+        bannerStyle = bannerStyle.replace("transform: translateY(10px)", "transform: translateY(0)");
+        banner.style.cssText = bannerStyle;
+        expectedBannerStyle = banner.style.cssText;
+    }, 100);
+
+    // ensure the banner is always visible
+    const interval = setInterval(() => {
+        const parent = ctx.domElement.shadowRoot || ctx.domElement;
+        if (banner.parentNode !== parent) {
+            parent.appendChild(banner);
+        }
+        if (expectedBannerStyle != banner.style.cssText) {
+            banner.style.cssText = bannerStyle;
+            expectedBannerStyle = banner.style.cssText;
+        }
+    }, 1000);
+
+    if (hasEduLicense()) {
+        const removeDelay = 20_000;
+        setTimeout(() => {
+            clearInterval(interval);
+            banner?.remove();
+            // show the logo every x minutes
+            const intervalInMinutes = 5;
+            setTimeout(() => {
+                if (ctx.domElement.parentNode)
+                    insertNonCommercialUseHint(ctx);
+            }, 1000 * 60 * intervalInMinutes)
+        }, removeDelay);
+    }
+
+}
+
+
+const base64Logo = "data:image/webp;base64,UklGRrABAABXRUJQVlA4WAoAAAAQAAAAHwAAHwAAQUxQSKEAAAARN6CmbSM4WR7vdARON11EBDq3fLiNbVtVzpMCPlKAEzsx0Y/x+Ovuv4dn0EFE/ydAvz6YggXzgh5sVgXM/zOC/4sii7qgGvB5N7hmuQYwkvazWAu1JPW41FXSHq6pnaQWvqYH18Fc0j1hO/BFTtIeSBlJi5w6qIIO7IOrwhFsB2Yxukif0FTRLpXswHR8MxbslKe9VZsn/Ub5C7YFOpqSTABWUDgg6AAAAFAGAJ0BKiAAIAA+7VyoTqmkpCI3+qgBMB2JbACdMt69DwMIQBLhkTO6XwY00UEDK6cNIDnuNibPf0EgAP7Y1myuiQHLDsF/0h5unrGh6WAbv7aegg2ZMd3uRKfT/3SJztcaujYfTvMXspfCTmYcoO6a+vhC3ss4M8uM58t4siiu59I4aOl59e9Sr6xoxYlHf2v+NnBNpJYeJf8jABQAId/PXuBkLEFkiCucgSGEcfhvajql/j3reCGl0M5/9gQWy7ayNPs+wlvIxFnNfSlfuND4CZOCyxOHhRqOmHN4ULHo3tCSrUNvgAA=";
+
 let lastLogTime = 0;
 async function logNonCommercialUse(_logo?: string) {
     const now = Date.now();
     if (now - lastLogTime < 2000) return;
     lastLogTime = now;
-    const logo = "data:image/webp;base64,UklGRrABAABXRUJQVlA4WAoAAAAQAAAAHwAAHwAAQUxQSKEAAAARN6CmbSM4WR7vdARON11EBDq3fLiNbVtVzpMCPlKAEzsx0Y/x+Ovuv4dn0EFE/ydAvz6YggXzgh5sVgXM/zOC/4sii7qgGvB5N7hmuQYwkvazWAu1JPW41FXSHq6pnaQWvqYH18Fc0j1hO/BFTtIeSBlJi5w6qIIO7IOrwhFsB2Yxukif0FTRLpXswHR8MxbslKe9VZsn/Ub5C7YFOpqSTABWUDgg6AAAAFAGAJ0BKiAAIAA+7VyoTqmkpCI3+qgBMB2JbACdMt69DwMIQBLhkTO6XwY00UEDK6cNIDnuNibPf0EgAP7Y1myuiQHLDsF/0h5unrGh6WAbv7aegg2ZMd3uRKfT/3SJztcaujYfTvMXspfCTmYcoO6a+vhC3ss4M8uM58t4siiu59I4aOl59e9Sr6xoxYlHf2v+NnBNpJYeJf8jABQAId/PXuBkLEFkiCucgSGEcfhvajql/j3reCGl0M5/9gQWy7ayNPs+wlvIxFnNfSlfuND4CZOCyxOHhRqOmHN4ULHo3tCSrUNvgAA=";
     const style = `
         position: relative;
         display: block;
@@ -265,7 +314,7 @@ async function logNonCommercialUse(_logo?: string) {
         background-size: 20px;
         background-position: 10px 5px;
         background-repeat:no-repeat;
-        background-image:url('${logo}');
+        background-image:url('${base64Logo}');
         background-max-size: 40px;
         margin-bottom: 5px;
         margin-top: .3em;

package/src/engine/engine_networking_blob.ts

@@ -1,6 +1,7 @@
 // workaround for this is not a function when deployed
 // see https://github.com/pvorb/node-md5/issues/52
 import md5 from "md5";
+import { FileLoader } from "three";
 
 import { showBalloonWarning } from "./debug/index.js";
 import { hasCommercialLicense } from "./engine_license.js";
@@ -219,35 +220,55 @@ export namespace BlobStorage {
     }
 
     export async function download(url: string, progressCallback?: (prog: ProgressEvent) => void): Promise<Uint8Array | null> {
-        const response = await fetch(url);
-
-        const reader = response.body?.getReader();
-        const contentLength = response.headers.get('Content-Length');
-        const total = contentLength ? parseInt(contentLength) : 0;
-
-        if (!reader) return null;
-
-        let received: number = 0;
-        const chunks: Uint8Array[] = [];
-        while (true) {
-            const { done, value } = await reader.read();
-            if (value) {
-                chunks.push(value);
-                received += value.length;
-                progressCallback?.call(null, new ProgressEvent('progress', { loaded: received, total: total }));
-            }
 
-            if (done) {
-                break;
+        // Using a FileLoader here instead of manually fetching so we're able to use the three.js cache system
+        const loader = new FileLoader();
+        loader.setResponseType('arraybuffer');
+        // loader.setRequestHeader( this.requestHeader );
+        // loader.setWithCredentials( this.withCredentials );
+        const res = await loader.loadAsync(url, prog => {
+            if (progressCallback) {
+                progressCallback.call(null, prog);
             }
+        });
+        if (!(res instanceof ArrayBuffer)) {
+            console.error("Download failed, no arraybuffer returned");
+            return null;
         }
-        const final = new Uint8Array(received);
-        let position = 0;
-        for (const chunk of chunks) {
-            final.set(chunk, position);
-            position += chunk.length;
-        }
-        return final;
+        return new Uint8Array(res);
+
+
+        // Old solution: this didn't re-use the three.js loading cache. Using a FileLoader the GLTFLoader under the hood is smart enough to NOT start a new download request
+
+        // const response = await fetch(url);
+
+        // const reader = response.body?.getReader();
+        // const contentLength = response.headers.get('Content-Length');
+        // const total = contentLength ? parseInt(contentLength) : 0;
+
+        // if (!reader) return null;
+
+        // let received: number = 0;
+        // const chunks: Uint8Array[] = [];
+        // while (true) {
+        //     const { done, value } = await reader.read();
+        //     if (value) {
+        //         chunks.push(value);
+        //         received += value.length;
+        //         progressCallback?.call(null, new ProgressEvent('progress', { loaded: received, total: total }));
+        //     }
+
+        //     if (done) {
+        //         break;
+        //     }
+        // }
+        // const final = new Uint8Array(received);
+        // let position = 0;
+        // for (const chunk of chunks) {
+        //     final.set(chunk, position);
+        //     position += chunk.length;
+        // }
+        // return final;
     }
 }
 

package/src/engine/engine_physics_rapier.ts

@@ -598,17 +598,15 @@ export class RapierPhysics implements IPhysicsEngine {
         scale.multiplyScalar(0.5);
 
         // prevent negative scale
-        if (scale.x < 0)
-            scale.x = Math.abs(scale.x);
-        if (scale.y < 0)
-            scale.y = Math.abs(scale.y);
-        if (scale.z < 0)
-            scale.z = Math.abs(scale.z);
+        if (scale.x < 0) scale.x = Math.abs(scale.x);
+        if (scale.y < 0) scale.y = Math.abs(scale.y);
+        if (scale.z < 0) scale.z = Math.abs(scale.z);
 
         // prevent zero scale - seems normals are flipped otherwise
-        if (scale.x == 0) scale.x = 0.0000001;
-        if (scale.y == 0) scale.y = 0.0000001;
-        if (scale.z == 0) scale.z = 0.0000001;
+        const minSize = 0.0000001;
+        if (scale.x < minSize) scale.x = minSize;
+        if (scale.y < minSize) scale.y = minSize;
+        if (scale.z < minSize) scale.z = minSize;
 
         const desc = MODULES.RAPIER_PHYSICS.MODULE.ColliderDesc.cuboid(scale.x, scale.y, scale.z);
         // const objectLayerMask = collider.gameObject.layers.mask;
@@ -994,9 +992,9 @@ export class RapierPhysics implements IPhysicsEngine {
                 const sc = col as IBoxCollider;
                 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;
+                const newX = Math.abs(sc.size.x * 0.5 * scale.x);
+                const newY = Math.abs(sc.size.y * 0.5 * scale.y);
+                const newZ = Math.abs(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;

package/src/engine/engine_serialization_core.ts

@@ -517,11 +517,14 @@ function deserializeObjectWithType(data: any, typeOrConstructor: ConstructorConc
     // then we dont need to do anything else
     if (!typeIsFunction && currentValue) {
         if (currentValue instanceof Material) return currentValue;
-        if (currentValue instanceof Texture) return currentValue;
         if (currentValue instanceof Mesh) return currentValue;
         if (currentValue instanceof BufferGeometry) return currentValue;
         if (currentValue instanceof AnimationClip) return currentValue;
+        // We need to call the RenderTexture deserializer so we can not just return here:
+        // if (currentValue instanceof Texture) return currentValue;
+        // So this has now been moved down below the deserializer code
     }
+    
     // Removed this line because it prevents assigning serialized values to existing instances for e.g. EventList
     // https://linear.app/needle/issue/NE-5350
     // if (!typeIsFunction && currentValue instanceof type) return currentValue;
@@ -594,6 +597,8 @@ function deserializeObjectWithType(data: any, typeOrConstructor: ConstructorConc
 
     // console.log(type.prototype.get("$serializedTypes"));
 
+    // We check textures AFTER running deserializers because some textures might need to be converted to a RenderTexture
+    if (currentValue instanceof Texture) return currentValue;
 
     let instance: any = undefined;
     if (data && (data.isMaterial || data.isTexture || data.isObject3D || data instanceof AnimationClip)) {

package/src/engine/engine_utils_screenshot.ts

@@ -175,7 +175,7 @@ export function screenshot2(opts: ScreenshotOptionsDataUrl | ScreenshotOptionsTe
     }
 
     const renderer = context.renderer;
-    const isXRScreenshot = renderer.xr.enabled;
+    const isXRScreenshot = renderer.xr.enabled && renderer.xr.isPresenting;
 
 
     // Perform XR screenshot in onBeforeRender (after the screenshot we want to render the original camera view)

package/src/engine/js-extensions/RGBAColor.ts

@@ -20,14 +20,15 @@ export class RGBAColor extends Color {
      */
     constructor(r: number, g: number, b: number, a: number);
     constructor(r: number | ColorRepresentation, g?: number, b?: number, a?: number) {
-        // if the user passed in the r, g, b, a components
-        if (g != undefined && b != undefined) {
-            super(r as number, g, b);
-            this.alpha = a as number;
-        }
-        // if the user passed in a color representation
-        else {
-            super(r);
+        // AMD compilation creates recursive super calls with local function wrappers
+        // Call super() first with the minimum arguments needed
+        super();
+        
+        if (typeof r === "number" && typeof g === "number" && typeof b === "number") {
+            this.set(r, g, b);
+            this.alpha = typeof a === "number" ? a : 1;
+        } else if (r !== undefined) {
+            this.set(r as ColorRepresentation);
             this.alpha = 1;
         }
     }
@@ -73,4 +74,54 @@ export class RGBAColor extends Color {
         this.alpha = array[offset + 3];
         return super.fromArray(array, offset);
     }
+
+    static fromColorRepresentation(col: ColorRepresentation) {
+
+        if (typeof col === "string") {
+            if (col.trim() === "transparent") {
+                return new RGBAColor(0, 0, 0, 0);
+            }
+            // handle hex colors with alpha
+            if (col.startsWith("#") && col.length === 9) {
+                const hex = parseInt(col.slice(1, 9), 16);
+                const r = (hex >> 24) & 0xff;
+                const g = (hex >> 16) & 0xff;
+                const b = (hex >> 8) & 0xff;
+                const a = (hex >> 0) & 0xff;
+                return new RGBAColor(r / 255, g / 255, b / 255, a / 255);
+            }
+            // handle hex colors
+            else if (col.startsWith("#")) {
+                const hex = parseInt(col.slice(1), 16);
+                const r = (hex >> 16) & 0xff;
+                const g = (hex >> 8) & 0xff;
+                const b = (hex >> 0) & 0xff;
+                return new RGBAColor(r / 255, g / 255, b / 255, 1);
+            }
+            // handle rgba string
+            else if (col.startsWith("rgba")) {
+                const rgba = col.slice(5, -1).split(",").map(Number);
+                return new RGBAColor(rgba[0] / 255, rgba[1] / 255, rgba[2] / 255, rgba[3]);
+            }
+            // handle rgb string
+            else if (col.startsWith("rgb")) {
+                const rgb = col.slice(4, -1).split(",").map(Number);
+                return new RGBAColor(rgb[0] / 255, rgb[1] / 255, rgb[2] / 255, 1);
+            }
+        }
+        else if (Array.isArray(col)) {
+            // handle rgba colors
+            if (col.length === 4) {
+                return new RGBAColor(col[0], col[1], col[2], col[3]);
+            }
+            // handle rgb colors
+            else if (col.length === 3) {
+                return new RGBAColor(col[0], col[1], col[2], 1);
+            }
+            else {
+                console.error("Invalid color array length. Expected 3 or 4, got " + col.length);
+            }
+        }
+        return new RGBAColor(col);
+    }
 }

package/src/engine/physics/workers/mesh-bvh/GenerateMeshBVHWorker.js

@@ -3,13 +3,13 @@ import { MeshBVH } from 'three-mesh-bvh';
 
 // Modified according to https://github.com/gkjohnson/three-mesh-bvh/issues/636#issuecomment-2209571751
 import { WorkerBase } from "three-mesh-bvh/src/workers/utils/WorkerBase.js";
-import generateMeshBVHWorker from "three-mesh-bvh/src/workers/generateMeshBVH.worker.js?worker&inline";
 
 export class GenerateMeshBVHWorker extends WorkerBase {
 
 	constructor() {
-
-		super(new generateMeshBVHWorker());
+        super(new Worker(new URL("three-mesh-bvh/src/workers/generateMeshBVH.worker.js", import.meta.url), {
+            type: 'module'
+        }));
 		this.name = 'GenerateMeshBVHWorker';
 
 	}
@@ -27,10 +27,10 @@ export class GenerateMeshBVHWorker extends WorkerBase {
 
 			}
 
-			worker.onerror = e => {
-
-				reject( new Error( `GenerateMeshBVHWorker: ${ e.message }` ) );
+            worker.onerror = e => {
 
+                reject(new Error(`[GenerateMeshBVHWorker] ${e.message || "Unknown error. Please check the server console. If you're using vite try adding 'three-mesh-bvh' to 'optimizeDeps.exclude' in your vite.config.js"}`));
+            
 			};
 
 			worker.onmessage = e => {

package/src/engine/webcomponents/needle menu/needle-menu-spatial.ts

@@ -155,7 +155,7 @@ export class NeedleSpatialMenu {
     private readonly positionFilter = new OneEuroFilterXYZ(90, .5);
 
     private updateMenu() {
-        performance.mark('NeedleSpatialMenu updateMenu start');
+        //performance.mark('NeedleSpatialMenu updateMenu start');
         const menu = this.getMenu();
         this.handleNeedleWatermark();
         this._context.scene.add(menu as any);
@@ -200,14 +200,14 @@ export class NeedleSpatialMenu {
         }
 
         if (this.uiisDirty) {
-            performance.mark('SpatialMenu.update.uiisDirty.start');
+            //performance.mark('SpatialMenu.update.uiisDirty.start');
             this.uiisDirty = false;
             ThreeMeshUI.update();
-            performance.mark('SpatialMenu.update.uiisDirty.end');
-            performance.measure('SpatialMenu.update.uiisDirty', 'SpatialMenu.update.uiisDirty.start', 'SpatialMenu.update.uiisDirty.end');
+            //performance.mark('SpatialMenu.update.uiisDirty.end');
+            //performance.measure('SpatialMenu.update.uiisDirty', 'SpatialMenu.update.uiisDirty.start', 'SpatialMenu.update.uiisDirty.end');
         }
-        performance.mark('NeedleSpatialMenu updateMenu end');
-        performance.measure('SpatialMenu.update', 'NeedleSpatialMenu updateMenu start', 'NeedleSpatialMenu updateMenu end');
+        //performance.mark('NeedleSpatialMenu updateMenu end');
+        //performance.measure('SpatialMenu.update', 'NeedleSpatialMenu updateMenu start', 'NeedleSpatialMenu updateMenu end');
     }
 
     private ensureRenderOnTop(obj: Object3D, level: number = 0) {

package/src/engine/webcomponents/needle menu/needle-menu.ts

@@ -174,6 +174,10 @@ export class NeedleMenu {
         this._spatialMenu?.showNeedleLogo(visible);
         // setTimeout(()=>this.showNeedleLogo(!visible), 1000);
     }
+    /** @returns true if the logo is visible */
+    get logoIsVisible() {
+        return this._menu.logoIsVisible;
+    }
     /** When enabled=true the menu will be visible in VR/AR sessions */
     showSpatialMenu(enabled: boolean) {
         this._spatialMenu.setEnabled(enabled);
@@ -640,7 +644,7 @@ export class NeedleMenuElement extends HTMLElement {
 
         </style>
         
-        <div id="root" class="logo-visible floating-panel-style bottom">
+        <div id="root" class="logo-hidden floating-panel-style bottom">
             <div class="wrapper">
                 <div class="foldout">
                     <div class="options" part="options">
@@ -699,6 +703,9 @@ export class NeedleMenuElement extends HTMLElement {
                     if (visible === undefined) visible = false;
                     this.___onSetLogoVisible(visible);
                 }
+                else {
+                    this.___onSetLogoVisible(true);
+                }
             }));
         } catch (e) {
             console.error("[Needle Menu] License check failed.", e);
@@ -822,13 +829,17 @@ export class NeedleMenuElement extends HTMLElement {
         this._userRequestedLogoVisible = visible;
         if (!visible) {
             if (!hasCommercialLicense() || debugNonCommercial) {
-                console.warn("Needle Menu: You need a PRO license to hide the Needle Engine logo.");
+                console.warn("[Needle Engine] You need a PRO license to hide the Needle Engine logo in production.");
                 const localNetwork = isLocalNetwork()
                 if (!localNetwork) return;
             }
         }
         this.___onSetLogoVisible(visible);
     }
+    /** @returns true if the logo is visible */
+    get logoIsVisible() {
+        return !this.root.classList.contains("logo-hidden");
+    }
 
     private ___onSetLogoVisible(visible: boolean) {
         this.logoContainer.style.display = "";

package/src/engine/xr/NeedleXRController.ts

@@ -381,12 +381,11 @@ export class NeedleXRController implements IPointerHitEventReceiver {
     }
 
     onUpdate(frame: XRFrame) {
-        performance.mark('NeedleXRController onUpdate start');
         this.onUpdateFrame(frame);
         this.updateInputEvents();
         this.onUpdateMove();
-        performance.mark('NeedleXRController onUpdate end');
-        performance.measure('NeedleXRController onUpdate', 'NeedleXRController onUpdate start', 'NeedleXRController onUpdate end');
+        //performance.mark('NeedleXRController onUpdate end');
+        //performance.measure('NeedleXRController onUpdate', 'NeedleXRController onUpdate start', 'NeedleXRController onUpdate end');
     }
 
     onRenderDebug() {