Needle Engine 4.3.0-alpha

Files changed (5) hide show

plugins/vite/alias.js +6 -3
src/engine/engine_addressables.ts +21 -0
src/engine/engine_input.ts +20 -1
src/engine-components/ui/EventSystem.ts +9 -7
src/engine-components/SceneSwitcher.ts +30 -8

plugins/vite/alias.js CHANGED Viewed

@@ -57,6 +57,8 @@
     }
     if (debug) {
         const outputFilePath = path.resolve(projectDir, 'node_modules/.vite/needle.alias.log');
+        const outputDirectory = path.dirname(outputFilePath);
+        if (!existsSync(outputDirectory)) mkdirSync(outputDirectory, { recursive: true });
         outputDebugFile = createWriteStream(outputFilePath, { flags: "a" });
         const timestamp = new Date().toISOString();
         outputDebugFile.write("\n\n\n--------------------------\n");
@@ -68,7 +70,7 @@
     const aliasPlugin = {
         name: "needle-alias",
         config(config) {
-            if (debug)  console.log('[needle-alias] ProjectDirectory: ' + projectDir);
+            if (debug) console.log('[needle-alias] ProjectDirectory: ' + projectDir);
             if (!config.resolve) config.resolve = {};
             if (!config.resolve.alias) config.resolve.alias = {};
             const aliasDict = config.resolve.alias;
@@ -97,6 +99,7 @@
     let lastImporter = "";
     /** This plugin logs all imports. This helps to find cases where incorrect folders are found/resolved. */
+    /** @type {import("vite").Plugin} */
     const debuggingPlugin = {
         name: "needle:alias-debug",
         // needs to run before regular resolver
@@ -115,9 +118,9 @@
             // verbose logging for all imports
             if (lastImporter !== importer) {
                 lastImporter = importer;
-                log('[needle-alias] Resolving: ', importer, "(file)");
+                log(`[needle-alias] Resolving: ${importer} (file${options?.ssr ? ", SSR" : ""})`);
             }
-            log('[needle-alias]                 → ' + id);
+            log(`[needle-alias]     → ${id}`);
             return;
         },
     }

src/engine/engine_addressables.ts CHANGED Viewed

@@ -164,6 +164,11 @@
         return this._url;
     }
+    /** The name of the assigned url. This name is deduced from the url and might not reflect the actual name of the asset */
+    get urlName(): string {
+        return this._urlName;
+    };
     /**
      * @returns true if the uri is a valid URL (http, https, blob)
      */
@@ -180,6 +185,7 @@
     private _asset: any;
     private _glbRoot?: Object3D | null;
     private _url: string;
+    private _urlName: string;
     private _progressListeners: ProgressCallback[] = [];
     private _hash?: string;
@@ -191,12 +197,27 @@
     /** @internal */
     constructor(uri: string, hash?: string, asset: any = null) {
         this._url = uri;
+        const lastUriPart = uri.lastIndexOf("/");
+        if (lastUriPart >= 0) {
+            this._urlName = uri.substring(lastUriPart + 1);
+            // remove file extension
+            const lastDot = this._urlName.lastIndexOf(".");
+            if (lastDot >= 0) {
+                this._urlName = this._urlName.substring(0, lastDot);
+            }
+        }
+        else {
+            this._urlName = uri;
+        }
         this._hash = hash;
         if (uri.includes("?v="))
             this._hashedUri = uri;
         else
             this._hashedUri = hash ? uri + "?v=" + hash : uri;
         if (asset !== null) this.asset = asset;
         registerPrefabProvider(this._url, this.onResolvePrefab.bind(this));
     }

src/engine/engine_input.ts CHANGED Viewed

@@ -255,7 +255,26 @@
     /** Adds an event listener for the specified event type. The callback will be called when the event is triggered.
      * @param type The event type to listen for
      * @param callback The callback to call when the event is triggered
-     * @param options The options for adding the event listener
+     * @param options The options for adding the event listener.
+     * @example Basic usage:
+     * ```ts
+     * input.addEventListener("pointerdown", (evt) => {
+     *   console.log("Pointer down", evt.pointerId, evt.pointerType);
+     * });
+     * ```
+     * @example Adding a listener that is called after all other listeners
+     * By using a higher value for the queue the listener will be called after other listeners (default queue is 0).
+     * ```ts
+     * input.addEventListener("pointerdown", (evt) => {
+     *  console.log("Pointer down", evt.pointerId, evt.pointerType);
+     * }, { queue: 10 });
+     * ```
+     * @example Adding a listener that is only called once
+     * ```ts
+     * input.addEventListener("pointerdown", (evt) => {
+     * console.log("Pointer down", evt.pointerId, evt.pointerType);
+     * }, { once: true });
+     * ```
      */
     addEventListener(type: PointerEventNames, callback: PointerEventListener, options?: EventListenerOptions);
     addEventListener(type: KeyboardEventNames, callback: KeyboardEventListener, options?: EventListenerOptions);

src/engine-components/ui/EventSystem.ts CHANGED Viewed

@@ -59,6 +59,7 @@
         return ctx.scene.getComponent(EventSystem);
     }
+    /** Get the currently active event system */
     static get instance(): EventSystem | null {
         return this.get(Context.Current);
     }
@@ -75,7 +76,10 @@
         }
     }
