@oeave/bakery3 0.1.0 → 0.3.0

package/dist/{chunk-CX4WTVGH.js → chunk-WLEFNUOH.js}

@@ -1,11 +1,12 @@
-import { captureCamera } from './chunk-V3QINEEG.js';
-import { protocolVersionFor, SDK_VERSION, QUALITY } from './chunk-APBOWWSV.js';
+import { captureCamera } from './chunk-62M6XXNX.js';
+import { protocolVersionFor, SDK_VERSION, QUALITY } from './chunk-R5IUPOWI.js';
 import { BAKERY_NODE_MARKER, builtinFor, tslRuntimeRegistered, toNodeObject } from './chunk-S4AJTLLN.js';
-import { findPresetRooms, sha256, environmentSourceFor, isPresetEnvironment, roomPresetSpecOf, roomPresetFactsOf, roomPresetAssetsOf } from './chunk-AF5BIELI.js';
-import { idOf, shouldExclude, captureFog, readUserData, scenePath, captureLights, captureRuntime, stampIds, captureEnvironmentSettings, excludedItself, bakeCandidates, resolveProbe, defaultIncludeIds, quantizeBakeView, bakeBounds, isBakeWrittenUv } from './chunk-HQTUFVMM.js';
-import { MAX_BAKE_OBJECTS, MAX_BAKE_TEXELS, roomIsPrebaked, roomPrebakeChanges, MAX_BAKE_SIMPLIFY, BAKE_TEXTURE_SIZES, MAX_BAKE_SIMPLIFY_TRIANGLES, BAKE_ATLAS_SIZES } from './chunk-W6WQ5UP7.js';
+import { sha256, environmentSourceFor, isPresetEnvironment } from './chunk-KZLVTSBI.js';
+import { idOf, shouldExclude, captureFog, scenePath, captureLights, captureRuntime, stampIds, captureEnvironmentSettings, excludedItself, readUserData, bakeCandidates, resolveProbe, defaultIncludeIds, quantizeBakeView, bakeBounds, isBakeWrittenUv, ID_KEY } from './chunk-NEK5TBEH.js';
+import { findPresetRooms, roomShownBaked, roomPresetFactsOf, roomPresetSpecOf, roomPresetAssetsOf, MAX_BAKE_OBJECTS, MAX_BAKE_TEXELS, roomIsPrebaked, roomPrebakeChanges, MAX_BAKE_SIMPLIFY, BAKE_TEXTURE_SIZES, MAX_BAKE_SIMPLIFY_TRIANGLES, BAKE_ATLAS_SIZES } from './chunk-EN4ROBYQ.js';
 import { Bakery3Error } from './chunk-3G5QL4F4.js';
-import { Vector3, Vector2, Matrix4, Quaternion } from 'three';
+import { readCameraLookAt, propertyDefinition, CAMERA_PROPERTIES, OBJECT_PROPERTIES, hexToLinear } from './chunk-OPM2L63B.js';
+import { Vector3, Vector2, Matrix4, Quaternion, Color, MeshPhysicalMaterial, MeshStandardMaterial, LinearSRGBColorSpace } from 'three';
 import { GLTFExporter } from 'three/examples/jsm/exporters/GLTFExporter.js';
 
 // src/timeline/easing.ts
@@ -163,256 +164,6 @@ function normalize(v) {
   return length === 0 ? [0, 0, 0] : [v[0] / length, v[1] / length, v[2] / length];
 }
 
