feat: initial make-space full-stack release with weighted multi-provider LLM and Dockerfile
This commit is contained in:
commit
37b323c9ac
55 files changed
+17087
No files matched your search
+787
@@ -0,0 +1,787 @@
|
||||
import * as THREE from "three";
|
||||
import { OrbitControls } from "three/addons/controls/OrbitControls.js";
|
||||
|
||||
const FLOOR_HEIGHT = 3.6;
|
||||
const WALL_HEIGHT = 2.6;
|
||||
const WALL_THICK = 0.16;
|
||||
|
||||
// sRGB equivalents of the Aurora light canvas and blue action palette.
|
||||
const SCENE_COLORS = {
|
||||
background: 0xeff0f2,
|
||||
gridMajor: 0xd6d9df,
|
||||
gridMinor: 0xe3e5e9,
|
||||
accent: 0x235cc7,
|
||||
};
|
||||
|
||||
const ZONE_COLORS = {
|
||||
seating: 0xe8dfd1,
|
||||
counter: 0xd4a373,
|
||||
bar: 0xc89f81,
|
||||
kitchen: 0xb7b7a4,
|
||||
restroom: 0xa8dadc,
|
||||
terrace: 0xccd5ae,
|
||||
entrance: 0xf4e285,
|
||||
other: 0xdedbd2,
|
||||
};
|
||||
|
||||
const scenes = new Map();
|
||||
let nextId = 1;
|
||||
|
||||
function floorIndex(floors, level) {
|
||||
const sorted = [...floors].sort((a, b) => a.level - b.level);
|
||||
const idx = sorted.findIndex((f) => f.level === level);
|
||||
return idx >= 0 ? idx : 0;
|
||||
}
|
||||
|
||||
function createScene(canvas, layoutJson, onZoneSelect, cleanup) {
|
||||
const layout = JSON.parse(layoutJson);
|
||||
if (!layout || !Array.isArray(layout.floors)) throw new Error("Invalid floor layout");
|
||||
const coarsePointer = window.matchMedia("(pointer: coarse)");
|
||||
const originalTouchAction = canvas.style.touchAction;
|
||||
const renderer = new THREE.WebGLRenderer({ canvas, antialias: true, alpha: false });
|
||||
cleanup.push(() => renderer.dispose());
|
||||
renderer.shadowMap.enabled = true;
|
||||
renderer.shadowMap.type = THREE.PCFSoftShadowMap;
|
||||
renderer.setClearColor(SCENE_COLORS.background, 1);
|
||||
|
||||
const scene = new THREE.Scene();
|
||||
cleanup.push(() => disposeSceneObjects(scene));
|
||||
scene.fog = new THREE.FogExp2(SCENE_COLORS.background, 0.015);
|
||||
|
||||
const camera = new THREE.PerspectiveCamera(42, 1, 0.1, 200);
|
||||
const controls = new OrbitControls(camera, canvas);
|
||||
cleanup.push(() => { controls.dispose(); canvas.style.touchAction = originalTouchAction; });
|
||||
const reducedMotion = window.matchMedia("(prefers-reduced-motion: reduce)");
|
||||
controls.enableDamping = !reducedMotion.matches;
|
||||
controls.dampingFactor = 0.08;
|
||||
controls.maxPolarAngle = Math.PI * 0.48;
|
||||
|
||||
const hemi = new THREE.HemisphereLight(0xffffff, 0xaab0ba, 1.05);
|
||||
scene.add(hemi);
|
||||
|
||||
const dir = new THREE.DirectionalLight(0xffffff, 1.25);
|
||||
dir.position.set(16, 28, 18);
|
||||
dir.castShadow = true;
|
||||
dir.shadow.mapSize.set(2048, 2048);
|
||||
dir.shadow.camera.near = 1;
|
||||
dir.shadow.camera.far = 90;
|
||||
const d = 24;
|
||||
dir.shadow.camera.left = -d;
|
||||
dir.shadow.camera.right = d;
|
||||
dir.shadow.camera.top = d;
|
||||
dir.shadow.camera.bottom = -d;
|
||||
scene.add(dir);
|
||||
|
||||
const groundGrid = new THREE.GridHelper(60, 60, SCENE_COLORS.gridMajor, SCENE_COLORS.gridMinor);
|
||||
groundGrid.position.y = -0.08;
|
||||
scene.add(groundGrid);
|
||||
|
||||
const floorGroups = new Map();
|
||||
const pinMeshes = [];
|
||||
const floors = layout.floors || [];
|
||||
|
||||
floors.forEach((floor) => {
|
||||
const idx = floorIndex(floors, floor.level);
|
||||
const yBase = idx * FLOOR_HEIGHT;
|
||||
const group = buildFloorGroup(floor, yBase, pinMeshes);
|
||||
scene.add(group);
|
||||
floorGroups.set(floor.level, { group, yBase, floor });
|
||||
});
|
||||
|
||||
const maxW = Math.max(10, ...floors.map((f) => f.width_m || 10));
|
||||
const maxD = Math.max(10, ...floors.map((f) => f.depth_m || 10));
|
||||
const span = Math.max(maxW, maxD);
|
||||
camera.position.set(span * 1.15, span * 1.05, span * 1.25);
|
||||
controls.target.set(0, (floors.length - 1) * FLOOR_HEIGHT * 0.35, 0);
|
||||
controls.update();
|
||||
|
||||
let hasSize = false;
|
||||
let visible = true;
|
||||
let contextLost = false;
|
||||
let disposed = false;
|
||||
let raf = 0;
|
||||
let st;
|
||||
const requestFrame = () => {
|
||||
if (!disposed && !contextLost && !document.hidden && visible && hasSize && !raf) {
|
||||
raf = requestAnimationFrame(animate);
|
||||
}
|
||||
};
|
||||
let pixelRatio = 0;
|
||||
const resize = () => {
|
||||
const rect = canvas.getBoundingClientRect();
|
||||
const w = rect.width;
|
||||
const h = rect.height;
|
||||
hasSize = w > 0 && h > 0;
|
||||
if (!hasSize) return;
|
||||
const nextPixelRatio = Math.min(window.devicePixelRatio || 1, coarsePointer.matches ? 1.5 : 2);
|
||||
if (nextPixelRatio !== pixelRatio) {
|
||||
renderer.setPixelRatio(nextPixelRatio);
|
||||
pixelRatio = nextPixelRatio;
|
||||
}
|
||||
renderer.setSize(w, h, false);
|
||||
camera.aspect = w / h;
|
||||
// Leave room around the model on portrait and near-square phone viewports.
|
||||
camera.fov = (2 * Math.atan(Math.tan((42 * Math.PI) / 360) / Math.min(1, camera.aspect / 1.15)) * 180) / Math.PI;
|
||||
camera.updateProjectionMatrix();
|
||||
requestFrame();
|
||||
};
|
||||
resize();
|
||||
const ro = new ResizeObserver(resize);
|
||||
cleanup.push(() => ro.disconnect());
|
||||
ro.observe(canvas);
|
||||
window.addEventListener("resize", resize);
|
||||
cleanup.push(() => window.removeEventListener("resize", resize));
|
||||
|
||||
const raycaster = new THREE.Raycaster();
|
||||
const pointer = new THREE.Vector2();
|
||||
const activePointers = new Set();
|
||||
let downPos = null;
|
||||
|
||||
const syncInteraction = () => {
|
||||
downPos = null;
|
||||
controls.enabled = !coarsePointer.matches || canvas.dataset.interactive === "true";
|
||||
// OrbitControls sets this to "none" in its constructor, so apply the page-scroll mode afterward.
|
||||
canvas.style.touchAction = controls.enabled ? "none" : "pan-y";
|
||||
};
|
||||
syncInteraction();
|
||||
const interactionObserver = new MutationObserver(syncInteraction);
|
||||
cleanup.push(() => interactionObserver.disconnect());
|
||||
interactionObserver.observe(canvas, { attributes: true, attributeFilter: ["data-interactive"] });
|
||||
const onPointerModeChange = () => {
|
||||
syncInteraction();
|
||||
resize();
|
||||
};
|
||||
coarsePointer.addEventListener("change", onPointerModeChange);
|
||||
cleanup.push(() => coarsePointer.removeEventListener("change", onPointerModeChange));
|
||||
|
||||
const onActivePointerDown = (e) => {
|
||||
activePointers.add(e.pointerId);
|
||||
if (activePointers.size > 1) downPos = null;
|
||||
};
|
||||
const onPointerDown = (e) => {
|
||||
activePointers.add(e.pointerId);
|
||||
// Pins remain tappable in page-scroll mode; only orbit gestures require opt-in.
|
||||
if (activePointers.size !== 1 || e.isPrimary === false || e.button !== 0) {
|
||||
downPos = null;
|
||||
return;
|
||||
}
|
||||
downPos = { pointerId: e.pointerId, x: e.clientX, y: e.clientY, at: performance.now() };
|
||||
};
|
||||
const onPointerMove = (e) => {
|
||||
if (downPos?.pointerId === e.pointerId && Math.hypot(e.clientX - downPos.x, e.clientY - downPos.y) > 6) {
|
||||
downPos = null;
|
||||
}
|
||||
};
|
||||
const onPointerUp = (e) => {
|
||||
const wasOnlyPointer = activePointers.size === 1 && activePointers.has(e.pointerId);
|
||||
activePointers.delete(e.pointerId);
|
||||
const tap = downPos;
|
||||
downPos = null;
|
||||
if (!wasOnlyPointer || tap?.pointerId !== e.pointerId || performance.now() - tap.at > 800) return;
|
||||
if (Math.hypot(e.clientX - tap.x, e.clientY - tap.y) > 6) return;
|
||||
const rect = canvas.getBoundingClientRect();
|
||||
if (rect.width <= 0 || rect.height <= 0) return;
|
||||
if (e.clientX < rect.left || e.clientX > rect.right || e.clientY < rect.top || e.clientY > rect.bottom) return;
|
||||
pointer.x = ((e.clientX - rect.left) / rect.width) * 2 - 1;
|
||||
pointer.y = -((e.clientY - rect.top) / rect.height) * 2 + 1;
|
||||
raycaster.setFromCamera(pointer, camera);
|
||||
const selectablePins = pinMeshes.filter((pin) => {
|
||||
if (st.activeLevel !== 0 && pin.userData.floorLevel !== st.activeLevel) return false;
|
||||
for (let parent = pin; parent; parent = parent.parent) {
|
||||
if (!parent.visible) return false;
|
||||
}
|
||||
return true;
|
||||
});
|
||||
const hits = raycaster.intersectObjects(selectablePins, true);
|
||||
let obj = hits[0]?.object;
|
||||
// The decorative pin is small; use a 44px minimum tap target around its visible center.
|
||||
if (!obj) {
|
||||
let distance = 22;
|
||||
const projected = new THREE.Vector3();
|
||||
for (const pin of selectablePins) {
|
||||
pin.getWorldPosition(projected);
|
||||
projected.project(camera);
|
||||
if (projected.z < -1 || projected.z > 1) continue;
|
||||
const x = rect.left + (projected.x + 1) * rect.width / 2;
|
||||
const y = rect.top + (1 - projected.y) * rect.height / 2;
|
||||
const candidateDistance = Math.hypot(e.clientX - x, e.clientY - y);
|
||||
if (candidateDistance < distance) {
|
||||
distance = candidateDistance;
|
||||
obj = pin;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (obj) {
|
||||
while (obj && !obj.userData?.photoIds) {
|
||||
obj = obj.parent;
|
||||
}
|
||||
if (obj && obj.userData?.photoIds && typeof onZoneSelect === "function") {
|
||||
highlightZone(st.id, obj.userData.zoneLabel, JSON.stringify(obj.userData.photoIds));
|
||||
onZoneSelect(obj.userData.zoneLabel || "구역", JSON.stringify(obj.userData.photoIds));
|
||||
}
|
||||
}
|
||||
};
|
||||
const onPointerCancel = (e) => {
|
||||
activePointers.delete(e.pointerId);
|
||||
downPos = null;
|
||||
};
|
||||
canvas.addEventListener("pointerdown", onPointerDown);
|
||||
window.addEventListener("pointerdown", onActivePointerDown, true);
|
||||
window.addEventListener("pointermove", onPointerMove, true);
|
||||
canvas.addEventListener("lostpointercapture", onPointerCancel);
|
||||
// Capture release/cancel even when a scrolling or dragged pointer leaves the canvas.
|
||||
window.addEventListener("pointerup", onPointerUp, true);
|
||||
window.addEventListener("pointercancel", onPointerCancel, true);
|
||||
cleanup.push(() => {
|
||||
canvas.removeEventListener("pointerdown", onPointerDown);
|
||||
window.removeEventListener("pointerdown", onActivePointerDown, true);
|
||||
window.removeEventListener("pointermove", onPointerMove, true);
|
||||
canvas.removeEventListener("lostpointercapture", onPointerCancel);
|
||||
window.removeEventListener("pointerup", onPointerUp, true);
|
||||
window.removeEventListener("pointercancel", onPointerCancel, true);
|
||||
});
|
||||
|
||||
function animate() {
|
||||
raf = 0;
|
||||
if (disposed || contextLost || document.hidden || !visible || !hasSize) return;
|
||||
const t = performance.now() / 1000;
|
||||
pinMeshes.forEach((pin, i) => {
|
||||
pin.position.y = pin.userData.baseY + (reducedMotion.matches ? 0 : Math.sin(t * 2.6 + i) * 0.08);
|
||||
pin.rotation.y = reducedMotion.matches ? 0 : t * 1.1 + i;
|
||||
});
|
||||
controls.update();
|
||||
renderer.render(scene, camera);
|
||||
if (!reducedMotion.matches) requestFrame();
|
||||
}
|
||||
const stopFrame = () => {
|
||||
cancelAnimationFrame(raf);
|
||||
raf = 0;
|
||||
};
|
||||
const onVisibilityChange = () => document.hidden ? stopFrame() : requestFrame();
|
||||
document.addEventListener("visibilitychange", onVisibilityChange);
|
||||
cleanup.push(() => { disposed = true; stopFrame(); document.removeEventListener("visibilitychange", onVisibilityChange); });
|
||||
const intersectionObserver = new IntersectionObserver(([entry]) => {
|
||||
visible = entry.isIntersecting;
|
||||
visible ? requestFrame() : stopFrame();
|
||||
});
|
||||
intersectionObserver.observe(canvas);
|
||||
cleanup.push(() => intersectionObserver.disconnect());
|
||||
const onMotionChange = () => {
|
||||
controls.enableDamping = !reducedMotion.matches;
|
||||
requestFrame();
|
||||
};
|
||||
reducedMotion.addEventListener("change", onMotionChange);
|
||||
controls.addEventListener("change", requestFrame);
|
||||
cleanup.push(() => { reducedMotion.removeEventListener("change", onMotionChange); controls.removeEventListener("change", requestFrame); });
|
||||
const onContextLost = (event) => {
|
||||
event.preventDefault();
|
||||
contextLost = true;
|
||||
stopFrame();
|
||||
reportSceneState(canvas, "공간 화면이 중단됐습니다. 잠시 후 다시 시도해 주세요.");
|
||||
};
|
||||
const onContextRestored = () => {
|
||||
contextLost = false;
|
||||
resize();
|
||||
requestFrame();
|
||||
reportSceneState(canvas, null);
|
||||
};
|
||||
canvas.addEventListener("webglcontextlost", onContextLost);
|
||||
canvas.addEventListener("webglcontextrestored", onContextRestored);
|
||||
cleanup.push(() => { canvas.removeEventListener("webglcontextlost", onContextLost); canvas.removeEventListener("webglcontextrestored", onContextRestored); });
|
||||
|
||||
const id = nextId++;
|
||||
st = {
|
||||
id,
|
||||
renderer,
|
||||
scene,
|
||||
camera,
|
||||
controls,
|
||||
floorGroups,
|
||||
pinMeshes,
|
||||
ro,
|
||||
interactionObserver,
|
||||
coarsePointer,
|
||||
onPointerModeChange,
|
||||
resize,
|
||||
requestFrame,
|
||||
reducedMotion,
|
||||
onMotionChange,
|
||||
intersectionObserver,
|
||||
onVisibilityChange,
|
||||
onContextLost,
|
||||
onContextRestored,
|
||||
stopAnimation: () => {
|
||||
disposed = true;
|
||||
stopFrame();
|
||||
},
|
||||
canvas,
|
||||
originalTouchAction,
|
||||
onPointerDown,
|
||||
onActivePointerDown,
|
||||
onPointerMove,
|
||||
onPointerUp,
|
||||
onPointerCancel,
|
||||
span,
|
||||
activeLevel: 0,
|
||||
viewMode: "3d",
|
||||
};
|
||||
scenes.set(id, st);
|
||||
resetScene(id);
|
||||
reportSceneState(canvas, null);
|
||||
requestFrame();
|
||||
return id;
|
||||
}
|
||||
|
||||
function reportSceneState(canvas, message) {
|
||||
canvas.dataset.sceneError = message || "";
|
||||
canvas.dispatchEvent(new Event(message ? "scene-error" : "scene-ready", { bubbles: true }));
|
||||
}
|
||||
|
||||
export function mountScene(canvas, layoutJson, onZoneSelect) {
|
||||
const cleanup = [];
|
||||
try {
|
||||
return createScene(canvas, layoutJson, onZoneSelect, cleanup);
|
||||
} catch (error) {
|
||||
cleanup.reverse().forEach((dispose) => { try { dispose(); } catch { /* Finish the remaining cleanup. */ } });
|
||||
console.warn("Space viewer could not start", error?.message);
|
||||
reportSceneState(canvas, "공간 화면을 열 수 없습니다. 아래 정보와 사진을 확인하거나 다시 시도해 주세요.");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
export function setFloor(handle, level) {
|
||||
const st = scenes.get(handle);
|
||||
if (!st) return;
|
||||
if (level !== 0 && !st.floorGroups.has(level)) return;
|
||||
const previousY = floorTarget(st);
|
||||
st.activeLevel = level;
|
||||
const offsetY = floorTarget(st) - previousY;
|
||||
st.camera.position.y += offsetY;
|
||||
st.controls.target.y += offsetY;
|
||||
st.floorGroups.forEach(({ group, yBase }, fLevel) => {
|
||||
if (level === 0) {
|
||||
group.visible = true;
|
||||
setGroupOpacity(group, 1.0);
|
||||
} else if (fLevel === level) {
|
||||
group.visible = true;
|
||||
setGroupOpacity(group, 1.0);
|
||||
} else if (fLevel < level) {
|
||||
group.visible = st.viewMode !== "plan";
|
||||
setGroupOpacity(group, 0.18);
|
||||
} else {
|
||||
group.visible = false;
|
||||
}
|
||||
});
|
||||
st.controls.update();
|
||||
st.requestFrame();
|
||||
}
|
||||
|
||||
function floorTarget(st) {
|
||||
return st.floorGroups.get(st.activeLevel)?.yBase ?? Math.max(0, st.floorGroups.size - 1) * FLOOR_HEIGHT * 0.35;
|
||||
}
|
||||
|
||||
export function setViewMode(handle, mode) {
|
||||
const st = scenes.get(handle);
|
||||
if (!st) return;
|
||||
st.viewMode = mode === "plan" ? "plan" : "3d";
|
||||
const plan = st.viewMode === "plan";
|
||||
st.controls.enableRotate = !plan;
|
||||
st.controls.minPolarAngle = 0;
|
||||
st.controls.maxPolarAngle = plan ? 0 : Math.PI * 0.48;
|
||||
st.controls.screenSpacePanning = true;
|
||||
st.controls.mouseButtons.LEFT = plan ? THREE.MOUSE.PAN : THREE.MOUSE.ROTATE;
|
||||
st.controls.touches.ONE = plan ? THREE.TOUCH.PAN : THREE.TOUCH.ROTATE;
|
||||
st.controls.touches.TWO = THREE.TOUCH.DOLLY_PAN;
|
||||
setFloor(handle, st.activeLevel);
|
||||
resetScene(handle);
|
||||
}
|
||||
|
||||
export function resetScene(handle) {
|
||||
const st = scenes.get(handle);
|
||||
if (!st) return;
|
||||
const yTarget = floorTarget(st);
|
||||
const s = st.span;
|
||||
// Flush accumulated damping so reset and view changes do not inherit a prior gesture.
|
||||
const damping = st.controls.enableDamping;
|
||||
st.controls.enableDamping = false;
|
||||
st.controls.update();
|
||||
st.controls.enableDamping = damping;
|
||||
st.controls.minDistance = Math.max(2, s * 0.18);
|
||||
st.controls.maxDistance = s * 5;
|
||||
if (st.viewMode === "plan") {
|
||||
st.camera.position.set(0, yTarget + s * 1.65, 0.01);
|
||||
st.controls.target.set(0, yTarget, 0);
|
||||
} else {
|
||||
st.camera.position.set(s * 1.15, yTarget + s * 1.0, s * 1.25);
|
||||
st.controls.target.set(0, yTarget + 0.4, 0);
|
||||
}
|
||||
st.controls.update();
|
||||
st.requestFrame();
|
||||
}
|
||||
|
||||
export function zoomScene(handle, delta) {
|
||||
const st = scenes.get(handle);
|
||||
if (!st || !Number.isFinite(delta)) return;
|
||||
const offset = st.camera.position.clone().sub(st.controls.target);
|
||||
const distance = THREE.MathUtils.clamp(offset.length() * Math.exp(-delta * 0.18), st.controls.minDistance, st.controls.maxDistance);
|
||||
st.camera.position.copy(st.controls.target).add(offset.setLength(distance));
|
||||
st.controls.update();
|
||||
st.requestFrame();
|
||||
}
|
||||
|
||||
export function highlightZone(handle, label, photoIdsJson) {
|
||||
const st = scenes.get(handle);
|
||||
if (!st) return;
|
||||
let photoIds = [];
|
||||
try { photoIds = JSON.parse(photoIdsJson); } catch { /* An empty selection simply clears emphasis. */ }
|
||||
st.scene.traverse((obj) => {
|
||||
if (!obj.userData.zoneSurface) return;
|
||||
const selected = Boolean(label) && obj.userData.zoneLabel === label &&
|
||||
(!photoIds.length || obj.userData.photoIds.some((id) => photoIds.includes(id)));
|
||||
obj.material.emissive.setHex(selected ? SCENE_COLORS.accent : 0x000000);
|
||||
obj.material.emissiveIntensity = selected ? 0.23 : 0;
|
||||
});
|
||||
st.pinMeshes.forEach((pin) => {
|
||||
const selected = Boolean(label) && pin.userData.zoneLabel === label &&
|
||||
(!photoIds.length || pin.userData.photoIds.some((id) => photoIds.includes(id)));
|
||||
pin.scale.setScalar(selected ? 1.4 : 1);
|
||||
});
|
||||
st.requestFrame();
|
||||
}
|
||||
|
||||
export function disposeScene(handle) {
|
||||
const st = scenes.get(handle);
|
||||
if (!st) return;
|
||||
st.stopAnimation();
|
||||
st.ro.disconnect();
|
||||
st.intersectionObserver.disconnect();
|
||||
st.interactionObserver.disconnect();
|
||||
st.coarsePointer.removeEventListener("change", st.onPointerModeChange);
|
||||
st.reducedMotion.removeEventListener("change", st.onMotionChange);
|
||||
document.removeEventListener("visibilitychange", st.onVisibilityChange);
|
||||
window.removeEventListener("resize", st.resize);
|
||||
st.canvas.removeEventListener("pointerdown", st.onPointerDown);
|
||||
window.removeEventListener("pointerdown", st.onActivePointerDown, true);
|
||||
window.removeEventListener("pointermove", st.onPointerMove, true);
|
||||
st.canvas.removeEventListener("lostpointercapture", st.onPointerCancel);
|
||||
window.removeEventListener("pointerup", st.onPointerUp, true);
|
||||
window.removeEventListener("pointercancel", st.onPointerCancel, true);
|
||||
st.canvas.removeEventListener("webglcontextlost", st.onContextLost);
|
||||
st.canvas.removeEventListener("webglcontextrestored", st.onContextRestored);
|
||||
st.controls.removeEventListener("change", st.requestFrame);
|
||||
st.controls.dispose();
|
||||
st.canvas.style.touchAction = st.originalTouchAction;
|
||||
disposeSceneObjects(st.scene);
|
||||
st.renderer.dispose();
|
||||
scenes.delete(handle);
|
||||
}
|
||||
|
||||
function disposeSceneObjects(scene) {
|
||||
const geometries = new Set();
|
||||
const materials = new Set();
|
||||
scene.traverse((obj) => {
|
||||
if (obj.geometry) geometries.add(obj.geometry);
|
||||
if (obj.material) (Array.isArray(obj.material) ? obj.material : [obj.material]).forEach((m) => materials.add(m));
|
||||
if (obj.shadow) obj.shadow.dispose();
|
||||
});
|
||||
geometries.forEach((geometry) => geometry.dispose());
|
||||
materials.forEach((material) => material.dispose());
|
||||
}
|
||||
|
||||
function setGroupOpacity(group, opacity) {
|
||||
group.traverse((obj) => {
|
||||
if (obj.isMesh && obj.material) {
|
||||
const mats = Array.isArray(obj.material) ? obj.material : [obj.material];
|
||||
mats.forEach((m) => {
|
||||
if (m.userData.baseOpacity === undefined) {
|
||||
m.userData.baseOpacity = m.opacity ?? 1.0;
|
||||
m.userData.wasTransparent = m.transparent ?? false;
|
||||
}
|
||||
if (opacity < 0.99) {
|
||||
m.transparent = true;
|
||||
m.opacity = m.userData.baseOpacity * opacity;
|
||||
} else {
|
||||
m.transparent = m.userData.wasTransparent;
|
||||
m.opacity = m.userData.baseOpacity;
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// Convert floor local (x east 0..W, y north 0..D) into Three.js world (x east -W/2..W/2, z south -D/2..D/2)
|
||||
// Note: local y=0 is SOUTH (front/entrance), which maps to z = +D/2 in Three.js so south faces the viewer.
|
||||
function toWorldXZ(floor, lx, ly) {
|
||||
return [lx - floor.width_m / 2, floor.depth_m / 2 - ly];
|
||||
}
|
||||
|
||||
function buildFloorGroup(floor, yBase, pinMeshes) {
|
||||
const group = new THREE.Group();
|
||||
group.position.y = yBase;
|
||||
const W = floor.width_m || 10;
|
||||
const D = floor.depth_m || 10;
|
||||
|
||||
// Floor slab
|
||||
const slabGeo = new THREE.BoxGeometry(W, 0.14, D);
|
||||
const slabMat = new THREE.MeshStandardMaterial({ color: 0xf3ede2, roughness: 0.85 });
|
||||
const slab = new THREE.Mesh(slabGeo, slabMat);
|
||||
slab.position.y = -0.07;
|
||||
slab.receiveShadow = true;
|
||||
group.add(slab);
|
||||
|
||||
// Subtle perimeter walls (low cutaway height on South/East so interior is easy to see)
|
||||
buildWalls(group, floor);
|
||||
|
||||
// Zones + furniture + pins
|
||||
(floor.zones || []).forEach((zone) => {
|
||||
const zg = buildZone(floor, zone, pinMeshes);
|
||||
group.add(zg);
|
||||
});
|
||||
|
||||
// Verticals (stairs / elevator)
|
||||
(floor.verticals || []).forEach((v) => {
|
||||
group.add(buildVertical(floor, v));
|
||||
});
|
||||
|
||||
return group;
|
||||
}
|
||||
|
||||
function buildWalls(group, floor) {
|
||||
const W = floor.width_m;
|
||||
const D = floor.depth_m;
|
||||
const wallMat = new THREE.MeshStandardMaterial({ color: 0xd8d2c5, roughness: 0.75 });
|
||||
const glassMat = new THREE.MeshStandardMaterial({
|
||||
color: 0x8ecae6,
|
||||
transparent: true,
|
||||
opacity: 0.32,
|
||||
roughness: 0.2,
|
||||
});
|
||||
const doorMat = new THREE.MeshStandardMaterial({ color: 0xe76f51, roughness: 0.6 });
|
||||
|
||||
// Back walls (North & West) full height; front walls (South & East) cutaway 0.9m so camera sees inside
|
||||
const north = new THREE.Mesh(new THREE.BoxGeometry(W, WALL_HEIGHT, WALL_THICK), wallMat.clone());
|
||||
north.position.set(0, WALL_HEIGHT / 2, -D / 2);
|
||||
north.castShadow = true;
|
||||
group.add(north);
|
||||
|
||||
const west = new THREE.Mesh(new THREE.BoxGeometry(WALL_THICK, WALL_HEIGHT, D), wallMat.clone());
|
||||
west.position.set(-W / 2, WALL_HEIGHT / 2, 0);
|
||||
west.castShadow = true;
|
||||
group.add(west);
|
||||
|
||||
const lowH = 0.65;
|
||||
const south = new THREE.Mesh(new THREE.BoxGeometry(W, lowH, WALL_THICK), wallMat.clone());
|
||||
south.position.set(0, lowH / 2, D / 2);
|
||||
group.add(south);
|
||||
|
||||
const east = new THREE.Mesh(new THREE.BoxGeometry(WALL_THICK, lowH, D), wallMat.clone());
|
||||
east.position.set(W / 2, lowH / 2, 0);
|
||||
group.add(east);
|
||||
|
||||
// Render openings (windows as glass panels, entrances as welcome mats + arch)
|
||||
(floor.openings || []).forEach((op) => {
|
||||
const len = Math.max(0.9, op.length_m || 1.5);
|
||||
const off = op.offset_m || 1.0;
|
||||
const isWindow = op.kind === "window";
|
||||
const h = isWindow ? 1.5 : 2.1;
|
||||
const yCenter = isWindow ? 1.3 : h / 2;
|
||||
const mat = isWindow ? glassMat.clone() : doorMat.clone();
|
||||
|
||||
let mesh;
|
||||
if (op.wall === "south" || op.wall === "north") {
|
||||
mesh = new THREE.Mesh(new THREE.BoxGeometry(len, h, WALL_THICK * 1.3), mat);
|
||||
const x = -W / 2 + off + len / 2;
|
||||
const z = op.wall === "south" ? D / 2 : -D / 2;
|
||||
mesh.position.set(x, yCenter, z);
|
||||
} else {
|
||||
mesh = new THREE.Mesh(new THREE.BoxGeometry(WALL_THICK * 1.3, h, len), mat);
|
||||
const z = D / 2 - (off + len / 2);
|
||||
const x = op.wall === "east" ? W / 2 : -W / 2;
|
||||
mesh.position.set(x, yCenter, z);
|
||||
}
|
||||
group.add(mesh);
|
||||
});
|
||||
}
|
||||
|
||||
function buildZone(floor, zone, pinMeshes) {
|
||||
const g = new THREE.Group();
|
||||
const [wx, wz] = toWorldXZ(floor, zone.x + zone.w / 2, zone.y + zone.d / 2);
|
||||
g.position.set(wx, 0.02, wz);
|
||||
|
||||
const color = ZONE_COLORS[zone.kind] || ZONE_COLORS.other;
|
||||
const pad = new THREE.Mesh(
|
||||
new THREE.BoxGeometry(Math.max(0.8, zone.w - 0.12), 0.04, Math.max(0.8, zone.d - 0.12)),
|
||||
new THREE.MeshStandardMaterial({ color, roughness: 0.9 })
|
||||
);
|
||||
pad.receiveShadow = true;
|
||||
pad.userData = { zoneSurface: true, zoneLabel: zone.label || zone.kind, photoIds: zone.evidence_photos || [] };
|
||||
g.add(pad);
|
||||
|
||||
// Place furniture groups inside the zone
|
||||
(zone.furniture || []).forEach((fg) => {
|
||||
populateFurniture(g, zone.w, zone.d, fg);
|
||||
});
|
||||
|
||||
// If this zone has evidence photos, place a glowing interactive pin above it
|
||||
if (zone.evidence_photos && zone.evidence_photos.length > 0) {
|
||||
const pin = buildPin(zone.label || zone.kind, zone.evidence_photos);
|
||||
pin.position.set(0, 1.65, 0);
|
||||
pin.userData.baseY = 1.65;
|
||||
pin.userData.floorLevel = floor.level;
|
||||
g.add(pin);
|
||||
pinMeshes.push(pin);
|
||||
}
|
||||
return g;
|
||||
}
|
||||
|
||||
function populateFurniture(zoneGroup, zw, zd, fg) {
|
||||
const count = Math.min(24, Math.max(1, fg.count || 1));
|
||||
const cols = Math.max(1, Math.ceil(Math.sqrt(count * (zw / Math.max(1, zd)))));
|
||||
const rows = Math.max(1, Math.ceil(count / cols));
|
||||
const cellW = (zw * 0.82) / cols;
|
||||
const cellD = (zd * 0.82) / rows;
|
||||
|
||||
for (let i = 0; i < count; i++) {
|
||||
const r = Math.floor(i / cols);
|
||||
const c = i % cols;
|
||||
const x = -zw * 0.41 + (c + 0.5) * cellW;
|
||||
const z = -zd * 0.41 + (r + 0.5) * cellD;
|
||||
const item = buildFurnitureMesh(fg.kind, cellW, cellD);
|
||||
item.position.set(x, 0.02, z);
|
||||
zoneGroup.add(item);
|
||||
}
|
||||
}
|
||||
|
||||
function buildFurnitureMesh(kind, cellW, cellD) {
|
||||
const g = new THREE.Group();
|
||||
const wood = new THREE.MeshStandardMaterial({ color: 0x8b5e3c, roughness: 0.7 });
|
||||
const darkWood = new THREE.MeshStandardMaterial({ color: 0x5c3d28, roughness: 0.75 });
|
||||
const chairMat = new THREE.MeshStandardMaterial({ color: 0x3d405b, roughness: 0.8 });
|
||||
const sofaMat = new THREE.MeshStandardMaterial({ color: 0x6b705c, roughness: 0.85 });
|
||||
const metal = new THREE.MeshStandardMaterial({ color: 0xadb5bd, metalness: 0.5, roughness: 0.4 });
|
||||
const leaf = new THREE.MeshStandardMaterial({ color: 0x52b788, roughness: 0.8 });
|
||||
|
||||
if (kind === "counter_bar") {
|
||||
const w = Math.min(2.6, Math.max(1.2, cellW * 0.9));
|
||||
const d = Math.min(1.0, Math.max(0.65, cellD * 0.6));
|
||||
const body = new THREE.Mesh(new THREE.BoxGeometry(w, 0.95, d), darkWood);
|
||||
body.position.y = 0.475;
|
||||
body.castShadow = true;
|
||||
g.add(body);
|
||||
const machine = new THREE.Mesh(new THREE.BoxGeometry(0.45, 0.35, 0.35), metal);
|
||||
machine.position.set(-w * 0.2, 1.12, 0);
|
||||
g.add(machine);
|
||||
return g;
|
||||
}
|
||||
|
||||
if (kind === "bar_seat") {
|
||||
const stool = new THREE.Mesh(new THREE.CylinderGeometry(0.2, 0.2, 0.68, 12), chairMat);
|
||||
stool.position.y = 0.34;
|
||||
stool.castShadow = true;
|
||||
g.add(stool);
|
||||
return g;
|
||||
}
|
||||
|
||||
if (kind === "sofa") {
|
||||
const seat = new THREE.Mesh(new THREE.BoxGeometry(1.3, 0.42, 0.65), sofaMat);
|
||||
seat.position.y = 0.21;
|
||||
seat.castShadow = true;
|
||||
const back = new THREE.Mesh(new THREE.BoxGeometry(1.3, 0.45, 0.16), sofaMat);
|
||||
back.position.set(0, 0.55, -0.24);
|
||||
g.add(seat, back);
|
||||
return g;
|
||||
}
|
||||
|
||||
if (kind === "plant") {
|
||||
const pot = new THREE.Mesh(new THREE.CylinderGeometry(0.22, 0.16, 0.36, 12), darkWood);
|
||||
pot.position.y = 0.18;
|
||||
const crown = new THREE.Mesh(new THREE.SphereGeometry(0.36, 12, 10), leaf);
|
||||
crown.position.y = 0.62;
|
||||
crown.castShadow = true;
|
||||
g.add(pot, crown);
|
||||
return g;
|
||||
}
|
||||
|
||||
// Tables (table2, table4, table6, communal_table)
|
||||
const isLarge = kind === "table6" || kind === "communal_table";
|
||||
const isFour = kind === "table4";
|
||||
const tw = isLarge ? 1.5 : isFour ? 0.95 : 0.68;
|
||||
const td = isLarge ? 0.8 : 0.68;
|
||||
const top = new THREE.Mesh(new THREE.BoxGeometry(tw, 0.06, td), wood);
|
||||
top.position.y = 0.72;
|
||||
top.castShadow = true;
|
||||
const leg = new THREE.Mesh(new THREE.CylinderGeometry(0.06, 0.08, 0.7, 10), metal);
|
||||
leg.position.y = 0.35;
|
||||
g.add(top, leg);
|
||||
|
||||
const chairOffsets = isLarge
|
||||
? [
|
||||
[-0.45, -0.52],
|
||||
[0, -0.52],
|
||||
[0.45, -0.52],
|
||||
[-0.45, 0.52],
|
||||
[0, 0.52],
|
||||
[0.45, 0.52],
|
||||
]
|
||||
: isFour
|
||||
? [
|
||||
[-0.24, -0.48],
|
||||
[0.24, -0.48],
|
||||
[-0.24, 0.48],
|
||||
[0.24, 0.48],
|
||||
]
|
||||
: [
|
||||
[0, -0.46],
|
||||
[0, 0.46],
|
||||
];
|
||||
|
||||
chairOffsets.forEach(([cx, cz]) => {
|
||||
const ch = new THREE.Mesh(new THREE.BoxGeometry(0.32, 0.44, 0.32), chairMat);
|
||||
ch.position.set(cx, 0.22, cz);
|
||||
ch.castShadow = true;
|
||||
g.add(ch);
|
||||
});
|
||||
return g;
|
||||
}
|
||||
|
||||
function buildVertical(floor, v) {
|
||||
const g = new THREE.Group();
|
||||
const [wx, wz] = toWorldXZ(floor, v.x + v.w / 2, v.y + v.d / 2);
|
||||
g.position.set(wx, 0, wz);
|
||||
const mat = new THREE.MeshStandardMaterial({ color: 0xadb5bd, roughness: 0.6 });
|
||||
|
||||
if (v.kind === "elevator") {
|
||||
const box = new THREE.Mesh(new THREE.BoxGeometry(v.w, WALL_HEIGHT, v.d), mat);
|
||||
box.position.y = WALL_HEIGHT / 2;
|
||||
g.add(box);
|
||||
} else {
|
||||
const steps = 8;
|
||||
for (let i = 0; i < steps; i++) {
|
||||
const sh = ((i + 1) / steps) * (WALL_HEIGHT * 0.85);
|
||||
const step = new THREE.Mesh(new THREE.BoxGeometry(v.w, sh, v.d / steps), mat);
|
||||
step.position.set(0, sh / 2, -v.d / 2 + ((i + 0.5) * v.d) / steps);
|
||||
step.castShadow = true;
|
||||
g.add(step);
|
||||
}
|
||||
}
|
||||
return g;
|
||||
}
|
||||
|
||||
function buildPin(zoneLabel, photoIds) {
|
||||
const g = new THREE.Group();
|
||||
g.userData = { zoneLabel, photoIds };
|
||||
const headMat = new THREE.MeshStandardMaterial({
|
||||
color: SCENE_COLORS.accent,
|
||||
emissive: SCENE_COLORS.accent,
|
||||
emissiveIntensity: 0.18,
|
||||
roughness: 0.3,
|
||||
});
|
||||
const head = new THREE.Mesh(new THREE.OctahedronGeometry(0.24, 0), headMat);
|
||||
head.position.y = 0.2;
|
||||
const stem = new THREE.Mesh(
|
||||
new THREE.CylinderGeometry(0.03, 0.03, 0.35, 8),
|
||||
new THREE.MeshBasicMaterial({ color: SCENE_COLORS.accent })
|
||||
);
|
||||
g.add(head, stem);
|
||||
return g;
|
||||
}
|
||||
Reference in new issue
Block a user