let-them-talk 4.2.0 → 5.2.0

package/office/builder.js

@@ -0,0 +1,355 @@
+// builder.js — Real-time World Builder for the 3D Hub
+// Press B to toggle builder mode. Click to place assets. R to rotate. Right-click to delete.
+import * as THREE from 'three';
+import { S } from './state.js';
+import { ASSETS, ASSET_CATEGORIES, getAsset, getAssetsByCategory, createGhost } from './assets.js';
+import { addPlacement, removePlacement, loadWorld, getPlacements } from './world-save.js';
+import { isPlayerMode } from './player.js';
+
+var _active = false;          // builder mode on/off
+var _panel = null;             // UI panel element
+var _selectedAsset = null;     // currently selected asset ID
+var _ghostMesh = null;         // preview mesh following cursor
+var _rotation = 0;             // current placement rotation (0, PI/2, PI, 3PI/2)
+var _placedMeshes = {};        // id → THREE.Group map for deletion
+var _gridHelper = null;        // grid overlay
+var _raycaster = new THREE.Raycaster();
+var _mouse = new THREE.Vector2();
+var _floorPlane = new THREE.Plane(new THREE.Vector3(0, 1, 0), 0); // Y=0 plane
+var GRID_SIZE = 0.5;           // snap grid in world units
+var _undoStack = [];           // for undo (Ctrl+Z)
+
+// ===================== PUBLIC API =====================
+
+export function isBuilderActive() { return _active; }
+
+export function toggleBuilder() {
+  if (_active) exitBuilder();
+  else enterBuilder();
+}
+
+export function enterBuilder() {
+  if (_active) return;
+  _active = true;
+  showPanel();
+  showGrid();
+  addListeners();
+}
+
+export function exitBuilder() {
+  if (!_active) return;
+  _active = false;
+  hidePanel();
+  hideGrid();
+  removeGhost();
+  removeListeners();
+  _selectedAsset = null;
+}
+
+// Load saved placements and render them in the scene
+export function loadSavedWorld() {
+  loadWorld().then(function(placements) {
+    if (!placements || !Array.isArray(placements)) return;
+    for (var i = 0; i < placements.length; i++) {
+      renderPlacement(placements[i]);
+    }
+  });
+}
+
+// ===================== GRID =====================
+
+function showGrid() {
+  if (_gridHelper) return;
+  _gridHelper = new THREE.GridHelper(50, 100, 0x444466, 0x333355); // 50 units, 0.5 unit cells
+  _gridHelper.position.y = 0.005;
+  _gridHelper.material.transparent = true;
+  _gridHelper.material.opacity = 0.3;
+  S.scene.add(_gridHelper);
+}
+
+function hideGrid() {
+  if (_gridHelper) {
+    S.scene.remove(_gridHelper);
+    _gridHelper.geometry.dispose();
+    _gridHelper.material.dispose();
+    _gridHelper = null;
+  }
+}
+
+// ===================== GHOST PREVIEW =====================
+
+function setGhost(assetId) {
+  removeGhost();
+  if (!assetId) return;
+  _ghostMesh = createGhost(assetId);
+  if (_ghostMesh) {
+    S.scene.add(_ghostMesh);
+  }
+}
+
+function removeGhost() {
+  if (_ghostMesh) {
+    S.scene.remove(_ghostMesh);
+    _ghostMesh.traverse(function(c) {
+      if (c.geometry) c.geometry.dispose();
+      if (c.material) c.material.dispose();
+    });
+    _ghostMesh = null;
+  }
+}
+
+function updateGhostPosition(event) {
+  if (!_ghostMesh || !S.renderer || !S.camera) return;
+  var rect = S.renderer.domElement.getBoundingClientRect();
+  _mouse.x = ((event.clientX - rect.left) / rect.width) * 2 - 1;
+  _mouse.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;
+  _raycaster.setFromCamera(_mouse, S.camera);
+
+  var intersect = new THREE.Vector3();
+  _raycaster.ray.intersectPlane(_floorPlane, intersect);
+  if (intersect) {
+    // Snap to grid
+    intersect.x = Math.round(intersect.x / GRID_SIZE) * GRID_SIZE;
+    intersect.z = Math.round(intersect.z / GRID_SIZE) * GRID_SIZE;
+    intersect.y = 0;
+    _ghostMesh.position.copy(intersect);
+    _ghostMesh.rotation.y = _rotation;
+  }
+}
+
+// ===================== PLACEMENT =====================
+
+function placeAsset(event) {
+  if (!_selectedAsset || !_ghostMesh) return;
+
+  var pos = _ghostMesh.position.clone();
+  var entry = addPlacement(_selectedAsset, pos.x, pos.y, pos.z, _rotation, 'user');
+  renderPlacement(entry);
+  _undoStack.push(entry.id);
+}
+
+function renderPlacement(entry) {
+  var asset = getAsset(entry.type);
+  if (!asset) return;
+  var group = asset.factory();
+  group.position.set(entry.x, entry.y || 0, entry.z);
+  group.rotation.y = entry.rotY || 0;
+  group.userData.placementId = entry.id;
+  group.userData.isPlaced = true;
+  S.scene.add(group);
+  _placedMeshes[entry.id] = group;
+}
+
+function deleteNearestPlacement(event) {
+  if (!S.renderer || !S.camera) return;
+  var rect = S.renderer.domElement.getBoundingClientRect();
+  _mouse.x = ((event.clientX - rect.left) / rect.width) * 2 - 1;
+  _mouse.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;
+  _raycaster.setFromCamera(_mouse, S.camera);
+
+  // Collect all placed meshes
+  var meshes = [];
+  for (var id in _placedMeshes) {
+    _placedMeshes[id].traverse(function(c) {
+      if (c.isMesh) { c.userData._placementId = id; meshes.push(c); }
+    });
+  }
+
+  var hits = _raycaster.intersectObjects(meshes, false);
+  if (hits.length > 0) {
+    var hitId = hits[0].object.userData._placementId;
+    if (hitId && _placedMeshes[hitId]) {
+      // Remove from scene
+      var group = _placedMeshes[hitId];
+      S.scene.remove(group);
+      group.traverse(function(c) {
+        if (c.geometry) c.geometry.dispose();
+        if (c.material && !c.material._shared) c.material.dispose();
+      });
+      delete _placedMeshes[hitId];
+      // Remove from save data
+      removePlacement(hitId);
+    }
+  }
+}
+
+function undoLast() {
+  if (_undoStack.length === 0) return;
+  var lastId = _undoStack.pop();
+  if (_placedMeshes[lastId]) {
+    var group = _placedMeshes[lastId];
+    S.scene.remove(group);
+    group.traverse(function(c) {
+      if (c.geometry) c.geometry.dispose();
+      if (c.material) c.material.dispose();
+    });
+    delete _placedMeshes[lastId];
+    removePlacement(lastId);
+  }
+}
+
+// ===================== UI PANEL =====================
+
+function showPanel() {
+  if (_panel) return;
+  _panel = document.createElement('div');
+  _panel.id = 'builder-panel';
+  _panel.style.cssText = 'position:fixed;right:12px;top:80px;z-index:999999;width:180px;max-height:70vh;overflow-y:auto;background:rgba(22,27,34,0.95);border:1px solid #30363d;border-radius:10px;padding:0 8px 8px;font-family:system-ui;color:#e6edf3;backdrop-filter:blur(8px);';
+
+  // Drag handle header
+  var header = document.createElement('div');
+  header.style.cssText = 'text-align:center;font-size:13px;font-weight:bold;color:#58a6ff;padding:8px 0;border-bottom:1px solid #30363d;margin-bottom:8px;cursor:grab;user-select:none;';
+  header.textContent = '\u2630 World Builder';
+  header.title = 'Drag to move';
+  _panel.appendChild(header);
+
+  // Drag logic — store refs for cleanup in hidePanel()
+  var dragOffX = 0, dragOffY = 0, dragging = false;
+  header.addEventListener('mousedown', function(e) {
+    dragging = true;
+    dragOffX = e.clientX - _panel.getBoundingClientRect().left;
+    dragOffY = e.clientY - _panel.getBoundingClientRect().top;
+    header.style.cursor = 'grabbing';
+    e.preventDefault();
+  });
+  _panel._dragMove = function(e) {
+    if (!dragging || !_panel) return;
+    _panel.style.left = (e.clientX - dragOffX) + 'px';
+    _panel.style.top = (e.clientY - dragOffY) + 'px';
+    _panel.style.right = 'auto';
+    _panel.style.transform = 'none';
+  };
+  _panel._dragUp = function() {
+    if (dragging) { dragging = false; if (header) header.style.cursor = 'grab'; }
+  };
+  document.addEventListener('mousemove', _panel._dragMove);
+  document.addEventListener('mouseup', _panel._dragUp);
+
+  // Hint
+  var hint = document.createElement('div');
+  hint.style.cssText = 'font-size:9px;color:#8b949e;text-align:center;margin-bottom:8px;';
+  hint.textContent = 'Click=Place | R=Rotate | Right-click=Delete | Ctrl+Z=Undo | B=Close';
+  _panel.appendChild(hint);
+
+  // Categories + assets
+  for (var ci = 0; ci < ASSET_CATEGORIES.length; ci++) {
+    var cat = ASSET_CATEGORIES[ci];
+    var catAssets = getAssetsByCategory(cat.id);
+    if (catAssets.length === 0) continue;
+
+    var catLabel = document.createElement('div');
+    catLabel.style.cssText = 'font-size:10px;color:#8b949e;padding:4px 0 2px;text-transform:uppercase;letter-spacing:1px;';
+    catLabel.textContent = cat.icon + ' ' + cat.label;
+    _panel.appendChild(catLabel);
+
+    for (var ai = 0; ai < catAssets.length; ai++) {
+      var asset = catAssets[ai];
+      var btn = document.createElement('button');
+      btn.style.cssText = 'display:block;width:100%;padding:6px 8px;margin:2px 0;background:rgba(48,54,61,0.6);border:1px solid transparent;border-radius:6px;color:#c9d1d9;font-size:11px;cursor:pointer;text-align:left;transition:all 0.15s;';
+      btn.textContent = asset.icon + ' ' + asset.name;
+      btn.dataset.assetId = asset.id;
+      btn.addEventListener('mouseenter', function() { this.style.background = 'rgba(88,166,255,0.2)'; this.style.borderColor = '#58a6ff'; });
+      btn.addEventListener('mouseleave', function() {
+        if (this.dataset.assetId !== _selectedAsset) {
+          this.style.background = 'rgba(48,54,61,0.6)'; this.style.borderColor = 'transparent';
+        }
+      });
+      btn.addEventListener('click', function(e) {
+        e.stopPropagation();
+        var id = this.dataset.assetId;
+        _selectedAsset = id;
+        _rotation = 0;
+        setGhost(id);
+        // Highlight selected
+        var btns = _panel.querySelectorAll('button');
+        for (var b = 0; b < btns.length; b++) {
+          btns[b].style.background = 'rgba(48,54,61,0.6)'; btns[b].style.borderColor = 'transparent';
+        }
+        this.style.background = 'rgba(88,166,255,0.3)'; this.style.borderColor = '#58a6ff';
+      });
+      _panel.appendChild(btn);
+    }
+  }
+
+  // Append to fullscreen element if active, otherwise document.body
+  // This ensures the builder panel is visible when the 3D container is fullscreened
+  var target = document.fullscreenElement || document.body;
+  target.appendChild(_panel);
+}
+
+function hidePanel() {
+  if (_panel) {
+    // Remove drag listeners to prevent leaks
+    if (_panel._dragMove) document.removeEventListener('mousemove', _panel._dragMove);
+    if (_panel._dragUp) document.removeEventListener('mouseup', _panel._dragUp);
+    if (_panel.parentElement) _panel.remove();
+  }
+  _panel = null;
+}
+
+// ===================== EVENT LISTENERS =====================
+
+var _onMouseMove = null;
+var _onMouseDown = null;
+var _onContextMenu = null;
+var _onKeyDown = null;
+
+function addListeners() {
+  _onMouseMove = function(e) { updateGhostPosition(e); };
+  _onMouseDown = function(e) {
+    if (!_active) return;
+    if (e.button === 0 && _selectedAsset) { // left click
+      // Don't place if clicking the panel
+      if (_panel && _panel.contains(e.target)) return;
+      placeAsset(e);
+    }
+  };
+  _onContextMenu = function(e) {
+    if (!_active) return;
+    e.preventDefault();
+    deleteNearestPlacement(e);
+  };
+  _onKeyDown = function(e) {
+    if (!_active) return;
+    if (e.target.tagName === 'INPUT' || e.target.tagName === 'TEXTAREA') return;
+    if (e.code === 'KeyR') {
+      // Rotate 90 degrees
+      _rotation = (_rotation + Math.PI / 2) % (Math.PI * 2);
+      if (_ghostMesh) _ghostMesh.rotation.y = _rotation;
+    }
+    if (e.code === 'KeyZ' && (e.ctrlKey || e.metaKey)) {
+      e.preventDefault();
+      undoLast();
+    }
+  };
+
+  window.addEventListener('mousemove', _onMouseMove);
+  window.addEventListener('mousedown', _onMouseDown);
+  window.addEventListener('contextmenu', _onContextMenu);
+  window.addEventListener('keydown', _onKeyDown);
+}
+
+function removeListeners() {
+  if (_onMouseMove) window.removeEventListener('mousemove', _onMouseMove);
+  if (_onMouseDown) window.removeEventListener('mousedown', _onMouseDown);
+  if (_onContextMenu) window.removeEventListener('contextmenu', _onContextMenu);
+  if (_onKeyDown) window.removeEventListener('keydown', _onKeyDown);
+  _onMouseMove = _onMouseDown = _onContextMenu = _onKeyDown = null;
+}
+
+// ===================== CLEANUP =====================
+
+export function cleanupBuilder() {
+  exitBuilder();
+  // Remove all placed meshes from scene
+  for (var id in _placedMeshes) {
+    var group = _placedMeshes[id];
+    S.scene.remove(group);
+    group.traverse(function(c) {
+      if (c.geometry) c.geometry.dispose();
+      if (c.material) c.material.dispose();
+    });
+  }
+  _placedMeshes = {};
+  _undoStack = [];
+}

