@dcl-regenesislabs/bevy-explorer-web 0.1.0-35932535123.commit-9883f71 → 0.1.0-36033403701.commit-19347eb

package/engine/pkg/snippets/bevy_internal-2d8ddab1173ada7c/src/web_worker.js

@@ -0,0 +1,121 @@
+// The worker script of `bevy::web_worker`, and its page-side spawner. The same file runs on the
+// page, where the wasm-bindgen glue imports it, and as the script of every worker it spawns.
+//
+// A worker is told, in its init message, the url of the glue and the exports to call, in order,
+// once its wasm instance is up (over the shared module and memory the page passes). The page functions
+// the engine calls (extern blocks marked `#[page_functions]`, listed by the glue exports that
+// attribute generates) each become a function on the worker's global that posts the call to the
+// page and resolves with the page function's result. Console output is sent to the page to
+// print. When the last export returns (or its promise resolves) the worker posts
+// `{ __bevy_ready: tag }`; if importing the glue or an export fails it posts
+// `{ __bevy_ready: tag, error }` instead.
+
+/**
+ * Page side: spawns a worker and posts it its init message.
+ * @param {{ glueUrl: string, calls: { entry: string, args: any[] }[], tag: string,
+ *           module: WebAssembly.Module, memory: WebAssembly.Memory, stackSize?: number,
+ *           transfer: Transferable[] }} init
+ * @returns {Worker}
+ */
+export function spawnWorker(init) {
+  const worker = new Worker(new URL(import.meta.url), { type: "module" });
+  worker.addEventListener("message", async ({ data }) => {
+    if (!data) return;
+    if (data.__bevy_log) {
+      console[data.__bevy_log](...data.args);
+      return;
+    }
+    if (data.__bevy_call !== undefined) {
+      const fn = globalThis[data.__bevy_call];
+      let value, error;
+      try {
+        if (typeof fn !== "function") throw new Error(`${data.__bevy_call} is not defined on the page`);
+        value = await fn(...data.args);
+      } catch (err) {
+        error = err?.message ?? String(err);
+        console.error(`[bevy] ${data.tag} worker: ${data.__bevy_call} failed`, err);
+      }
+      worker.postMessage({ __bevy_result: data.__bevy_id, value, error });
+    }
+  });
+  const { transfer = [], ...message } = init;
+  worker.postMessage({ __bevy_init: message }, transfer);
+  return worker;
+}
+
+// Worker side.
+if (typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope) {
+  const pending = new Map();
+  let nextId = 1;
+  self.addEventListener("message", ({ data }) => {
+    if (!data || data.__bevy_result === undefined) return;
+    const call = pending.get(data.__bevy_result);
+    if (!call) return;
+    pending.delete(data.__bevy_result);
+    if (data.error !== undefined) call.reject(new Error(String(data.error)));
+    else call.resolve(data.value);
+  });
+  self.addEventListener("message", async ({ data }) => {
+    const init = data?.__bevy_init;
+    if (!init) return;
+    const { glueUrl, calls, tag, module, memory, stackSize } = init;
+    forwardConsole(tag);
+    try {
+      const glue = await import(glueUrl);
+      await glue.default({ module_or_path: module, memory, thread_stack_size: stackSize });
+      for (const key of Object.keys(glue)) {
+        if (!key.startsWith("__bevy_page_functions_")) continue;
+        for (const name of glue[key]()) {
+          self[name] = (...args) =>
+            new Promise((resolve, reject) => {
+              const id = nextId++;
+              pending.set(id, { resolve, reject });
+              postMessage({ __bevy_call: name, __bevy_id: id, args, tag });
+            });
+        }
+      }
+      for (const { entry, args = [] } of calls) {
+        const entryFn = glue[entry];
+        if (typeof entryFn !== "function") throw new Error(`${entry} is not exported by ${glueUrl}`);
+        await entryFn(...args);
+      }
+      postMessage({ __bevy_ready: tag });
+    } catch (e) {
+      console.error(`[bevy] ${tag} worker failed to start`, e);
+      postMessage({ __bevy_ready: tag, error: String(e?.stack ?? e) });
+    }
+  });
+}
+
+// Sends this worker's console to the page, which prints it (and whose console hooks see it).
+// It is not printed here as well: DevTools shows a worker's console alongside the page's, so
+// every line would appear twice. Arguments are passed through as-is where they can be cloned, so
+// styled (`%c`) lines render the same on the page.
+function forwardConsole(tag) {
+  for (const level of ["log", "info", "warn", "error", "debug"]) {
+    const original = console[level].bind(console);
+    console[level] = (...args) => {
+      try {
+        postMessage({ __bevy_log: level, tag, args: args.map(cloneable) });
+      } catch (_) {
+        // not cloneable: print it here instead
+        original(...args);
+      }
+    };
+  }
+  self.addEventListener("error", (e) => console.error(`[${tag} worker] uncaught: ${e.message}`));
+  self.addEventListener("unhandledrejection", (e) =>
+    console.error(`[${tag} worker] unhandled rejection: ${e.reason?.stack ?? e.reason}`)
+  );
+}
+
+function cloneable(value) {
+  if (value instanceof Error) return value.stack || value.message;
+  const t = typeof value;
+  if (t === "string" || t === "number" || t === "boolean" || t === "bigint" || value == null) return value;
+  try {
+    return JSON.stringify(value);
+  } catch (_) {
+    return String(value);
+  }
+}

