@needle-tools/usd 0.0.1-1d6bd1e

package/src/bindings/emHdBindings.worker.js

@@ -0,0 +1,124 @@
+"use strict";
+var Module = {};
+var ENVIRONMENT_IS_NODE =
+  typeof process == "object" &&
+  typeof process.versions == "object" &&
+  typeof process.versions.node == "string";
+if (ENVIRONMENT_IS_NODE) {
+  var nodeWorkerThreads = require("worker_threads");
+  var parentPort = nodeWorkerThreads.parentPort;
+  parentPort.on("message", (data) => onmessage({ data: data }));
+  var fs = require("fs");
+  Object.assign(global, {
+    self: global,
+    require: require,
+    Module: Module,
+    location: { href: __filename },
+    Worker: nodeWorkerThreads.Worker,
+    importScripts: (f) =>
+      (0, eval)(fs.readFileSync(f, "utf8") + "//# sourceURL=" + f),
+    postMessage: (msg) => parentPort.postMessage(msg),
+    performance: global.performance || { now: Date.now },
+  });
+}
+var initializedJS = false;
+function threadPrintErr() {
+  var text = Array.prototype.slice.call(arguments).join(" ");
+  if (ENVIRONMENT_IS_NODE) {
+    fs.writeSync(2, text + "\n");
+    return;
+  }
+  console.error(text);
+}
+function threadAlert() {
+  var text = Array.prototype.slice.call(arguments).join(" ");
+  postMessage({
+    cmd: "alert",
+    text: text,
+    threadId: Module["_pthread_self"](),
+  });
+}
+var err = threadPrintErr;
+self.alert = threadAlert;
+Module["instantiateWasm"] = (info, receiveInstance) => {
+  var module = Module["wasmModule"];
+  Module["wasmModule"] = null;
+  var instance = new WebAssembly.Instance(module, info);
+  return receiveInstance(instance);
+};
+self.onunhandledrejection = (e) => {
+  throw e.reason || e;
+};
+function handleMessage(e) {
+  try {
+    if (e.data.cmd === "load") {
+      let messageQueue = [];
+      self.onmessage = (e) => messageQueue.push(e);
+      // self.addEventListener("message", e => console.log("\x1B[1;mworker received message: " + e.data.cmd + "\x1B[0m"));
+      self.startWorker = (instance) => {
+        Module = instance;
+        postMessage({ cmd: "loaded" });
+        for (let msg of messageQueue) {
+          handleMessage(msg);
+        }
+        self.onmessage = handleMessage;
+      };
+      Module["wasmModule"] = e.data.wasmModule;
+      for (const handler of e.data.handlers) {
+        Module[handler] = (...args) => {
+          postMessage({ cmd: "callHandler", handler: handler, args: args });
+        };
+      }
+      Module["wasmMemory"] = e.data.wasmMemory;
+      Module["buffer"] = Module["wasmMemory"].buffer;
+      Module["ENVIRONMENT_IS_PTHREAD"] = true;
+      if (typeof e.data.urlOrBlob == "string") {
+        importScripts(e.data.urlOrBlob);
+      } else {
+        var objectUrl = URL.createObjectURL(e.data.urlOrBlob);
+        importScripts(objectUrl);
+        URL.revokeObjectURL(objectUrl);
+      }
+      getUsdModule(Module);
+    } else if (e.data.cmd === "run") {
+      Module["__emscripten_thread_init"](e.data.pthread_ptr, 0, 0, 1);
+      Module["__emscripten_thread_mailbox_await"](e.data.pthread_ptr);
+      Module["establishStackSpace"]();
+      Module["PThread"].receiveObjectTransfer(e.data);
+      Module["PThread"].threadInitTLS();
+      if (!initializedJS) {
+        Module["__embind_initialize_bindings"]();
+        initializedJS = true;
+      }
+      try {
+        Module["invokeEntryPoint"](e.data.start_routine, e.data.arg);
+      } catch (ex) {
+        if (ex != "unwind") {
+          throw ex;
+        }
+      }
+    } else if (e.data.cmd === "cancel") {
+      if (Module["_pthread_self"]()) {
+        Module["__emscripten_thread_exit"](-1);
+      }
+    } else if (e.data.target === "setimmediate") {
+    } else if (e.data.cmd === "checkMailbox") {
+      if (initializedJS) {
+        Module["checkMailbox"]();
+      }
+    } 
+    else if (e.data.cmd === "callHandlerAsyncResult") {
+      // ignore, handled elsewhere
+    }
+    else if (e.data.cmd) {
+      err(`worker.js received unknown command ${e.data.cmd}`);
+      err(e.data);
+    }
+  } catch (ex) {
+    if (Module["__emscripten_thread_crashed"]) {
+      Module["__emscripten_thread_crashed"]();
+    }
+    throw ex;
+  }
+}
+self.onmessage = handleMessage;

