| import * as THREE from "three"; |
| import { isFloor } from "../../shared/entry-points.mjs"; |
| function scanPresentationBounds(definition) { |
| const bounds = new THREE.Box3(); |
| for (const o of (definition?.objects || []).filter(isFloor)) { |
| const c = Math.cos(o.rotation), s = Math.sin(o.rotation); |
| for (const x of [-o.size[0] / 2, o.size[0] / 2]) for (const z of [-o.size[2] / 2, o.size[2] / 2]) bounds.expandByPoint(new THREE.Vector3(o.position[0] + c * x + s * z, 0, o.position[2] - s * x + c * z)); |
| } |
| return { center: bounds.getCenter(new THREE.Vector3()).toArray(), extent: Math.max(...bounds.getSize(new THREE.Vector3()).toArray()) }; |
| } |
| function createCreationLayout(panel, world) { |
| let yaw = 0, hasYaw = false, stableSince = null, start = null, previous = null; |
| const up = new THREE.Vector3(0, 1, 0); |
| function sample(view) { |
| const position = view.getWorldPosition(new THREE.Vector3()), q = view.getWorldQuaternion(new THREE.Quaternion()); |
| const forward = new THREE.Vector3(0, 0, -1).applyQuaternion(q); |
| forward.y = 0; |
| const horizontal = forward.lengthSq() > 0.04; |
| if (horizontal) { |
| yaw = Math.atan2(-forward.x, -forward.z); |
| hasYaw = true; |
| } |
| return { position, yaw, horizontal }; |
| } |
| return { |
| reset() { |
| stableSince = start = null; |
| previous = null; |
| hasYaw = false; |
| yaw = 0; |
| }, |
| ready(view, time, valid = true) { |
| if (!valid) { |
| stableSince = start = null; |
| previous = null; |
| return false; |
| } |
| const pose = sample(view); |
| start ??= time; |
| if (!hasYaw) return false; |
| const angle = previous ? Math.atan2(Math.sin(pose.yaw - previous.yaw), Math.cos(pose.yaw - previous.yaw)) : 0; |
| if (!previous || Math.abs(angle) > 0.04 || pose.position.distanceTo(previous.position) > 0.04) { |
| stableSince = time; |
| previous = pose; |
| } |
| return time - stableSince >= 250 || time - start >= 1500; |
| }, |
| place(view, { miniature = false, center = [0, 0, 0], rotationOffset = 0 } = {}) { |
| const { position, yaw: yaw2 } = sample(view), forward = new THREE.Vector3(-Math.sin(yaw2), 0, -Math.cos(yaw2)); |
| panel.position.copy(position).addScaledVector(forward, miniature ? 1.25 : 1.5); |
| panel.position.y -= miniature ? 0.64 : 0.18; |
| panel.quaternion.setFromAxisAngle(up, yaw2); |
| panel.visible = true; |
| panel.updateMatrixWorld(true); |
| if (miniature) { |
| world.quaternion.setFromAxisAngle(up, yaw2 + rotationOffset); |
| const offset = new THREE.Vector3().fromArray(center).multiply(world.scale).applyQuaternion(world.quaternion); |
| world.position.copy(position).addScaledVector(forward, 1.9).sub(offset); |
| world.position.y -= 0.48; |
| world.updateMatrixWorld(true); |
| } |
| } |
| }; |
| } |
| function alignedRoomPose(candidate, ground) { |
| const yaw = candidate.yaw - (ground?.rotation || 0), q = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), yaw); |
| const local = new THREE.Vector3(ground?.position[0] || 0, ground ? ground.position[1] + ground.size[1] / 2 : 0, ground?.position[2] || 0).applyQuaternion(q); |
| return { position: new THREE.Vector3().fromArray(candidate.origin).sub(local).toArray(), yaw }; |
| } |
| function captureCreationPose(world, rig, camera, alignedMode) { |
| const copy = (o) => ({ position: o.position.toArray(), quaternion: o.quaternion.toArray(), scale: o.scale.toArray() }); |
| return { world: copy(world), rig: copy(rig), camera: copy(camera), alignedMode }; |
| } |
| function restoreCreationPose(saved, world, rig, camera, { xr = false } = {}) { |
| const restore = (o, p) => { |
| o.position.fromArray(p.position); |
| o.quaternion.fromArray(p.quaternion); |
| o.scale.fromArray(p.scale); |
| o.updateMatrixWorld(true); |
| }; |
| restore(world, saved.world); |
| restore(rig, saved.rig); |
| if (!xr) restore(camera, saved.camera); |
| } |
| export { |
| alignedRoomPose, |
| captureCreationPose, |
| createCreationLayout, |
| restoreCreationPose, |
| scanPresentationBounds |
| }; |
|
|
