@oeave/bakery3 0.0.0-stage → 0.2.0

package/dist/chunk-HNMSWQU7.js

@@ -0,0 +1,1709 @@
+import { rememberEnvironmentSource, sha256 } from './chunk-KZLVTSBI.js';
+import { presetBaseUrl } from './chunk-4E5VV4QY.js';
+import { applyRoomPrebake, roomPresetSpecOf } from './chunk-APWUCEEB.js';
+import { HDRI_PRESETS, PRESETS_VERSION, MATERIAL_PRESETS, PEDESTAL_PRESETS } from './chunk-6NYR73Y7.js';
+import { ROOM_PRESETS } from './chunk-LAKXC4WR.js';
+import { Bakery3Error } from './chunk-3G5QL4F4.js';
+import { EquirectangularReflectionMapping, Color, MathUtils, DataTexture, RGBAFormat, FloatType, LinearSRGBColorSpace, MeshStandardMaterial, Group, MeshPhysicalMaterial, DoubleSide, DirectionalLight, Object3D, Vector3, Float32BufferAttribute, Matrix4, Box3, SpotLight, HemisphereLight, ShadowMaterial, Mesh, LightProbe, FileLoader, HalfFloatType, LinearFilter, TextureLoader, RepeatWrapping, SRGBColorSpace, PlaneGeometry, DataUtils, SphericalHarmonics3, Shape, Path, ShapeGeometry, Texture, BoxGeometry, Quaternion, Euler, BufferGeometry } from 'three';
+import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
+import { GroundedSkybox } from 'three/addons/objects/GroundedSkybox.js';
+import { MeshoptDecoder } from 'three/addons/libs/meshopt_decoder.module.js';
+import { mergeGeometries } from 'three/addons/utils/BufferGeometryUtils.js';
+
+var HALF_MAX = 65504;
+function decodeRadianceHdr(buffer) {
+  const bytes = new Uint8Array(buffer);
+  let pos = 0;
+  const line = () => {
+    const end = bytes.indexOf(10, pos);
+    if (end < 0) return null;
+    let text = "";
+    for (let i = pos; i < end; i++) text += String.fromCharCode(bytes[i]);
+    pos = end + 1;
+    return text;
+  };
+  const refuse = (why) => new Error(`@oeave/bakery3/presets: not a readable .hdr file (${why}).`);
+  const magic = line();
+  if (!magic || !/^#\?\S+/.test(magic)) throw refuse("no #? header");
+  let format = false;
+  let width = 0;
+  let height = 0;
+  for (let text = line(); text !== null; text = line()) {
+    if (text.startsWith("#")) continue;
+    if (/^\s*FORMAT=32-bit_rle_rgbe\s*$/.test(text)) format = true;
+    const size = /^\s*-Y\s+(\d+)\s+\+X\s+(\d+)\s*$/.exec(text);
+    if (size) {
+      height = Number(size[1]);
+      width = Number(size[2]);
+      break;
+    }
+  }
+  if (!format) throw refuse("missing FORMAT=32-bit_rle_rgbe");
+  if (!(width > 0 && height > 0)) throw refuse("missing -Y h +X w");
+  const rgbe = scanlines(bytes.subarray(pos), width, height, refuse);
+  const data = new Uint16Array(width * height * 4);
+  const one = DataUtils.toHalfFloat(1);
+  for (let i = 0; i < width * height; i++) {
+    const o = i * 4;
+    const e = rgbe[o + 3];
+    const scale = e ? Math.pow(2, e - 128) / 255 : 0;
+    data[o] = DataUtils.toHalfFloat(Math.min(rgbe[o] * scale, HALF_MAX));
+    data[o + 1] = DataUtils.toHalfFloat(
+      Math.min(rgbe[o + 1] * scale, HALF_MAX)
+    );
+    data[o + 2] = DataUtils.toHalfFloat(
+      Math.min(rgbe[o + 2] * scale, HALF_MAX)
+    );
+    data[o + 3] = one;
+  }
+  return { width, height, data };
+}
+function scanlines(body, width, height, refuse) {
+  const flat = width < 8 || width > 32767 || body[0] !== 2 || body[1] !== 2 || (body[2] & 128) !== 0;
+  if (flat) {
+    if (body.length < width * height * 4) throw refuse("file is cut short");
+    return body.subarray(0, width * height * 4);
+  }
+  const out = new Uint8Array(width * height * 4);
+  const planes = new Uint8Array(width * 4);
+  let pos = 0;
+  for (let row = 0; row < height; row++) {
+    if (pos + 4 > body.length) throw refuse("file is cut short");
+    if (body[pos] !== 2 || body[pos + 1] !== 2 || (body[pos + 2] << 8 | body[pos + 3]) !== width)
+      throw refuse("bad scanline header");
+    pos += 4;
+    let ptr = 0;
+    while (ptr < planes.length) {
+      if (pos >= body.length) throw refuse("file is cut short");
+      let count = body[pos++];
+      const run = count > 128;
+      if (run) count -= 128;
+      if (count === 0 || ptr + count > planes.length)
+        throw refuse("bad scanline data");
+      if (run) {
+        planes.fill(body[pos++], ptr, ptr + count);
+      } else {
+        planes.set(body.subarray(pos, pos + count), ptr);
+        pos += count;
+      }
+      ptr += count;
+    }
+    const base = row * width * 4;
+    for (let col = 0; col < width; col++) {
+      const o = base + col * 4;
+      out[o] = planes[col];
+      out[o + 1] = planes[width + col];
+      out[o + 2] = planes[2 * width + col];
+      out[o + 3] = planes[3 * width + col];
+    }
+  }
+  return out;
+}
+async function loadRadianceHdr(url) {
+  const buffer = await new FileLoader().setResponseType("arraybuffer").loadAsync(url);
+  const image = decodeRadianceHdr(buffer);
+  const texture = new DataTexture(
+    image.data,
+    image.width,
+    image.height,
+    RGBAFormat,
+    HalfFloatType
+  );
+  texture.colorSpace = LinearSRGBColorSpace;
+  texture.minFilter = LinearFilter;
+  texture.magFilter = LinearFilter;
+  texture.generateMipmaps = false;
+  texture.flipY = true;
+  texture.needsUpdate = true;
+  return texture;
+}
+
+// src/presets/library.ts
+function presetTextureUrl(name, map, size = "2k", base = presetBaseUrl()) {
+  return `${base}/v${PRESETS_VERSION}/materials/${name}/${size}/${MATERIAL_PRESETS[name].files[map]}`;
+}
+function pedestalUrl(name, base = presetBaseUrl()) {
+  return `${base}/v${PRESETS_VERSION}/objects/${name}.glb`;
+}
+function presetEnvironmentUrl(name, asset = "preview", base = presetBaseUrl()) {
+  const file = asset === "preview" ? "preview.hdr" : "render.exr";
+  return `${base}/v${PRESETS_VERSION}/hdri/${name}/${file}`;
+}
+async function loadPresetEnvironment(name, options = {}) {
+  const base = options.baseUrl ?? presetBaseUrl();
+  const texture = await loadPresetHdr(name, base);
+  rememberEnvironmentSource(
+    texture,
+    presetEnvironmentUrl(name, "render", base),
+    { preset: true }
+  );
+  return texture;
+}
+async function loadPresetHdr(name, base = presetBaseUrl()) {
+  if (!HDRI_PRESETS[name]) {
+    throw new Error(
+      `'${String(name)}' is not an HDRI preset. Known: ${Object.keys(HDRI_PRESETS).join(", ")}.`
+    );
+  }
+  const texture = await loadRadianceHdr(
+    presetEnvironmentUrl(name, "preview", base)
+  );
+  texture.mapping = EquirectangularReflectionMapping;
+  texture.userData.bakery3Preset = {
+    kind: "hdri",
+    name,
+    version: PRESETS_VERSION,
+    previewResolution: HDRI_PRESETS[name].preview.resolution,
+    renderResolution: HDRI_PRESETS[name].render.resolution
+  };
+  return texture;
+}
+function createSkyEnvironment(options = {}) {
+  const zenith = new Color(options.zenith ?? 3108816);
+  const horizon = new Color(options.horizon ?? 10274037);
+  const ground = new Color(options.ground ?? 9406073);
+  const intensity = options.intensity ?? 1;
+  const width = Math.max(8, Math.round(options.width ?? 128));
+  const height = width / 2;
+  const data = new Float32Array(width * height * 4);
+  const color = new Color();
+  for (let row = 0; row < height; row++) {
+    const elevation = (0.5 - (row + 0.5) / height) * Math.PI;
+    if (elevation >= 0) {
+      color.copy(zenith).lerp(horizon, Math.pow(1 - Math.sin(elevation), 2.2));
+    } else {
+      color.copy(horizon).lerp(ground, Math.min(1, -elevation / MathUtils.degToRad(3)));
+    }
+    for (let col = 0; col < width; col++) {
+      const i = (row * width + col) * 4;
+      data[i] = color.r * intensity;
+      data[i + 1] = color.g * intensity;
+      data[i + 2] = color.b * intensity;
+      data[i + 3] = 1;
+    }
+  }
+  const texture = new DataTexture(data, width, height, RGBAFormat, FloatType);
+  texture.mapping = EquirectangularReflectionMapping;
+  texture.colorSpace = LinearSRGBColorSpace;
+  texture.flipY = true;
+  texture.needsUpdate = true;
+  texture.userData.bakery3Preset = { kind: "sky", ...options };
+  rememberEnvironmentSource(texture, encodeRadianceHdr(data, width, height));
+  return texture;
+}
+function encodeRadianceHdr(data, width, height) {
+  if (width < 8 || width > 32767) {
+    throw new Error(
+      `@oeave/bakery3/presets: a Radiance scanline is 8 to 32767 pixels wide, not ${width}.`
+    );
+  }
+  const header = new TextEncoder().encode(
+    `#?RADIANCE
+FORMAT=32-bit_rle_rgbe
+
+-Y ${height} +X ${width}
+`
+  );
+  const chunks = Math.ceil(width / 128);
+  const scanline = 4 + 4 * (width + chunks);
+  const out = new Uint8Array(header.length + height * scanline);
+  out.set(header, 0);
+  let o = header.length;
+  const planes = new Uint8Array(width * 4);
+  for (let row = 0; row < height; row++) {
+    for (let col = 0; col < width; col++) {
+      const i = (row * width + col) * 4;
+      const r = data[i];
+      const g = data[i + 1];
+      const b = data[i + 2];
+      const max = Math.max(r, g, b);
+      if (max < 1e-32) {
+        planes[col] = planes[width + col] = planes[2 * width + col] = 0;
+        planes[3 * width + col] = 0;
+        continue;
+      }
+      let e = Math.ceil(Math.log2(max));
+      let m = max / Math.pow(2, e);
+      if (m >= 1) {
+        m /= 2;
+        e += 1;
+      } else if (m < 0.5) {
+        m *= 2;
+        e -= 1;
+      }
+      const scale = m * 256 / max;
+      planes[col] = Math.min(255, Math.floor(r * scale));
+      planes[width + col] = Math.min(255, Math.floor(g * scale));
+      planes[2 * width + col] = Math.min(255, Math.floor(b * scale));
+      planes[3 * width + col] = e + 128;
+    }
+    out[o++] = 2;
+    out[o++] = 2;
+    out[o++] = width >> 8 & 255;
+    out[o++] = width & 255;
+    for (let plane = 0; plane < 4; plane++) {
+      for (let start = 0; start < width; start += 128) {
+        const n = Math.min(128, width - start);
+        out[o++] = n;
+        out.set(
+          planes.subarray(plane * width + start, plane * width + start + n),
+          o
+        );
+        o += n;
+      }
+    }
+  }
+  return out.buffer;
+}
+function presetRepeat(name) {
+  return 1 / MATERIAL_PRESETS[name].tileMeters;
+}
+var textureCache = /* @__PURE__ */ new Map();
+var sharedLoader;
+function loadTexture(url, srgb, repeat, anisotropy) {
+  const key = `${url}#${repeat}`;
+  const cached = textureCache.get(key);
+  if (cached) return cached;
+  sharedLoader ??= new TextureLoader();
+  const texture = sharedLoader.load(url);
+  texture.wrapS = texture.wrapT = RepeatWrapping;
+  texture.repeat.set(repeat, repeat);
+  if (srgb) texture.colorSpace = SRGBColorSpace;
+  texture.anisotropy = anisotropy;
+  textureCache.set(key, texture);
+  return texture;
+}
+function createPresetMaterial(name, options = {}) {
+  const info = MATERIAL_PRESETS[name];
+  const size = options.size ?? "2k";
+  const base = options.baseUrl ?? presetBaseUrl();
+  const repeat = presetRepeat(name) * (options.repeat ?? 1);
+  const anisotropy = options.anisotropy ?? 8;
+  const url = (map) => presetTextureUrl(name, map, size, base);
+  const material = new MeshStandardMaterial({
+    metalness: info.metalness,
+    roughness: 1,
+    map: loadTexture(url("albedo"), true, repeat, anisotropy),
+    normalMap: loadTexture(url("normal"), false, repeat, anisotropy),
+    roughnessMap: loadTexture(url("roughness"), false, repeat, anisotropy)
+  });
+  if (options.ao !== false) {
+    material.aoMap = loadTexture(url("ao"), false, repeat, anisotropy);
+  }
+  material.normalScale.setScalar(info.normalScale);
+  material.userData.bakery3Preset = { name, size };
+  return material;
+}
+async function loadPresetMaterial(name, options = {}) {
+  const material = createPresetMaterial(name, options);
+  const maps = [
+    material.map,
+    material.normalMap,
+    material.roughnessMap,
+    material.aoMap
+  ];
+  await Promise.all(
+    maps.filter((t) => t !== null).map((t) => textureReady(t, name))
+  );
+  return material;
+}
+function textureReady(texture, presetName) {
+  return new Promise((resolve, reject) => {
+    if (texture.source.data) return resolve();
+    const started = Date.now();
+    const poll = setInterval(() => {
+      if (texture.source.data) {
+        clearInterval(poll);
+        resolve();
+      } else if (Date.now() - started > 3e4) {
+        clearInterval(poll);
+        reject(
+          new Error(
+            `@oeave/bakery3/presets: timed out loading a map for '${presetName}'`
+          )
+        );
+      }
+    }, 50);
+  });
+}
+function planeMeters(width, height) {
+  const geometry = new PlaneGeometry(width, height);
+  const uv = geometry.attributes.uv;
+  for (let i = 0; i < uv.count; i++) {
+    uv.setXY(i, uv.getX(i) * width, uv.getY(i) * height);
+  }
+  return geometry;
+}
+var WINDOW_DEFAULTS = {
+  offset: 0,
+  width: 1.2,
+  height: 1.4,
+  sill: 0.9,
+  frame: true,
+  glass: false,
+  foliage: true
+};
+var WINDOW_MARGIN = 0.05;
+function resolveWindows(wall, specs, wallWidth, roomHeight) {
+  const list = specs === void 0 ? [] : Array.isArray(specs) ? specs : [specs];
+  const openings = list.map((spec, index) => {
+    const { offset, width, height, sill, frame, glass, foliage } = {
+      ...WINDOW_DEFAULTS,
+      ...spec
+    };
+    const label = `@oeave/bakery3/presets: ${wall} window ${index}`;
+    if (width <= 0 || height <= 0) {
+      throw new Error(
+        `${label} has a non-positive size (${width} \xD7 ${height} m).`
+      );
+    }
+    if (sill < 0) {
+      throw new Error(
+        `${label} has its sill ${sill} m below the floor. Use sill: 0 or higher.`
+      );
+    }
+    const opening = {
+      x0: offset - width / 2,
+      x1: offset + width / 2,
+      y0: sill,
+      y1: sill + height,
+      frame,
+      glass,
+      foliage
+    };
+    const limit = wallWidth / 2 - WINDOW_MARGIN;
+    if (opening.x0 < -limit || opening.x1 > limit) {
+      throw new Error(
+        `${label} (offset ${offset}, width ${width}) does not fit the ${wallWidth} m wall. Keep it ${WINDOW_MARGIN} m clear of the corners.`
+      );
+    }
+    if (opening.y1 > roomHeight - WINDOW_MARGIN) {
+      throw new Error(
+        `${label} reaches ${opening.y1} m but the room is ${roomHeight} m tall. Lower the sill or shrink the height.`
+      );
+    }
+    return opening;
+  });
+  for (let i = 0; i < openings.length; i++) {
+    for (let j = i + 1; j < openings.length; j++) {
+      const a = openings[i];
+      const b = openings[j];
+      if (a.x0 < b.x1 && b.x0 < a.x1 && a.y0 < b.y1 && b.y0 < a.y1) {
+        throw new Error(
+          `@oeave/bakery3/presets: ${wall} windows ${i} and ${j} overlap. Separate their offsets.`
+        );
+      }
+    }
+  }
+  return openings;
+}
+function wallFaceGeometry(width, height, openings) {
+  const shape = new Shape();
+  shape.moveTo(-width / 2, 0);
+  shape.lineTo(width / 2, 0);
+  shape.lineTo(width / 2, height);
+  shape.lineTo(-width / 2, height);
+  shape.closePath();
+  for (const opening of openings) {
+    const hole = new Path();
+    hole.moveTo(opening.x0, opening.y0);
+    hole.lineTo(opening.x0, opening.y1);
+    hole.lineTo(opening.x1, opening.y1);
+    hole.lineTo(opening.x1, opening.y0);
+    hole.closePath();
+    shape.holes.push(hole);
+  }
+  return new ShapeGeometry(shape);
+}
+var FRAME_MEMBER = 0.055;
+var FRAME_DEPTH = 0.045;
+function buildWindow(opening, index, thickness, materials) {
+  const { x0, x1, y0, y1 } = opening;
+  const w = x1 - x0;
+  const h = y1 - y0;
+  const cx = (x0 + x1) / 2;
+  const cy = (y0 + y1) / 2;
+  const z = -thickness / 2;
+  const group = new Group();
+  group.name = `window-${index}`;
+  const reveal = (geometry, position, rotation, name) => {
+    const mesh = new Mesh(geometry, materials.wall);
+    mesh.name = name;
+    mesh.position.set(...position);
+    mesh.rotation.set(...rotation);
+    mesh.castShadow = true;
+    mesh.receiveShadow = true;
+    group.add(mesh);
+  };
+  reveal(
+    planeMeters(thickness, h),
+    [x0, cy, z],
+    [0, Math.PI / 2, 0],
+    "reveal-left"
+  );
+  reveal(
+    planeMeters(thickness, h),
+    [x1, cy, z],
+    [0, -Math.PI / 2, 0],
+    "reveal-right"
+  );
+  reveal(
+    planeMeters(w, thickness),
+    [cx, y1, z],
+    [Math.PI / 2, 0, 0],
+    "reveal-top"
+  );
+  reveal(
+    planeMeters(w, thickness),
+    [cx, y0, z],
+    [-Math.PI / 2, 0, 0],
+    "reveal-sill"
+  );
+  if (opening.frame) {
+    const bar = (bw, bh, position) => {
+      const mesh = new Mesh(
+        new BoxGeometry(bw, bh, FRAME_DEPTH),
+        materials.frame
+      );
+      mesh.name = "frame";
+      mesh.position.set(...position);
+      mesh.castShadow = true;
+      mesh.receiveShadow = true;
+      group.add(mesh);
+    };
+    bar(w, FRAME_MEMBER, [cx, y0 + FRAME_MEMBER / 2, z]);
+    bar(w, FRAME_MEMBER, [cx, y1 - FRAME_MEMBER / 2, z]);
+    bar(FRAME_MEMBER, h - 2 * FRAME_MEMBER, [x0 + FRAME_MEMBER / 2, cy, z]);
+    bar(FRAME_MEMBER, h - 2 * FRAME_MEMBER, [x1 - FRAME_MEMBER / 2, cy, z]);
+    if (w > 1.05) bar(FRAME_MEMBER * 0.7, h - 2 * FRAME_MEMBER, [cx, cy, z]);
+  }
+  if (opening.glass) {
+    const pane = new Mesh(planeMeters(w, h), materials.glass);
+    pane.name = "glass";
+    pane.position.set(cx, cy, z + FRAME_DEPTH / 2 + 2e-3);
+    group.add(pane);
+  }
+  if (opening.foliage) {
+    group.add(buildFoliage(opening, index, thickness, materials.foliage));
+  }
+  return group;
+}
+function buildFoliage(opening, index, thickness, materials) {
+  const { x0, x1, y0, y1 } = opening;
+  const h = y1 - y0;
+  const random = mulberry32(
+    Math.round((x0 * 73 + y0 * 151 + x1 * 271 + y1 * 397) * 1e3) + index * 7919
+  );
+  const depth = -(thickness + 0.7);
+  const cell = 0.5;
+  const xStart = x0 - 0.35;
+  const xEnd = x1 + 0.35;
+  const yStart = y0 + h * 0.15;
+  const yEnd = y1 + 0.7;
+  const cols = Math.max(2, Math.round((xEnd - xStart) / cell));
+  const rows = Math.max(2, Math.round((yEnd - yStart) / cell));
+  const leaves = [];
+  const twigs = [];
+  const position = new Vector3();
+  const rotation = new Quaternion();
+  const unit = new Vector3(1, 1, 1);
+  const matrix = new Matrix4();
+  const euler = new Euler();
+  const place = (geometry, x, y, z, rx, ry, rz) => {
+    position.set(x, y, z);
+    euler.set(rx, ry, rz);
+    rotation.setFromEuler(euler);
+    matrix.compose(position, rotation, unit);
+    geometry.applyMatrix4(matrix);
+    return geometry;
+  };
+  for (let row = 0; row < rows; row++) {
+    for (let col = 0; col < cols; col++) {
+      if (random() < 0.3) continue;
+      const clumpX = xStart + (col + 0.5) * (xEnd - xStart) / cols + (random() - 0.5) * cell * 0.6;
+      const clumpY = yStart + (row + 0.5) * (yEnd - yStart) / rows + (random() - 0.5) * cell * 0.6;
+      const clumpZ = depth + (random() - 0.5) * 0.3;
+      const radius = 0.24 + random() * 0.14;
+      for (let t = 0; t < 3; t++) {
+        twigs.push(
+          place(
+            new BoxGeometry(8e-3, 8e-3, radius * 1.7),
+            clumpX + (random() - 0.5) * radius * 0.5,
+            clumpY + (random() - 0.5) * radius * 0.5,
+            clumpZ,
+            (random() - 0.5) * 0.8,
+            (random() - 0.5) * 3.2,
+            (random() - 0.5) * 0.8
+          )
+        );
+      }
+      const count = Math.round(radius * radius * Math.PI * 210);
+      for (let i = 0; i < count; i++) {
+        leaves.push(
+          place(
+            leafGeometry(0.08 + random() * 0.06),
+            clumpX + (random() + random() - 1) * radius,
+            clumpY + (random() + random() - 1) * radius * 0.85,
+            clumpZ + (random() - 0.5) * 0.2,
+            (random() - 0.5) * 1.4,
+            (random() - 0.5) * 1.4,
+            random() * Math.PI * 2
+          )
+        );
+      }
+    }
+  }
+  const merge = (parts, name, material) => {
+    const geometry = mergeGeometries(parts, false) ?? new BufferGeometry();
+    for (const part of parts) part.dispose();
+    geometry.computeVertexNormals();
+    const mesh = new Mesh(geometry, material);
+    mesh.name = name;
+    mesh.castShadow = true;
+    mesh.receiveShadow = false;
+    return mesh;
+  };
+  const group = new Group();
+  group.name = "foliage";
+  group.add(
+    merge(leaves, "leaves", materials.leaf),
+    merge(twigs, "twigs", materials.twig)
+  );
+  return group;
+}
+function leafGeometry(length) {
+  const half = length * 0.34;
+  const shape = new Shape();
+  shape.moveTo(0, 0);
+  shape.quadraticCurveTo(half, length * 0.45, 0, length);
+  shape.quadraticCurveTo(-half, length * 0.55, 0, 0);
+  return new ShapeGeometry(shape, 5);
+}
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function createRoom(options = {}) {
+  const width = options.width ?? 4;
+  const depth = options.depth ?? 4;
+  const height = options.height ?? 2.7;
+  const thickness = options.wallThickness ?? 0.15;
+  const materialFor = (name) => {
+    const material = createPresetMaterial(name, options.materialOptions);
+    material.shadowSide = DoubleSide;
+    return material;
+  };
+  const room = new Group();
+  room.name = "bakery3-room";
+  room.userData.bakery3Preset = {
+    room: { width, depth, height, windows: options.windows ?? null }
+  };
+  const surface2 = (name, geometry, material, position, rotation, parent = room) => {
+    const mesh = new Mesh(geometry, material);
+    mesh.name = name;
+    mesh.position.set(...position);
+    mesh.rotation.set(...rotation);
+    mesh.castShadow = true;
+    mesh.receiveShadow = true;
+    parent.add(mesh);
+    return mesh;
+  };
+  const floor = materialFor(options.floor ?? "oak_floor");
+  surface2(
+    "floor",
+    planeMeters(width, depth),
+    floor,
+    [0, 0, 0],
+    [-Math.PI / 2, 0, 0]
+  );
+  if (options.ceiling !== null) {
+    const ceiling = materialFor(options.ceiling ?? "matte_paint");
+    surface2(
+      "ceiling",
+      planeMeters(width, depth),
+      ceiling,
+      [0, height, 0],
+      [Math.PI / 2, 0, 0]
+    );
+  }
+  const wallMaterial = materialFor(options.walls ?? "white_plaster");
+  const frameMaterial = new MeshStandardMaterial({
+    color: 16053232,
+    roughness: 0.5,
+    metalness: 0
+  });
+  const glassMaterial = new MeshPhysicalMaterial({
+    roughness: 0.04,
+    metalness: 0,
+    transmission: 1,
+    ior: 1.52,
+    thickness: 6e-3,
+    side: DoubleSide
+  });
+  const leafMaterial = new MeshStandardMaterial({
+    color: 3824170,
+    roughness: 0.7,
+    metalness: 0,
+    side: DoubleSide
+  });
+  leafMaterial.name = "foliage-leaf";
+  const twigMaterial = new MeshStandardMaterial({
+    color: 4864556,
+    roughness: 0.9,
+    metalness: 0
+  });
+  twigMaterial.name = "foliage-twig";
+  const buildWall = (name, wallWidth, position, rotationY) => {
+    const openings = resolveWindows(
+      name,
+      options.windows?.[name],
+      wallWidth,
+      height
+    );
+    const wall = new Group();
+    wall.name = `wall-${name}`;
+    wall.position.set(...position);
+    wall.rotation.y = rotationY;
+    surface2(
+      "face",
+      wallFaceGeometry(wallWidth, height, openings),
+      wallMaterial,
+      [0, 0, 0],
+      [0, 0, 0],
+      wall
+    );
+    openings.forEach((opening, index) => {
+      wall.add(
+        buildWindow(opening, index, thickness, {
+          wall: wallMaterial,
+          frame: frameMaterial,
+          glass: glassMaterial,
+          foliage: { leaf: leafMaterial, twig: twigMaterial }
+        })
+      );
+    });
+    room.add(wall);
+  };
+  buildWall("north", width, [0, 0, -depth / 2], 0);
+  buildWall("south", width, [0, 0, depth / 2], Math.PI);
+  buildWall("west", depth, [-width / 2, 0, 0], Math.PI / 2);
+  buildWall("east", depth, [width / 2, 0, 0], -Math.PI / 2);
+  if (options.sun) {
+    room.add(
+      createRoomSun(
+        options.sun === true ? {} : options.sun,
+        width,
+        depth,
+        height
+      )
+    );
+  }
+  return room;
+}
+function createRoomSun(options, width, depth, height) {
+  const elevation = MathUtils.degToRad(options.elevation ?? 32);
+  const azimuth = MathUtils.degToRad(options.azimuth ?? 0);
+  const reach = Math.hypot(width, depth, height);
+  const group = new Group();
+  group.name = "sun";
+  const sun = new DirectionalLight(
+    options.color ?? 16773855,
+    options.intensity ?? 3.5
+  );
+  sun.name = "sun-light";
+  const horizontal = 2 * reach * Math.cos(elevation);
+  sun.position.set(
+    horizontal * Math.sin(azimuth),
+    2 * reach * Math.sin(elevation) + height / 2,
+    -horizontal * Math.cos(azimuth)
+  );
+  const target = new Object3D();
+  target.name = "sun-target";
+  target.position.set(0, height / 2, 0);
+  group.add(sun, target);
+  sun.target = target;
+  sun.userData.bakery3 = { angleDeg: options.angleDeg ?? 0.53 };
+  sun.castShadow = true;
+  sun.shadow.mapSize.set(2048, 2048);
+  sun.shadow.camera.left = sun.shadow.camera.bottom = -reach;
+  sun.shadow.camera.right = sun.shadow.camera.top = reach;
+  sun.shadow.camera.near = 0.1;
+  sun.shadow.camera.far = 6 * reach;
+  sun.shadow.bias = -3e-4;
+  return group;
+}
+var sharedGltfLoader;
+var gltfCache = /* @__PURE__ */ new Map();
+function loadGlb(url) {
+  let pending = gltfCache.get(url);
+  if (!pending) {
+    sharedGltfLoader ??= new GLTFLoader();
+    pending = sharedGltfLoader.loadAsync(url).then((gltf) => gltf.scene);
+    gltfCache.set(url, pending);
+  }
+  return pending;
+}
+function createPedestal(typeOrOptions = {}, more = {}) {
+  const options = typeof typeOrOptions === "string" ? { ...more, type: typeOrOptions } : typeOrOptions ?? {};
+  const type = options.type ?? "pedestal_block";
+  const info = PEDESTAL_PRESETS[type];
+  if (!info) {
+    throw new Bakery3Error({
+      code: "InvalidRequest",
+      message: `"${String(type)}" is not a pedestal.`,
+      fix: `Use one of: ${Object.keys(PEDESTAL_PRESETS).join(", ")}.`,
+      docs: "https://bakery3.com/docs/presets"
+    });
+  }
+  const material = createPresetMaterial(
+    options.material ?? info.defaultMaterial,
+    {
+      baseUrl: options.baseUrl,
+      ...options.materialOptions
+    }
+  );
+  const pedestal = new Group();
+  pedestal.name = `bakery3-${type}`;
+  pedestal.userData.topY = info.size.y;
+  pedestal.userData.bakery3Preset = { object: type };
+  pedestal.userData.ready = loadGlb(
+    pedestalUrl(type, options.baseUrl ?? presetBaseUrl())
+  ).then((glb) => {
+    const instance = glb.clone();
+    instance.traverse((node) => {
+      if (!node.isMesh) return;
+      const mesh = node;
+      mesh.geometry = mesh.geometry.clone();
+      mesh.material = material;
+      mesh.castShadow = true;
+      mesh.receiveShadow = true;
+    });
+    pedestal.add(instance);
+    return pedestal;
+  });
+  return pedestal;
+}
+function bakedRoomUrl(name, lighting, base = presetBaseUrl(), presetsVersion = 1) {
+  return `${base.replace(/\/$/, "")}/v${presetsVersion}/rooms/${name}/baked/${lighting}/`;
+}
+
+// src/presets/room.ts
+var DOME_RADIUS = 60;
+var GROUND_DROP = 0.05;
+function presetRoomUrl(name, base = presetBaseUrl()) {
+  const info = ROOM_PRESETS[name];
+  return `${base.replace(/\/$/, "")}/v${info.presetsVersion}/${info.preview.glb}`;
+}
+var IES_PEAK_PER_WATT = 6e-3;
+var FIXTURE_GLOW_STRENGTH = 5;
+var DOWNLIGHT_SCALE = 9;
+var CANDELA_PER_WATT = 683 / (4 * Math.PI);
+var CAN_FULL_WATTS = 20;
+var ACCENT_BEAM = {
+  narrow: { angleDeg: 17.5, penumbra: 0.5 },
+  medium: { angleDeg: 31.6, penumbra: 0.5 },
+  wide: { angleDeg: 48.6, penumbra: 0.5 }
+};
+var MODE_LOOK = {
+  day: { hemi: 0.55, sun: 0.42, point: 10, sky: "#e9eef4", ground: "#6a5f52" },
+  golden: { hemi: 0.4, sun: 0.5, point: 10, sky: "#f1dcc2", ground: "#6a5f52" },
+  overcast: {
+    hemi: 0.8,
+    sun: 0.3,
+    point: 10,
+    sky: "#dfe3e8",
+    ground: "#6a5f52"
+  },
+  night: { hemi: 0.06, sun: 0.3, point: 4, sky: "#2a3550", ground: "#1a1712" }
+};
+function hexLuminance(hex) {
+  const m = /^#?([0-9a-f]{6})$/i.exec(hex.trim());
+  if (!m) return 1;
+  const channel = (i) => {
+    const v = parseInt(m[1].slice(i, i + 2), 16) / 255;
+    return v <= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4;
+  };
+  return 0.2126 * channel(0) + 0.7152 * channel(2) + 0.0722 * channel(4);
+}
+function hemisphereFill(look, fill) {
+  if (!fill?.sky || !fill?.ground) {
+    return {
+      sky: new Color(look.sky),
+      ground: new Color(look.ground),
+      intensity: 1
+    };
+  }
+  const skyLevel = hexLuminance(look.sky);
+  const groundLevel = hexLuminance(look.ground);
+  const peak = (rgb) => Math.max(rgb[0], rgb[1], rgb[2]);
+  const scale = Math.max(
+    skyLevel * peak(fill.sky),
+    groundLevel * peak(fill.ground),
+    1e-6
+  );
+  const color = (rgb, level) => new Color().setRGB(
+    rgb[0] * level / scale,
+    rgb[1] * level / scale,
+    rgb[2] * level / scale
+  );
+  return {
+    sky: color(fill.sky, skyLevel),
+    ground: color(fill.ground, groundLevel),
+    intensity: scale
+  };
+}
+var sharedLoader2;
+var glbCache = /* @__PURE__ */ new Map();
+function loadRoomGlb(url) {
+  let pending = glbCache.get(url);
+  if (!pending) {
+    if (!sharedLoader2) {
+      sharedLoader2 = new GLTFLoader();
+      sharedLoader2.setMeshoptDecoder(MeshoptDecoder);
+    }
+    pending = sharedLoader2.loadAsync(url).then((gltf) => gltf.scene);
+    glbCache.set(url, pending);
+  }
+  return pending;
+}
+var BAKED_SHADOW_REACH = 1.6;
+var bakedCache = /* @__PURE__ */ new Map();
+function loadBakedGlb(url, exposure) {
+  let pending = bakedCache.get(url);
+  if (!pending) {
+    pending = new GLTFLoader().loadAsync(url).then((gltf) => {
+      const scale = exposure > 0 ? 1 / exposure : 1;
+      const seen = /* @__PURE__ */ new Set();
+      gltf.scene.traverse((node) => {
+        const light = node;
+        if (light.isLight) light.intensity *= scale;
+        const mesh = node;
+        if (!mesh.isMesh) return;
+        for (const material of Array.isArray(mesh.material) ? mesh.material : [mesh.material]) {
+          if (seen.has(material)) continue;
+          seen.add(material);
+          if (bakedLit(mesh) === "glow") material.side = DoubleSide;
+          const basic = material;
+          const standard = material;
+          if (basic.isMeshBasicMaterial) basic.color.multiplyScalar(scale);
+          else if (standard.isMeshStandardMaterial)
+            standard.emissiveIntensity *= scale;
+        }
+      });
+      return gltf.scene;
+    });
+    bakedCache.set(url, pending);
+    pending.catch(() => bakedCache.delete(url));
+  }
+  return pending;
+}
+function scaleHalfFloats(data, scale) {
+  if (scale === 1) return;
+  for (let i = 0; i < data.length; i += 4) {
+    for (let c = 0; c < 3; c++) {
+      data[i + c] = DataUtils.toHalfFloat(
+        Math.min(DataUtils.fromHalfFloat(data[i + c]) * scale, 65e3)
+      );
+    }
+  }
+}
+function irradianceOf(data, width, height) {
+  const sh = new SphericalHarmonics3();
+  const basis = new Array(9).fill(0);
+  const direction = new Vector3();
+  const color = new Vector3();
+  const step = Math.max(1, Math.floor(width / 128));
+  let total = 0;
+  for (let row = Math.floor(step / 2); row < height; row += step) {
+    const latitude = (0.5 - (row + 0.5) / height) * Math.PI;
+    const weight = Math.cos(latitude);
+    for (let column = Math.floor(step / 2); column < width; column += step) {
+      const longitude = ((column + 0.5) / width - 0.5) * 2 * Math.PI;
+      direction.set(
+        Math.cos(latitude) * Math.cos(longitude),
+        Math.sin(latitude),
+        Math.cos(latitude) * Math.sin(longitude)
+      );
+      const at = (row * width + column) * 4;
+      color.set(
+        DataUtils.fromHalfFloat(data[at]),
+        DataUtils.fromHalfFloat(data[at + 1]),
+        DataUtils.fromHalfFloat(data[at + 2])
+      );
+      SphericalHarmonics3.getBasisAt(direction, basis);
+      for (let j = 0; j < 9; j++)
+        sh.coefficients[j].addScaledVector(color, basis[j] * weight);
+      total += weight;
+    }
+  }
+  if (total > 0) sh.scale(4 * Math.PI / total);
+  return sh;
+}
+function bakedLit(mesh) {
+  for (let at = mesh; at; at = at.parent) {
+    if (typeof at.userData.bakery3Lit === "string")
+      return at.userData.bakery3Lit;
+  }
+  return null;
+}
+function bakedRole(mesh) {
+  for (let at = mesh; at; at = at.parent) {
+    if (typeof at.userData.bakery3Role === "string")
+      return at.userData.bakery3Role;
+  }
+  return null;
+}
+var surface = (option) => option === void 0 ? void 0 : typeof option === "string" ? { material: option } : {
+  material: option.material,
+  ...option.color ? { color: option.color } : {}
+};
+var PLANTER_PARTS = /* @__PURE__ */ new Set([
+  "pot",
+  "base",
+  "gravel",
+  "pebbles",
+  "ground",
+  "dirt"
+]);
+var ROOM_STAND_INS = 12;
+function stampRoomStandIns(root, roomPlants) {
+  const plants = [...roomPlants].sort((a, b) => b.length - a.length);
+  const wanted = [];
+  const groups = /* @__PURE__ */ new Set();
+  root.traverse((node) => {
+    const mesh = node;
+    if (!mesh.isMesh) return;
+    const hint = plantPart(mesh, plants) ?? bookPart(mesh.name);
+    if (!hint) return;
+    wanted.push({ mesh, ...hint });
+    groups.add(hint.group);
+  });
+  if (groups.size > ROOM_STAND_INS) return 0;
+  for (const { mesh, to, group } of wanted) {
+    const existing = mesh.userData.bakery3 ?? {};
+    if (existing.simplify !== void 0) continue;
+    mesh.userData.bakery3 = { ...existing, simplify: { to, group } };
+  }
+  return groups.size;
+}
+function bookPart(name) {
+  const parts = name.split(".");
+  if (parts[0] !== "book" || parts.length < 4) return null;
+  return { to: "box", group: `room:books/${parts[1]}.${parts[2]}.${parts[3]}` };
+}
+function plantPart(mesh, plants) {
+  const preset = plants.find(
+    (presetName) => mesh.name.startsWith(`${presetName}_`)
+  );
+  if (!preset) return null;
+  const part = mesh.name.slice(preset.length + 1).split(".")[0] ?? "";
+  const where = `${mesh.parent?.name ?? "room"}/${preset}`;
+  return PLANTER_PARTS.has(part) ? { to: "lowpoly", group: `room:planter/${where}` } : { to: "billboard", group: `room:foliage/${where}` };
+}
+function stampRoomIds(root, name) {
+  const seen = /* @__PURE__ */ new Map();
+  let named = 0;
+  root.traverse((node) => {
+    if (!node.isMesh) return;
+    if (typeof node.userData.bakery3Id === "string" && node.userData.bakery3Id)
+      return;
+    const base = `room:${name}/${node.name || node.type}`;
+    const before = seen.get(base) ?? 0;
+    seen.set(base, before + 1);
+    node.userData.bakery3Id = before === 0 ? base : `${base}#${before}`;
+    named++;
+  });
+  return named;
+}
+var plainName = (object) => object.name.toLowerCase().replace(/[._]/g, "");
+async function hangPictures(instance, pictures, roomName) {
+  const frames = [];
+  instance.traverse((node) => {
+    const mesh = node;
+    if (mesh.isMesh && /^picture\.\d+\.art$/.test(mesh.name)) frames.push(mesh);
+  });
+  frames.sort(
+    (a, b) => Number(a.name.split(".")[1]) - Number(b.name.split(".")[1])
+  );
+  if (pictures.length > frames.length) {
+    throw new Bakery3Error({
+      code: "InvalidRequest",
+      message: `${roomName} hangs ${frames.length} picture${frames.length === 1 ? "" : "s"}, and ${pictures.length} were given.`,
+      why: "Pictures fill the room's own frames in order; there is no wall to hang a spare on.",
+      fix: `ROOM_PRESETS['${roomName}'].pictures says how many there are and which walls they are on.`,
+      docs: "https://bakery3.com/docs/presets#pictures"
+    });
+  }
+  const hashes = [];
+  const assets = [];
+  for (const [index, picture] of pictures.entries()) {
+    if (!picture) {
+      hashes.push(null);
+      continue;
+    }
+    const frame = frames[index];
+    const { hash, data, contentType, texture } = await loadPicture(picture);
+    coverFit(texture, frame);
+    const material = Array.isArray(frame.material) ? frame.material[0] : frame.material;
+    const replacement = material.clone();
+    replacement.map = texture;
+    replacement.needsUpdate = true;
+    frame.material = replacement;
+    hashes.push(hash);
+    assets.push({ hash, data, contentType, name: `picture-${index}` });
+  }
+  return { hashes, assets };
+}
+async function loadPicture(picture) {
+  let blob;
+  if (typeof picture === "string") {
+    const response = await fetch(picture);
+    if (!response.ok) {
+      throw new Bakery3Error({
+        code: "InvalidRequest",
+        message: `The picture at ${picture} could not be loaded (${response.status} ${response.statusText}).`,
+        why: "The page fetches it, so it has to be reachable from the browser and CORS-readable.",
+        fix: "Serve it from your own origin, or with an Access-Control-Allow-Origin header.",
+        docs: "https://bakery3.com/docs/presets#pictures"
+      });
+    }
+    blob = await response.blob();
+  } else {
+    blob = picture;
+  }
+  const data = await blob.arrayBuffer();
+  const hash = await sha256(data);
+  const bitmap = await createImageBitmap(
+    new Blob([data], { type: blob.type || "image/jpeg" })
+  );
+  const texture = new Texture(bitmap);
+  texture.flipY = false;
+  texture.colorSpace = SRGBColorSpace;
+  texture.needsUpdate = true;
+  return { hash, data, contentType: blob.type || "image/jpeg", texture };
+}
+function coverFit(texture, frame) {
+  const image = texture.image;
+  if (!image?.width || !image?.height) return;
+  if (!frame.geometry.boundingBox) frame.geometry.computeBoundingBox();
+  const box = frame.geometry.boundingBox;
+  if (!box) return;
+  const height = box.max.y - box.min.y;
+  const width = Math.max(box.max.x - box.min.x, box.max.z - box.min.z);
+  if (!(height > 0) || !(width > 0)) return;
+  const opening = width / height;
+  const picture = image.width / image.height;
+  if (picture > opening) texture.repeat.set(opening / picture, 1);
+  else texture.repeat.set(1, picture / opening);
+  texture.offset.set((1 - texture.repeat.x) / 2, (1 - texture.repeat.y) / 2);
+}
+var SHELF_MATERIAL = "oak_veneer_05";
+function strippedPreset(mesh) {
+  const name = mesh.userData?.bakery3Material;
+  if (typeof name !== "string" || !name) return null;
+  const color = mesh.userData?.bakery3MaterialColor;
+  return {
+    material: name,
+    ...typeof color === "string" && color && color.toLowerCase() !== "#ffffff" ? { color } : {}
+  };
+}
+function coerceDefaultMaterial(mesh) {
+  const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+  for (const material of materials) {
+    const standard = material;
+    if (!standard.isMeshStandardMaterial) continue;
+    const bare = standard.metalness === 1 && standard.roughness === 1 && !standard.map && standard.color.getHex() === 16777215;
+    if (!bare) continue;
+    standard.metalness = 0;
+    standard.roughness = 0.6;
+    standard.color.set("#b9b2a6");
+    warnBareMaterial(mesh.name);
+  }
+}
+var warnedBare = /* @__PURE__ */ new Set();
+function warnBareMaterial(name) {
+  if (warnedBare.has(name)) return;
+  warnedBare.add(name);
+  console.warn(
+    `[bakery3] "${name}" arrived with no material and has been given a plain one. Republish the room so it carries the preset material it was built with.`
+  );
+}
+function createPresetRoom(name, options = {}) {
+  const info = ROOM_PRESETS[name];
+  if (!info) {
+    throw new Error(
+      `'${String(name)}' is not a room preset. Known rooms: ${Object.keys(ROOM_PRESETS).join(", ") || "none"}.`
+    );
+  }
+  const lighting = options.lighting ?? info.lighting;
+  const materialOptions = {
+    ...options.baseUrl ? { baseUrl: options.baseUrl } : {},
+    ...options.materialOptions
+  };
+  const standType = options.pedestal === void 0 ? info.stand.type : options.pedestal;
+  if (options.pedestal && !(options.pedestal in PEDESTAL_PRESETS)) {
+    throw new Bakery3Error({
+      code: "InvalidRequest",
+      message: `"${String(options.pedestal)}" is not a pedestal.`,
+      fix: `Use one of: ${Object.keys(PEDESTAL_PRESETS).join(", ")}, or null for the floor.`,
+      docs: "https://bakery3.com/docs/presets"
+    });
+  }
+  const standInfo = standType ? PEDESTAL_PRESETS[standType] : void 0;
+  const standBaked = Boolean(standInfo);
+  const standMaterial = !standType || !standBaked ? null : options.pedestalMaterial ?? (options.pedestal === void 0 ? info.stand.material : standInfo?.defaultMaterial ?? null);
+  const topY = !standType ? 0 : options.pedestal === void 0 ? info.stand.top : standInfo.size.y;
+  const published = info.hdri?.[lighting] ?? null;
+  const hdriName = options.hdri === false ? null : options.hdri ?? (published && published.name in HDRI_PRESETS ? published.name : null);
+  const hdriChoice = hdriName ? {
+    name: hdriName,
+    // Turned so its sun sits at the room's, as the render will turn
+    // it: the published map's turn is the room's sun minus that
+    // map's sun, so another map's turn is the same sum with its own.
+    rotationDeg: options.hdri ? hdriTurn(hdriName, published, lighting) : published.rotationDeg,
+    groundHeight: HDRI_PRESETS[hdriName].groundHeight,
+    // Shown at the room's own exposure: what this mode's sky delivers
+    // over what the map's does. The render exposes its dome by the same
+    // ratio.
+    exposure: hdriExposure(
+      info.skyIrradiance[lighting],
+      HDRI_PRESETS[hdriName].skyIrradiance
+    )
+  } : null;
+  const state = {
+    name,
+    build: info.build,
+    lighting,
+    ...options.bake ? { standIn: true } : {},
+    ...options.hdri === false ? { hdri: null } : options.hdri ? { hdri: options.hdri } : {},
+    ...options.floor || options.walls || options.ceiling || options.sill ? {
+      surfaces: {
+        ...options.floor ? { floor: surface(options.floor) } : {},
+        ...options.walls ? { walls: surface(options.walls) } : {},
+        ...options.ceiling ? { ceiling: surface(options.ceiling) } : {},
+        ...options.sill ? { sill: { material: options.sill } } : {}
+      }
+    } : {},
+    ...options.pedestal === void 0 ? {} : options.pedestal === null ? { pedestal: null } : {
+      pedestal: {
+        type: options.pedestal,
+        ...standMaterial ? { material: standMaterial } : {}
+      }
+    }
+  };
+  const room = new Group();
+  room.name = `bakery3-room-${name}`;
+  room.userData.bakery3Preset = {
+    roomPreset: state,
+    // For the capture's compatibility note, so it never opens the catalog.
+    roomFacts: {
+      label: info.label,
+      triangles: info.preview.triangles,
+      ...info.complexity ? { objects: info.complexity.objects } : {}
+    }
+  };
+  room.userData.topY = topY;
+  room.userData.stand = new Vector3(info.stand.x, topY, info.stand.z);
+  room.userData.exposure = info.exposure[lighting];
+  const floor = surface(options.floor) ?? info.surfaces.floor;
+  const walls = surface(options.walls) ?? info.surfaces.walls;
+  const ceiling = surface(options.ceiling) ?? info.surfaces.ceiling;
+  const sill = options.sill ?? info.surfaces.sill.material;
+  const cache = /* @__PURE__ */ new Map();
+  const preset = (material, color) => {
+    const key = `${material}|${color ?? ""}`;
+    let made = cache.get(key);
+    if (!made) {
+      if (!(material in MATERIAL_PRESETS)) {
+        throw new Error(`'${material}' is not a preset material.`);
+      }
+      made = createPresetMaterial(
+        material,
+        materialOptions
+      );
+      made.shadowSide = DoubleSide;
+      if (color && color.toLowerCase() !== "#ffffff") made.color.set(color);
+      cache.set(key, made);
+    }
+    return made;
+  };
+  const plain = (color, roughness = 0.5) => new MeshStandardMaterial({ color, roughness });
+  const makeDome = () => hdriChoice ? loadPresetHdr(hdriChoice.name, options.baseUrl ?? presetBaseUrl()).then(
+    (map) => {
+      const dome = new GroundedSkybox(
+        map,
+        hdriChoice.groundHeight,
+        DOME_RADIUS
+      );
+      dome.name = "hdri.dome";
+      dome.position.y = hdriChoice.groundHeight - GROUND_DROP;
+      dome.rotation.y = -MathUtils.degToRad(hdriChoice.rotationDeg);
+      dome.castShadow = false;
+      dome.receiveShadow = false;
+      dome.userData.bakery3Dome = {
+        name: hdriChoice.name,
+        exposure: hdriChoice.exposure,
+        rotationDeg: hdriChoice.rotationDeg,
+        groundHeight: hdriChoice.groundHeight,
+        radius: DOME_RADIUS
+      };
+      dome.userData.bakery3 = { exclude: true };
+      checkDomeReachOnce(dome);
+      return dome;
+    }
+  ) : Promise.resolve(null);
+  const buildStandIn = () => Promise.all([
+    loadRoomGlb(presetRoomUrl(name, options.baseUrl)),
+    makeDome()
+  ]).then(async ([glb, dome]) => {
+    if (dome) room.add(dome);
+    const instance = glb.clone();
+    const look = MODE_LOOK[lighting];
+    const glass = new MeshPhysicalMaterial({
+      transmission: 1,
+      roughness: 0.05,
+      ior: 1.45,
+      thickness: 0.01
+    });
+    let glowColor = null;
+    instance.traverse((node) => {
+      const lamp = node;
+      if (!glowColor && (lamp.isPointLight || node.isSpotLight) && !/^accent\./.test(node.name)) {
+        glowColor = lamp.color.clone();
+      }
+    });
+    const glow = new MeshStandardMaterial({
+      color: 0,
+      emissive: glowColor ?? new Color("#ffd9a8"),
+      emissiveIntensity: FIXTURE_GLOW_STRENGTH,
+      roughness: 1
+    });
+    instance.traverse((node) => {
+      const mesh = node;
+      if (mesh.isMesh) {
+        mesh.geometry = options.bake ? plainFloatGeometry(mesh.geometry.clone()) : mesh.geometry.clone();
+        mesh.castShadow = true;
+        mesh.receiveShadow = true;
+        const n = plainName(mesh);
+        if (n.startsWith("wall"))
+          mesh.material = preset(walls.material, walls.color);
+        else if (n.startsWith("floor"))
+          mesh.material = preset(floor.material, floor.color);
+        else if (n.startsWith("ceiling"))
+          mesh.material = preset(ceiling.material, ceiling.color);
+        else if (n.startsWith("sill")) mesh.material = preset(sill);
+        else if (n.startsWith("glass") || n.startsWith("skylightglass")) {
+          mesh.material = glass;
+          mesh.castShadow = false;
+          mesh.userData.bakery3 = {
+            ...mesh.userData.bakery3 ?? {},
+            exclude: true
+          };
+        } else if (n.startsWith("fixtureglow")) {
+          mesh.material = glow;
+          mesh.userData.bakery3 = {
+            ...mesh.userData.bakery3 ?? {},
+            bake: false
+          };
+        } else if (n.startsWith("covestrip")) {
+          mesh.material = glow;
+          if (n.startsWith("covestripdetail")) {
+            const both = glow.clone();
+            both.side = DoubleSide;
+            mesh.material = both;
+          }
+          mesh.userData.bakery3 = {
+            ...mesh.userData.bakery3 ?? {},
+            exclude: true
+          };
+        } else if (n.startsWith("fixturebezel"))
+          mesh.material = plain("#1a1a1c", 0.4);
+        else if (n.startsWith("frame") || n.startsWith("baseboard") || n.startsWith("skylightcurb") || n.startsWith("coveledge")) {
+          mesh.material = plain("#eeeae2", 0.35);
+        } else if (n.startsWith("shelf") || n.startsWith("bookcase")) {
+          const wore = strippedPreset(mesh);
+          mesh.material = preset(
+            wore?.material ?? SHELF_MATERIAL,
+            wore?.color
+          );
+        } else if (n.startsWith("rug")) {
+          mesh.material = new MeshPhysicalMaterial({
+            color: "#8a7a68",
+            roughness: 0.95,
+            sheen: 1,
+            sheenRoughness: 0.4
+          });
+        } else if (n.startsWith("pedestal")) {
+          mesh.material = info.stand.material ? preset(info.stand.material) : plain("#d9d6d0");
+        } else {
+          const wore = strippedPreset(mesh);
+          if (wore) mesh.material = preset(wore.material, wore.color);
+          else {
+            const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+            const cloned = materials.map((m) => m.clone());
+            mesh.material = Array.isArray(mesh.material) ? cloned : cloned[0];
+            coerceDefaultMaterial(mesh);
+          }
+        }
+      }
+    });
+    const standGroup = instance.getObjectByName("stand");
+    if (standGroup && options.pedestal !== void 0) {
+      for (const child of [...standGroup.children]) standGroup.remove(child);
+      standGroup.position.set(0, 0, 0);
+      standGroup.rotation.set(0, 0, 0);
+      if (standType) {
+        const object = createPedestal({
+          type: standType,
+          ...standMaterial ? { material: standMaterial } : {},
+          ...options.baseUrl ? { baseUrl: options.baseUrl } : {},
+          materialOptions
+        });
+        object.rotation.y = MathUtils.degToRad(info.stand.rotationDeg);
+        object.position.set(info.stand.x, 0, info.stand.z);
+        standGroup.add(object);
+      }
+    } else if (standGroup && standMaterial) {
+      standGroup.traverse((node) => {
+        if (node.isMesh)
+          node.material = preset(standMaterial);
+      });
+    }
+    const brightness = info.previewBrightness[lighting];
+    if (dome && hdriChoice) {
+      dome.material.color.setScalar(
+        hdriChoice.exposure * look.sun * brightness
+      );
+    }
+    const lights = [];
+    instance.traverse((node) => {
+      if (node.isLight) lights.push(node);
+    });
+    for (const light of lights)
+      light.userData.bakery3 = {
+        ...light.userData.bakery3 ?? {},
+        exclude: true
+      };
+    if (options.lights === false) {
+      for (const light of lights) light.parent?.remove(light);
+    } else {
+      const reach = Math.max(info.size.width, info.size.depth);
+      for (const light of lights) {
+        if (light.isDirectionalLight) {
+          const sun = light;
+          sun.visible = lighting === "day" || lighting === "golden";
+          sun.intensity = 3.5 * look.sun * brightness;
+          sun.castShadow = true;
+          sun.shadow.mapSize.set(2048, 2048);
+          sun.shadow.camera.left = -reach;
+          sun.shadow.camera.right = reach;
+          sun.shadow.camera.top = reach;
+          sun.shadow.camera.bottom = -reach;
+          sun.shadow.camera.far = 60;
+          sun.shadow.bias = -2e-4;
+          sun.shadow.normalBias = 0.02;
+          if (sun.target && !sun.target.parent) instance.add(sun.target);
+        } else if (/^accent\./.test(light.name) && (light.isPointLight || light.isSpotLight)) {
+          const lamp = light;
+          const beam = ACCENT_BEAM[light.name.split(".")[1]] ?? ACCENT_BEAM.narrow;
+          const watts = lamp.intensity * 4 * Math.PI / 683;
+          const spot = new SpotLight(
+            lamp.color,
+            watts * IES_PEAK_PER_WATT * look.sun * brightness
+          );
+          spot.name = light.name;
+          spot.angle = MathUtils.degToRad(beam.angleDeg);
+          spot.penumbra = beam.penumbra;
+          spot.decay = 2;
+          spot.distance = 0;
+          spot.castShadow = true;
+          spot.shadow.mapSize.set(1024, 1024);
+          spot.shadow.bias = -2e-4;
+          spot.shadow.normalBias = 0.02;
+          spot.position.copy(lamp.position);
+          spot.target.position.copy(lamp.position).add(new Vector3(0, 0, -2).applyQuaternion(lamp.quaternion));
+          spot.userData.bakery3 = { exclude: true };
+          spot.target.userData.bakery3 = { exclude: true };
+          const parent = lamp.parent ?? instance;
+          parent.remove(lamp);
+          parent.add(spot, spot.target);
+        } else if (light.isPointLight || light.isSpotLight) {
+          const lamp = light;
+          const watts = lamp.intensity / CANDELA_PER_WATT / DOWNLIGHT_SCALE;
+          lamp.intensity = look.point * Math.min(1, watts / CAN_FULL_WATTS) * brightness;
+          lamp.decay = 2;
+          lamp.distance = 0;
+          lamp.castShadow = false;
+        }
+      }
+      const colors = hemisphereFill(look, info.previewFill?.[lighting]);
+      const fill = new HemisphereLight(
+        colors.sky,
+        colors.ground,
+        look.hemi * brightness * colors.intensity
+      );
+      fill.name = "fill";
+      fill.userData.bakery3 = { exclude: true };
+      instance.add(fill);
+    }
+    for (const camera of instance.children.filter(
+      (c) => c.isCamera
+    )) {
+      instance.remove(camera);
+    }
+    room.add(instance);
+    if (options.pictures?.length) {
+      const hung = await hangPictures(instance, options.pictures, name);
+      if (hung.hashes.some(Boolean)) {
+        state.pictures = hung.hashes;
+        room.userData.bakery3Preset = {
+          ...room.userData.bakery3Preset,
+          roomPreset: state,
+          pictureAssets: hung.assets
+        };
+      }
+    }
+    if (options.simplify !== false) stampRoomStandIns(instance, info.plants);
+    stampRoomIds(room, name);
+    room.userData.shown = "standIn";
+    return room;
+  });
+  const buildBaked = async () => {
+    const base = options.baseUrl ?? presetBaseUrl();
+    const url = bakedRoomUrl(name, lighting, base, info.presetsVersion);
+    const response = await fetch(`${url}room.json`);
+    if (!response.ok) throw new Error(`${url}room.json: ${response.status}`);
+    const manifest = await response.json();
+    const [source, probe, standSource] = await Promise.all([
+      loadBakedGlb(`${url}${manifest.glb}`, manifest.exposureBakedIn),
+      loadRadianceHdr(`${url}${manifest.probe.uri}`),
+      info.standGlb ? loadRoomGlb(
+        `${base.replace(/\/$/, "")}/v${info.presetsVersion}/${info.standGlb}`
+      ) : Promise.resolve(null)
+    ]);
+    const baked = source.clone();
+    baked.name = "baked";
+    const stand = standSource?.clone() ?? null;
+    const catchers = [];
+    const doomed = [];
+    let key = null;
+    baked.traverse((node) => {
+      node.userData.bakery3 = {
+        ...node.userData.bakery3 ?? {},
+        exclude: true
+      };
+      node.userData.bakery3RoomShell = true;
+      const light = node;
+      if (light.isLight) key = light;
+      const mesh = node;
+      if (!mesh.isMesh) return;
+      mesh.castShadow = false;
+      mesh.receiveShadow = false;
+      const role = bakedRole(mesh);
+      if (role === "stand" && stand) doomed.push(mesh);
+      else if (role === "floor") catchers.push(mesh);
+    });
+    for (const mesh of doomed) mesh.parent?.remove(mesh);
+    room.add(baked);
+    if (stand) {
+      stand.traverse((node) => {
+        const mesh = node;
+        if (!mesh.isMesh) return;
+        mesh.geometry = plainFloatGeometry(mesh.geometry.clone());
+        mesh.castShadow = true;
+        mesh.receiveShadow = true;
+        if (plainName(mesh).startsWith("pedestal")) {
+          mesh.material = info.stand.material ? preset(info.stand.material) : plain("#d9d6d0");
+          return;
+        }
+        const wore = strippedPreset(mesh);
+        if (wore) mesh.material = preset(wore.material, wore.color);
+        else {
+          const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+          const cloned = materials.map((m) => m.clone());
+          mesh.material = Array.isArray(mesh.material) ? cloned : cloned[0];
+          coerceDefaultMaterial(mesh);
+        }
+      });
+      for (const camera of stand.children.filter(
+        (c) => c.isCamera
+      ))
+        stand.remove(camera);
+      room.add(stand);
+    }
+    let lamp = key;
+    if (!lamp) {
+      const overhead = new DirectionalLight(16777215, 1e-4);
+      overhead.name = "contact";
+      overhead.position.set(info.stand.x + 0.4, topY + 6, info.stand.z + 0.3);
+      overhead.target.position.set(info.stand.x, topY, info.stand.z);
+      overhead.userData.bakery3 = { exclude: true };
+      overhead.target.userData.bakery3 = { exclude: true };
+      overhead.shadow.radius = 6;
+      baked.add(overhead, overhead.target);
+      lamp = overhead;
+    }
+    if (lamp) {
+      lamp.castShadow = true;
+      lamp.shadow.mapSize.set(1024, 1024);
+      lamp.shadow.bias = -2e-4;
+      lamp.shadow.normalBias = 0.02;
+      if (lamp.isDirectionalLight) {
+        const camera = lamp.shadow.camera;
+        camera.left = camera.bottom = -BAKED_SHADOW_REACH;
+        camera.right = camera.top = BAKED_SHADOW_REACH;
+        camera.far = 20;
+      }
+      if (lamp.target && !lamp.target.parent) baked.add(lamp.target);
+      const shadow = new ShadowMaterial({
+        opacity: 0.45,
+        depthWrite: false,
+        polygonOffset: true,
+        polygonOffsetFactor: -2,
+        polygonOffsetUnits: -2
+      });
+      for (const mesh of catchers) {
+        const catcher = new Mesh(mesh.geometry, shadow);
+        catcher.name = `${mesh.name}.shadow`;
+        catcher.receiveShadow = true;
+        catcher.renderOrder = 1;
+        catcher.userData.bakery3 = { exclude: true };
+        mesh.add(catcher);
+      }
+    }
+    probe.mapping = EquirectangularReflectionMapping;
+    scaleHalfFloats(
+      probe.image.data,
+      1 / manifest.exposureBakedIn
+    );
+    probe.needsUpdate = true;
+    const ambient = new LightProbe(
+      irradianceOf(
+        probe.image.data,
+        probe.image.width,
+        probe.image.height
+      )
+    );
+    ambient.name = "fill";
+    ambient.userData.bakery3 = { exclude: true };
+    room.add(ambient);
+    room.userData.environment = probe;
+    room.userData.bakedManifest = manifest;
+    stampRoomIds(room, name);
+    room.userData.bakery3Preset = {
+      ...room.userData.bakery3Preset,
+      shown: "baked"
+    };
+    room.userData.shown = "baked";
+    return room;
+  };
+  const asPublished = options.floor === void 0 && options.walls === void 0 && options.ceiling === void 0 && options.sill === void 0 && options.pedestal === void 0 && options.pedestalMaterial === void 0 && options.hdri === void 0 && !options.pictures?.some(Boolean) && !options.bake && options.lights !== false;
+  const wantsBaked = options.baked !== false && asPublished && info.baked.includes(lighting);
+  room.userData.ready = wantsBaked ? buildBaked().catch((error) => {
+    if (typeof console !== "undefined") {
+      console.warn(
+        `[bakery3] The baked version of ${name} (${lighting}) could not be loaded, so the room is shown as its stand-in: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    for (const child of [...room.children]) room.remove(child);
+    return buildStandIn();
+  }) : buildStandIn();
+  room.userData.prebaked = options.prebaked === false || options.pedestalMaterial ? Promise.resolve(null) : room.userData.ready.then(
+    () => (
+      // A baked room carries its light already.
+      room.userData.shown === "baked" ? null : applyRoomPrebake(
+        room,
+        state,
+        options.baseUrl ?? presetBaseUrl(),
+        info.presetsVersion
+      )
+    ),
+    () => null
+  );
+  return room;
+}
+function hdriExposure(roomSky, mapSky) {
+  if (!(mapSky > 0) || !(roomSky > 0)) return 1;
+  return Math.round(roomSky / mapSky * 1e3) / 1e3;
+}
+function checkDomeReachOnce(dome) {
+  dome.onBeforeRender = (_renderer, _scene, camera) => {
+    delete dome.onBeforeRender;
+    const far = camera.far;
+    if (typeof far !== "number") return;
+    const reach = DOME_RADIUS * dome.matrixWorld.getMaxScaleOnAxis() + camera.getWorldPosition(new Vector3()).distanceTo(dome.getWorldPosition(new Vector3()));
+    if (far >= reach || typeof console === "undefined") return;
+    console.warn(
+      [
+        `[bakery3] The map outside this preset room hangs on a dome ${Math.round(reach)} m from the camera, but camera.far is ${far}:`,
+        "the sky through the windows is clipped to black. Set camera.far to 100 or more (then",
+        "camera.updateProjectionMatrix()), or pass hdri: false to createPresetRoom() for no map outside.",
+        "https://bakery3.com/docs/presets#room-presets"
+      ].join("\n")
+    );
+  };
+}
+function hdriTurn(name, published, lighting) {
+  const category = HDRI_PRESETS[name].category;
+  if (category !== "day" && category !== "golden") return 0;
+  if (published && HDRI_PRESETS[published.name]?.category === category)
+    return published.rotationDeg;
+  return lighting === "day" || lighting === "golden" ? published?.rotationDeg ?? 0 : 0;
+}
+function plainFloatGeometry(geometry) {
+  for (const name of Object.keys(geometry.attributes)) {
+    const attribute = geometry.getAttribute(name);
+    const plain = attribute.isInterleavedBufferAttribute === void 0 && attribute.array instanceof Float32Array && !attribute.normalized;
+    if (plain) continue;
+    const size = attribute.itemSize;
+    const out = new Float32Array(attribute.count * size);
+    const get = [
+      attribute.getX,
+      attribute.getY,
+      attribute.getZ,
+      attribute.getW
+    ];
+    for (let i = 0; i < attribute.count; i++) {
+      for (let c = 0; c < size; c++)
+        out[i * size + c] = get[c].call(attribute, i);
+    }
+    geometry.setAttribute(name, new Float32BufferAttribute(out, size));
+  }
+  return geometry;
+}
+function roomLensFovDeg(lensMm, aspect) {
+  const sensorV = aspect >= 1 ? 36 / aspect : 36;
+  return MathUtils.radToDeg(2 * Math.atan(sensorV / (2 * lensMm)));
+}
+function applyPresetRoomCamera(camera, room) {
+  const state = roomPresetSpecOf(room);
+  if (!state)
+    throw new Error(
+      "applyPresetRoomCamera needs a group made by createPresetRoom()."
+    );
+  const info = ROOM_PRESETS[state.name];
+  const world = new Matrix4().fromArray(state.matrix);
+  const position = new Vector3(...info.camera.position).applyMatrix4(world);
+  const target = new Vector3(...info.camera.target).applyMatrix4(world);
+  camera.position.copy(position);
+  camera.lookAt(target);
+  camera.fov = roomLensFovDeg(info.camera.lensMm, camera.aspect || 1);
+  camera.updateProjectionMatrix();
+}
+function presetRoomBounds(name) {
+  const { width, height, depth } = ROOM_PRESETS[name].size;
+  return new Box3(
+    new Vector3(-width / 2, 0, -depth / 2),
+    new Vector3(width / 2, height, depth / 2)
+  );
+}
+
+export { applyPresetRoomCamera, coverFit, createPedestal, createPresetMaterial, createPresetRoom, createRoom, createSkyEnvironment, loadPresetEnvironment, loadPresetMaterial, plainFloatGeometry, presetRoomBounds, presetRoomUrl, roomLensFovDeg, stampRoomIds, stampRoomStandIns };
+//# sourceMappingURL=chunk-HNMSWQU7.js.map
+//# sourceMappingURL=chunk-HNMSWQU7.js.map