package/src/bindings/index.js

@@ -0,0 +1,124 @@
+import "./emHdBindings.js";
+
+/**
+ * @type {Promise<import("..").USD> | null}
+ */
+let usd_module_promise = null;
+
+
+/**
+ * @param {undefined | import("..").GetUsdModuleOptions} opts
+ */
+export async function getUsdModule(opts) {
+
+    if (usd_module_promise) {
+        return usd_module_promise;
+    }
+
+
+    /**
+     * @type {import("..").getUsdModule}
+     */
+    const getUsdModuleFn = globalThis["NEEDLE:USD:GET"];
+
+    if (!getUsdModuleFn) {
+        throw new Error("\"NEEDLE:USD:GET\" not found in globalThis - please modify \"emHdBindings.js\" and add: globalThis[\"NEEDLE:USD:GET\"] = getUsdModule;");
+    }
+
+
+    // HACK for worker import: \"Cannot use import statement outside a module\""
+    // https://github.com/vitejs/vite/issues/6979
+
+    // @ts-ignore
+    const isProd = import.meta.env?.PROD ?? true;
+
+
+    /**
+     * We use a async import here because otherwise sveltekit vite complains about unknown file extensions (e.g. .wasm)
+     */
+    const bindingsPromise = await Promise.all([
+        /** @ts-ignore */
+        import(`./emHdBindings.js?url`),
+        /** @ts-ignore */
+        import(`./emHdBindings.data?url`),
+        // https://v3.vitejs.dev/guide/features.html#web-workers
+        // https://github.com/vitejs/vite/issues/6979
+        /** @ts-ignore */
+        import(`./emHdBindings.worker.js?worker&url`),
+        /** @ts-ignore */
+        import(`./emHdBindings.worker.js?url`),
+        /** @ts-ignore */
+        import(`./emHdBindings.wasm?url`),
+    ]);
+    const [bindings, data, workerProd, workerDev, wasm] = bindingsPromise;
+    const worker = isProd ? workerProd : workerDev;
+    const preloaded_data = await fetch(data.default).then(r => r.arrayBuffer());
+
+    return usd_module_promise = getUsdModuleFn({
+        mainScriptUrlOrBlob: bindings.default,// "./emHdBindings.js",
+        ...opts,
+        setStatus: (status) => {
+            // TODO: would be nice to have a progress event
+            // for now we parse the log 'Downloading data... (219516/849069)'
+            if (opts?.onDownloadProgress && status.includes("Downloading data...")) {
+                const start = status.indexOf("(");
+                const end = status.indexOf("/");
+                const start2 = status.indexOf("/", end);
+                const end2 = status.indexOf(")", start2);
+                const startNum = parseInt(status.substring(start + 1, end));
+                const endNum = parseInt(status.substring(end + 1, end2));
+                opts.onDownloadProgress(startNum, endNum);
+            }
+            if (opts?.setStatus) opts.setStatus(status);
+            else console.debug("🧊 USD STATUS", status);
+        },
+        locateFile: (file) => {
+            // if (opts?.debug === true) console.warn("LOCATE FILE:", file)
+
+            const userResult = opts?.locateFile?.(file);
+            if (userResult) {
+                return userResult;
+            }
+
+            /** resolved filepath */
+            let res = null;
+
+            if (file.includes("emHdBindings.data")) {
+                res = data.default;
+            }
+            else if (file.includes("emHdBindings.wasm")) {
+                res = wasm.default;
+            }
+            else if (file.includes("emHdBindings.worker.js")) {
+                res = worker.default;
+            }
+
+            // if (url?.startsWith("data:text/javascript;base64")) {
+            //     // we're client side and Buffer and atob are not available
+            //     // so we need to convert the base64 to a blob
+            //     const base64 = url.split(",")[1];
+            //     const binary = atob(base64);
+            //     const bytes = new Uint8Array(binary.length);
+            //     for (let i = 0; i < binary.length; i++) {
+            //         bytes[i] = binary.charCodeAt(i);
+            //     }
+
+            // }
+
+            return res ?? file;
+        },
+        getPreloadedPackage(name, size) {
+            const userResult = opts?.getPreloadedPackage?.(name, size);
+            if (userResult) return userResult;
+
+            // For debugging if the data file isnt loaded or the size might be wrong
+            // Make sure to clear the vite cache. See https://linear.app/needle/issue/NE-4851#comment-2a9538e3
+            if (name.includes("emHdBindings.data")) {
+                if (preloaded_data.byteLength !== size) {
+                    throw new Error(`emHdBindings.data size mismatch: expected ${size} but got ${preloaded_data.byteLength}\n${data.default}`);
+                }
+            }
+            return null;
+        },
+    });
+}

