@needle-tools/engine 3.5.1-alpha → 3.5.3-alpha

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@needle-tools/engine",
-    "version": "3.5.1-alpha",
+    "version": "3.5.3-alpha",
     "description": "Needle Engine is a web-based runtime for 3D apps. It runs on your machine for development with great integrations into editors like Unity or Blender - and can be deployed onto any device! It is flexible, extensible and networking and XR are built-in",
     "main": "dist/needle-engine.umd.cjs",
     "type": "module",

package/plugins/vite/license.js

@@ -13,8 +13,8 @@ export const needleLicense = (command, config, userSettings) => {
             if (isNeedleEngineFile || isViteChunkFile) {
                 const needleConfig = await loadConfig();
                 if (needleConfig) {
-                    if (needleConfig.hasProLicense === true) {
-                        src = src.replace("NEEDLE_ENGINE_COMMERCIAL_USE_LICENSE = false;", "NEEDLE_ENGINE_COMMERCIAL_USE_LICENSE = " + needleConfig.hasProLicense + ";");
+                    if (typeof needleConfig.license === "string") {
+                        src = src.replace("const NEEDLE_ENGINE_LICENSE_TYPE: string = \"\";", "const NEEDLE_ENGINE_LICENSE_TYPE: string = \"" + needleConfig.license + "\";");
                         return { code: src, map: null }
                     }
                 }

package/src/engine/codegen/register_types.js

@@ -14,6 +14,7 @@ import { Animator } from "../../engine-components/Animator";
 import { AnimatorController } from "../../engine-components/AnimatorController";
 import { Antialiasing } from "../../engine-components/postprocessing/Effects/Antialiasing";
 import { AttachedObject } from "../../engine-components/webxr/WebXRController";
+import { AudioExtension } from "../../engine-components/export/usdz/extensions/behavior/AudioExtension";
 import { AudioListener } from "../../engine-components/AudioListener";
 import { AudioSource } from "../../engine-components/AudioSource";
 import { AudioTrackHandler } from "../../engine-components/timeline/TimelineTracks";
@@ -116,6 +117,7 @@ import { ParticleSystemRenderer } from "../../engine-components/ParticleSystem";
 import { PixelationEffect } from "../../engine-components/postprocessing/Effects/Pixelation";
 import { PlayableDirector } from "../../engine-components/timeline/PlayableDirector";
 import { PlayAnimationOnClick } from "../../engine-components/export/usdz/extensions/behavior/BehaviourComponents";
+import { PlayAudioOnClick } from "../../engine-components/export/usdz/extensions/behavior/BehaviourComponents";
 import { PlayerColor } from "../../engine-components/PlayerColor";
 import { PlayerState } from "../../engine-components-experimental/networking/PlayerSync";
 import { PlayerSync } from "../../engine-components-experimental/networking/PlayerSync";
@@ -184,7 +186,6 @@ import { TriggerModel } from "../../engine-components/export/usdz/extensions/beh
 import { UIRaycastUtils } from "../../engine-components/ui/RaycastUtils";
 import { UIRootComponent } from "../../engine-components/ui/BaseUIComponent";
 import { UsageMarker } from "../../engine-components/Interactable";
-import { USDZBehaviours } from "../../engine-components/export/usdz/extensions/behavior/Behaviour";
 import { USDZExporter } from "../../engine-components/export/usdz/USDZExporter";
 import { USDZText } from "../../engine-components/export/usdz/extensions/USDZText";
 import { VariantAction } from "../../engine-components/export/usdz/extensions/behavior/Actions";
@@ -229,6 +230,7 @@ TypeStore.add("Animator", Animator);
 TypeStore.add("AnimatorController", AnimatorController);
 TypeStore.add("Antialiasing", Antialiasing);
 TypeStore.add("AttachedObject", AttachedObject);
+TypeStore.add("AudioExtension", AudioExtension);
 TypeStore.add("AudioListener", AudioListener);
 TypeStore.add("AudioSource", AudioSource);
 TypeStore.add("AudioTrackHandler", AudioTrackHandler);
@@ -331,6 +333,7 @@ TypeStore.add("ParticleSystemRenderer", ParticleSystemRenderer);
 TypeStore.add("PixelationEffect", PixelationEffect);
 TypeStore.add("PlayableDirector", PlayableDirector);
 TypeStore.add("PlayAnimationOnClick", PlayAnimationOnClick);
+TypeStore.add("PlayAudioOnClick", PlayAudioOnClick);
 TypeStore.add("PlayerColor", PlayerColor);
 TypeStore.add("PlayerState", PlayerState);
 TypeStore.add("PlayerSync", PlayerSync);
@@ -399,7 +402,6 @@ TypeStore.add("TriggerModel", TriggerModel);
 TypeStore.add("UIRaycastUtils", UIRaycastUtils);
 TypeStore.add("UIRootComponent", UIRootComponent);
 TypeStore.add("UsageMarker", UsageMarker);
-TypeStore.add("USDZBehaviours", USDZBehaviours);
 TypeStore.add("USDZExporter", USDZExporter);
 TypeStore.add("USDZText", USDZText);
 TypeStore.add("VariantAction", VariantAction);

package/src/engine/debug/debug_overlay.ts

@@ -107,7 +107,8 @@ const currentMessages = new Set<string>();
 function showMessage(type: LogType, element: HTMLElement, msg: string) {
     const container = getLogsContainer(element);
     if (container.childElementCount >= 20) {
-        return;
+        const last = container.lastElementChild;
+        returnMessageContainer(last as HTMLElement);
     }
     // truncate long messages before they go into the cache/set
     if(msg.length > 300) msg = msg.substring(0, 300) + "...";

package/src/engine/engine_components.ts

@@ -160,7 +160,8 @@ export function getComponent<T>(obj: Object3D, componentType: Constructor<T>) {
 
 export function getComponents<T>(obj: Object3D, componentType: Constructor<T>, arr?: T[] | null): T[] {
     if (!arr) arr = [];
-    return onGetComponent(obj, componentType, arr);
+    onGetComponent(obj, componentType, arr);
+    return arr;
 }
 
 export function getComponentInChildren<T>(obj: Object3D, componentType: Constructor<T>, includeInactive?: boolean) {

package/src/engine/engine_element_loading.ts

@@ -3,7 +3,7 @@ import { Mathf } from "./engine_math";
 import { LoadingProgressArgs } from "./engine_setup";
 import { getParam } from "./engine_utils";
 import { logoSVG } from "./assets"
-import { hasProLicense } from "./engine_license";
+import { hasCommercialLicense, hasProLicense } from "./engine_license";
 
 const debug = getParam("debugloadingbar");
 const debugRendering = getParam("debugloadingbarrendering");
@@ -186,7 +186,7 @@ export class EngineLoadingView implements ILoadingViewHandler {
             if (loadingStyle === "light")
                 this._loadingElement.style.backgroundColor = "#ddd";
             else
-                this._loadingElement.style.backgroundColor = "#000";
+                this._loadingElement.style.backgroundColor = "#222";
             this._loadingElement.style.display = "flex";
             this._loadingElement.style.alignItems = "center";
             this._loadingElement.style.justifyContent = "center";
@@ -289,7 +289,7 @@ export class EngineLoadingView implements ILoadingViewHandler {
         messageContainer.style.fontSize = ".8em";
         messageContainer.style.paddingTop = ".5em";
         messageContainer.style.fontWeight = "200";
-        messageContainer.style.fontFamily = "Roboto, sans-serif";
+        messageContainer.style.fontFamily = "Roboto, sans-serif, Arial";
         // messageContainer.style.border = "1px solid rgba(255,255,255,.1)";
         messageContainer.style.justifyContent = "center";
         this._loadingElement.appendChild(messageContainer);
@@ -301,7 +301,7 @@ export class EngineLoadingView implements ILoadingViewHandler {
             }
         }
 
-        if (!hasLicense) {
+        if (!hasCommercialLicense()) {
             const nonCommercialContainer = document.createElement("div");
             nonCommercialContainer.style.paddingTop = ".6em";
             nonCommercialContainer.style.fontSize = ".8em";

package/src/engine/engine_gameobject.ts

@@ -113,6 +113,9 @@ export function destroy(instance: Object3D | Component, recursive: boolean = tru
 }
 
 function internalDestroy(instance: Object3D | Component, recursive: boolean = true, dispose: boolean = false, isRoot: boolean = true) {
+    if (instance === null || instance === undefined)
+        return;
+    
     const comp = instance as Component;
     if (comp.isComponent) {
         comp.__internalDisable();

package/src/engine/engine_input.ts

@@ -611,9 +611,12 @@ export class Input extends EventTarget implements IInput {
 
         const lf = this._pointerPositionsLastFrame[evt.button];
         lf.copy(this._pointerPositions[evt.button]);
+        // accumulate delta (it's reset in end of frame), if we just write it here it's not correct when the browser console is open
+        const delta = this._pointerPositionsDelta[evt.button];
         const dx = evt.clientX - lf.x;
         const dy = evt.clientY - lf.y;
-        this._pointerPositionsDelta[evt.button].set(dx, dy);
+        delta.x += dx;
+        delta.y += dy;
 
         this._pointerPositions[evt.button].x = evt.clientX;
         this._pointerPositions[evt.button].y = evt.clientY;

package/src/engine/engine_license.ts

@@ -7,10 +7,28 @@ const debug = getParam("debuglicense");
 
 // This is modified by a bundler (e.g. vite)
 // Do not edit manually
-const NEEDLE_ENGINE_COMMERCIAL_USE_LICENSE = false;
+const NEEDLE_ENGINE_LICENSE_TYPE: string = "";
+if (debug) console.log("License Type: " + NEEDLE_ENGINE_LICENSE_TYPE)
 
 export function hasProLicense() {
-    return NEEDLE_ENGINE_COMMERCIAL_USE_LICENSE;
+    switch (NEEDLE_ENGINE_LICENSE_TYPE) {
+        case "pro":
+        case "enterprise":
+            return true;
+    };
+    return false;
+}
+
+export function hasIndieLicense() {
+    switch (NEEDLE_ENGINE_LICENSE_TYPE) {
+        case "indie":
+            return true;
+    }
+    return false;
+}
+
+export function hasCommercialLicense() {
+    return hasProLicense() || hasIndieLicense();
 }
 
 
@@ -52,7 +70,8 @@ function insertNonCommercialUseHint(ctx: IContext) {
         }
     }, 100);
 
-    logNonCommercialUse();
+    if (!hasCommercialLicense())
+        logNonCommercialUse();
 
     let svg = `<img class="logo" src="${logoSVG}" style="width: 40px; height: 40px; margin-right: 2px; vertical-align: middle; margin-bottom: 2px;"/>`;
     const logoElement = document.createElement("div");
@@ -66,7 +85,9 @@ function insertNonCommercialUseHint(ctx: IContext) {
     //     textElement.innerHTML = "Needle Engine<br/><span class=\"non-commercial\">Non Commercial</span>";
     licenseElement.appendChild(textElement);
 
-    licenseElement.title = "Needle Engine — non commercial version";
+    licenseElement.title = "Needle Engine";
+    if (!hasCommercialLicense())
+        licenseElement.title += " non commercial version";
     licenseElement.addEventListener("click", () => {
         globalThis.open("https://needle.tools", "_blank");
     });

package/src/engine/engine_physics_rapier.ts

@@ -207,7 +207,8 @@ export class RapierPhysics implements IPhysicsEngine {
     private async internalInitialization() {
         // NEEDLE_PHYSICS_INIT_START
         // use .env file with VITE_NEEDLE_USE_RAPIER=false to treeshape rapier
-        if (import.meta.env.VITE_NEEDLE_USE_RAPIER === "false") {
+        // @ts-ignore
+        if ("env" in import.meta && import.meta.env.VITE_NEEDLE_USE_RAPIER === "false") {
             return false;
         }
         // Can be transformed during build time to disable rapier

package/src/engine/engine_serialization_core.ts

@@ -434,7 +434,14 @@ function implictlyAssignPrimitiveTypes(obj: any, serializedData: any) {
                 if (targetMember !== undefined) continue;
                 // resolve serialized primitive types
                 if (isPrimitiveType(data[key]) && !isPrimitiveType(member)) {
-                    // console.log("ASSIGN", key, member, member[key], targetMember, data[key]);
+
+                    const prop = tryFindPropertyDescriptor(member, key);
+                    if (!prop?.writable === false || (prop && prop.set === undefined)) {
+                        if (debug)
+                            console.warn("Property is not writable \"" + key + "\"", member, prop, data[key], member[key]);
+                        continue;
+                    }
+                    // console.log("ASSIGN", key, member, member[key], targetMember, data[key], prop);
                     member[key] = data[key];
                 }
             }
@@ -442,6 +449,15 @@ function implictlyAssignPrimitiveTypes(obj: any, serializedData: any) {
     }
 }
 
+function tryFindPropertyDescriptor(obj: object, key: string) : PropertyDescriptor | undefined {
+    while(obj){
+        const desc = Object.getOwnPropertyDescriptor(obj, key);
+        if(desc) return desc;
+        obj = Object.getPrototypeOf(obj);
+    }
+    return undefined;
+}
+
 function isPrimitiveType(val): boolean {
     switch (typeof val) {
         case "number":

package/src/engine/extensions/NEEDLE_lighting_settings.ts

@@ -48,8 +48,9 @@ export class NEEDLE_lighting_settings implements GLTFLoaderPlugin {
                 let settings: SceneLightSettings | undefined = undefined;
                 // If the result scene has only one child we add the LightingSettingsComponent to that child
                 if (_result.scene.children.length === 1) {
+                    const obj = _result.scene.children[0];
                     // add a component to the root of the scene
-                    settings = GameObject.addNewComponent(_result.scene.children[0], SceneLightSettings, false);
+                    settings = GameObject.addNewComponent(obj, SceneLightSettings, false);
                 }
                 // if the scene already has multiple children we add it as a new object
                 else {
@@ -117,6 +118,15 @@ export class SceneLightSettings extends Behaviour {
                 }
             });
         }
+
+        // make sure the component is in the end of the list 
+        // (e.g. if we have an animation on the first component from an instance and add the scenelightingcomponent the animation binding will break)
+        const comps = this.gameObject.userData?.components;
+        if (comps) {
+            const index = comps.indexOf(this);
+            comps.splice(index, 1);
+            comps.push(this);
+        }
     }
 
     onDestroy(): void {

package/src/engine-components/Component.ts

@@ -195,9 +195,6 @@ export abstract class GameObject extends Object3D implements Object3D, IGameObje
      * @param instance component to move to the GO
      */
     public static moveComponent(go: IGameObject, instance: Component): void {
-        if (instance.gameObject == null) {
-            throw new Error("Did you mean to create a new component? Use addNewComponent");
-        }
         moveComponentInstance(go, instance as any);
     }
 
@@ -277,6 +274,7 @@ export abstract class GameObject extends Object3D implements Object3D, IGameObje
     // these are implemented via threejs object extensions
     abstract activeSelf: boolean;
     abstract addNewComponent<T>(type: Constructor<T>): T | null;
+    // TODO: add method for addExisting component
     abstract removeComponent(comp: Component): Component;
     abstract getOrAddComponent<T>(typeName: Constructor<T> | null): T;
     abstract getComponent<T>(type: Constructor<T>): T | null;

package/src/engine-components/SceneSwitcher.ts

@@ -56,11 +56,27 @@ export class SceneSwitcher extends Behaviour {
     @serializable()
     useSceneLighting: boolean = true;
 
+    /** how many scenes after the currently active scene should be preloaded */
+    @serializable()
+    preloadNext: number = 1;
+
+    /** how many scenes before the currently active scene should be preloaded */
+    @serializable()
+    preloadPrevious: number = 1;
+
+    /** how many scenes can be loaded in parallel */
+    @serializable()
+    preloadConcurrent: number = 2;
+
+
+    get currentIndex(): number { return this._currentIndex; }
 
     private _currentIndex: number = -1;
     private _currentScene: AssetReference | undefined = undefined;
     private _engineElementOverserver: MutationObserver | undefined = undefined;
 
+    private _preloadScheduler?: PreLoadScheduler;
+
     async start() {
         if (this._currentIndex === -1 && !await this.tryLoadFromQueryParam()) {
             const value = this.context.domElement.getAttribute(ENGINE_ELEMENT_SCENE_ATTRIBUTE_NAME);
@@ -100,6 +116,13 @@ export class SceneSwitcher extends Behaviour {
         this._engineElementOverserver.observe(this.context.domElement, {
             attributes: true
         });
+
+        if (!this._preloadScheduler)
+            this._preloadScheduler = new PreLoadScheduler(this);
+        this._preloadScheduler.maxLoadAhead = this.preloadNext;
+        this._preloadScheduler.maxLoadBehind = this.preloadPrevious;
+        this._preloadScheduler.maxConcurrent = this.preloadConcurrent;
+        this._preloadScheduler.begin();
     }
 
     onDisable(): void {
@@ -107,6 +130,7 @@ export class SceneSwitcher extends Behaviour {
         this.context.input.removeEventListener(InputEvents.KeyDown, this.onKeyDown);
         this.context.input.removeEventListener(InputEvents.PointerMove, this.onPointerMove);
         this.context.input.removeEventListener(InputEvents.PointerUp, this.onPointerUp);
+        this._preloadScheduler?.stop();
     }
 
     private onPopState = async (_state: PopStateEvent) => {
@@ -189,7 +213,7 @@ export class SceneSwitcher extends Behaviour {
     select(index: number | string): Promise<boolean> {
         if (debug) console.log("select", index);
 
-        if(typeof index === "object"){
+        if (typeof index === "object") {
             // If a user tries to reference a scene object in a UnityEvent and invoke select(obj) 
             // Then the object will be serialized as a object { guid : ... } or with the index json pointer
             // This case is not supported right now. Object references in the editor must not be scene references
@@ -271,6 +295,15 @@ export class SceneSwitcher extends Behaviour {
         return false;
     }
 
+    preload(index: number) {
+        if (index >= 0 && index < this.scenes.length) {
+            const scene = this.scenes[index];
+            if(scene instanceof AssetReference) 
+                return scene.preload();
+        }
+        return couldNotLoadScenePromise;
+    }
+
     private tryLoadFromQueryParam() {
         if (!this.queryParameterName?.length) return couldNotLoadScenePromise;
         // try restore the scene from the url
@@ -308,3 +341,105 @@ export class SceneSwitcher extends Behaviour {
         return couldNotLoadScenePromise;
     }
 }
+
+
+
+
+class PreLoadScheduler {
+    maxLoadAhead: number;
+    maxLoadBehind: number;
+    maxConcurrent: number;
+
+    private _isRunning: boolean = false;
+    private _rooms: SceneSwitcher;
+    private _roomTasks: LoadTask[] = [];
+    private _maxConcurrentLoads: number = 1;
+
+    constructor(rooms: SceneSwitcher, ahead: number = 1, behind: number = 1, maxConcurrent: number = 2) {
+        this._rooms = rooms;
+        this.maxLoadAhead = ahead;
+        this.maxLoadBehind = behind;
+        this.maxConcurrent = maxConcurrent;
+    }
+
+    begin() {
+        if (this._isRunning) return;
+        if (debug) console.log("Preload begin")
+        this._isRunning = true;
+        let lastRoom: number = -1;
+        let searchDistance: number;
+        let searchCall: number;
+        const array = this._rooms.scenes;
+        let interval = setInterval(() => {
+            if (this.allLoaded()) {
+                if (debug)
+                    console.log("All scenes loaded");
+                this.stop();
+            }
+            if (!this._isRunning) {
+                clearInterval(interval);
+                return;
+            }
+            if (this.canLoadNewScene() === false) return;
+            if (lastRoom !== this._rooms.currentIndex) {
+                lastRoom = this._rooms.currentIndex;
+                searchCall = 0;
+                searchDistance = 0;
+            }
+            const searchForward = searchCall % 2 === 0;
+            if (searchForward) searchDistance += 1;
+            searchCall += 1;
+            const maxSearchDistance = searchForward ? this.maxLoadAhead : this.maxLoadBehind;
+            if (searchDistance > maxSearchDistance) return;
+            let roomIndex = searchForward ? lastRoom + searchDistance : lastRoom - searchDistance;
+            if (roomIndex < 0) return;
+            // if (roomIndex < 0) roomIndex = array.length + roomIndex;
+            if (roomIndex < 0 || roomIndex >= array.length) return;
+            const scene = array[roomIndex];
+            new LoadTask(roomIndex, scene, this._roomTasks);
+        }, 200);
+    }
+
+    stop() {
+        this._isRunning = false;
+    }
+
+    canLoadNewScene(): boolean {
+        return this._roomTasks.length < this._maxConcurrentLoads;
+    }
+
+    allLoaded(): boolean {
+        for (const room of this._rooms.scenes) {
+            if (room.isLoaded() === false) return false;
+        }
+        return true;
+    }
+}
+
+class LoadTask {
+
+    index: number;
+    asset: AssetReference;
+    tasks: LoadTask[];
+
+    constructor(index: number, asset: AssetReference, tasks: LoadTask[]) {
+        this.index = index;
+        this.asset = asset;
+        this.tasks = tasks;
+        tasks.push(this);
+        this.awaitLoading();
+    }
+
+    private async awaitLoading() {
+        if (!this.asset.isLoaded()) {
+            if (debug)
+                console.log("Preload start: " + this.asset.uri, this.index);
+            await this.asset.preload();
+            if (debug)
+                console.log("Preload finished: " + this.asset.uri, this.index);
+        }
+
+        const i = this.tasks.indexOf(this);
+        if (i >= 0) this.tasks.splice(i, 1);
+    }
+}

package/src/engine-components/codegen/components.ts

@@ -12,6 +12,7 @@ export { Animator } from "../Animator";
 export { AnimatorController } from "../AnimatorController";
 export { Antialiasing } from "../postprocessing/Effects/Antialiasing";
 export { AttachedObject } from "../webxr/WebXRController";
+export { AudioExtension } from "../export/usdz/extensions/behavior/AudioExtension";
 export { AudioListener } from "../AudioListener";
 export { AudioSource } from "../AudioSource";
 export { AudioTrackHandler } from "../timeline/TimelineTracks";
@@ -114,6 +115,7 @@ export { ParticleSystemRenderer } from "../ParticleSystem";
 export { PixelationEffect } from "../postprocessing/Effects/Pixelation";
 export { PlayableDirector } from "../timeline/PlayableDirector";
 export { PlayAnimationOnClick } from "../export/usdz/extensions/behavior/BehaviourComponents";
+export { PlayAudioOnClick } from "../export/usdz/extensions/behavior/BehaviourComponents";
 export { PlayerColor } from "../PlayerColor";
 export { PointerEventData } from "../ui/PointerEvents";
 export { PostProcessingHandler } from "../postprocessing/PostProcessingHandler";
@@ -179,7 +181,6 @@ export { TriggerModel } from "../export/usdz/extensions/behavior/BehavioursBuild
 export { UIRaycastUtils } from "../ui/RaycastUtils";
 export { UIRootComponent } from "../ui/BaseUIComponent";
 export { UsageMarker } from "../Interactable";
-export { USDZBehaviours } from "../export/usdz/extensions/behavior/Behaviour";
 export { USDZExporter } from "../export/usdz/USDZExporter";
 export { USDZText } from "../export/usdz/extensions/USDZText";
 export { VariantAction } from "../export/usdz/extensions/behavior/Actions";

package/src/engine-components/export/usdz/Extension.ts

@@ -1,11 +1,12 @@
-import { USDObject } from "./ThreeUSDZExporter";
+import { USDObject, USDZExporterContext } from "./ThreeUSDZExporter";
+import { Object3D } from "three";
 
 export interface IUSDExporterExtension {
 
     get extensionName(): string;
     onBeforeBuildDocument?(context);
     onAfterBuildDocument?(context);
-    onExportObject?(object, model : USDObject, context);
+    onExportObject?(object: Object3D, model : USDObject, context: USDZExporterContext);
     onAfterSerialize?(context);
     onAfterHierarchy?(context, writer : any);
 }