-    get hasActiveUI() { return this.currentActiveMeshUIComponents.length > 0; }
+    get hasActiveUI() {
+        return this.currentActiveMeshUIComponents.length > 0;
+    }
     get isHoveringObjects() { return this.hoveredByID.size > 0; }
     awake(): void {
@@ -424,7 +428,6 @@
                     const res = UIRaycastUtils.isInteractable(actualGo, this.out);
                     if (!res) return false;
                     canvasGroup = this.out.canvasGroup ?? null;
                     const handled = this.handleMeshUIIntersection(object, pressedOrClicked);
                     if (!clicked && handled) {
                         // return true;
@@ -753,7 +756,6 @@
     }
     private resetMeshUIStates() {
         if (this.context.input.getPointerPressedCount() > 0) {
             MeshUIHelper.resetLastSelected();
         }
@@ -816,7 +818,7 @@
         let foundBlock: Object3D | null = null;
         if (intersect) {
-            foundBlock = this.findBlockInParent(intersect);
+            foundBlock = this.findBlockOrTextInParent(intersect);
             // console.log(intersect, "-- found block:", foundBlock)
             if (foundBlock && foundBlock !== this.lastSelected) {
                 const interactable = foundBlock["interactable"];
@@ -840,13 +842,13 @@
         this.needsUpdate = true;
     }
-    static findBlockInParent(elem: any): Object3D | null {
+    static findBlockOrTextInParent(elem: any): Object3D | null {
         if (!elem) return null;
-        if (elem.isBlock) {
+        if (elem.isBlock || (elem.isText)) {
             // @TODO : Replace states managements
             // if (Object.keys(elem.states).length > 0)
             return elem;
         }
-        return this.findBlockInParent(elem.parent);
+        return this.findBlockOrTextInParent(elem.parent);
     }
 }

src/engine-components/SceneSwitcher.ts CHANGED Viewed

@@ -46,6 +46,10 @@
     index: number;
 }
+export type LoadSceneProgressEvent = LoadSceneEvent & {
+    progress: number,
+}
 /**
  * The ISceneEventListener is called by the {@link SceneSwitcher} when a scene is loaded or unloaded.
  * It must be added to the root object of your scene (that is being loaded) or on the same object as the SceneSwitcher
@@ -226,6 +230,15 @@
     get currentlyLoadedScene() { return this._currentScene; }
     /**
+     * Called when a scene starts loading
+     */
+    @serializable(EventList)
+    sceneLoadingStart: EventList<LoadSceneEvent> = new EventList();
+    @serializable(EventList)
+    sceneLoadingProgress: EventList<ProgressEvent> = new EventList();
+    /**
      * The sceneLoaded event is called when a scene/glTF is loaded and added to the scene
      */
     @serializable(EventList)
@@ -281,7 +294,7 @@
         this._preloadScheduler.maxLoadAhead = this.preloadNext;
         this._preloadScheduler.maxLoadBehind = this.preloadPrevious;
         this._preloadScheduler.maxConcurrent = this.preloadConcurrent;
-        this._preloadScheduler.begin();
+        this._preloadScheduler.begin(2000);
         // Begin loading the loading scene
         if (this.autoLoadFirstScene && this._currentIndex === -1 && !await this.tryLoadFromQueryParam()) {
@@ -602,11 +615,13 @@
             const loadStartEvt = new CustomEvent<LoadSceneEvent>("loadscene-start", { detail: { scene: scene, switcher: this, index: index } })
             this.dispatchEvent(loadStartEvt);
+            this.sceneLoadingStart?.invoke(loadStartEvt.detail);
             await this.onStartLoading();
             // start loading and wait for the scene to be loaded
             await scene.loadAssetAsync((_, prog) => {
                 this._currentLoadingProgress = prog;
                 this.dispatchEvent(prog);
+                this.sceneLoadingProgress?.invoke(prog);
             }).catch(console.error);
             await this.onEndLoading();
             const finishedEvt = new CustomEvent<LoadSceneEvent>("loadscene-finished", { detail: { scene: scene, switcher: this, index: index } });
@@ -859,26 +874,30 @@
         this.maxConcurrent = maxConcurrent;
     }
-    begin() {
+    begin(delay: number) {
         if (this._isRunning) return;
-        if (debug) console.log("Preload begin")
+        if (debug) console.log("Preload begin", { delay })
         this._isRunning = true;
-        let lastRoom: number = -1;
+        let lastRoom: number = -10;
         let searchDistance: number;
         let searchCall: number;
         const array = this._switcher.scenes;
+        const startTime = Date.now() + delay;
         const interval = setInterval(() => {
             if (this.allLoaded()) {
                 if (debug)
-                    console.log("All scenes loaded");
+                    console.log("All scenes (pre-)loaded");
                 this.stop();
             }
             if (!this._isRunning) {
                 clearInterval(interval);
                 return;
             }
+            if (Date.now() < startTime) return;
             if (this.canLoadNewScene() === false) return;
-            if (lastRoom !== this._switcher.currentIndex) {
+            if (lastRoom === -10 || lastRoom !== this._switcher.currentIndex) {
                 lastRoom = this._switcher.currentIndex;
                 searchCall = 0;
                 searchDistance = 0;
@@ -892,8 +911,11 @@
             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._loadTasks);
+            if (!this._loadTasks.some(t => t.index === roomIndex)) {
+                const scene = array[roomIndex];
+                if (debug) console.log("Preload scene", { roomIndex, searchForward, lastRoom, currentIndex: this._switcher.currentIndex, tasks: this._loadTasks.length }, scene?.url);
+                new LoadTask(roomIndex, scene, this._loadTasks);
+            }
         }, 200);
     }