package/engine/pkg/snippets/comms-53217a45365bb5fa/livekit_web_bindings.js

@@ -11,12 +11,17 @@ function error(...args) {
 var audioContext = null;
 var microphonePermission = "denied";
 
-export function setupMicrophonePermission() {
+/**
+ * @param {function} on_change called with the permission state now and whenever it changes
+ */
+export function setupMicrophonePermission(on_change) {
     navigator.permissions.query({ name: "microphone" }).then((permissionState) => {
         microphonePermission = permissionState.state;
+        on_change(microphonePermission);
 
         permissionState.onchange = () => {
             microphonePermission = permissionState.state;
+            on_change(microphonePermission);
         };
     });
 }
@@ -60,7 +65,13 @@ export async function room_connect(url, token, room_options, room_connect_option
 
     set_room_event_handler(room, handler);
 
-    await room.connect(url, token, room_connect_options);
+    try {
+        await room.connect(url, token, room_connect_options);
+    } catch (err) {
+        // the handler does not outlive a failed connect
+        room.removeAllListeners();
+        throw err;
+    }
 
     return room;
 }
@@ -73,6 +84,14 @@ export async function room_close(room) {
     await room.disconnect();
 }
 
+/**
+ * Releases a room the engine dropped: its event handler is gone.
+ * @param {livekit.Room} room
+ */
+export function room_drop(room) {
+    room.removeAllListeners();
+}
+
 /**
  * 
  * @param {livekit.Room} room
@@ -439,6 +458,30 @@ export function remote_track_publication_track(remote_track_publication) {
     return remote_track_publication.track;
 }
 
+/**
+ * @param {livekit.LocalTrackPublication} local_track_publication
+ * @returns string
+ */
+export function local_track_publication_sid(local_track_publication) {
+    return local_track_publication.trackSid;
+}
+
+/**
+ * @param {livekit.LocalTrackPublication} local_track_publication
+ * @returns string
+ */
+export function local_track_publication_kind(local_track_publication) {
+    return local_track_publication.kind;
+}
+
+/**
+ * @param {livekit.LocalTrackPublication} local_track_publication
+ * @returns string
+ */
+export function local_track_publication_source(local_track_publication) {
+    return local_track_publication.source;
+}
+
 /**
  * 
  * @param {livekit.AudioCaptureOptions} options 
@@ -452,15 +495,6 @@ export async function local_audio_track_new(options) {
     }
 }
 
-/**
- * 
- * @param {livekit.LocalAudioTrack} local_audio_track 
- * @returns livekit.TrackSid
- */
-export function local_audio_track_sid(local_audio_track) {
-    return local_audio_track.sid;
-}
-
 /**
  * 
  * @param {livekit.RemoteTrack} remote_track 
@@ -522,8 +556,8 @@ function track_rig_drop(remote_track) {
 export function remote_track_pan_and_volume(remote_track, pan, volume) {
     // log(`Setting pan and volume for track ${remote_track.sid}.`);
     const track_rig = remote_track.trackRig;
-    // Pan value should be between -1 (left) and 1 (right)
-    track_rig.pannerNode.pan.value = Math.max(-1, Math.min(1, pan));
+    // kira's 0 (left) .. 1 (right) to the stereo panner's -1 .. 1
+    track_rig.pannerNode.pan.value = Math.max(-1, Math.min(1, pan * 2 - 1));
     // Volume should be between 0 and 1 (or higher for boost)
     track_rig.gainNode.gain.value = Math.max(0, volume);
 

package/engine/pkg/snippets/decentra-bevy-f9c23e535711925a/deploy/web/engine/gpu_cache.js

@@ -0,0 +1,439 @@
+var count = 0;
+
+function simpleHash(s) {
+  var h = 0x811c9dc5;
+
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h += (h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24);
+  }
+
+  return h >>> 0;
+}
+
+var gpuSessionState = {};
+var requiredItemTypes = new Map();
+var precaching = false;
+
+const dbConfig = {
+  name: "GpuCacheDB",
+  version: 1,
+  onUpgrade: (db) => {
+    if (!db.objectStoreNames.contains("shader")) db.createObjectStore("shader");
+    if (!db.objectStoreNames.contains("bindgroup"))
+      db.createObjectStore("bindgroup");
+    if (!db.objectStoreNames.contains("layout")) db.createObjectStore("layout");
+    if (!db.objectStoreNames.contains("pipeline"))
+      db.createObjectStore("pipeline");
+    if (!db.objectStoreNames.contains("requiredItems"))
+      db.createObjectStore("requiredItems");
+    if (!db.objectStoreNames.contains("deviceConfig"))
+      db.createObjectStore("deviceConfig");
+  },
+};
+
+var dbPromise;
+function openDB() {
+  if (dbPromise) {
+    return dbPromise;
+  }
+  dbPromise = new Promise((resolve, reject) => {
+    const request = indexedDB.open(dbConfig.name, dbConfig.version);
+    request.onupgradeneeded = (event) => {
+      dbConfig.onUpgrade(event.target.result);
+    };
+    request.onsuccess = (event) => resolve(event.target.result);
+    request.onerror = (event) => reject(event.target.error);
+  });
+  return dbPromise;
+}
+
+async function clearDatabase() {
+  const db = await openDB();
+
+  const tableNames = ["shader", "bindgroup", "layout", "pipeline", "requiredItems"];
+
+  const tx = db.transaction(tableNames, "readwrite");
+
+  const clearPromises = tableNames.map(name => {
+    const store = tx.objectStore(name);
+    const request = store.clear();
+    return new Promise((resolve, reject) => {
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  });
+
+  await Promise.all(clearPromises);
+  await new Promise((resolve, reject) => {
+    tx.oncomplete = resolve;
+    tx.onabort = reject;
+    tx.onerror = reject;
+  });
+}
+
+async function fetchRequiredItems() {
+  const db = await openDB();
+  return new Promise((resolve) => {
+    const tx = db.transaction("requiredItems", "readonly");
+    const request = tx.objectStore("requiredItems").get("it");
+    request.onsuccess = () => {
+      resolve(request.result ?? new Map());
+    };
+    request.onerror = () => {
+      resolve(new Map());
+    };
+  });
+}
+
+async function storeRequiredItems() {
+  const db = await openDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction("requiredItems", "readwrite");
+    tx.oncomplete = () => {
+      resolve();
+    };
+    tx.onerror = () => {
+      console.log("[GPU Cache] failed to store requiredItems");
+      reject(tx.error);
+    };
+    tx.objectStore("requiredItems").put(requiredItemTypes, "it");
+  });
+}
+
+// The small settings that lived in localStorage, which a worker has no access to.
+async function getConfig(key) {
+  const db = await openDB();
+  return new Promise((resolve) => {
+    const request = db.transaction("deviceConfig", "readonly").objectStore("deviceConfig").get(key);
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => resolve(undefined);
+  });
+}
+
+async function setConfig(key, value) {
+  const db = await openDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction("deviceConfig", "readwrite");
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+    tx.objectStore("deviceConfig").put(value, key);
+  });
+}
+
+async function fetchInstance(type, hash) {
+  const db = await openDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(type, "readonly");
+    const request = tx.objectStore(type).get(hash);
+    request.onsuccess = () => {
+      if (request.result) {
+        resolve(JSON.parse(request.result));
+      } else {
+        reject("undefined");
+      }
+    };
+    request.onerror = () => {
+      reject("error");
+    };
+  });
+}
+
+async function storeInstance(type, hash, value) {
+  const db = await openDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(type, "readwrite");
+    tx.oncomplete = () => {
+      resolve();
+    };
+    tx.onerror = () => {
+      console.log("[GPU Cache] failed to store ${type} instance");
+      reject(tx.error);
+    };
+    tx.objectStore(type).put(JSON.stringify(value), hash);
+  });
+}
+
+export async function initGpuCache(key, fakeAsync) {
+  console.log(`[GPU Cache] key: ${key}`);
+  patchWebgpuAdapter(fakeAsync);
+  await createGpuCache(key);
+}
+
+function patchWebgpuAdapter(fakeAsync) {
+  const originalRequestDevice = GPUAdapter.prototype.requestDevice;
+  GPUAdapter.prototype.requestDevice = async function (descriptor) {
+    const jsonDescriptor = JSON.stringify(descriptor || {});
+    if (gpuSessionState.deviceDescriptor === jsonDescriptor) {
+      console.log("[GPU Cache] using precached device");
+      return gpuSessionState.device;
+    }
+
+    if (!precaching) {
+      console.log(
+        "[GPU Cache] device params are different: creating device and clearing cache"
+      );
+      clearDatabase();
+    }
+    gpuSessionState = {
+      shader: new Map(),
+      bindgroup: new Map(),
+      layout: new Map(),
+      pipeline: new Map(),
+    };
+    gpuSessionState.deviceDescriptor = jsonDescriptor;
+    var device = undefined;
+    try {
+      device = await originalRequestDevice.apply(this, [descriptor]);
+    } catch (err) {
+      console.warn("Failed to request a device with descriptor, requesting device with default parameters.");
+      device = await originalRequestDevice.apply(this, []);
+    }
+    gpuSessionState.device = device;
+    await setConfig("deviceDescriptor", jsonDescriptor);
+
+    function wrapDeviceFunction(itemType, originalFunction) {
+      return (...args) => {
+        const jsonArgs = JSON.stringify(args);
+        const hash = simpleHash(jsonArgs);
+        const cachedItem = gpuSessionState[itemType].get(hash);
+        if (cachedItem !== undefined) {
+          return cachedItem;
+        }
+
+        const item = originalFunction.apply(device, args);
+        item.__gpu_item_type = itemType;
+        item.__gpu_hash = hash;
+        gpuSessionState[itemType].set(hash, item);
+
+        if (!precaching) {
+          console.log(`[GPU Cache] no cached ${itemType} for ${hash}`);
+          if (!requiredItemTypes.has(itemType)) {
+            requiredItemTypes.set(itemType, new Set());
+          }
+          const requiredItems = requiredItemTypes.get(itemType);
+          if (!requiredItems.has(hash)) {
+            requiredItems.add(hash);
+            storeRequiredItems();
+            storeInstance(itemType, hash, args);
+          }
+        }
+        return item;
+      };
+    }
+
+    device.createShaderModule = wrapDeviceFunction(
+      "shader",
+      device.createShaderModule
+    );
+    device.createBindGroupLayout = wrapDeviceFunction(
+      "bindgroup",
+      device.createBindGroupLayout
+    );
+    device.createPipelineLayout = wrapDeviceFunction(
+      "layout",
+      device.createPipelineLayout
+    );
+    if (fakeAsync) {
+      device.createRenderPipeline = wrapDeviceFunction(
+        "pipeline",
+        device.createRenderPipeline
+      );
+    } else {
+      let inline_function = wrapDeviceFunction("pipeline", device.createRenderPipeline);
+
+      globalThis.pendingAsyncPipelineCount = 0;
+      globalThis.lastPipelineWasValidFlag = false;
+      globalThis.wgpuResolveIdle = [];
+      const itemType = "pipeline";
+      const placeholderPipeline = getPlaceholder(device);
+
+      device.createRenderPipeline = (...args) => {
+        const jsonArgs = JSON.stringify(args);
+        const hash = simpleHash(jsonArgs);
+        const cachedItem = gpuSessionState[itemType].get(hash);
+        if (cachedItem !== undefined) {
+          globalThis.nextPipelineCanFail = false;
+          globalThis.lastPipelineWasValidFlag = true;
+          return cachedItem;
+        }
+
+        console.log(`[GPU Cache] (async) no cached ${itemType} for ${hash}`);
+
+        if (!globalThis.nextPipelineCanFail) {
+          return inline_function.apply(device, args);
+        }
+        globalThis.__setShaderCompiling?.(true);
+        globalThis.nextPipelineCanFail = false;
+        globalThis.lastPipelineWasValidFlag = false;
+        globalThis.pendingAsyncPipelineCount++;
+
+        const promise = device.createRenderPipelineAsync(args[0]).then(async (item) => {
+          item.__gpu_item_type = itemType;
+          item.__gpu_hash = hash;
+          gpuSessionState[itemType].set(hash, item);
+          globalThis.pendingAsyncPipelineCount--;
+
+          if (!requiredItemTypes.has(itemType)) {
+            requiredItemTypes.set(itemType, new Set());
+          }
+          const requiredItems = requiredItemTypes.get(itemType);
+          if (!requiredItems.has(hash)) {
+            requiredItems.add(hash);
+            await storeRequiredItems();
+            await storeInstance(itemType, hash, args);
+          }
+
+          if (globalThis.pendingAsyncPipelineCount === 0) {
+            while (globalThis.wgpuResolveIdle.length > 0) {
+              globalThis.wgpuResolveIdle.pop()();
+            }
+            globalThis.__setShaderCompiling?.(false);
+          }
+
+          return item;
+        })
+
+        return placeholderPipeline;
+      }
+    }
+
+    return device;
+  };
+}
+
+async function createGpuCache(key) {
+  const cachedKey = await getConfig("gpuCacheKey");
+  if (cachedKey != key) {
+    console.log("shaders updated, clearing db");
+    await clearDatabase();
+    await setConfig("gpuCacheKey", key);
+    return;
+  }
+
+  const cachedDeviceDescriptor = await getConfig("deviceDescriptor");
+  if (cachedDeviceDescriptor === undefined) {
+    return;
+  }
+  precaching = true;
+  const started = performance.now();
+  const adapter = await navigator.gpu.requestAdapter();
+  const device = await adapter.requestDevice(
+    JSON.parse(cachedDeviceDescriptor)
+  );
+
+  requiredItemTypes = await fetchRequiredItems();
+  try {
+    await createItemType("shader", async (args) => {
+      return device.createShaderModule(args);
+    });
+    await createItemType("bindgroup", async (args) => {
+      return device.createBindGroupLayout(args);
+    });
+    await createItemType("layout", async (args) => {
+      return device.createPipelineLayout(args);
+    });
+    await createItemType("pipeline", async (args) => {
+      return await device.createRenderPipelineAsync(args);
+    });
+  } finally {
+    precaching = false;
+  }
+  storeRequiredItems();
+  const stats = Object.keys(gpuSessionState).map(
+    (k) => `\n${k}: ${gpuSessionState[k].size ?? "ok"}`
+  );
+  console.log(`[GPU Cache]: preloaded in ${Math.round(performance.now() - started)} ms ${stats}`);
+}
+
+async function createItemType(itemType, asyncCreateFunction) {
+  const storedItems = requiredItemTypes.get(itemType) ?? new Set();
+
+  await Promise.all(
+    [...storedItems].map(async (hash) => {
+      try {
+        const args = await fetchInstance(itemType, hash);
+        rehydrateItem(args);
+        const item = await asyncCreateFunction(args[0]);
+        gpuSessionState[itemType].set(hash, item);
+      } catch (e) {
+        console.warn(`[GPU Cache] failed to precreate ${itemType}: ${e}`);
+        storedItems.delete(hash);
+      }
+    })
+  );
+}
+
+function rehydrateItem(currentObject) {
+  if (typeof currentObject !== "object" || currentObject === null) {
+    return;
+  }
+
+  if (Array.isArray(currentObject)) {
+    for (let i = 0; i < currentObject.length; i++) {
+      const item = currentObject[i];
+      if (item && item.__gpu_hash) {
+        const type = item.__gpu_item_type;
+        const hash = item.__gpu_hash;
+        currentObject[i] = gpuSessionState[type].get(hash);
+        if (!currentObject[i]) {
+          throw `failed to rehydrate: missing ${type} with hash ${hash}`;
+        }
+      } else {
+        rehydrateItem(item);
+      }
+    }
+  } else {
+    for (const key in currentObject) {
+      if (Object.prototype.hasOwnProperty.call(currentObject, key)) {
+        const value = currentObject[key];
+        if (value && value.__gpu_hash) {
+          const type = value.__gpu_item_type;
+          const hash = value.__gpu_hash;
+          currentObject[key] = gpuSessionState[type].get(hash);
+          if (!currentObject[key]) {
+            throw `failed to rehydrate: missing ${type} with hash ${hash}`;
+          }
+        } else {
+          rehydrateItem(value);
+        }
+      }
+    }
+  }
+}
+
+function getPlaceholder(device) {
+  // create a trivial shader and pipeline
+  const module = device.createShaderModule({
+    code: `
+        @vertex fn vs_main() -> @builtin(position) vec4f { return vec4f(0.0, 0.0, 0.0, 1.0); }
+        @fragment fn fs_main() -> @location(0) vec4f { return vec4f(0.0, 1.0, 0.0, 1.0); }
+        `
+  });
+
+  return device.createRenderPipeline({
+    layout: device.createPipelineLayout({
+      bindGroupLayouts: []
+    }),
+    vertex: { module, entryPoint: 'vs_main' },
+    fragment: { module, entryPoint: 'fs_main', targets: [{ format: 'bgra8unorm' }] }, // Adjust format if needed
+    primitive: { topology: 'triangle-list' }
+  });
+}
+
+globalThis.allowADummyPipeline = function() {
+    globalThis.nextPipelineCanFail = true;
+}
+
+globalThis.lastPipelineWasValid = function() {
+    return globalThis.lastPipelineWasValidFlag;
+}
+
+globalThis.waitForPipelines = function() {
+    if (globalThis.pendingAsyncPipelineCount === 0) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+        globalThis.wgpuResolveIdle.push(resolve);
+    });
+};