@needle-tools/engine 4.16.4-next.90e872e → 4.16.4-next.d7334fa

package/plugins/vite/alias.js

@@ -1,50 +1,46 @@
-import { createWriteStream, existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { createWriteStream, existsSync, mkdirSync } from 'fs';
 import path from 'path';
 import { needleLog } from './logging.js';
 
 const projectDir = process.cwd() + "/";
 
 /**
- * @typedef {"auto-resolve" | ((res: string, packageName: string, index: number, path: string) => string | null | void)} PackageResolveValue
+ * @typedef {"auto-resolve" | ((res: string, packageName: string, index: number, importPath: string) => string | null | void)} PackageResolveValue
  */
 
-/** these are alias callbacks as in the vite.alias dictionary
- * the first argument is the already resoled absolute path (it is only invoked if the path was found in node_modules)
- * the 2,3,4 args are the same as in vite.alias (packageName, index, path);
- */
 /**
  * @type {Record<string, PackageResolveValue>}
  */
 const packages_to_resolve = {
     // We are currently overriding "three" resolution to ensure that all dependencies resolve to the same three.js version.
-    // This is hacky, but the alternative is potentially having conflicting three.js versions since some packages are 
+    // This is hacky, but the alternative is potentially having conflicting three.js versions since some packages are
     // stubborn with their peer dependencies or just slow (slower as we) with updating.
     // NOT adding this allows node.js to correctly resolve `exports` specified in three.js package.json;
     // since we're overriding resolution here we need to manually resolve the subset of exports that we use.
-    'three/addons': (res, packageName, index, path) => {
+    'three/addons': (res, packageName, index, importPath) => {
         return "three/examples/jsm";
     },
-    'three/nodes': (res, packageName, index, path) => {
+    'three/nodes': (res, packageName, index, importPath) => {
         return "three/examples/jsm/nodes/Nodes.js";
     },
     'three': "auto-resolve",
 
     // Handle all previous imports where users did import using @needle-engine/src
-    '@needle-tools/engine/src': (res, packageName, index, path) => {
+    '@needle-tools/engine/src': (res, packageName, index, importPath) => {
         // resolve old engine/src imports UNLESS it's the asap plugin (the asap plugin currently only exists in the src folder)
-        if (!path.startsWith("@needle-tools/engine/src/asap")) {
+        if (!importPath.startsWith("@needle-tools/engine/src/asap")) {
             return res + "/../lib";
         }
     },
-    /* 
-    Removed the previously present @needle-tools/engine entry 
+    /*
+    Removed the previously present @needle-tools/engine entry
     because this is automatically done by vite according to whatever we define in our package.json exports
     This did previously prevent us from declaring proper exports in package.json
     */
-    '@needle-tools/engine': (res, packageName, index, _path) => {
+    '@needle-tools/engine': (res, packageName, index, importPath) => {
         // Check if the import is something like @needle-tools/engine/engine/engine_utils
         // in which case we want to resolve into the lib directory
-        if (_path.startsWith("@needle-tools/engine/engine")) {
+        if (importPath.startsWith("@needle-tools/engine/engine")) {
             return res + "/lib";
         }
         const node_modules_path = path.resolve(projectDir, 'node_modules', '@needle-tools/engine');
@@ -60,10 +56,6 @@ const packages_to_resolve = {
     'three-mesh-bvh': "auto-resolve",
     'postprocessing': "auto-resolve",
     '@dimforge/rapier3d-compat': "auto-resolve",
-
-    // Note: this isnt necessary anymore since we exclude needle-engine from optimization when locally installed in the dev server
-    // '@needle-tools/gltf-progressive': "auto-resolve",
-    // '@needle-tools/materialx': "auto-resolve",
 }
 
 /**
@@ -98,32 +90,91 @@ export function needleViteAlias(command, config, userSettings) {
         log("Logging to:", outputFilePath);
     }
 
+    // Pre-compute resolved paths for each package
+    /** @type {Array<{name: string, fullpath: string, pathExists: boolean, isNestedInEngine: boolean, callback: ((res: string, packageName: string, index: number, importPath: string) => string | null | void) | null}>} */
+    const resolvers = [];
+    /** @type {Array<{find: string, replacement: string}>} Aliases for nested engine auto-resolve packages */
+    const nestedAliases = [];
+    for (const name in packages_to_resolve) {
+        const value = packages_to_resolve[name];
+        const callback = typeof value === "function" ? value : null;
+        const isAutoResolve = value === "auto-resolve";
+
+        let fullpath = path.resolve(projectDir, 'node_modules', name);
+        let isNestedInEngine = false;
+        {
+            const pathInEngine = path.resolve(projectDir, 'node_modules', "@needle-tools/engine", "node_modules", name);
+            if (existsSync(pathInEngine)) {
+                fullpath = pathInEngine;
+                isNestedInEngine = true;
+            }
+        }
+        const pathExists = existsSync(fullpath);
+        resolvers.push({ name, fullpath, pathExists, isNestedInEngine, callback });
+
+        // For auto-resolve packages nested in the engine, use resolve.alias so both
+        // the optimizer and resolveId see the same path. This ensures Vite pre-bundles
+        // these deps (handling CJS interop) while keeping a single copy.
+        if (isAutoResolve && isNestedInEngine && pathExists) {
+            nestedAliases.push({ find: name, replacement: fullpath });
+        }
+    }
+
+    const workingDirectory = `${process.cwd()}/`;
 
     /** @type {import("vite").Plugin} */
     const aliasPlugin = {
         name: "needle-alias",
+        // Register resolve.alias for nested engine packages so Vite's optimizer
+        // can find and pre-bundle them (with proper CJS interop).
         config(config) {
-            if (debug) log('ProjectDirectory: ' + projectDir);
-            if (!config.resolve) config.resolve = {};
-            if (!config.resolve.alias) config.resolve.alias = {};
-            const aliasDict = config.resolve.alias;
-
-            for (const name in packages_to_resolve) {
-                if (!aliasDict[name]) {
-                    addPathResolver(name, aliasDict, packages_to_resolve[name], debug ?? false);
+            if (nestedAliases.length > 0) {
+                if (!config.resolve) config.resolve = {};
+                // resolve.alias can be an array of {find,replacement} or a Record<string,string>.
+                // Convert to array format if needed (works in Vite 2-8).
+                if (!config.resolve.alias) {
+                    config.resolve.alias = [];
+                }
+                else if (!Array.isArray(config.resolve.alias)) {
+                    // Convert Record<string,string> to array format
+                    const entries = Object.entries(config.resolve.alias);
+                    config.resolve.alias = entries.map(([find, replacement]) => ({ find, replacement }));
+                }
+                for (const alias of nestedAliases) {
+                    config.resolve.alias.push(alias);
+                    needleLog("needle-alias", `Adding resolve.alias: ${alias.find} → ${alias.replacement.split('node_modules/').pop()}`);
                 }
             }
+        },
+        // Use resolveId instead of resolve.alias to support both Rollup and Rolldown (Vite 8+).
+        // Rolldown does not support function-based alias replacements.
+        enforce: 'pre',
+        async resolveId(id, _importer, _options) {
+            for (const { name, fullpath, pathExists, isNestedInEngine, callback } of resolvers) {
+                // Check if import matches this resolver (exact match or starts with name/)
+                if (id !== name && !id.startsWith(name + '/')) continue;
+
+                if (callback !== null) {
+                    const overrideResult = callback(fullpath, name, 0, id);
+                    if (typeof overrideResult === "string") {
+                        if (debug) log(`Redirecting "${id}"   →   "${overrideResult}"`);
+                        // Let Vite resolve the result further (handles directories, package.json exports, etc.)
+                        return this.resolve(overrideResult, _importer, { skipSelf: true });
+                    }
+                }
 
-
-            if (debug) {
-                const testResults = [];
-                for (const name in aliasDict) {
-                    const entry = aliasDict[name];
-                    let res = entry;
-                    if (typeof entry === "function") res = entry(name, 0, name);
-                    testResults.push({ name, entry: res });
+                // For auto-resolve packages in the project's own node_modules,
+                // let Vite handle resolution naturally (preserves CJS interop / optimizeDeps).
+                // Only redirect when the package is nested inside @needle-tools/engine/node_modules.
+                if (pathExists && (callback !== null || isNestedInEngine)) {
+                    if (debug) log(`Resolved "${id}"   →   "${fullpath.substring(workingDirectory.length).replaceAll("\\", "/")}"`);
+                    // Rewrite the import to resolve from the target directory, letting Vite handle package.json/exports
+                    const subpath = id.substring(name.length); // e.g. "" or "/something"
+                    const rewritten = fullpath + subpath;
+                    return this.resolve(rewritten, _importer, { skipSelf: true });
                 }
-                log('Aliases: ' + JSON.stringify(testResults));
+
+                break;
             }
         },
     }
@@ -145,9 +196,6 @@ export function needleViteAlias(command, config, userSettings) {
                 if (importer.includes("node_modules/.vite")) importer = ".vite" + importer.split("node_modules/.vite")[1];
             }
 
-            // could filter here, e.g. for things related to three
-            // if (id.includes("three")) return;
-
             // verbose logging for all imports
             if (lastImporter !== importer) {
                 lastImporter = importer;
@@ -159,47 +207,4 @@ export function needleViteAlias(command, config, userSettings) {
     }
     if (debug) return [debuggingPlugin, aliasPlugin];
     return [aliasPlugin];
-
-
-    /**
-     * Adds a path resolver to the alias dictionary.
-     * @param {string} name - The name of the package to resolve.
-     * @param {import("vite").AliasOptions} aliasDict - The alias dictionary to add the resolver to.
-     * @param {PackageResolveValue | null} value - A callback function to override the default resolution behavior.
-     * @param {boolean} debug - Whether to log debug information.
-     * @returns {void}
-     */
-    function addPathResolver(name, aliasDict, value, debug) {
-        // If a package at the node_modules path exist we resolve the request there
-        // introduced in 89a50718c38940abb99ee16c5e029065e41d7d65
-        const callback = typeof value === "function" ? value : null;
-
-        let fullpath = path.resolve(projectDir, 'node_modules', name);
-        // if (!existsSync(path.resolve(fullpath, "package.json"))) 
-        {
-            const pathInEngine = path.resolve(projectDir, 'node_modules', "@needle-tools/engine", "node_modules", name);
-            if (existsSync(pathInEngine)) {
-                fullpath = pathInEngine;
-            }
-        }
-
-        const workingDirectory = `${process.cwd()}/`;
-        const pathExists = existsSync(fullpath);
-
-        aliasDict[name] = (packageName, index, path) => {
-            if (callback !== null) {
-                const overrideResult = callback(fullpath, packageName, index, path);
-                if (typeof overrideResult === "string")
-                    if (existsSync(overrideResult)) {
-                        if (debug && overrideResult !== packageName) log(`[needle-alias] Resolved \"${path}\"   →   \"${overrideResult.substring(workingDirectory.length).replaceAll("\\", "/")}\"`);
-                        return overrideResult;
-                    }
-            }
-
-            if (pathExists) {
-                if (debug && path !== packageName) log(`[needle-alias] Resolved \"${path}\"   →   \"${fullpath.substring(workingDirectory.length).replaceAll("\\", "/")}\"`);
-                return fullpath;
-            }
-        }
-    }
 }

package/plugins/vite/build-pipeline.js

@@ -130,9 +130,10 @@ export async function needleBuildPipeline(command, config, userSettings) {
             if (verboseOutput) {
                 log("Apply:", env);
             }
-            // Don't run for SSR builds (e.g. sveltekit). 
-            // Unfortunately this is always falls in vite 4.3 so we can not rely on it solely
-            if (env.ssrBuild) return false;
+            // Don't run for SSR builds (e.g. sveltekit).
+            // Unfortunately this is always false in vite 4.3 so we can not rely on it solely
+            // Vite 8+ renamed ssrBuild to isSsrBuild
+            if (env.isSsrBuild ?? env.ssrBuild) return false;
             // Dont run if there's already a build pipeline task running
             if (env.command === "build") {
                 increaseMaxWaitTime(verboseOutput);

package/plugins/vite/dependencies.js

@@ -103,14 +103,16 @@ function handleManualChunks(config) {
     if (!config.build) {
         config.build = {};
     }
-    if (!config.build.rollupOptions) {
-        config.build.rollupOptions = {};
+    // Support both rolldownOptions (Vite 8+) and rollupOptions (Vite 7 and earlier)
+    const optionsKey = 'rolldownOptions' in (config.build) ? 'rolldownOptions' : 'rollupOptions';
+    if (!config.build[optionsKey]) {
+        config.build[optionsKey] = {};
     }
-    if (!config.build.rollupOptions.output) {
-        config.build.rollupOptions.output = {};
+    if (!config.build[optionsKey].output) {
+        config.build[optionsKey].output = {};
     }
 
-    const rollupOutput = config.build.rollupOptions.output;
+    const rollupOutput = config.build[optionsKey].output;
 
     if (Array.isArray(rollupOutput)) {
         // append the manualChunks function to the array

package/plugins/vite/drop.js

@@ -42,16 +42,14 @@ export function needleDrop(command, config, userSettings) {
                 ];
             },
         },
-        configureServer(/** @type {{ ws: { on(event: string, cb: (...args: unknown[]) => void): void, send(type: string, data?: unknown): void } }} */ server) {
+        configureServer(/** @type {import('vite').ViteDevServer} */ server) {
+            const hot = server.hot ?? server.ws;
 
-            server.ws.on('needle:drop-file', async (/** @type {unknown} */ data, /** @type {unknown} */ client) => {
-                server.ws.send('needle-editor:drop-file', data);
+            hot.on('needle:drop-file', async (/** @type {unknown} */ data, /** @type {unknown} */ client) => {
+                hot.send('needle-editor:drop-file', data);
             });
-            // TODO: not sure how we can receive it with the normal vite server
-            // server.ws.on("custom", (data, client) => {
-            //     console.log(data);
-            // })
 
+            // Raw WebSocket access for editor messages
             server.ws.on('connection', (/** @type {{ on(event: string, cb: (...args: unknown[]) => void): void }} */ socket, /** @type {unknown} */ request) => {
                 socket.on('message', async (/** @type {Buffer | string} */ bytes) => {
                     try {
@@ -59,7 +57,7 @@ export function needleDrop(command, config, userSettings) {
                         if (message && message.startsWith("{")) {
                             const obj = /** @type {{ type: string, data: unknown }} */ (JSON.parse(message));
                             if (obj.type === "needle-editor:exported-file") {
-                                server.ws.send(obj.type, obj.data);
+                                hot.send(obj.type, obj.data);
                             }
                         }
                     }

package/plugins/vite/editor-connection.js

@@ -86,8 +86,9 @@ function createPlugin(isInstalled) {
         },
 
         configureServer(server) {
-            try 
+            try
             {
+                // Raw WebSocket access needed for direct socket communication
                 server.ws.on('connection', (socket, _request) => {
     
                     // console.log("Send editor sync status: " + isInstalled);

package/plugins/vite/index.js

@@ -158,5 +158,17 @@ export async function needlePlugins(command, config = undefined, userSettings =
 
     array.push(await editorConnection(command, config, userSettings, array));
     array.push(needleDependencyWatcher(command, config, userSettings));
+
+    // Ensure the process exits on SIGINT (Ctrl+C) since plugin timers/sockets can keep the event loop alive
+    if (command === "serve") {
+        process.on('SIGINT', () => {
+            // Wait a moment to allow plugins to clean up if needed, then exit
+            setTimeout(() => {
+                console.debug('\nGoodbye!');
+                process.exit();
+            }, 1000);
+        });
+    }
+
     return array;
 }

package/plugins/vite/poster.js

@@ -24,7 +24,8 @@ export function needlePoster(command, config, userSettings) {
     return {
         name: 'needle:poster',
         configureServer(server) {
-            server.ws.on('needle:screenshot', async (data, client) => {
+            const hot = server.hot ?? server.ws;
+            hot.on('needle:screenshot', async (data, client) => {
                 if (userSettings.noPoster) return;
                 if (!data?.data) {
                     console.warn("Received empty screenshot data, ignoring");

package/plugins/vite/reload.js

@@ -112,10 +112,15 @@ const posterPath = getPosterPath();
 let reloadIsScheduled = false;
 const lockFileName = "needle.lock";
 
+/** @param {import('vite').ViteDevServer} server */
+function getHot(server) {
+    return server.hot ?? server.ws;
+}
+
 /** @param {import('vite').ViteDevServer} server @param {string} [file] */
 function notifyClientWillReload(server, file) {
     console.log("Send reload notification");
-    server.ws.send('needle:reload', { type: 'will-reload', file: file });
+    getHot(server).send('needle:reload', { type: 'will-reload', file: file });
 }
 
 /**
@@ -236,7 +241,7 @@ async function scheduleReload(server, level = 0) {
     lastReloadTime = Date.now();
     const readableTime = new Date(lastReloadTime).toLocaleTimeString();
     console.log("< Reloading... " + readableTime)
-    server.ws.send({
+    getHot(server).send({
         type: 'full-reload',
         path: '*'
     });

package/src/engine/engine_feature_flags.ts

@@ -1,8 +1,4 @@
 
-
-export namespace NEEDLE_ENGINE_FEATURE_FLAGS {
-
-    // eslint-disable-next-line prefer-const
-    export let experimentalSmartHierarchyUpdate = false;
-
-}
+export const NEEDLE_ENGINE_FEATURE_FLAGS = {
+    experimentalSmartHierarchyUpdate: false,
+};

package/src/engine/engine_lods.ts

@@ -14,8 +14,10 @@ const _tempBox: Box3 = new Box3();
 const _tempSphere: Sphere = new Sphere();
 
 /**
- * Needle Engine LODs manager. Wrapper around the internal LODs manager.  
- * It uses the @needle-tools/gltf-progressive package to manage LODs.
+ * Needle Engine LODs manager. Wrapper around the internal LODs manager.
+ * It uses the [@needle-tools/gltf-progressive](https://npmjs.com/package/@needle-tools/gltf-progressive) package to manage LODs.
+ *
+ * For lower-level control (e.g. configuring max concurrent loading tasks, queue settings, or other progressive loading specifics), use {@link NEEDLE_progressive} directly.
  * @link https://npmjs.com/package/@needle-tools/gltf-progressive
  */
 export class LODsManager implements NEEDLE_progressive_plugin {
@@ -37,6 +39,11 @@ export class LODsManager implements NEEDLE_progressive_plugin {
         return this._lodsManager;
     }
 
+    /**
+     * The interval (in seconds) at which the bounding volumes of skinned meshes are automatically updated.  
+     * If set to 0, automatic updates are disabled and bounding volumes will only be updated when the mesh is loaded or when the `updateSkinnedMeshBounds` method is called manually.  
+     * @default 0
+     */
     get skinnedMeshAutoUpdateBoundsInterval() {
         return this._lodsManager?.skinnedMeshAutoUpdateBoundsInterval || this._settings.skinnedMeshAutoUpdateBoundsInterval || 0;
     }
@@ -57,6 +64,7 @@ export class LODsManager implements NEEDLE_progressive_plugin {
         this.applySettings();
     }
 
+    /** @internal */
     constructor(context: Context) {
         this.context = context;
     }

package/src/engine/engine_mainloop_utils.ts

@@ -270,6 +270,10 @@ export function isNeedleXRSessionEventReceiver(script: any, mode: XRSessionMode
 }
 
 
+
+
+// #region activeInHierarchy
+
 let needsUpdate = true;
 export function markHierarchyDirty() {
     needsUpdate = true;
@@ -304,7 +308,7 @@ export function updateIsActive(obj?: Object3D, force: boolean = false) {
     }
 }
 
-function updateIsActiveInHierarchyRecursiveRuntime(go: Object3D, activeInHierarchy: boolean, allowEventCall: boolean, level: number = 0) {
+function updateIsActiveInHierarchyRecursiveRuntime(go: Object3D, activeInHierarchy: boolean, allowEventCall: boolean, level: number = 0): boolean {
     if (level > 1000) {
         console.warn("Hierarchy is too deep (> 1000 level) - will abort updating active state");
         return false;
@@ -336,74 +340,70 @@ function updateIsActiveInHierarchyRecursiveRuntime(go: Object3D, activeInHierarc
         go[constants.activeInHierarchyFieldName] = activeInHierarchy;
 
         if (debugHierarchy)
-            console.warn("ACTIVE CHANGE", go.name, activeSelf, go.visible, activeInHierarchy, "changed?" + changed, go);
+            console.warn("ACTIVE CHANGE", { name: go.name, activeSelf, visible: go.visible, activeInHierarchy, changed, go });
         if (allowEventCall) {
-            perComponent(go, comp => {
-                if (activeInHierarchy) {
-                    if (comp.enabled) {
-                        safeInvoke(comp.__internalAwake.bind(comp));
+            const components = go.userData?.components;
+            if (components) {
+                for (let ci = 0, cl = components.length; ci < cl; ci++) {
+                    const comp = components[ci];
+                    if (activeInHierarchy) {
                         if (comp.enabled) {
-                            comp.__internalEnable();
+                            try { comp.__internalAwake(); }
+                            catch (err) { console.error(err); }
+                            if (comp.enabled) {
+                                comp.__internalEnable();
+                            }
                         }
                     }
-                }
-                else {
-                    if (comp["__didAwake"] && comp.enabled) {
-                        comp["__didEnable"] = false;
-                        comp.onDisable();
+                    else {
+                        if (comp["__didAwake"] && comp.enabled) {
+                            comp["__didEnable"] = false;
+                            comp.onDisable();
+                        }
                     }
                 }
-            });
+            }
         }
     }
-
-    let success = true;
-    if (go.children) {
-        for (const ch of go.children) {
-            const res = updateIsActiveInHierarchyRecursiveRuntime(ch, activeInHierarchy, allowEventCall, level + 1);
-            if (res === false) success = false;
+    const children = go.children;
+    if (children) {
+        // When this node is inactive and hasn't changed, skip children that are already
+        // marked inactive. Only recurse into children that still have a stale active=true
+        // (e.g. after reparenting into this inactive subtree).
+        if (!changed && !activeInHierarchy) {
+            let success = true;
+            for (let i = 0, l = children.length; i < l; i++) {
+                const ch = children[i];
+                if (ch[constants.activeInHierarchyFieldName] !== false) {
+                    if (updateIsActiveInHierarchyRecursiveRuntime(ch, false, allowEventCall, level + 1) === false)
+                        success = false;
+                }
+            }
+            return success;
         }
+        let success = true;
+        for (let i = 0, l = children.length; i < l; i++) {
+            if (updateIsActiveInHierarchyRecursiveRuntime(children[i], activeInHierarchy, allowEventCall, level + 1) === false)
+                success = false;
+        }
+        return success;
     }
-    return success;
+    return true;
 }
 
-// function tryFindActiveStateInParent(obj: Object3D): boolean {
-//     let current: Object3D | undefined | null = obj;
-//     while (current) {
-//         const activeState = current[constants.activeInHierarchyFieldName];
-//         if (activeState !== undefined) return activeState;
-//         if (current instanceof Scene && !current.parent) {
-//             return true;
-//         }
-//         current = current.parent;
-//     }
-//     return false;
-// }
-
-// let isRunning = false;
-// // Prevent: https://github.com/needle-tools/needle-tiny/issues/641
-// const temporyChildArrayBuffer: Array<Array<Object3D>> = [];
-// export function* iterateChildrenSafe(obj: Object3D) {
-//     if (!obj || !obj.children) yield null;
-//     // if(isRunning) return;
-//     // isRunning = true;
-//     const arr = temporyChildArrayBuffer.pop() || [];
-//     arr.push(...obj.children);
-//     for (const ch of arr) {
-//         yield ch;
-//     }
-//     // isRunning = false;
-//     arr.length = 0;
-//     temporyChildArrayBuffer.push(arr);
-// }
+
+
 
 /** @internal */
 export function updateActiveInHierarchyWithoutEventCall(go: Object3D) {
+    if (!go) {
+        console.error("GO is null");
+        return;
+    }
     let activeInHierarchy = true;
+    let foundScene = false;
     let current: Object3D | null = go;
-    let foundScene: boolean = false;
     while (current) {
-        if (!current) break;
         if (current.type === "Scene") foundScene = true;
         if (!isActiveSelf(current)) {
             activeInHierarchy = false;
@@ -411,22 +411,14 @@ export function updateActiveInHierarchyWithoutEventCall(go: Object3D) {
         }
         current = current.parent;
     }
-    if (!go) {
-        console.error("GO is null");
-        return;
-    }
     go[constants.activeInHierarchyFieldName] = activeInHierarchy && foundScene;
 }
 
-function perComponent(go: Object3D, evt: (comp: IComponent) => void) {
-    if (go.userData?.components) {
-        for (const comp of go.userData.components) {
-            evt(comp);
-        }
-    }
-}
 
 
+
+// #region prewarm
+
 const prewarmList: Map<IContext, Object3D[]> = new Map();
 const $prewarmedFlag = Symbol("prewarmFlag");
 const $waitingForPrewarm = Symbol("waitingForPrewarm");