-// src/timeline/properties.ts
-function hemisphereOf(object) {
-  const light = object;
-  return light.isHemisphereLight ? light : void 0;
-}
-function sceneOf(object) {
-  const scene = object;
-  return scene.isScene ? scene : void 0;
-}
-function aimedLight(object) {
-  const light = object;
-  return (light.isDirectionalLight || light.isSpotLight) && light.target ? light : void 0;
-}
-function materialOf(object) {
-  const material = object.material;
-  if (!material) return void 0;
-  return Array.isArray(material) ? material[0] : material;
-}
-function readVector(v) {
-  return v ? [v.x, v.y, v.z] : void 0;
-}
-function scalar(get, set) {
-  return {
-    size: 1,
-    read(object) {
-      const material = materialOf(object);
-      const value = material ? get(material) : void 0;
-      return typeof value === "number" ? [value] : void 0;
-    },
-    write(object, value) {
-      const material = materialOf(object);
-      if (material) set(material, value[0]);
-    }
-  };
-}
-function colorProperty(pick) {
-  return {
-    size: 3,
-    color: true,
-    read(object) {
-      const target = pick(object);
-      return target ? [target.r, target.g, target.b] : void 0;
-    },
-    write(object, value) {
-      const target = pick(object);
-      if (!target) return;
-      if (target.setRGB) target.setRGB(value[0], value[1], value[2]);
-      else Object.assign(target, { r: value[0], g: value[1], b: value[2] });
-    }
-  };
-}
-var OBJECT_PROPERTIES = {
-  position: {
-    size: 3,
-    read: (object) => readVector(object.position),
-    write: (object, value) => object.position.set(value[0], value[1], value[2])
-  },
-  rotation: {
-    size: 3,
-    channel: "quaternion",
-    read: (object) => readVector(
-      object.rotation
-    ),
-    write: (object, value) => object.rotation.set(value[0], value[1], value[2])
-  },
-  scale: {
-    size: 3,
-    read: (object) => readVector(object.scale),
-    write: (object, value) => object.scale.set(value[0], value[1], value[2])
-  },
-  // A light's own color (the worker drives the lamp, or for an ambient or
-  // hemisphere light the dome), and a mesh's material's.
-  color: colorProperty(
-    (object) => object.isLight ? object.color : materialOf(object)?.color
-  ),
-  emissive: colorProperty((object) => materialOf(object)?.emissive),
-  emissiveIntensity: scalar(
-    (material) => material.emissiveIntensity,
-    (material, value) => {
-      material.emissiveIntensity = value;
-    }
-  ),
-  roughness: scalar(
-    (material) => material.roughness,
-    (material, value) => {
-      material.roughness = value;
-    }
-  ),
-  metalness: scalar(
-    (material) => material.metalness,
-    (material, value) => {
-      material.metalness = value;
-    }
-  ),
-  opacity: scalar(
-    (material) => material.opacity,
-    (material, value) => {
-      material.opacity = value;
-      if (value < 1 && !material.transparent) {
-        material.transparent = true;
-        material.needsUpdate = true;
-      }
-    }
-  ),
-  intensity: {
-    size: 1,
-    read(object) {
-      const light = object;
-      return light.isLight && typeof light.intensity === "number" ? [light.intensity] : void 0;
-    },
-    write(object, value) {
-      const light = object;
-      if (light.isLight) light.intensity = value[0];
-    }
-  },
-  /** A HemisphereLight's color from below. Its `color` is the sky. */
-  groundColor: {
-    ...colorProperty((object) => hemisphereOf(object)?.groundColor),
-    appliesTo: (object) => hemisphereOf(object) !== void 0
-  },
-  /**
-   * The scene's own `environmentIntensity`, on the Scene as a target: the
-   * environment's `intensity` channel. It scales the HDRI only, as in three.
-   */
-  environmentIntensity: {
-    size: 1,
-    appliesTo: (object) => sceneOf(object) !== void 0,
-    read(object) {
-      const value = sceneOf(object)?.environmentIntensity;
-      return typeof value === "number" ? [value] : void 0;
-    },
-    write(object, value) {
-      const scene = sceneOf(object);
-      if (scene) scene.environmentIntensity = value[0];
-    }
-  },
-  /**
-   * The scene's `environmentRotation`, radians, XYZ, as three holds it: the
-   * environment's `rotation` channel. Unlike an object's rotation it stays
-   * an euler on the wire, because that is what the environment carries.
-   */
-  environmentRotation: {
-    size: 3,
-    appliesTo: (object) => sceneOf(object) !== void 0,
-    read: (object) => readVector(sceneOf(object)?.environmentRotation),
-    write(object, value) {
-      sceneOf(object)?.environmentRotation?.set(
-        value[0],
-        value[1],
-        value[2]
-      );
-    }
-  },
-  /**
-   * Where a directional or spot light aims: its `target`'s WORLD position,
-   * which is what three aims it at and what the channel carries. Written
-   * back through the target's parent, if it has one, so the light points at
-   * the same place in the viewport as in the render.
-   */
-  target: {
-    size: 3,
-    appliesTo: (object) => aimedLight(object) !== void 0,
-    read(object) {
-      const target = aimedLight(object)?.target;
-      if (!target) return void 0;
-      target.updateMatrixWorld();
-      const e = target.matrixWorld.elements;
-      return [e[12], e[13], e[14]];
-    },
-    write(object, value) {
-      const target = aimedLight(object)?.target;
-      if (!target) return;
-      target.position.set(value[0], value[1], value[2]);
-      target.parent?.worldToLocal(target.position);
-      target.updateMatrixWorld();
-    }
-  }
-};
-var CAMERA_PROPERTIES = {
-  position: OBJECT_PROPERTIES.position,
-  lookAt: {
-    size: 3,
-    // There is no live "lookAt" to read; the timeline supplies its own center
-    // when a keyframe is captured. Returning undefined keeps the panel from
-    // offering a capture button that would silently record the wrong thing.
-    read: () => void 0,
-    // Applied together with position by the timeline, never alone: aiming at a
-    // point before moving to the position it was computed for produces one
-    // frame of visible swing.
-    write: () => void 0
-  },
-  fov: {
-    size: 1,
-    read(object) {
-      const camera = object;
-      return typeof camera.fov === "number" ? [camera.fov] : void 0;
-    },
-    write(object, value) {
-      const camera = object;
-      if (typeof camera.fov !== "number") return;
-      camera.fov = value[0];
-      camera.updateProjectionMatrix?.();
-    }
-  }
-};
-function propertyDefinition(target, property) {
-  return target === "camera" ? CAMERA_PROPERTIES[property] : OBJECT_PROPERTIES[property];
-}
-function readCameraLookAt(camera, center) {
-  camera.updateMatrixWorld();
-  const e = camera.matrixWorld.elements;
-  const position = [e[12], e[13], e[14]];
-  const forward = normalize2([-e[8], -e[9], -e[10]]);
-  const distance = Math.hypot(
-    position[0] - center[0],
-    position[1] - center[1],
-    position[2] - center[2]
-  ) || 1;
-  return [
-    position[0] + forward[0] * distance,
-    position[1] + forward[1] * distance,
-    position[2] + forward[2] * distance
-  ];
-}
-function normalize2(v) {
-  const length = Math.hypot(v[0], v[1], v[2]);
-  return length === 0 ? [0, 0, -1] : [v[0] / length, v[1] / length, v[2] / length];
-}
-function hexToLinear(hex) {
-  const value = hex.trim().replace(/^#/, "");
-  const full = value.length === 3 ? value.split("").map((c) => c + c).join("") : value;
-  const int = Number.parseInt(full, 16);
-  if (!Number.isFinite(int)) return [1, 1, 1];
-  return [
-    srgbToLinear((int >> 16 & 255) / 255),
-    srgbToLinear((int >> 8 & 255) / 255),
-    srgbToLinear((int & 255) / 255)
-  ];
-}
-function srgbToLinear(c) {
-  return c < 0.04045 ? c * 0.0773993808 : Math.pow(c * 0.9478672986 + 0.0521327014, 2.4);
-}
-function linearToSrgbHex(value) {
-  const channel = (v) => {
-    const srgb = v < 31308e-7 ? v * 12.92 : 1.055 * Math.pow(Math.max(v, 0), 0.41666) - 0.055;
-    return Math.round(Math.max(0, Math.min(1, srgb)) * 255).toString(16).padStart(2, "0");
-  };
-  return `#${channel(value[0] ?? 0)}${channel(value[1] ?? 0)}${channel(value[2] ?? 0)}`;
-}
-
 // src/protocol/animation.ts
 var ENVIRONMENT_CHANNEL_SIZES = {
   intensity: 1,
@@ -1317,7 +1068,7 @@ var Timeline = class _Timeline {
     const { at, end } = this.span(options);
     for (const [property, raw] of Object.entries(props)) {
       const track = this.track(target, property);
-      const value = normalize3(raw, track.size, property);
+      const value = normalize2(raw, track.size, property);
       this.anchor(track, at);
       this.insert(track, {
         time: end,
@@ -1337,14 +1088,14 @@ var Timeline = class _Timeline {
       if (start !== void 0) {
         this.insert(track, {
           time: at,
-          value: normalize3(start, track.size, property)
+          value: normalize2(start, track.size, property)
         });
       } else {
         this.anchor(track, at);
       }
       this.insert(track, {
         time: end,
-        value: normalize3(raw, track.size, property),
+        value: normalize2(raw, track.size, property),
         ...options.easing ? { easing: options.easing } : {}
       });
     }
@@ -1452,7 +1203,7 @@ var Timeline = class _Timeline {
    */
   keyframe(target, property, time = this._time, value) {
     const track = this.track(target, property);
-    const resolved = value !== void 0 ? normalize3(value, track.size, property) : this.live(target, property) ?? this.valueAt(track, time);
+    const resolved = value !== void 0 ? normalize2(value, track.size, property) : this.live(target, property) ?? this.valueAt(track, time);
     if (!resolved) {
       throw new Bakery3Error({
         code: "InvalidRequest",
@@ -1925,7 +1676,7 @@ function noCamera(what, bound) {
 function createTimeline(options = {}) {
   return new Timeline(options);
 }
-function normalize3(value, size, property) {
+function normalize2(value, size, property) {
   const flat = flatten(value, size, property);
   if (flat && flat.length === size && flat.every((n) => Number.isFinite(n)))
     return flat;
@@ -2936,7 +2687,7 @@ function staticProperties(material) {
       properties[key] = `#${value.getHexString()}`;
     }
   };
-  const scalar2 = (key, prop) => {
+  const scalar = (key, prop) => {
     const value = material[prop];
     if (typeof value === "number" && Number.isFinite(value)) {
       properties[key] = value;
@@ -2947,23 +2698,23 @@ function staticProperties(material) {
   color("sheenColor", "sheenColor");
   color("specularColor", "specularColor");
   color("attenuationColor", "attenuationColor");
-  scalar2("roughness", "roughness");
-  scalar2("metalness", "metalness");
-  scalar2("emissiveIntensity", "emissiveIntensity");
-  scalar2("opacity", "opacity");
-  scalar2("alphaTest", "alphaTest");
-  scalar2("ior", "ior");
-  scalar2("transmission", "transmission");
-  scalar2("thickness", "thickness");
-  scalar2("attenuationDistance", "attenuationDistance");
-  scalar2("clearcoat", "clearcoat");
-  scalar2("clearcoatRoughness", "clearcoatRoughness");
-  scalar2("sheen", "sheen");
-  scalar2("sheenRoughness", "sheenRoughness");
-  scalar2("specularIntensity", "specularIntensity");
-  scalar2("iridescence", "iridescence");
-  scalar2("iridescenceIOR", "iridescenceIOR");
-  scalar2("anisotropy", "anisotropy");
+  scalar("roughness", "roughness");
+  scalar("metalness", "metalness");
+  scalar("emissiveIntensity", "emissiveIntensity");
+  scalar("opacity", "opacity");
+  scalar("alphaTest", "alphaTest");
+  scalar("ior", "ior");
+  scalar("transmission", "transmission");
+  scalar("thickness", "thickness");
+  scalar("attenuationDistance", "attenuationDistance");
+  scalar("clearcoat", "clearcoat");
+  scalar("clearcoatRoughness", "clearcoatRoughness");
+  scalar("sheen", "sheen");
+  scalar("sheenRoughness", "sheenRoughness");
+  scalar("specularIntensity", "specularIntensity");
+  scalar("iridescence", "iridescence");
+  scalar("iridescenceIOR", "iridescenceIOR");
+  scalar("anisotropy", "anisotropy");
   if (material.transparent === true) properties.transparent = true;
   if (material.side === 2) properties.doubleSided = true;
   return properties;
@@ -3024,6 +2775,175 @@ function describeNodeType(type) {
   };
   return KNOWN[type] ?? `A "${type}"`;
 }
+function fallbackFor(material, object) {
+  const own = material.userData?.bakery3?.fallback;
+  if (isRecord(own)) return { values: own, declaredOn: "material" };
+  const objects = readUserData(object).fallback;
+  if (isRecord(objects)) return { values: objects, declaredOn: "object" };
+  return null;
+}
+function objectFallbackId(material, object) {
+  return `${idOf(material)}@${idOf(object)}`;
+}
+function fallbackMaterialId(material, object, fallback) {
+  return fallback.declaredOn === "object" ? objectFallbackId(material, object) : idOf(material);
+}
+function exporterCannotWrite(material) {
+  const m = material;
+  if (m.isShaderMaterial) return true;
+  return typeof m.color?.toArray !== "function";
+}
+function fallbackEmits(values) {
+  if (values.emissive === void 0) return false;
+  const intensity = typeof values.emissiveIntensity === "number" ? values.emissiveIntensity : 1;
+  if (!(intensity > 0)) return false;
+  const color = toColor(values.emissive);
+  return Boolean(color && color.r + color.g + color.b > 0);
+}
+function materialStandIns(root) {
+  const shared = /* @__PURE__ */ new Map();
+  const standIns = /* @__PURE__ */ new Map();
+  root.traverse((object) => {
+    if (shouldExclude(object)) return;
+    const drawable = object;
+    if (!(drawable.isMesh || drawable.isLine || drawable.isPoints)) return;
+    if (!drawable.material) return;
+    const list = Array.isArray(drawable.material) ? drawable.material : [drawable.material];
+    const own = /* @__PURE__ */ new Map();
+    let changed = false;
+    const written = list.map((material) => {
+      if (!material) return material;
+      const standIn2 = standInFor(material, object, shared, own);
+      if (standIn2 !== material) changed = true;
+      return standIn2;
+    });
+    if (!changed) return;
+    standIns.set(
+      object,
+      Array.isArray(drawable.material) ? written : written[0]
+    );
+  });
+  return standIns;
+}
+function standInFor(material, object, shared, own) {
+  const fallback = fallbackFor(material, object);
+  if (fallback?.declaredOn === "object") {
+    let copy2 = own.get(material);
+    if (!copy2) {
+      copy2 = standIn(
+        material,
+        fallback.values,
+        objectFallbackId(material, object)
+      );
+      own.set(material, copy2);
+    }
+    return copy2;
+  }
+  if (!fallback && !exporterCannotWrite(material)) return material;
+  let copy = shared.get(material);
+  if (!copy) {
+    copy = standIn(material, fallback?.values ?? null, idOf(material));
+    shared.set(material, copy);
+  }
+  return copy;
+}
+function standIn(material, fallback, id) {
+  const out = fallback ? fromFallback(fallback) : flatGray();
+  out.name = material.name;
+  out.side = material.side;
+  const userData = {
+    ...material.userData,
+    [ID_KEY]: id
+  };
+  if (fallback) {
+    const bakery3 = isRecord(userData.bakery3) ? userData.bakery3 : {};
+    userData.bakery3 = { ...bakery3, fallback };
+  }
+  out.userData = userData;
+  return out;
+}
+function flatGray() {
+  const material = new MeshStandardMaterial({ roughness: 1, metalness: 0 });
+  material.color.setRGB(0.8, 0.8, 0.8, LinearSRGBColorSpace);
+  return material;
+}
+var NUMBER_FIELDS = [
+  "metalness",
+  "roughness",
+  "clearcoat",
+  "clearcoatRoughness",
+  "transmission",
+  "thickness",
+  "ior",
+  "emissiveIntensity",
+  "opacity",
+  "sheen",
+  "iridescence",
+  "anisotropy"
+];
+function fromFallback(values) {
+  const material = new MeshPhysicalMaterial();
+  const color = toColor(values.color);
+  if (color) material.color.copy(color);
+  const emissive = toColor(values.emissive);
+  if (emissive) material.emissive.copy(emissive);
+  const sheenColor = toColor(values.sheenColor);
+  if (sheenColor) material.sheenColor.copy(sheenColor);
+  const target = material;
+  for (const field of NUMBER_FIELDS) {
+    const value = values[field];
+    if (typeof value === "number" && Number.isFinite(value))
+      target[field] = value;
+  }
+  if (material.opacity < 1) material.transparent = true;
+  return material;
+}
+function toColor(value) {
+  if (typeof value !== "string" && typeof value !== "number" && !value?.isColor)
+    return null;
+  return new Color(value);
+}
+function substituteMaterials(exporter, standIns) {
+  let undo = () => {
+  };
+  if (standIns.size === 0) return undo;
+  exporter.register((writer) => {
+    const steps = writer;
+    const name = ["processMeshAsync", "processMesh"].find(
+      (key) => typeof steps[key] === "function"
+    );
+    if (name) {
+      const original = steps[name];
+      steps[name] = function(mesh) {
+        const material = standIns.get(mesh);
+        return original.call(
+          this,
+          material ? Object.create(mesh, {
+            material: { value: material, enumerable: true }
+          }) : mesh
+        );
+      };
+    } else {
+      undo = swapOnScene(standIns);
+    }
+    return {};
+  });
+  return () => undo();
+}
+function swapOnScene(standIns) {
+  const originals = [];
+  for (const [object, material] of standIns) {
+    const drawable = object;
+    originals.push({ object: drawable, material: drawable.material });
+    drawable.material = material;
+  }
+  return () => {
+    for (const { object, material } of originals) object.material = material;
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 
 // src/compat/analyze.ts
 var DOCS2 = "https://bakery3.com/docs";
@@ -3031,15 +2951,46 @@ var LARGE_TEXTURE_PX = 4096;
 var LARGE_TRIANGLE_COUNT = 1e7;
 var TRANSLATABLE = /* @__PURE__ */ new Set(["MeshStandardMaterial", "MeshPhysicalMaterial"]);
 var APPROXIMATED = {
-  MeshBasicMaterial: "Rendered as an emissive surface, since a path tracer has no unlit shading model.",
-  MeshLambertMaterial: "Rendered as a rough physically based material. Lambert has no specular term, so highlights will differ.",
-  MeshPhongMaterial: "Converted to roughness/metalness. Phong shininess is not a physical parameter, so the specular falloff is an approximation.",
-  MeshToonMaterial: "Rendered as flat diffuse. Cel shading is a screen-space stylization with no path-traced equivalent.",
-  MeshMatcapMaterial: "Rendered as diffuse using the matcap average. A matcap encodes lighting into a texture, which is exactly what path tracing replaces.",
-  MeshNormalMaterial: "Rendered as flat gray. Normal visualization is a debug view, not a surface.",
-  MeshDepthMaterial: "Rendered as flat gray. Depth output is a debug view.",
-  MeshDistanceMaterial: "Rendered as flat gray. Distance output is a debug view."
+  MeshBasicMaterial: "It shows its color and map unlit, as in the viewport, but it does not light the scene, cast a shadow, or show in reflections or through glass.",
+  MeshLambertMaterial: "It renders as a fully rough, non-metal surface in its color and map.",
+  MeshPhongMaterial: "It renders as a fully rough, non-metal surface in its color and map, like Lambert. Its `shininess` and `specular` are not used, so it has no sharp highlights.",
+  MeshToonMaterial: "It renders as a fully rough, non-metal surface in its color and map, without the cel shading of its `gradientMap`.",
+  MeshMatcapMaterial: "It renders as a fully rough, non-metal surface in its color and map, lit by the scene. The `matcap` texture is not used.",
+  MeshNormalMaterial: "It renders flat gray. It colors a surface by its normals, which is a debug view, not a look.",
+  MeshDepthMaterial: "It renders flat gray. It shows depth, which is a debug view, not a look.",
+  MeshDistanceMaterial: "It renders flat gray. It is made for shadow maps, not for a visible surface."
 };
+var IGNORED = [
+  {
+    name: "alphaMap",
+    used: (m) => isTexture(m.alphaMap) && Boolean(m.transparent || m.alphaTest > 0 || m.alphaHash),
+    fix: "For a cutout, use the alpha channel of `map`."
+  },
+  {
+    name: "bumpMap",
+    used: (m) => isTexture(m.bumpMap) && m.bumpScale !== 0,
+    fix: "Bake bump detail into a `normalMap`."
+  },
+  {
+    name: "displacementMap",
+    used: (m) => isTexture(m.displacementMap) && m.displacementScale !== 0,
+    fix: "Model the shape, or bake the detail into a `normalMap`."
+  },
+  { name: "specularMap", used: (m) => isTexture(m.specularMap) },
+  { name: "iridescence", used: (m) => m.iridescence > 0 },
+  {
+    name: "iridescenceMap",
+    used: (m) => m.iridescence > 0 && isTexture(m.iridescenceMap)
+  },
+  {
+    name: "iridescenceThicknessMap",
+    used: (m) => m.iridescence > 0 && isTexture(m.iridescenceThicknessMap)
+  },
+  {
+    name: "dispersion",
+    used: (m) => m.dispersion > 0 && m.transmission > 0
+  }
+];
 function emitsLight(material) {
   const m = material;
   if (m.isMeshBasicMaterial) return true;
@@ -3052,6 +3003,7 @@ function emitsLight(material) {
 function analyzeScene(root) {
   const issues = [];
   const seenMaterials = /* @__PURE__ */ new Set();
+  const unfaithful = /* @__PURE__ */ new Set();
   const seenTextures = /* @__PURE__ */ new Set();
   let triangles = 0;
   let faithfulTriangles = 0;
@@ -3085,12 +3037,21 @@ function analyzeScene(root) {
           });
         }
       }
-      if (seenMaterials.has(material.uuid)) continue;
-      seenMaterials.add(material.uuid);
-      if (emitsLight(material)) emitters++;
-      for (const issue of classifyMaterial(material, object)) {
+      const fallback = fallbackFor(material, object);
+      const key = fallback?.declaredOn === "object" ? `${object.uuid}:${material.uuid}` : material.uuid;
+      if (seenMaterials.has(key)) {
+        if (unfaithful.has(key)) objectIsFaithful = false;
+        continue;
+      }
+      seenMaterials.add(key);
+      if (fallback ? fallbackEmits(fallback.values) : emitsLight(material))
+        emitters++;
+      for (const issue of classifyMaterial(material, object, fallback)) {
         issues.push(issue);
-        if (issue.severity === "error") objectIsFaithful = false;
+        if (issue.severity === "error") {
+          objectIsFaithful = false;
+          unfaithful.add(key);
+        }
       }
     }
     if (objectIsFaithful) faithfulTriangles += count;
@@ -3123,98 +3084,142 @@ function collectFallbacks(root) {
   const fallbacks = [];
   const seen = /* @__PURE__ */ new Set();
   root.traverse((object) => {
+    if (shouldExclude(object)) return;
     const mesh = object;
     if (!mesh.isMesh) return;
     const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
     for (const material of materials) {
-      if (!material || seen.has(material.uuid)) continue;
-      const declared = material.userData?.bakery3?.fallback ?? readUserData(object).fallback;
-      if (!declared) continue;
-      seen.add(material.uuid);
+      if (!material) continue;
+      const fallback = fallbackFor(material, object);
+      if (!fallback) continue;
+      const materialId = fallbackMaterialId(material, object, fallback);
+      if (seen.has(materialId)) continue;
+      seen.add(materialId);
       fallbacks.push({
-        ...declared,
-        materialId: idOf(material),
+        ...fallback.values,
+        materialId,
         type: "physical"
       });
     }
   });
   return fallbacks;
 }
-function classifyMaterial(material, object) {
-  const hasFallback = Boolean(
-    material.userData?.bakery3?.fallback ?? readUserData(object).fallback
-  );
-  if (isNodeMaterial(material) && !hasFallback) {
+function classifyMaterial(material, object, fallback) {
+  if (fallback) {
+    return [
+      {
+        code: "material_fallback_used",
+        severity: "info",
+        message: `${labelOf(material)} renders with your declared fallback.`,
+        path: pathOf(object),
+        materialId: fallbackMaterialId(material, object, fallback),
+        materialName: material.name,
+        materialType: material.type,
+        docs: `${DOCS2}/material-fallbacks`
+      }
+    ];
+  }
+  if (isNodeMaterial(material)) {
     const extracted = extractMaterialShader(material);
-    return extracted.issues.map((issue) => ({
+    const issues = extracted.issues.map((issue) => ({
       ...issue,
       path: pathOf(object),
       materialId: idOf(material),
       materialName: material.name,
       materialType: material.type
     }));
+    if (!extracted.spec)
+      issues.push(...classicIssues(material, object, classicType(material)));
+    return issues;
   }
-  const verdict = classify(material, object, hasFallback);
-  return verdict ? [verdict.issue] : [];
+  return classicIssues(material, object, material.type);
 }
-function classify(material, object, hasFallback) {
-  if (TRANSLATABLE.has(material.type)) return null;
-  if (hasFallback) {
-    return {
-      issue: {
-        code: "material_fallback_used",
-        severity: "info",
-        message: `${material.type} "${material.name || "unnamed"}" renders with your declared fallback.`,
-        path: pathOf(object),
-        materialId: idOf(material),
-        materialName: material.name,
-        materialType: material.type,
-        docs: `${DOCS2}/material-fallbacks`
-      }
-    };
-  }
-  if (material.type === "ShaderMaterial" || material.type === "RawShaderMaterial") {
+function classicIssues(material, object, type) {
+  const issues = [];
+  const verdict = classify(material, object, type);
+  if (verdict) issues.push(verdict);
+  if (!exporterCannotWrite(material)) {
+    const ignored = ignoredSlots(material, object);
+    if (ignored) issues.push(ignored);
+  }
+  return issues;
+}
+function classify(material, object, type) {
+  if (TRANSLATABLE.has(type)) return null;
+  const about = {
+    path: pathOf(object),
+    materialId: idOf(material),
+    materialName: material.name,
+    materialType: material.type
+  };
+  if (material.isShaderMaterial) {
     return {
-      issue: {
-        code: "material_custom_shader",
-        severity: "error",
-        message: `Unsupported material: ${material.name || material.type}`,
-        path: pathOf(object),
-        materialId: idOf(material),
-        materialName: material.name,
-        materialType: material.type,
-        docs: `${DOCS2}/material-fallbacks`
-      }
+      code: "material_custom_shader",
+      severity: "error",
+      message: `${labelOf(material)} renders flat gray, because the render cannot run GLSL. Declare a fallback, or port it to TSL.`,
+      ...about,
+      docs: `${DOCS2}/material-fallbacks`
     };
   }
-  const approximation = APPROXIMATED[material.type];
+  const approximation = APPROXIMATED[type];
   if (approximation) {
     return {
-      issue: {
-        code: "material_approximated",
-        severity: "warning",
-        message: `${material.type} "${material.name || "unnamed"}" is approximated. ${approximation}`,
-        path: pathOf(object),
-        materialId: idOf(material),
-        materialName: material.name,
-        materialType: material.type,
-        docs: `${DOCS2}/materials`
-      }
+      code: "material_approximated",
+      severity: "warning",
+      message: `${labelOf(material)} is approximated. ${approximation}${emissiveNote(material)}`,
+      ...about,
+      docs: `${DOCS2}/materials`
     };
   }
+  const looks = exporterCannotWrite(material) ? "flat gray" : "as a fully rough, non-metal surface in its color";
   return {
-    issue: {
-      code: "material_unknown",
-      severity: "error",
-      message: `Unsupported material: ${material.name || material.type}`,
-      path: pathOf(object),
-      materialId: idOf(material),
-      materialName: material.name,
-      materialType: material.type,
-      docs: `${DOCS2}/materials`
-    }
+    code: "material_unknown",
+    severity: "error",
+    message: `${labelOf(material)} renders ${looks}, because the render does not support this material. Use MeshStandardMaterial or MeshPhysicalMaterial, or declare a fallback.`,
+    ...about,
+    docs: `${DOCS2}/materials`
   };
 }
+function emissiveNote(material) {
+  const m = material;
+  if (m.isMeshStandardMaterial || !m.emissive) return "";
+  if (m.emissiveIntensity === void 0 || m.emissiveIntensity === 1) return "";
+  if (m.emissive.r + m.emissive.g + m.emissive.b <= 0) return "";
+  return " Its `emissiveIntensity` is not used, so it glows at intensity 1.";
+}
+function ignoredSlots(material, object) {
+  const record2 = material;
+  const ignored = IGNORED.filter((slot) => slot.used(record2));
+  if (!ignored.length) return null;
+  const names = ignored.map((slot) => `\`${slot.name}\``);
+  const list = names.length === 1 ? names[0] : `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`;
+  const fixes = ignored.flatMap((slot) => slot.fix ? [slot.fix] : []);
+  return {
+    code: "material_map_ignored",
+    severity: "warning",
+    message: [
+      `${labelOf(material)} uses ${list}, which the render ignores.`,
+      ...fixes
+    ].join(" "),
+    path: pathOf(object),
+    materialId: idOf(material),
+    materialName: material.name,
+    materialType: material.type,
+    docs: `${DOCS2}/materials#slots-the-render-ignores`
+  };
+}
+function classicType(material) {
+  const m = material;
+  if (m.isMeshPhysicalMaterial) return "MeshPhysicalMaterial";
+  if (m.isMeshStandardMaterial) return "MeshStandardMaterial";
+  return material.type.replace(/NodeMaterial$/, "Material");
+}
+function labelOf(material) {
+  return `${material.type} "${material.name || "unnamed"}"`;
+}
+function isTexture(value) {
+  return Boolean(value?.isTexture);
+}
 var TEXTURE_SLOTS = [
   "map",
   "normalMap",
@@ -3268,7 +3273,8 @@ function sceneComplexity(scene, camera) {
   let objects = 0;
   const visit = (object) => {
     if (!object.visible) return;
-    if (excludedItself(object) && !rooms.has(object)) return;
+    const shell = Boolean(object.userData?.bakery3RoomShell);
+    if (excludedItself(object) && !rooms.has(object) && !shell) return;
     const mesh = object;
     if (mesh.isMesh && mesh.geometry?.attributes?.position) {
       const position = mesh.geometry.attributes.position;
@@ -3279,7 +3285,7 @@ function sceneComplexity(scene, camera) {
         (_, i) => i % 3 === 0 ? position.getX(i / 3 | 0) : i % 3 === 1 ? position.getY(i / 3 | 0) : position.getZ(i / 3 | 0)
       );
       const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
-      const emitter = materials.length > 0 && materials.every((material) => material && emitsLight(material));
+      const emitter = !shell && materials.length > 0 && materials.every((material) => material && emitsLight(material));
       const base = {
         positions,
         indices: index?.array ?? null,
@@ -3297,13 +3303,17 @@ function sceneComplexity(scene, camera) {
           });
         }
       } else {
-        objects += 1;
+        if (!shell) objects += 1;
         meshes.push({ ...base, matrix: mesh.matrixWorld.elements });
       }
     }
     for (const child of object.children) visit(child);
   };
   visit(scene);
+  for (const room of rooms) {
+    if (room.visible && roomShownBaked(room))
+      objects += roomPresetFactsOf(room)?.objects ?? 0;
+  }
   const eye = camera.getWorldPosition(new Vector3());
   return complexityOf(meshes, [eye.x, eye.y, eye.z], objects);
 }
@@ -3354,13 +3364,10 @@ async function captureShaders(root) {
     const list = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
     for (const material of list) {
       if (!material || seen.has(material.uuid)) continue;
+      if (!isNodeMaterial(material)) continue;
+      if (fallbackFor(material, object)) continue;
       seen.add(material.uuid);
-      const hasFallback = Boolean(
-        material.userData?.bakery3?.fallback ?? readUserData(object).fallback
-      );
-      if (isNodeMaterial(material) && !hasFallback) {
-        materials.push({ material, path: pathOf2(object) });
-      }
+      materials.push({ material, path: pathOf2(object) });
     }
   });
   for (const { material, path } of materials) {
@@ -3674,8 +3681,10 @@ async function captureScene(options) {
 }
 function exportGLB(scene) {
   const exporter = new GLTFExporter();
+  const standIns = materialStandIns(scene);
   const reattach = detachExcluded(scene);
   const unmute = muteLightWarnings();
+  const unswap = substituteMaterials(exporter, standIns);
   return new Promise((resolve, reject) => {
     exporter.parse(
       scene,
@@ -3709,6 +3718,7 @@ function exportGLB(scene) {
       }
     );
   }).finally(() => {
+    unswap();
     unmute();
     reattach();
   });
@@ -3925,7 +3935,7 @@ function presetRoomBake(scene, candidates, include) {
   const group = rooms[0];
   const room = roomPresetSpecOf(group);
   if (!room) return null;
-  if (!roomIsPrebaked(room.name, room.lighting)) {
+  if (!roomShownBaked(group) && !roomIsPrebaked(room.name, room.lighting)) {
     return {
       refused: {
         code: "BakeRoomNotPrebaked",
@@ -4009,15 +4019,31 @@ function isUnder(object, root) {
 function planBake(scene, camera, settings = {}) {
   const quality = settings.quality ?? "standard";
   const textureSize = settings.textureSize ?? 1024;
-  const candidates = bakeCandidates({ scene });
+  let candidates = bakeCandidates({ scene });
   let include = resolveInclude(candidates, settings);
   let preset;
   if (settings.room !== "full") {
-    const verdict = presetRoomBake(scene, candidates, include);
+    const hide = revealBakedStands(scene);
+    let seen = candidates;
+    let seenInclude = include;
+    if (hide.length) {
+      try {
+        seen = bakeCandidates({ scene });
+        seenInclude = resolveInclude(seen, settings);
+      } finally {
+        for (const undo of hide) undo();
+      }
+    }
+    const verdict = presetRoomBake(scene, seen, seenInclude);
     if (verdict && "ok" in verdict) {
       preset = verdict.ok;
+      candidates = seen;
       const keep = /* @__PURE__ */ new Set([...preset.spanIds]);
-      include = include.filter((id) => keep.has(id));
+      include = seenInclude.filter((id) => keep.has(id));
+      if (hide.length) {
+        for (const id of preset.standIds)
+          if (!include.includes(id)) include.push(id);
+      }
     }
   }
   const standIns = resolveSimplify(scene, candidates, settings);
@@ -4202,7 +4228,8 @@ async function prepareBake(options) {
 function holdRoomBack(preset, include) {
   const undo = [];
   const state = preset.group.userData?.bakery3Preset?.roomPreset;
-  if (!state?.standIn) return undo;
+  if (!state) return undo;
+  if (!state.standIn && !roomShownBaked(preset.group)) return undo;
   const shipping = new Set(
     include.filter((id) => preset.standIds.includes(id))
   );
@@ -4224,6 +4251,19 @@ function holdRoomBack(preset, include) {
   });
   return undo;
 }
+function revealBakedStands(scene) {
+  const undo = [];
+  for (const group of findPresetRooms(scene)) {
+    if (!roomShownBaked(group)) continue;
+    const state = group.userData?.bakery3Preset?.roomPreset;
+    if (!state || state.standIn) continue;
+    state.standIn = "stand";
+    undo.push(() => {
+      state.standIn = void 0;
+    });
+  }
+  return undo;
+}
 function developerUv1(candidates, include) {
   const wanted = new Set(include);
   return candidates.filter((candidate) => {
@@ -4487,6 +4527,6 @@ function resolveInclude(candidates, settings) {
   return resolved;
 }
 
-export { OBJECT_PROPERTIES, Timeline, analyzeScene, aspectOf, bakeQuoteOf, bindTimelineContext, captureScene, createTimeline, extractMaterialShader, isNodeMaterial, linearToSrgbHex, outputSize, prepareBake, quoteBake, resolveOutput, sceneComplexity, timelineFromGsap, timelineFromTheatre, tracedTriangles };
-//# sourceMappingURL=chunk-CX4WTVGH.js.map
-//# sourceMappingURL=chunk-CX4WTVGH.js.map
+export { Timeline, analyzeScene, aspectOf, bakeQuoteOf, bindTimelineContext, captureScene, createTimeline, extractMaterialShader, isNodeMaterial, outputSize, prepareBake, quoteBake, resolveOutput, sceneComplexity, timelineFromGsap, timelineFromTheatre, tracedTriangles };
+//# sourceMappingURL=chunk-WLEFNUOH.js.map
+//# sourceMappingURL=chunk-WLEFNUOH.js.map