@adatechnology/game-floorplan-three 0.2.1 → 0.3.0

package/dist/index.js

@@ -1,5 +1,6 @@
 // src/create.ts
 import * as props3d from "@adatechnology/game-props3d";
+import { shapeGeometries } from "@adatechnology/game-shapes-three";
 
 // src/locale.ts
 var en = {
@@ -1106,6 +1107,28 @@ function installHouseFloors(K, shared) {
     shared.ctx._flights = { r: R, l };
     return l;
   }
+  const panelRects = (p) => p.footprint && p.footprint.length ? p.footprint : [p.aabb];
+  function tilesOf(parent, rc) {
+    const ps = parent && shared.ctx.panelsOf && shared.ctx.panelsOf.get(parent);
+    if (!ps) return [[parent ? structurePiece(parent) : null, rc]];
+    const out = [], taken = [];
+    for (const p of ps) for (const q of panelRects(p)) {
+      const r = [Math.max(rc[0], q[0]), Math.max(rc[1], q[1]), Math.min(rc[2], q[2]), Math.min(rc[3], q[3])];
+      if (r[2] - r[0] > EPS && r[3] - r[1] > EPS) {
+        out.push([structurePiece(p.id), r]);
+        taken.push(r);
+      }
+    }
+    for (const r of subRects([rc], taken)) out.push([null, r]);
+    return out;
+  }
+  function panelAt(parent, x, z) {
+    const ps = shared.ctx.panelsOf && shared.ctx.panelsOf.get(parent);
+    if (!ps) return structurePiece(parent);
+    for (const p of ps) for (const q of panelRects(p)) if (x >= q[0] - EPS && x <= q[2] + EPS && z >= q[1] - EPS && z <= q[3] + EPS) return structurePiece(p.id);
+    return null;
+  }
+  const hasSlab = (id) => !!(shared.ctx.structureIndex[id] || shared.ctx.panelsOf && shared.ctx.panelsOf.has(id));
   function floorsAndSlabs() {
     const R = shared.ctx.r, nA = R.floors.length, C = shared.ctx.colors;
     const V = flights(), holes = (f) => V.filter((v) => v.to === f).flatMap((v) => {
@@ -1119,23 +1142,30 @@ function installHouseFloors(K, shared) {
       const y0 = Y0(f), bur = holes(f);
       for (const c of R.rooms.filter((c2) => c2.floor === f)) {
         if (c.type === "void" || c.outbuilding || c.type === "elevator" && f > 0) continue;
-        const col = floorColor(c);
-        cursor.pc = f > 0 ? structurePiece("slab_" + f + "_" + c.type) || structurePiece("slab_" + f + "_" + c.id) || structurePiece("slab_" + f) : null;
-        for (const rc of subRects(rectsOf2(c), bur)) bx("plaster", rc[0], y0 - 0.04, rc[1], rc[2], y0, rc[3], col);
+        const col = floorColor(c), parent = f > 0 ? ["slab_" + f + "_" + c.type, "slab_" + f + "_" + c.id, "slab_" + f].find(hasSlab) : null;
+        for (const rc of subRects(rectsOf2(c), bur)) for (const [pc, r] of tilesOf(parent, rc)) {
+          cursor.pc = pc;
+          bx("plaster", r[0], y0 - 0.04, r[1], r[2], y0, r[3], col);
+        }
       }
       if (f > 0) {
         const rs = R.rooms.filter((c) => c.floor === f && c.type !== "void" && c.type !== "elevator").flatMap(rectsOf2);
-        cursor.pc = structurePiece("slab_" + f);
-        for (const rc of subRects(rs, bur)) bx("plaster", rc[0], y0 - 0.24, rc[1], rc[2], y0 - 0.04, rc[3], C.ceiling != null ? C.ceiling : 15657698);
+        for (const rc of subRects(rs, bur)) for (const [pc, r] of tilesOf("slab_" + f, rc)) {
+          cursor.pc = pc;
+          bx("plaster", r[0], y0 - 0.24, r[1], r[2], y0 - 0.04, r[3], C.ceiling != null ? C.ceiling : 15657698);
+        }
       }
       cursor.group = "t" + f;
-      cursor.pc = structurePiece("slab_" + (f + 1)) || (f === nA - 1 ? structurePiece("slab_ceiling") || structurePiece("slab_top") : null);
+      const ceilingOf = hasSlab("slab_" + (f + 1)) ? "slab_" + (f + 1) : f === nA - 1 ? ["slab_ceiling", "slab_top"].find(hasSlab) : null;
       const above = R.rooms.filter((c) => c.floor === f + 1).flatMap(rectsOf2);
-      for (const c of R.rooms.filter((c2) => c2.floor === f && !OPEN_AREA(c2))) for (const rc of subRects(rectsOf2(c), above)) bx("plaster", rc[0], y0 + c.ceiling, rc[1], rc[2], y0 + c.ceiling + 0.2, rc[3], C.ceiling != null ? C.ceiling : 15657698);
+      for (const c of R.rooms.filter((c2) => c2.floor === f && !OPEN_AREA(c2))) for (const rc of subRects(rectsOf2(c), above)) for (const [pc, r] of tilesOf(ceilingOf, rc)) {
+        cursor.pc = pc;
+        bx("plaster", r[0], y0 + c.ceiling, r[1], r[2], y0 + c.ceiling + 0.2, r[3], C.ceiling != null ? C.ceiling : 15657698);
+      }
       cursor.pc = null;
     }
   }
-  Object.assign(K, { flights, floorsAndSlabs });
+  Object.assign(K, { flights, floorsAndSlabs, tilesOf, panelAt });
 }
 
 // src/house/stairs.ts
@@ -1920,13 +1950,14 @@ function installRoofSlabs(K, shared) {
   const { boxC, bx, cursor, drain, roomAt, structurePiece } = K;
   const sh = (...a) => K.sh(...a);
   function slabs(f, xs, zs, O, U, nx, nz, full, pe, C) {
-    cursor.pc = structurePiece("slab_top");
+    cursor.pc = null;
     const c = C.facade != null ? C.facade : 14209216, cap = sh(c, 1.12), pr = 0.5, t = 0.14, o = 0.08, slab = sh(C.ceiling != null ? C.ceiling : 12104876, 0.85);
     const yb0 = pe(xs[0], zs[0], xs[nx], zs[nz]);
     const free = (j, i) => !O(j, i) && !U(j, i);
     for (let j = 0; j < nz; j++) for (let i = 0; i < nx; i++) {
       if (!O(j, i)) continue;
       const x0 = xs[i], x1 = xs[i + 1], z0 = zs[j], z1 = zs[j + 1], yb = pe(x0, z0, x1, z1);
+      cursor.pc = K.panelAt("slab_top", (x0 + x1) / 2, (z0 + z1) / 2);
       const ex0 = free(j, i - 1) ? o : 0, ex1 = free(j, i + 1) ? o : 0, ez0 = free(j - 1, i) ? o : 0, ez1 = free(j + 1, i) ? o : 0;
       bx("plaster", x0 - ex0, yb, z0 - ez0, x1 + ex1, yb + 0.03, z1 + ez1, slab);
       const side = (ok, ax0, az0, ax1, az1) => {
@@ -6000,6 +6031,23 @@ function installLightsRoomLight(K, shared) {
 // src/destruction/pieces.ts
 import { assemblyPart, getAssembly } from "@adatechnology/game-destruction";
 import { DENSITY, toDestructibleSpec } from "@adatechnology/game-floorplan-structure";
+
+// src/destruction/panels.ts
+import { resolveSlabPanels, slabPanelView } from "@adatechnology/game-floorplan-structure";
+var NONE = { panels: [], replaced: [], supports: [] };
+var MEMO = /* @__PURE__ */ new WeakMap();
+function panelViewOf(structure, enabled) {
+  if (!enabled || !structure || !structure.parts) return NONE;
+  let view = MEMO.get(structure);
+  if (!view) {
+    const options = resolveSlabPanels(true);
+    view = options ? slabPanelView(structure, options) : NONE;
+    MEMO.set(structure, view);
+  }
+  return view;
+}
+
+// src/destruction/pieces.ts
 function installDestructionPieces(K, shared) {
   const { THREE, floorAtY, pieceRecord } = K;
   shared.destructionSeq = 0;
@@ -6079,9 +6127,9 @@ function installDestructionPieces(K, shared) {
       parts.push(p);
       byId.set(p.id, p);
     }
-    const base = parts.length;
+    const base = parts.length, view = shared.ctx.panelView || panelViewOf(null, false), panelIds = new Set(view.panels.map((e) => e.id));
     for (const [id, pc] of shared.ctx.pieces) {
-      if (byId.has(id) || !meshes.has(id)) continue;
+      if (byId.has(id) || panelIds.has(id) || !meshes.has(id)) continue;
       const b = box3(id);
       if (!b) continue;
       const vol = Math.max(1e-6, (b[3] - b[0]) * (b[4] - b[1]) * (b[5] - b[2]));
@@ -6108,6 +6156,21 @@ function installDestructionPieces(K, shared) {
       }
       if (m) supports.push({ part: p.id, on: m.id, joint: /^(window|jamb)/.test(p.id) ? "glue" : "clip", bears: false, extra: true });
     }
+    const specParts = parts.slice(), specSupports = supports.slice();
+    if (view.panels.length) {
+      const gone = new Set(view.replaced);
+      parts.splice(0, parts.length, ...parts.filter((p) => !gone.has(p.id)));
+      for (const id of gone) byId.delete(id);
+      for (const e of view.panels) {
+        const p = Object.assign({}, e, { meshes: (meshes.get(e.id) || []).length, extra: false }), pc = shared.ctx.pieces.get(e.id);
+        if (pc) {
+          for (const k of ["contains", "explodes", "tags", "form", "thickness", "fill"]) if (pc[k] != null && p[k] == null) p[k] = pc[k];
+        }
+        parts.push(p);
+        byId.set(p.id, p);
+      }
+      supports.splice(0, supports.length, ...supports.filter((s) => !gone.has(s.part) && !gone.has(s.on)), ...view.supports.filter((s) => byId.has(s.part) && (byId.has(s.on) || s.on === "ground")).map((a) => Object.assign({}, a)));
+    }
     const structure = {
       ...E0,
       system: r0.construction && r0.construction.system || "masonry",
@@ -6133,7 +6196,7 @@ function installDestructionPieces(K, shared) {
       // One part per wall, as the house draws them (a mesh range per wall): the panels of `wallDetail: 'panels'` would name parts the meshes do not have.
       // A masonry wall keeps its assembly (layers, units, rebar, breach) on the same box, so its stage 2 can open the courses; `o.wallDetail` still overrides.
       spec: (o) => {
-        const spec = toDestructibleSpec(structure, { wallDetail: "coarse", ...o });
+        const spec = toDestructibleSpec({ ...structure, parts: specParts, supports: specSupports }, { wallDetail: "coarse", ...o });
         if (o && o.wallDetail && o.wallDetail !== "coarse") return spec;
         spec.parts = spec.parts.map((sp) => {
           const pc0 = byId.get(sp.id);
@@ -6143,7 +6206,7 @@ function installDestructionPieces(K, shared) {
           return Object.keys(extra).length ? { ...sp, ...extra } : sp;
         });
         spec.parts = spec.parts.map((sp) => {
-          const pc = byId.get(sp.id);
+          const pc = byId.get(sp.id) || (sp.structure ? { role: sp.structure.role, material: sp.material } : null);
           if (!pc || pc.unit) return sp;
           if (pc.role !== "wall" && pc.role !== "partition") {
             const def = getAssembly(pc.assembly || (pc.material === "concrete" && ["slab", "beam", "column", "stair"].includes(pc.role) ? "reinforced_concrete" : ""));
@@ -6677,6 +6740,17 @@ function installBuildBuild(K, shared) {
     shared.ctx.pieceObjects = /* @__PURE__ */ new Map();
     shared.ctx.structureIndex = {};
     for (const e of r0.structure && r0.structure.parts || []) shared.ctx.structureIndex[e.id] = e;
+    {
+      const view = shared.ctx.panelView = panelViewOf(r0.structure, !!cfg.destruction);
+      shared.ctx.panelsOf = /* @__PURE__ */ new Map();
+      for (const id of view.replaced) delete shared.ctx.structureIndex[id];
+      for (const e of view.panels) {
+        shared.ctx.structureIndex[e.id] = e;
+        const l = shared.ctx.panelsOf.get(e.slab);
+        if (l) l.push(e);
+        else shared.ctx.panelsOf.set(e.slab, [e]);
+      }
+    }
     shared.ctx.panes = r0.roof && r0.roof.panes || [];
     shared.ctx.noPiece = false;
     cursor.separate = opts.pieces === "meshes";
@@ -7161,6 +7235,8 @@ function buildApi(K, shared) {
     types: TYPES,
     mv: props,
     applyPart,
+    // the kernel and the shared state, for recorders that run the team's builders into something else than the house (`furnitureSpec`, `tapSpec`): not a stable api
+    internals: { K, shared },
     get materials() {
       return shared.mats;
     },
@@ -7214,7 +7290,7 @@ function create(THREE, options = {}) {
     }
     return id;
   };
-  const K = { t: createTranslator(cfg.locale), seedKey, THREE, cfg, DOC, PROPS, Reflector, FLEET, HP, invalidate, invalidateShadow, colliderChanged, VERSION, rectsOf, isOpenArea, OPEN_ROOM_TYPES };
+  const K = { t: createTranslator(cfg.locale), seedKey, THREE: shapeGeometries(THREE), cfg, DOC, PROPS, Reflector, FLEET, HP, invalidate, invalidateShadow, colliderChanged, VERSION, rectsOf, isOpenArea, OPEN_ROOM_TYPES };
   installKernelGeometry(K, shared);
   installKernelNoise(K, shared);
   installMaterialsTextures(K, shared);
@@ -7831,13 +7907,11 @@ function createHouseScenarios(text, at = SPECIMEN_AT) {
         const list = events(room);
         const columns = groundColumns(parts);
         const laj = slabs(parts);
-        blunt(room, oid, columns[0].id, centre(columns[0].id), 3e6);
-        blunt(room, oid, columns[1].id, centre(columns[1].id), 3e6);
+        const first = columns[0];
+        const mate = columns.slice(1).filter((p) => Math.abs(p.position[0] - first.position[0]) < 0.5).sort((a, b) => Math.abs(b.position[2] - first.position[2]) - Math.abs(a.position[2] - first.position[2]))[0] ?? columns[1];
+        blunt(room, oid, first.id, centre(first.id), 3e6);
+        blunt(room, oid, mate.id, centre(mate.id), 3e6);
         step(90);
-        for (let next = 2; next < columns.length && !slabs(parts).some((id) => collapsed(list).includes(id)); next++) {
-          blunt(room, oid, columns[next].id, centre(columns[next].id), 3e6);
-          step(90);
-        }
         const fell = collapsed(list);
         expect(laj.some((id) => fell.includes(id)), fill(T.two_slab_fell, { n: fell.length }));
         expect(parts.filter((p) => role(p) === "roof").some((p) => fell.includes(p.id)), T.two_roof_fell);
@@ -7906,8 +7980,9 @@ function createHouseScenarios(text, at = SPECIMEN_AT) {
 }
 
 // src/test-area/specimens.ts
+import { shapeGeometries as shapeGeometries2 } from "@adatechnology/game-shapes-three";
 var DEFAULT_SPECIMENS = [
-  { id: "house_casa_portico", template: "townhouse", seed: 1, portico: true },
+  { id: "house_casa_portico", template: "townhouse", seed: 1, portico: true, sizing: { safety: 0.72, redundancy: 0.97 } },
   { id: "house_casa_inteira", template: "single_storey_a", seed: 1 },
   { id: "house_casa_wood_frame", template: "wood_frame_house", seed: 1 },
   { id: "house_casa_tronco", template: "log_cabin", seed: 1 },
@@ -7935,12 +8010,12 @@ var cache = /* @__PURE__ */ new WeakMap();
 function specimenSpec(THREE, engine, def, houseOptions = {}) {
   let byId = cache.get(THREE);
   if (!byId) cache.set(THREE, byId = /* @__PURE__ */ new Map());
-  const key = `${def.id}|${def.template}|${def.seed ?? 1}|${def.state ?? "normal"}|${def.portico ? "p" : ""}`;
+  const key = `${def.id}|${def.template}|${def.seed ?? 1}|${def.state ?? "normal"}|${def.portico ? "p" : ""}|${def.sizing ? JSON.stringify(def.sizing) : ""}`;
   let made = byId.get(key);
   if (!made) {
     const plan = engine.generate(def.template, { seed: def.seed ?? 1, ...def.state ? { state: def.state } : {} });
     const house = create(THREE, { ...houseOptions, destruction: void 0, destructionRenderer: void 0, interactives: void 0, vegetation: void 0, fleet: null }).build(plan, { quality: "game", terrain: false, noPerimeter: true });
-    const spec = house.structure.spec({ wallDetail: "coarse", ...def.portico ? { portico: true } : {} });
+    const spec = house.structure.spec({ wallDetail: "coarse", ...def.portico ? { portico: true } : {}, ...def.sizing ?? {} });
     house.dispose();
     made = { spec, plan };
     byId.set(key, made);
@@ -7948,11 +8023,12 @@ function specimenSpec(THREE, engine, def, houseOptions = {}) {
   return { spec: JSON.parse(JSON.stringify(made.spec)), plan: made.plan };
 }
 function buildSpecimenMeshes(THREE, spec) {
+  const G = shapeGeometries2(THREE);
   const root = new THREE.Group();
   for (const part of spec.parts) {
     if (part.id === "ground") continue;
     const shape = part.shape;
-    const geometry = shape.kind === "cylinder" ? new THREE.CylinderGeometry(shape.radius, shape.radius, shape.height, 14) : shape.kind === "sphere" ? new THREE.SphereGeometry(shape.radius, 12, 8) : new THREE.BoxGeometry(shape.size[0], shape.size[1], shape.size[2]);
+    const geometry = shape.kind === "cylinder" ? new G.CylinderGeometry(shape.radius, shape.radius, shape.height, 14) : shape.kind === "sphere" ? new G.SphereGeometry(shape.radius, 12, 8) : new G.BoxGeometry(shape.size[0], shape.size[1], shape.size[2]);
     const glass = /glass/.test(part.material);
     const material = new THREE.MeshStandardMaterial({ color: COLOR[part.material] ?? 8947848, roughness: 0.8, metalness: part.material === "steel" || part.material === "aluminium" ? 0.5 : 0, transparent: glass, opacity: glass ? 0.45 : 1 });
     const mesh = new THREE.Mesh(geometry, material);
@@ -7977,6 +8053,7 @@ var HITS = {
 };
 var GAP = 4;
 var EYE = 1.7;
+var TALL_STOREYS = 10;
 var bounds = (plan) => ({ width: Number(plan.w) || 10, depth: Number(plan.d) || 10 });
 function createFloorplanTestModule(options = {}) {
   const locale = options.locale ?? "pt-BR";
@@ -8362,9 +8439,14 @@ function createFloorplanTestModule(options = {}) {
     id: "floorplan_typologies",
     name: locale === "en" ? "every typology of every package builds, with structure and floors" : "toda tipologia de todo pacote constr\xF3i, com estrutura e andares",
     run({ expect }) {
+      const templates = engine?.listTemplates() ?? [];
+      const shortest = (id) => {
+        const range = templates.find((t) => t.id === id)?.floorRange;
+        return range && range[0] >= TALL_STOREYS ? { floors: range[0] } : {};
+      };
       for (const group of groups) {
         for (const id of group.templates) {
-          const plan = engine.generate(id, { seed: 1 });
+          const plan = engine.generate(id, { seed: 1, ...shortest(id) });
           const house = create(THREE ?? host?.THREE, { locale, ...options.house, destruction: void 0, destructionRenderer: void 0, interactives: void 0, vegetation: void 0, fleet: null }).build(plan, { quality: "game", terrain: false, noPerimeter: true });
           const ok = house.structure.parts.length > 0 && house.floors.length >= 1 && house.colliders.length > 0;
           expect(ok, `${groupName(group)}: ${templateName(id)} (${house.structure.parts.length})`);
@@ -8400,7 +8482,7 @@ function createFloorplanTestModule(options = {}) {
         { kind: "number", id: "budget", name: text.controls.budget, hint: text.hints.budget, min: 60, max: 2e3, step: 10, default: settings.budget },
         choice("floor_view", ["all", "0", "1", "2"], "all", text.options.floor_view),
         choice("hit", Object.keys(HITS), "burst_9mm", text.options.hit),
-        { kind: "action", id: "build", name: text.actions.build },
+        { kind: "action", id: "build", name: text.actions.build, slow: true },
         { kind: "action", id: "enter", name: text.actions.enter },
         { kind: "action", id: "up", name: text.actions.up },
         { kind: "action", id: "down", name: text.actions.down },
@@ -8441,7 +8523,8 @@ function createFloorplanTestModule(options = {}) {
         time += dt;
         if (dirty && time - dirtyAt > 0.4) {
           dirty = false;
-          build();
+          if (lent.loading) void lent.loading.busy(text.actions.build, () => build());
+          else build();
         }
         const c = cameraWorld();
         const auto = settings.lod === "auto";
@@ -8476,6 +8559,216 @@ function createFloorplanTestModule(options = {}) {
     }
   };
 }
+
+// src/furniture/spec.ts
+import { inferJoints } from "@adatechnology/game-destruction";
+import { residentialItems } from "@adatechnology/game-floorplan-residential";
+var WOOD_THIN = 0.035;
+var FLOOR_TOUCH = 5e-3;
+var LOOSE = /* @__PURE__ */ new Set(["paper"]);
+var BASE_MATERIAL = {
+  wood: "wood_hard",
+  metal: "steel",
+  fabric: "fabric",
+  glass: "glass",
+  plain: "plastic",
+  plant: "foliage",
+  picture: "paper",
+  emissive: "glass"
+};
+var renderers = /* @__PURE__ */ new WeakMap();
+function rendererOf(THREE, document2) {
+  let r = renderers.get(THREE);
+  if (!r) {
+    r = create(THREE, document2 ? { document: document2 } : {});
+    renderers.set(THREE, r);
+  }
+  return r;
+}
+function recordSpec(THREE, name, root, run, opts) {
+  const o = { chairs: opts.chairs };
+  const materialOf = { ...BASE_MATERIAL, ...opts.materials };
+  const drawn = [];
+  const counters = /* @__PURE__ */ new Map();
+  const q = new THREE.Quaternion();
+  const eul = new THREE.Euler();
+  const xyz = new THREE.Euler();
+  const v = new THREE.Vector3();
+  const loc = (M, lx, lz) => {
+    const c = Math.cos(M.ry);
+    const s = Math.sin(M.ry);
+    return [M.x + lx * c + lz * s, M.z - lx * s + lz * c];
+  };
+  const record = (M, key, shape, px, py, pz, rx, ry, rz, color) => {
+    if (o.chairs === false && M !== root || key === "water") return;
+    q.setFromEuler(eul.set(rx, ry, rz, "YXZ"));
+    const turned = rx !== 0 || ry !== 0 || rz !== 0;
+    const size = shape.kind === "box" ? shape.size : shape.kind === "cylinder" ? [shape.radius * 2, shape.height, shape.radius * 2] : [shape.radius * 2, shape.radius * 2, shape.radius * 2];
+    const min = [Infinity, Infinity, Infinity];
+    const max = [-Infinity, -Infinity, -Infinity];
+    for (const sx of [-0.5, 0.5]) for (const sy of [-0.5, 0.5]) for (const sz of [-0.5, 0.5]) {
+      v.set(sx * size[0], sy * size[1], sz * size[2]).applyQuaternion(q);
+      const c = [v.x + px - root.x, v.y + py, v.z + pz - root.z];
+      for (let k = 0; k < 3; k++) {
+        min[k] = Math.min(min[k], c[k]);
+        max[k] = Math.max(max[k], c[k]);
+      }
+    }
+    const n = counters.get(key) ?? 0;
+    counters.set(key, n + 1);
+    let rotation = null;
+    if (turned) {
+      xyz.setFromQuaternion(q, "XYZ");
+      rotation = [xyz.x, xyz.y, xyz.z];
+    }
+    drawn.push({ id: `${key}_${n}`, key, shape, position: [px - root.x, py, pz - root.z], rotation, color, min, max });
+  };
+  const A = {
+    box(M, mat, x, y, z, bw, bh, bd, color, ry = 0, rx = 0, rz = 0) {
+      const [px, pz] = loc(M, x, z);
+      record(M, mat, { kind: "box", size: [bw, bh, bd] }, px, M.base + y + bh / 2, pz, rx, M.ry + ry, rz, color);
+    },
+    cylinder(M, mat, x, y, z, r, ch, color, rx = 0, rz = 0) {
+      const [px, pz] = loc(M, x, z);
+      record(M, mat, { kind: "cylinder", radius: r, height: ch }, px, M.base + y + (rx || rz ? 0 : ch / 2), pz, rx || 0, M.ry, rz || 0, color);
+    },
+    leaf() {
+    },
+    plane() {
+    },
+    light() {
+    }
+  };
+  run(A);
+  if (!drawn.length) throw new Error(`game-floorplan-three: the builder of "${name}" drew no box or cylinder`);
+  const parts = drawn.map((p) => {
+    const thin = Math.min(...p.shape.kind === "box" ? p.shape.size : p.shape.kind === "cylinder" ? [p.shape.radius * 2, p.shape.height] : [p.shape.radius * 2]);
+    let material = materialOf[p.key] ?? "plastic";
+    if (p.key === "wood" && material === "wood_hard" && thin < WOOD_THIN) material = "wood_soft";
+    const part = { id: p.id, material, shape: p.shape, position: p.position };
+    if (p.rotation) part.rotation = p.rotation;
+    if (!LOOSE.has(material) && p.min[1] <= FLOOR_TOUCH) part.anchored = true;
+    return part;
+  });
+  const byId = new Map(drawn.map((p) => [p.id, p]));
+  const joints = [];
+  for (const j of inferJoints(parts, 0.01)) {
+    const a = parts.find((p) => p.id === j.a);
+    const b = parts.find((p) => p.id === j.b);
+    const la = LOOSE.has(a.material);
+    const lb = LOOSE.has(b.material);
+    if (la && lb) continue;
+    if (la || lb) {
+      const [loose, other] = la ? [a, b] : [b, a];
+      if (Math.abs(byId.get(loose.id).min[1] - byId.get(other.id).max[1]) > 0.02) continue;
+      joints.push({ id: j.id, a: j.a, b: j.b, kind: "resting" });
+      continue;
+    }
+    joints.push(j);
+  }
+  const all = drawn.reduce(
+    (m, p) => ({ x0: Math.min(m.x0, p.min[0]), x1: Math.max(m.x1, p.max[0]), z0: Math.min(m.z0, p.min[2]), z1: Math.max(m.z1, p.max[2]) }),
+    { x0: Infinity, x1: -Infinity, z0: Infinity, z1: -Infinity }
+  );
+  const footprint = (all.x1 - all.x0) * (all.z1 - all.z0);
+  let top = null;
+  for (const p of drawn) {
+    const part = parts.find((x) => x.id === p.id);
+    if (part.shape.kind === "sphere" || part.rotation || part.material === "fabric" || LOOSE.has(part.material)) continue;
+    const area = (p.max[0] - p.min[0]) * (p.max[2] - p.min[2]);
+    if (area < 0.6 * footprint || p.max[1] < 0.2) continue;
+    if (!top || p.max[1] > top.y + 1e-6) top = { part: p.id, y: p.max[1] };
+  }
+  const spec = { name, parts, joints, tags: ["furniture"] };
+  const colors = new Map(drawn.map((p) => [p.id, p.color]));
+  const build = (T3) => {
+    const group = new T3.Group();
+    group.name = name;
+    const mats = /* @__PURE__ */ new Map();
+    for (const p of parts) {
+      const color = colors.get(p.id) ?? 8947848;
+      const metal = p.material === "steel";
+      const glass = p.material === "glass";
+      const key = `${color}:${metal}:${glass}`;
+      let mat = mats.get(key);
+      if (!mat) {
+        mat = new T3.MeshStandardMaterial({ color, roughness: metal ? 0.45 : 0.85, metalness: metal ? 0.7 : 0, transparent: glass, opacity: glass ? 0.4 : 1 });
+        mats.set(key, mat);
+      }
+      const s = p.shape;
+      const geo = s.kind === "box" ? new T3.BoxGeometry(s.size[0], s.size[1], s.size[2]) : s.kind === "cylinder" ? new T3.CylinderGeometry(s.radius, s.radius, s.height, 14) : new T3.SphereGeometry(s.radius, 12, 8);
+      const mesh = new T3.Mesh(geo, mat);
+      mesh.name = p.id;
+      mesh.userData.destructionPart = p.id;
+      mesh.userData.destructionMaterial = p.material;
+      mesh.position.set(p.position[0], p.position[1], p.position[2]);
+      if (p.rotation) mesh.rotation.set(p.rotation[0], p.rotation[1], p.rotation[2], "XYZ");
+      mesh.castShadow = !glass;
+      mesh.receiveShadow = true;
+      group.add(mesh);
+    }
+    return group;
+  };
+  return { spec, build, top };
+}
+function furnitureSpec(THREE, type, opts = {}) {
+  const renderer = rendererOf(THREE, opts.document);
+  const ent = renderer.types[type];
+  if (!ent) throw new Error(`game-floorplan-three: no builder for the furniture type "${type}"`);
+  const entry = (opts.catalog ?? residentialItems).find((i) => i.type === type);
+  const w = opts.w ?? entry?.w;
+  const d = opts.d ?? entry?.d;
+  const h = opts.h ?? entry?.h;
+  if (w === void 0 || d === void 0 || h === void 0) throw new Error(`game-floorplan-three: furniture type "${type}" is not in the catalogue, so give w, d and h`);
+  const o = opts.options ?? {};
+  const seed = Math.round(opts.seed ?? 1);
+  const plain = /shelf|bookcase|rack/.test(type) ? "paper" : "plastic";
+  const root = { x: seed, z: 0, ry: 0, w, d, h, y: 0, base: 0, palette: o.palette, seed: `furniture_${type}_${seed}` };
+  const { K, shared } = renderer.internals;
+  const before = K.PARTS.length;
+  const made = recordSpec(
+    THREE,
+    type,
+    root,
+    (A) => {
+      const saved = { api0: shared.api0, ctx: shared.ctx };
+      shared.api0 = A;
+      shared.ctx = shared.ctx ?? {};
+      try {
+        ent.f(root, A);
+      } finally {
+        shared.api0 = saved.api0;
+        shared.ctx = saved.ctx;
+      }
+    },
+    { materials: { plain, ...o.materials }, chairs: o.chairs }
+  );
+  const spouts = K.PARTS.slice(before).filter((p) => p.type === "water_tap").map((p) => [p.pos[0] - root.x, p.pos[1], p.pos[2] - root.z]);
+  K.PARTS.length = before;
+  return { spec: made.spec, build: made.build, top: made.top, size: { w, d, h }, spouts };
+}
+function tapSpec(THREE, opts = {}) {
+  const renderer = rendererOf(THREE, opts.document);
+  const { K, shared } = renderer.internals;
+  const kind = opts.kind ?? "counter";
+  const root = { x: 1, z: 0, ry: 0, w: 0.3, d: 0.3, h: 0.3, y: 0, base: 0, seed: `tap_${kind}` };
+  const before = K.PARTS.length;
+  const made = recordSpec(THREE, kind === "counter" ? "tap" : "wall_tap", root, (A) => {
+    const kit = K.kit2(root, A);
+    const saved = shared.api0;
+    shared.api0 = A;
+    try {
+      if (kind === "counter") K.counterTap(kit, 0, 0, 0, opts.reach ?? 0.2, 0.17, {});
+      else K.wallTap(kit, 0, 0.3, 0, 1, 0.1, {});
+    } finally {
+      shared.api0 = saved;
+    }
+  }, { materials: {} });
+  const water = K.PARTS.slice(before).find((p) => p.type === "water_tap");
+  if (!water) throw new Error("game-floorplan-three: the tap drew no water thread");
+  K.PARTS.length = before;
+  return { spec: made.spec, build: made.build, spout: [water.pos[0] - root.x, water.pos[1], water.pos[2] - root.z] };
+}
 export {
   DEFAULT_SPECIMENS,
   FLOORPLAN_AREA_ID,
@@ -8491,12 +8784,14 @@ export {
   createHouseScenarios,
   createTranslator,
   en,
+  furnitureSpec,
   isOpenArea,
   locales,
   navigationDefOf,
   planLod,
   ptBR,
   rectsOf,
-  specimenSpec
+  specimenSpec,
+  tapSpec
 };
 //# sourceMappingURL=index.js.map