@oeave/bakery3 0.0.0-stage → 0.2.0

package/dist/chunk-KNUAOILG.js

@@ -0,0 +1,551 @@
+import { buildPatch, probeTargets, bakeCandidates, configureShadow } from './chunk-JFYUDERE.js';
+import { presetBaseUrl } from './chunk-4E5VV4QY.js';
+import { prebakedRoomsUnder, findPresetRooms, roomShownBaked } from './chunk-APWUCEEB.js';
+import { PRESETS_VERSION } from './chunk-6NYR73Y7.js';
+import { Bakery3Error } from './chunk-3G5QL4F4.js';
+import { LinearSRGBColorSpace, SRGBColorSpace, LinearFilter, ClampToEdgeWrapping, TextureLoader, EquirectangularReflectionMapping, NoColorSpace } from 'three';
+import { EXRLoader } from 'three/examples/jsm/loaders/EXRLoader.js';
+
+function configureLightmap(texture, format) {
+  texture.channel = 1;
+  texture.flipY = false;
+  texture.colorSpace = format === "exr" ? LinearSRGBColorSpace : SRGBColorSpace;
+  texture.generateMipmaps = false;
+  texture.minFilter = LinearFilter;
+  texture.magFilter = LinearFilter;
+  texture.wrapS = ClampToEdgeWrapping;
+  texture.wrapT = ClampToEdgeWrapping;
+  texture.needsUpdate = true;
+  return texture;
+}
+function configureProbe(texture) {
+  texture.mapping = EquirectangularReflectionMapping;
+  texture.colorSpace = LinearSRGBColorSpace;
+  texture.needsUpdate = true;
+  return texture;
+}
+function configureStandInMap(texture, role) {
+  texture.channel = 0;
+  if (role === "billboard") {
+    texture.colorSpace = LinearSRGBColorSpace;
+    texture.generateMipmaps = false;
+    texture.minFilter = LinearFilter;
+    texture.magFilter = LinearFilter;
+  } else {
+    texture.flipY = true;
+    texture.colorSpace = role === "color" ? SRGBColorSpace : NoColorSpace;
+  }
+  texture.wrapS = ClampToEdgeWrapping;
+  texture.wrapT = ClampToEdgeWrapping;
+  texture.needsUpdate = true;
+  return texture;
+}
+function defaultTextureFactory() {
+  const exr = new EXRLoader();
+  const png = new TextureLoader();
+  exr.setCrossOrigin("anonymous");
+  png.setCrossOrigin("anonymous");
+  return async (source) => {
+    const loader = source.format === "exr" ? exr : png;
+    const texture = await new Promise((resolve, reject) => {
+      loader.load(
+        source.url,
+        (loaded) => resolve(loaded),
+        void 0,
+        () => reject(
+          new Bakery3Error({
+            code: "InvalidRequest",
+            message: source.role === "probe" ? "Could not load the reflection probe." : source.role === "color" || source.role === "normal" || source.role === "billboard" ? `Could not load the ${source.role} map of "${source.objectId}".` : `Could not load the lightmap for "${source.objectId}".`,
+            why: `${source.url} did not load. A bundle's uris are relative to where the bundle came from, and the artifacts have to be reachable from the browser.`,
+            fix: "Pass { baseUrl } to addGeneration() if the bundle moved, and check the artifact server allows cross-origin reads."
+          })
+        )
+      );
+    });
+    if (source.role === "probe") return configureProbe(texture);
+    if (source.role === "shadow") return configureShadow(texture);
+    if (source.role === "color" || source.role === "normal" || source.role === "billboard") {
+      return configureStandInMap(texture, source.role);
+    }
+    return configureLightmap(texture, source.format);
+  };
+}
+function resolveBundleUri(uri, baseUrl) {
+  if (/^[a-z][a-z0-9+.-]*:/i.test(uri) || uri.startsWith("//")) return uri;
+  if (!baseUrl) return uri;
+  try {
+    return new URL(uri, baseUrl).toString();
+  } catch {
+    return uri;
+  }
+}
+
+// src/bake/session.ts
+var LIVE = -1;
+function createBakeSession(options) {
+  const scene = options.scene;
+  const intensity = options.intensity ?? 1;
+  const shading = options.shading ?? "replace";
+  const resident = Math.max(1, options.residentGenerations ?? 3);
+  let useProbe = options.probe ?? true;
+  const loadTexture = options.textureFactory ?? defaultTextureFactory();
+  const generations = [];
+  const loaded = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  let current = LIVE;
+  let patch = null;
+  let lastReport = null;
+  let comparing = false;
+  let muted = null;
+  let disposed = false;
+  let applyToken = 0;
+  let clock = 0;
+  let suspendedRooms = [];
+  function emit() {
+    for (const listener of listeners) listener(session);
+  }
+  function releasePatch() {
+    patch?.dispose();
+    patch = null;
+    comparing = false;
+    for (const room of suspendedRooms) room.resume();
+    suspendedRooms = [];
+  }
+  function disposeGeneration(index) {
+    const entry = loaded.get(index);
+    if (!entry) return;
+    for (const texture of new Set(entry.textures.values())) texture.dispose();
+    for (const texture of new Set(entry.room?.textures.values() ?? []))
+      texture.dispose();
+    for (const maps of entry.proxies.values()) {
+      if (maps.kind === "billboard") maps.map.dispose();
+      else if (maps.kind === "decimated") maps.light.dispose();
+      else
+        for (const texture of [maps.color, maps.normal, maps.light])
+          texture.dispose();
+    }
+    entry.probe?.dispose();
+    entry.shadow?.dispose();
+    loaded.delete(index);
+    const generation = generations[index];
+    if (generation) generation.loaded = false;
+  }
+  function evict(keep) {
+    if (loaded.size <= resident) return;
+    const ranked = [...loaded.entries()].filter(([index]) => index !== keep).sort((a, b) => a[1].usedAt - b[1].usedAt);
+    while (loaded.size > resident && ranked.length) {
+      disposeGeneration(ranked.shift()[0]);
+    }
+  }
+  async function ensureLoaded(index) {
+    const existing = loaded.get(index);
+    if (existing) {
+      existing.usedAt = ++clock;
+      return existing;
+    }
+    const generation = generations[index];
+    const textures = /* @__PURE__ */ new Map();
+    const failures = /* @__PURE__ */ new Map();
+    const byUrl = /* @__PURE__ */ new Map();
+    for (const baked of generation.bundle.objects) {
+      try {
+        const url = resolveBundleUri(baked.lightmap.uri, generation.baseUrl);
+        let texture = byUrl.get(url);
+        if (!texture) {
+          texture = await loadTexture({
+            url,
+            format: baked.lightmap.format,
+            objectId: baked.objectId,
+            size: baked.lightmap.size
+          });
+          byUrl.set(url, texture);
+        }
+        textures.set(baked.objectId, texture);
+      } catch (error) {
+        failures.set(baked.objectId, describe(error));
+      }
+    }
+    const proxies = /* @__PURE__ */ new Map();
+    for (const proxy of generation.bundle.proxies ?? []) {
+      const label = proxy.name ?? `stand-in ${proxy.index}`;
+      const load = (uri, format, role, size) => loadTexture({
+        url: resolveBundleUri(uri, generation.baseUrl),
+        format,
+        objectId: label,
+        size,
+        role
+      });
+      try {
+        if (proxy.kind === "billboard") {
+          proxies.set(proxy.index, {
+            kind: "billboard",
+            map: await load(proxy.map.uri, "exr", "billboard", proxy.map.width)
+          });
+        } else if (proxy.kind === "decimated") {
+          proxies.set(proxy.index, {
+            kind: "decimated",
+            light: await load(
+              proxy.lightmap.uri,
+              "exr",
+              "lightmap",
+              proxy.lightmap.size
+            )
+          });
+        } else {
+          const size = proxy.lightmap.size;
+          proxies.set(proxy.index, {
+            kind: "mesh",
+            color: await load(proxy.color.uri, "png", "color", size),
+            normal: await load(proxy.normal.uri, "png", "normal", size),
+            light: await load(proxy.lightmap.uri, "exr", "lightmap", size)
+          });
+        }
+      } catch (error) {
+        failures.set(`simplify[${proxy.index}]`, describe(error));
+      }
+    }
+    let shadow;
+    if (generation.bundle.shadow) {
+      const shadowEntry = generation.bundle.shadow;
+      try {
+        shadow = configureShadow(
+          await loadTexture({
+            url: resolveBundleUri(shadowEntry.uri, generation.baseUrl),
+            format: shadowEntry.format,
+            objectId: "shadow",
+            size: shadowEntry.size,
+            role: "shadow"
+          })
+        );
+      } catch (error) {
+        failures.set("shadow", describe(error));
+      }
+    }
+    let room;
+    let roomFailed;
+    const wantsRoom = findPresetRooms(scene).some(roomShownBaked) ? void 0 : generation.bundle.room;
+    if (wantsRoom) {
+      const base = `${(options.presetBaseUrl ?? presetBaseUrl()).replace(/\/$/, "")}/v${PRESETS_VERSION}/`;
+      const url = new URL(wantsRoom.uri, base).toString();
+      try {
+        const response = await fetch(url);
+        if (!response.ok)
+          throw new Error(`${response.status} ${response.statusText}`);
+        const bundle = await response.json();
+        const roomTextures = /* @__PURE__ */ new Map();
+        const byUrl2 = /* @__PURE__ */ new Map();
+        for (const baked of bundle.objects) {
+          const textureUrl = resolveBundleUri(baked.lightmap.uri, url);
+          let texture = byUrl2.get(textureUrl);
+          if (!texture) {
+            texture = await loadTexture({
+              url: textureUrl,
+              format: baked.lightmap.format,
+              objectId: baked.objectId,
+              size: baked.lightmap.size
+            });
+            byUrl2.set(textureUrl, texture);
+          }
+          roomTextures.set(baked.objectId, texture);
+        }
+        room = { bundle, baseUrl: url, textures: roomTextures };
+      } catch (error) {
+        roomFailed = describe(error);
+      }
+    }
+    const entry = {
+      textures,
+      failures,
+      proxies,
+      usedAt: ++clock,
+      ...shadow ? { shadow } : {},
+      ...room ? { room } : {},
+      ...roomFailed ? { roomFailed } : {}
+    };
+    loaded.set(index, entry);
+    generation.loaded = true;
+    return entry;
+  }
+  async function ensureProbe(index, entry) {
+    if (entry.probe || entry.probeFailed) return entry.probe;
+    const generation = generations[index];
+    const probeEntry = generation.bundle.probe;
+    if (!probeEntry) return void 0;
+    try {
+      entry.probe = configureProbe(
+        await loadTexture({
+          url: resolveBundleUri(probeEntry.uri, generation.baseUrl),
+          format: probeEntry.format,
+          objectId: "probe",
+          size: probeEntry.width,
+          role: "probe"
+        })
+      );
+    } catch (error) {
+      entry.probeFailed = describe(error);
+    }
+    return entry.probe;
+  }
+  const session = {
+    get generations() {
+      return generations;
+    },
+    get current() {
+      return current;
+    },
+    get lastReport() {
+      return lastReport;
+    },
+    get comparing() {
+      return comparing;
+    },
+    get lightsMuted() {
+      return muted !== null;
+    },
+    get probe() {
+      return useProbe;
+    },
+    candidates() {
+      return bakeCandidates({ scene });
+    },
+    addGeneration(bundle, addOptions = {}) {
+      if (disposed) throw disposedError("addGeneration");
+      const index = generations.length;
+      generations.push({
+        index,
+        label: addOptions.label ?? `${bundle.settings.textureSize} \xB7 ${bundle.settings.quality}`,
+        bundle,
+        ...addOptions.baseUrl !== void 0 ? { baseUrl: addOptions.baseUrl } : {},
+        createdAt: Date.now(),
+        loaded: false
+      });
+      emit();
+      return index;
+    },
+    async apply(index) {
+      if (disposed) throw disposedError("apply");
+      if (index === LIVE) {
+        session.revert();
+        return lastReport;
+      }
+      const generation = generations[index];
+      if (!generation) {
+        throw new Bakery3Error({
+          code: "InvalidRequest",
+          message: `There is no bake generation ${index}.`,
+          why: `This session has ${generations.length} generation(s).`,
+          fix: "Call addGeneration(bundle) with a BakeBundle first, or revert() to go back to live."
+        });
+      }
+      const token = ++applyToken;
+      const entry = await ensureLoaded(index);
+      const probe = useProbe ? await ensureProbe(index, entry) : void 0;
+      if (token !== applyToken || disposed)
+        return lastReport ?? emptyReport(index);
+      releasePatch();
+      const objects = [];
+      const missingTextures = [];
+      for (const baked of generation.bundle.objects) {
+        const texture = entry.textures.get(baked.objectId);
+        if (!texture) {
+          missingTextures.push({
+            objectId: baked.objectId,
+            ...baked.name ? { name: baked.name } : {},
+            code: "BakeLightmapUnavailable",
+            message: `The lightmap for "${baked.name ?? baked.objectId}" did not load.`,
+            why: entry.failures.get(baked.objectId) ?? "Its texture is missing from this generation, so there is nothing to apply.",
+            fix: "Check the bundle uris are reachable from the browser, then apply again."
+          });
+          continue;
+        }
+        objects.push({ baked, texture });
+      }
+      const roomObjects = (entry.room?.bundle.objects ?? []).flatMap(
+        (baked) => {
+          const texture = entry.room.textures.get(baked.objectId);
+          return texture ? [{ baked, texture }] : [];
+        }
+      );
+      const litIds = new Set(
+        generation.bundle.objects.map((object) => object.objectId)
+      );
+      for (const { baked } of roomObjects) litIds.add(baked.objectId);
+      const standIns = (generation.bundle.proxies ?? []).flatMap((proxy) => {
+        const textures = entry.proxies.get(proxy.index);
+        if (textures) return [{ proxy, textures }];
+        missingTextures.push({
+          objectId: `simplify[${proxy.index}]`,
+          ...proxy.name ? { name: proxy.name } : {},
+          code: "BakeLightmapUnavailable",
+          message: `The maps for the stand-in "${proxy.name ?? proxy.index}" did not load.`,
+          why: entry.failures.get(`simplify[${proxy.index}]`) ?? "One of its textures is missing from this generation.",
+          fix: "Check the bundle uris are reachable from the browser, then apply again. The objects it replaces are left as they were."
+        });
+        return [];
+      });
+      for (const { proxy } of standIns)
+        for (const id of proxy.replaces) litIds.add(id);
+      const byObjectId = /* @__PURE__ */ new Map();
+      for (const entry_ of [...roomObjects, ...objects])
+        byObjectId.set(entry_.baked.objectId, entry_);
+      const winners = [...byObjectId.values()];
+      const touched = /* @__PURE__ */ new Set([
+        ...byObjectId.keys(),
+        ...standIns.flatMap(({ proxy }) => proxy.replaces)
+      ]);
+      for (const { group, handle } of prebakedRoomsUnder(scene)) {
+        if (group === scene) continue;
+        let lightsIt = false;
+        group.traverse((node) => {
+          if (touched.has(node.userData.bakery3Id)) lightsIt = true;
+        });
+        if (!lightsIt) continue;
+        handle.suspend();
+        suspendedRooms.push(handle);
+      }
+      const built = buildPatch({
+        scene,
+        objects: winners,
+        intensity,
+        shading,
+        ...probe ? {
+          probe: {
+            texture: probe,
+            meshes: probeTargets(session.candidates(), litIds)
+          }
+        } : {},
+        ...standIns.length ? { proxies: standIns } : {},
+        ...generation.bundle.shadow && entry.shadow ? {
+          shadow: {
+            shadow: generation.bundle.shadow,
+            texture: entry.shadow
+          }
+        } : {}
+      });
+      built.patch.on();
+      patch = built.patch;
+      current = index;
+      const bakedIds = new Set(litIds);
+      for (const skip of generation.bundle.skipped) bakedIds.add(skip.objectId);
+      const unbaked = session.candidates().filter(
+        (candidate) => candidate.bakeable && candidate.defaultInclude && !bakedIds.has(candidate.objectId)
+      ).map((candidate) => candidate.objectId);
+      lastReport = {
+        generation: index,
+        applied: built.applied,
+        unmatched: built.unmatched,
+        unbaked,
+        skipped: [...missingTextures, ...built.skipped],
+        probed: built.probed,
+        standIns: built.standIns,
+        replaced: built.replaced,
+        shadow: built.shadow,
+        ...entry.room ? {
+          room: {
+            name: generation.bundle.room.name,
+            lighting: generation.bundle.room.lighting,
+            applied: roomObjects.filter(
+              ({ baked }) => built.applied.includes(baked.objectId)
+            ).length,
+            unmatched: roomObjects.filter(
+              ({ baked }) => built.unmatched.includes(baked.objectId)
+            ).length
+          }
+        } : {},
+        ...entry.roomFailed ? { roomError: entry.roomFailed } : {},
+        ...useProbe && entry.probeFailed ? { probeError: entry.probeFailed } : {}
+      };
+      evict(index);
+      emit();
+      return lastReport;
+    },
+    revert() {
+      releasePatch();
+      current = LIVE;
+      lastReport = emptyReport(LIVE);
+      emit();
+    },
+    compare(showLive) {
+      if (!patch) return;
+      if (showLive) patch.off();
+      else patch.on();
+      comparing = showLive;
+      emit();
+    },
+    async setProbe(on) {
+      if (disposed) throw disposedError("setProbe");
+      if (on === useProbe) return lastReport ?? emptyReport(current);
+      useProbe = on;
+      if (current === LIVE) {
+        emit();
+        return lastReport ?? emptyReport(LIVE);
+      }
+      return session.apply(current);
+    },
+    muteLights(on) {
+      if (on === (muted !== null)) return;
+      if (on) {
+        const touched = [];
+        scene.traverse((object) => {
+          const light = object;
+          if (!light.isLight) return;
+          touched.push({ light, intensity: light.intensity });
+          light.intensity = 0;
+        });
+        muted = touched;
+      } else {
+        for (const entry of muted) entry.light.intensity = entry.intensity;
+        muted = null;
+      }
+      emit();
+    },
+    on(_event, listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      releasePatch();
+      if (muted) {
+        for (const entry of muted) entry.light.intensity = entry.intensity;
+        muted = null;
+      }
+      for (const index of [...loaded.keys()]) disposeGeneration(index);
+      current = LIVE;
+      listeners.clear();
+    }
+  };
+  return session;
+}
+function emptyReport(generation) {
+  return {
+    generation,
+    applied: [],
+    unmatched: [],
+    unbaked: [],
+    skipped: [],
+    probed: [],
+    standIns: [],
+    replaced: [],
+    shadow: false
+  };
+}
+function describe(error) {
+  if (error && typeof error === "object" && "toDisplayString" in error) {
+    return error.toDisplayString();
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+function disposedError(what) {
+  return new Bakery3Error({
+    code: "InvalidRequest",
+    message: `${what}() was called on a disposed bake session.`,
+    why: "dispose() reverts the scene and drops every texture, so there is nothing left to apply.",
+    fix: "Create a new session with createBakeSession({ scene })."
+  });
+}
+
+export { LIVE, configureLightmap, createBakeSession };
+//# sourceMappingURL=chunk-KNUAOILG.js.map
+//# sourceMappingURL=chunk-KNUAOILG.js.map