package/src/create.three.js

@@ -0,0 +1,252 @@
+import { threeJsRenderDelegate } from "./hydra/index.js";
+import { tryDetermineFileFormat } from "./utils.js";
+
+
+/**
+ * @param {{USD:import("./types").USD, filepath:string, buffer?:ArrayBuffer, parent?:string,}} opts
+ */
+async function createFile(opts) {
+    if (typeof opts.filepath !== "string") throw new Error("Filepath must be a string");
+
+    let filepath = /** @type {string} */ (opts.filepath);
+
+    let arrayBuffer = opts.buffer;
+    if (!arrayBuffer) {
+        const blob = await fetch(filepath);
+        arrayBuffer = await blob.arrayBuffer();
+    }
+
+    // ensure that file paths are not using slashes
+    /** @ts-ignore */
+    filepath = filepath.replaceAll(/\\/g, "/").replaceAll("/", "_");
+
+    const format = tryDetermineFileFormat(arrayBuffer);
+    const ext = filepath.split(".").pop();
+    if (ext !== "usdz" && ext !== "usd" && ext !== "usda") {
+        if (format === "usdz" || format === "usd" || format === "usda") {
+            filepath += "." + format;
+        } else {
+            console.warn("Unknown file format - assuming .usdz");
+            filepath += ".usdz";
+        }
+    }
+    else if (format !== ext) {
+        console.warn("File extension does not match file format", { ext, format });
+    }
+
+    // Put a simple USDZ file into the virtual file system so USD can access it
+    // Create a file in the virtual file system
+    opts.USD.FS_createDataFile("", filepath, new Uint8Array(arrayBuffer), true, true, true);
+    return filepath;
+}
+
+export class USDLoadingManager {
+    static urlModifier = null;
+    static setURLModifier(urlModifier) {
+        USDLoadingManager.urlModifier = urlModifier;
+    }
+}
+
+/**
+ * Set up a Three.js Hydra render delegate.
+ * @param {import(".").createThreeHydraConfig} config
+ * @returns {Promise<import(".").NeedleThreeHydraHandle>}
+ */
+export async function createThreeHydra(config) {
+    const debug = config.debug || false;
+
+    config.USD.debug = debug;
+
+    if (debug) console.log("USD", config.USD);
+
+    await config.USD.ready.catch(console.error);
+
+    const { buffer, USD } = config;
+
+    // Some common directory is needed so that we don't get clashes with root-level files
+    // and directories in the virtual file system
+    const directoryForFiles = "needle/";
+
+    // We're loading all provided files into the virtual file system.
+    // Potentially, we could also resolve dropped files on the fly and load them only when needed,
+    // but this requires HTTPAssetResolver changes
+    if (Array.isArray(config.files)) {
+        for (const file of config.files) {
+            let fileName = file.name;
+            let directory = "/";
+            if (file.path) {
+                const parts = file.path.split('/');
+                if (parts.length > 1) {
+                    fileName = parts.pop() || fileName;
+                    directory = file.path.substring(0, file.path.length - fileName.length);
+                }
+            }
+
+            USD.FS_createPath("", directoryForFiles + directory, true, true);
+            USD.FS_createDataFile(directoryForFiles + directory, fileName, new Uint8Array(await file.arrayBuffer()), true, true, true);
+        }
+    }
+
+    // Capabilities of the loader.
+    // This depends on the HttpAssetResolver implementation and the virtual file system.
+    const allowFetchWebUrls = true;
+    const allowFetchLocalFiles = true;
+
+    // Which file we actually load as root file depends:
+    // - when an array of files is provided, we use the first one;
+    // - when a URL is provided, we use that;
+    // - when a blob is provided, we create a file from that blob and sanitize the filename.
+    let file = "";
+    if (config.files?.length) {
+        file = directoryForFiles + config.files[0].path;
+    }
+    else if (config.url) {
+        const isBlob = config.url.startsWith("blob");
+        const isWebUrl = config.url.startsWith("http");
+        if (isBlob) {
+            file = await createFile({ USD, filepath: config.url, buffer });
+        }
+        else if ((allowFetchWebUrls && isWebUrl) || allowFetchLocalFiles) {
+            file = config.url;
+        }
+        else {
+            file = await createFile({ USD, filepath: config.url, buffer });
+        }
+    }
+
+    // Log the virtual file system, composed of a hierarchy of FSNode objects
+    if (debug) {
+        console.log("VIRTUAL FILESYSTEM", USD.FS_analyzePath("/"));
+        console.log("MAIN FILE", file);
+    }
+
+    /**
+     * @type {null | import(".").HdWebSyncDriver | Promise<import(".").HdWebSyncDriver>}
+     */
+    let driverOrPromise = null;
+
+    /**
+     * @type {import(".").threeJsRenderDelegateConfig}
+     */
+    const delegateConfig = {
+        usdRoot: config.scene,
+        paths: new Array(),
+        driver: () => /** @type {import(".").HdWebSyncDriver} */(driverOrPromise),
+    };
+
+    const renderInterface = new threeJsRenderDelegate(delegateConfig);
+
+    if (debug) console.log("RENDER INTERFACE", renderInterface);
+
+    driverOrPromise = new config.USD.HdWebSyncDriver(renderInterface, file);
+    if (driverOrPromise instanceof Promise) {
+        driverOrPromise = await driverOrPromise;
+    }
+
+    const driver = /** @type {import(".").HdWebSyncDriver} */ (driverOrPromise);
+
+    if (debug) console.log("DRIVER", driver);
+
+    /** Draw once */
+    driver.Draw();
+
+    let stage = driver.GetStage();
+    if (stage instanceof Promise) {
+        stage = await stage;
+        stage = driver.GetStage();
+    }
+
+    /** Support for Y and Z up-axis in the root USD file */
+    delegateConfig.usdRoot.rotation.x = String.fromCharCode(stage.GetUpAxis()) === 'z' ? -Math.PI / 2 : 0;
+
+    let time = 0;
+
+    if (debug) {
+        console.log("STAGE", stage);
+        console.log("VIRTUAL FILESYSTEM", USD.FS_analyzePath("/"));
+    }
+
+    return {
+        driver: /** @type {import(".").HdWebSyncDriver} */ (driverOrPromise),
+        update: (dt) => {
+            // ensure we're not dead
+            if (driver.isDeleted()) {
+                if (debug) {
+                    if (config["debug:delete"] === undefined)
+                        console.error("Called update for three hydra after it was deleted!");
+                    config["debug:delete"] = true;
+                }
+                return;
+            }
+            time += dt;
+            let timecode = time * stage.GetTimeCodesPerSecond();
+            timecode = timecode % (stage.GetEndTimeCode() - stage.GetStartTimeCode());
+            driver.SetTime(timecode);
+            driver.Draw();
+        },
+        /**
+         * Dipoose the Three Hydra delegate.
+         * This does *not* clear the threejs scene but only dispose the USD delegate and loaded files
+         */
+        dispose: () => {
+            if (debug) console.warn("Disposing Three Hydra");
+
+            // Unlink all generated files and folders in the virtual file system.
+            const unlinkedFiles = new Set();
+            function unlinkFiles(dir, path) {
+                for (const fileName of Object.keys(dir.contents)) {
+                    const file = dir.contents[fileName];
+                    if (file.isFolder) {
+                        unlinkFiles(file, path + fileName + "/");
+                    }
+                    const fullPath = path + fileName;
+                    if (file.isFolder) {
+                        if (debug) console.log("unlinking folder", fullPath);
+                        try {
+                            config.USD.FS_rmdir(path + fileName);
+                        }
+                        catch (e) {
+                            console.error("Error unlinking folder", fullPath, e);
+                        }
+                    }
+                    else {
+                        if (debug) console.log("unlinking", fullPath);
+                        unlinkedFiles.add(fullPath);
+                        try {
+                            config.USD.FS_unlink(fullPath);
+                        }
+                        catch (e) {
+                            console.error("Error unlinking", fullPath, e);
+                        }
+                    }
+                }
+            }
+
+            function rmRootDir(rootDir) {
+                const allFiles = config.USD.FS_analyzePath(rootDir).object;
+                if (allFiles)
+                    unlinkFiles(allFiles, rootDir);
+            }
+
+            rmRootDir("/" + directoryForFiles);
+            rmRootDir("/1/"); // HTTPAssetResolver puts files into a series of folders named "/1/1/1/1" to allow for parent traversal
+
+            if (!unlinkedFiles.has(file)) {
+                if (debug) console.warn("Unlinking main file", file);
+                let fileToUnlink = file;
+                if (fileToUnlink.startsWith("http"))
+                    fileToUnlink = "/" + fileToUnlink.replace("://", ":/");
+                try {
+                    config.USD.FS_unlink(fileToUnlink);
+                } catch (e) {
+                    console.error("Error unlinking main file", fileToUnlink, e);
+                }
+            }
+
+            driver.delete();
+            driverOrPromise = null;
+
+            if (debug) console.warn("Disposed Three Hydra");
+        },
+    }
+}