package/office/building-interior.js

@@ -0,0 +1,261 @@
+import * as THREE from 'three';
+import { S } from './state.js';
+
+// ============================================================
+// BUILDING INTERIORS — enterable buildings with floors, desks
+// Agents sit at desks INSIDE buildings, visible through windows
+// ============================================================
+
+var FLOOR_HEIGHT = 3.0;
+var WALL_THICKNESS = 0.15;
+
+// Shared materials (created once)
+var intMats = null;
+
+function getIntMats() {
+  if (intMats) return intMats;
+  intMats = {
+    floor: new THREE.MeshStandardMaterial({ color: 0x8a8a7a, roughness: 0.6, side: THREE.DoubleSide }),
+    carpet: new THREE.MeshStandardMaterial({ color: 0x3a3d4a, roughness: 0.9 }),
+    wall: new THREE.MeshStandardMaterial({ color: 0xd8d4cc, roughness: 0.7, side: THREE.DoubleSide }),
+    wallAccent: new THREE.MeshStandardMaterial({ color: 0x6a7a8a, roughness: 0.5 }),
+    desk: new THREE.MeshStandardMaterial({ color: 0x5a4a3a, roughness: 0.5 }),
+    deskTop: new THREE.MeshStandardMaterial({ color: 0x7a6a5a, roughness: 0.4 }),
+    chair: new THREE.MeshStandardMaterial({ color: 0x2a2a2a, roughness: 0.6 }),
+    monitor: new THREE.MeshStandardMaterial({ color: 0x111111, roughness: 0.3 }),
+    screen: new THREE.MeshStandardMaterial({ color: 0x2244aa, emissive: 0x1133aa, emissiveIntensity: 0.8, roughness: 0.1 }),
+    ceiling: new THREE.MeshStandardMaterial({ color: 0xeeeeee, roughness: 0.8, side: THREE.DoubleSide }),
+    column: new THREE.MeshStandardMaterial({ color: 0xaaaaaa, roughness: 0.4, metalness: 0.2 }),
+    elevator: new THREE.MeshStandardMaterial({ color: 0x888888, roughness: 0.3, metalness: 0.5 }),
+    plant: new THREE.MeshStandardMaterial({ color: 0x2a6a2a, roughness: 0.8 }),
+  };
+  return intMats;
+}
+
+// ============================================================
+// BUILD FLOOR INTERIOR — desks, chairs, monitors per floor
+// ============================================================
+
+function buildFloorInterior(group, floorY, w, d, floorNum, seed) {
+  var m = getIntMats();
+  var innerW = w - WALL_THICKNESS * 2;
+  var innerD = d - WALL_THICKNESS * 2;
+
+  // Floor slab
+  var floorGeo = new THREE.BoxGeometry(innerW, 0.08, innerD);
+  var floor = new THREE.Mesh(floorGeo, floorNum === 0 ? m.floor : m.carpet);
+  floor.position.y = floorY + 0.04;
+  floor.receiveShadow = true;
+  group.add(floor);
+
+  // Ceiling
+  var ceilGeo = new THREE.BoxGeometry(innerW, 0.06, innerD);
+  var ceil = new THREE.Mesh(ceilGeo, m.ceiling);
+  ceil.position.y = floorY + FLOOR_HEIGHT - 0.03;
+  group.add(ceil);
+
+  // Ceiling light (fluorescent strip)
+  var lightGeo = new THREE.BoxGeometry(innerW * 0.6, 0.04, 0.15);
+  var lightMat = new THREE.MeshStandardMaterial({ color: 0xffffff, emissive: 0xeeeeff, emissiveIntensity: 0.6 });
+  var ceilLight = new THREE.Mesh(lightGeo, lightMat);
+  ceilLight.position.y = floorY + FLOOR_HEIGHT - 0.08;
+  group.add(ceilLight);
+
+  // Columns removed for performance
+
+  // Desks — limited count for performance
+  var deskCount = Math.min(3, Math.floor(innerW / 3));
+  var deskSpacing = innerW / (deskCount + 1);
+  var deskPositions = [];
+
+  for (var di = 0; di < deskCount; di++) {
+    var dx = -innerW / 2 + deskSpacing * (di + 1);
+    var dz = ((seed + di) % 2 === 0) ? -innerD * 0.2 : innerD * 0.2;
+
+    // Desk (table top + legs)
+    var topGeo = new THREE.BoxGeometry(1.2, 0.06, 0.6);
+    var top = new THREE.Mesh(topGeo, m.deskTop);
+    top.position.set(dx, floorY + 0.72, dz);
+    group.add(top);
+
+    // Desk legs
+    var legGeo = new THREE.BoxGeometry(0.05, 0.7, 0.05);
+    [[-0.55,-0.25],[0.55,-0.25],[0.55,0.25],[-0.55,0.25]].forEach(function(lp) {
+      var leg = new THREE.Mesh(legGeo, m.desk);
+      leg.position.set(dx + lp[0], floorY + 0.35, dz + lp[1]);
+      group.add(leg);
+    });
+
+    // Monitor
+    var monGeo = new THREE.BoxGeometry(0.5, 0.35, 0.03);
+    var mon = new THREE.Mesh(monGeo, m.monitor);
+    mon.position.set(dx, floorY + 1.0, dz - 0.15);
+    group.add(mon);
+
+    // Monitor screen (emissive — glows through windows)
+    var scrGeo = new THREE.PlaneGeometry(0.45, 0.3);
+    var scr = new THREE.Mesh(scrGeo, m.screen);
+    scr.position.set(dx, floorY + 1.0, dz - 0.16);
+    scr.rotation.y = Math.PI;
+    group.add(scr);
+
+    // Chair
+    var chairSeat = new THREE.Mesh(new THREE.BoxGeometry(0.4, 0.06, 0.4), m.chair);
+    chairSeat.position.set(dx, floorY + 0.45, dz + 0.45);
+    group.add(chairSeat);
+    var chairBack = new THREE.Mesh(new THREE.BoxGeometry(0.4, 0.4, 0.05), m.chair);
+    chairBack.position.set(dx, floorY + 0.65, dz + 0.65);
+    group.add(chairBack);
+
+    deskPositions.push({ x: dx, y: floorY, z: dz + 0.45, floor: floorNum });
+  }
+
+  // Plants removed for performance
+
+  return deskPositions;
+}
+
+// ============================================================
+// BUILD COMPLETE BUILDING — shell + interior per floor
+// ============================================================
+
+export function buildDetailedBuilding(cx, cz, w, d, floors, buildingType, color) {
+  var m = getIntMats();
+  var group = new THREE.Group();
+  var height = floors * FLOOR_HEIGHT;
+  var allDesks = [];
+
+  // === EXTERIOR WALLS (hollow shell, not solid box) ===
+  var wallMat = new THREE.MeshStandardMaterial({
+    color: color, roughness: 0.5, metalness: 0.15,
+  });
+
+  // Front wall (with window cutouts represented by glass)
+  var glassMat = new THREE.MeshStandardMaterial({
+    color: 0x99bbdd, transparent: true, opacity: 0.2,
+    roughness: 0.0, metalness: 0.3, side: THREE.DoubleSide,
+    depthWrite: false,
+  });
+
+  // Position group at building center — all children use local coords
+  group.position.set(cx, 0, cz);
+
+  // 4 walls as thin boxes (local coords, relative to group)
+  var wallParts = [
+    { sx: w, sy: height, sz: WALL_THICKNESS, px: 0, pz: d / 2 },       // front
+    { sx: w, sy: height, sz: WALL_THICKNESS, px: 0, pz: -d / 2 },      // back
+    { sx: WALL_THICKNESS, sy: height, sz: d, px: -w / 2, pz: 0 },      // left
+    { sx: WALL_THICKNESS, sy: height, sz: d, px: w / 2, pz: 0 },       // right
+  ];
+
+  wallParts.forEach(function(wp) {
+    var wallGeo = new THREE.BoxGeometry(wp.sx, wp.sy, wp.sz);
+    var wall = new THREE.Mesh(wallGeo, wallMat);
+    wall.position.set(wp.px, height / 2, wp.pz);
+    wall.castShadow = true;
+    wall.receiveShadow = true;
+    group.add(wall);
+  });
+
+  // Glass window panels on front and back (per floor)
+  for (var fi = 0; fi < floors; fi++) {
+    var winY = fi * FLOOR_HEIGHT + FLOOR_HEIGHT * 0.55;
+    var winH = FLOOR_HEIGHT * 0.5;
+
+    // Front windows
+    var fwGeo = new THREE.PlaneGeometry(w * 0.85, winH);
+    var fw = new THREE.Mesh(fwGeo, glassMat);
+    fw.position.set(0, winY, d / 2 + 0.01);
+    group.add(fw);
+
+    // Back windows
+    var bwGeo = new THREE.PlaneGeometry(w * 0.85, winH);
+    var bw = new THREE.Mesh(bwGeo, glassMat);
+    bw.position.set(0, winY, -d / 2 - 0.01);
+    bw.rotation.y = Math.PI;
+    group.add(bw);
+
+    // Side windows
+    [1, -1].forEach(function(side) {
+      var swGeo = new THREE.PlaneGeometry(d * 0.85, winH);
+      var sw = new THREE.Mesh(swGeo, glassMat);
+      sw.position.set(side * (w / 2 + 0.01), winY, 0);
+      sw.rotation.y = side * Math.PI / 2;
+      group.add(sw);
+    });
+  }
+
+  // Roof
+  var roofGeo = new THREE.BoxGeometry(w + 0.3, 0.2, d + 0.3);
+  var roof = new THREE.Mesh(roofGeo, wallMat);
+  roof.position.set(0, height + 0.1, 0);
+  roof.castShadow = true;
+  group.add(roof);
+
+  // Roof ledge (decorative)
+  var ledgeGeo = new THREE.BoxGeometry(w + 0.5, 0.4, 0.15);
+  var ledgeMat = new THREE.MeshStandardMaterial({ color: 0x888888, roughness: 0.4, metalness: 0.3 });
+  [1, -1].forEach(function(side) {
+    var ledge = new THREE.Mesh(ledgeGeo, ledgeMat);
+    ledge.position.set(0, height + 0.2, side * (d / 2 + 0.07));
+    group.add(ledge);
+  });
+
+  // === ENTRANCE (ground floor door) ===
+  var doorGeo = new THREE.BoxGeometry(1.5, 2.5, 0.1);
+  var doorMat = new THREE.MeshStandardMaterial({ color: 0x3a2a1a, roughness: 0.5 });
+  var door = new THREE.Mesh(doorGeo, doorMat);
+  door.position.set(0, 1.25, d / 2 + 0.08);
+  group.add(door);
+
+  // Glass door panels
+  var doorGlass = new THREE.Mesh(
+    new THREE.PlaneGeometry(0.55, 1.8),
+    glassMat
+  );
+  doorGlass.position.set(-0.3, 1.1, d / 2 + 0.09);
+  group.add(doorGlass);
+  var doorGlass2 = new THREE.Mesh(
+    new THREE.PlaneGeometry(0.55, 1.8),
+    glassMat
+  );
+  doorGlass2.position.set(0.3, 1.1, d / 2 + 0.09);
+  group.add(doorGlass2);
+
+  // Entrance canopy
+  var canopyGeo = new THREE.BoxGeometry(2.5, 0.1, 1.2);
+  var canopyMat = new THREE.MeshStandardMaterial({ color: 0x555555, roughness: 0.4, metalness: 0.3 });
+  var canopy = new THREE.Mesh(canopyGeo, canopyMat);
+  canopy.position.set(0, 2.7, d / 2 + 0.6);
+  canopy.castShadow = true;
+  group.add(canopy);
+
+  // === FLOOR INTERIORS ===
+  for (var floor = 0; floor < floors; floor++) {
+    var floorY = floor * FLOOR_HEIGHT;
+    var seed = Math.floor(cx * 7 + cz * 13 + floor * 31);
+    var desks = buildFloorInterior(group, floorY, w, d, floor, seed);
+
+    // Offset desk positions to world coords
+    desks.forEach(function(dp) {
+      allDesks.push({
+        x: cx + dp.x,
+        y: dp.y,
+        z: cz + dp.z,
+        floor: dp.floor,
+        building: buildingType,
+      });
+    });
+  }
+
+  // No point lights — use emissive ceiling lights instead (zero GPU cost)
+
+  S.furnitureGroup.add(group);
+
+  return {
+    group: group,
+    desks: allDesks,
+    height: height,
+    entrance: { x: cx, z: cz + d / 2 + 1 },  // world coords for external use
+  };
+}