@popaya/pgsg-viewer 0.1.9 → 0.1.11

package/dist/{pgsg-three-viewer-TOCXQMZQ.js → pgsg-three-viewer-KBOYGHT3.js}

@@ -1,6 +1,8 @@
 // src/viewers/three/pgsg-three-viewer.ts
-import * as THREE4 from "three";
-import { GLTFLoader } from "three/examples/jsm/Addons.js";
+import * as THREE5 from "three";
+import { GLTFLoader } from "three/addons/loaders/GLTFLoader.js";
+import { TransformControls } from "three/addons/controls/TransformControls.js";
+import * as RAPIER2 from "@dimforge/rapier3d-compat";
 import nipplejs from "nipplejs";
 
 // src/viewers/spark/SparkSplatRenderer.ts
@@ -40,119 +42,142 @@ var SparkSplatRenderer = class {
   }
 };
 
-// src/viewers/three/controls/WalkCapsuleController.ts
+// src/viewers/three/controls/RapierWalkCapsuleController.ts
 import * as THREE from "three";
-var WalkCapsuleController = class {
+import * as RAPIER from "@dimforge/rapier3d-compat";
+var RapierWalkController = class {
   dom;
   camera;
-  colliders;
-  eyeHeight;
+  world;
+  body;
+  collider;
   radius;
-  gravity;
-  walkSpeed;
-  runMultiplier;
+  halfHeight;
+  eyeHeight;
+  moveSpeed;
+  jumpSpeed;
   lookSensitivity;
+  usePointerLock;
   yaw = 0;
   pitch = 0;
-  velocity = new THREE.Vector3();
-  onGround = false;
-  lastGroundY = null;
   keys = /* @__PURE__ */ new Set();
-  raycaster = new THREE.Raycaster();
-  usePointerLock = false;
-  lastTouchX = 0;
-  lastTouchY = 0;
-  externalMove = new THREE.Vector2(0, 0);
-  useGyro = false;
-  gyroAlpha = 0;
-  gyroBeta = 0;
-  gyroGamma = 0;
+  moveVec = new THREE.Vector2(0, 0);
+  // joystick: x=forward, y=right
+  groundProbeExtra;
+  groundSnapMax;
+  // ---- bound handlers (so dispose works) ----
+  onClickBound = () => this.onClick();
+  onMouseMoveBound = (e) => this.onMouseMove(e);
+  onKeyDownBound = (e) => this.onKeyDown(e);
+  onKeyUpBound = (e) => this.onKeyUp(e);
+  onBlurBound = () => this.onBlur();
   constructor(opts) {
     this.dom = opts.dom;
     this.camera = opts.camera;
-    this.colliders = opts.colliders;
-    console.log("colliders", this.colliders.length);
+    this.world = opts.world;
+    this.radius = opts.radius ?? 0.2;
+    this.halfHeight = opts.halfHeight ?? 0.6;
     this.eyeHeight = opts.eyeHeight ?? 1.6;
-    this.radius = opts.radius ?? 0.35;
-    this.gravity = opts.gravity ?? 9.8;
-    this.walkSpeed = opts.walkSpeed ?? 2.5;
-    this.runMultiplier = opts.runMultiplier ?? 2;
+    this.moveSpeed = opts.moveSpeed ?? 3;
+    this.jumpSpeed = opts.jumpSpeed ?? 6;
     this.lookSensitivity = opts.lookSensitivity ?? 22e-4;
-    this.usePointerLock = opts.usePointerLock ?? false;
+    this.usePointerLock = opts.usePointerLock ?? true;
+    this.groundProbeExtra = opts.groundProbeExtra ?? 0.25;
+    this.groundSnapMax = opts.groundSnapMax ?? 0.65;
     const euler = new THREE.Euler().setFromQuaternion(
       this.camera.quaternion,
       "YXZ"
     );
     this.pitch = euler.x;
     this.yaw = euler.y;
-    if (this.usePointerLock === false) {
-      this.bindTouch();
-    } else {
-      this.bind();
-    }
+    const start = this.camera.position.clone();
+    const centerY = start.y - this.eyeHeight + (this.halfHeight + this.radius);
+    const bodyDesc = RAPIER.RigidBodyDesc.dynamic().setTranslation(start.x, centerY, start.z).lockRotations().setLinearDamping(6).setCcdEnabled(true);
+    this.body = this.world.createRigidBody(bodyDesc);
+    const colDesc = RAPIER.ColliderDesc.capsule(this.halfHeight, this.radius).setFriction(0.8).setRestitution(0);
+    this.collider = this.world.createCollider(colDesc, this.body);
+    this.collider.setActiveEvents?.(RAPIER.ActiveEvents.COLLISION_EVENTS);
+    this.bindInput();
   }
   dispose() {
-    if (this.usePointerLock === false) {
-      this.unbindTouch();
-    } else {
-      this.unbind();
-      if (this.usePointerLock) document.exitPointerLock();
+    this.unbindInput();
+    if (this.body) {
+      this.world.removeRigidBody(this.body);
     }
   }
+  // ---------------------------
+  // External movement (joystick)
+  // x = forward/back (-1..1), y = right/left (-1..1)
+  // ---------------------------
   setMovementVector(x, y) {
-    this.externalMove.set(x, y);
+    this.moveVec.set(x, y);
   }
-  enableGyro() {
-    if (typeof DeviceOrientationEvent === "undefined") return;
-    if (DeviceOrientationEvent.requestPermission) {
-      DeviceOrientationEvent.requestPermission().then((response) => {
-        if (response === "granted") {
-          this.startGyro();
-        }
-      }).catch(console.error);
-    } else {
-      this.startGyro();
-    }
-  }
-  // --------------------------------------------------
-  // Input binding (SAFE for pointer lock)
-  // --------------------------------------------------
-  bind() {
-    this.dom.addEventListener("click", this.onClick);
-    window.addEventListener("mousemove", this.onMouseMove);
-    window.addEventListener("keydown", this.onKeyDown);
-    window.addEventListener("keyup", this.onKeyUp);
-    window.addEventListener("blur", this.onBlur);
-    this.dom.addEventListener("contextmenu", (e) => e.preventDefault());
-  }
-  bindTouch() {
-    this.dom.addEventListener("touchstart", this.onTouchStart);
-    this.dom.addEventListener("touchmove", this.onTouchMove);
+  setRotation(yaw, pitch) {
+    this.yaw = yaw;
+    this.pitch = THREE.MathUtils.clamp(
+      pitch,
+      -Math.PI / 2 + 0.01,
+      Math.PI / 2 - 0.01
+    );
+    this.camera.quaternion.setFromEuler(
+      new THREE.Euler(this.pitch, this.yaw, 0, "YXZ")
+    );
   }
-  unbind() {
-    this.dom.removeEventListener("click", this.onClick);
-    window.removeEventListener("mousemove", this.onMouseMove);
-    window.removeEventListener("keydown", this.onKeyDown);
-    window.removeEventListener("keyup", this.onKeyUp);
-    window.removeEventListener("blur", this.onBlur);
+  resetVelocity() {
+    this.body.setLinvel({ x: 0, y: 0, z: 0 }, true);
+    this.body.setAngvel({ x: 0, y: 0, z: 0 }, true);
   }
-  unbindTouch() {
-    this.dom.removeEventListener("touchstart", this.onTouchStart);
-    this.dom.removeEventListener("touchmove", this.onTouchMove);
+  setPositionFromCamera() {
+    const p = this.camera.position;
+    const centerY = p.y - this.eyeHeight + (this.halfHeight + this.radius);
+    this.body.setTranslation({ x: p.x, y: centerY, z: p.z }, true);
+    this.resetVelocity();
   }
-  onClick = () => {
-    if (this.usePointerLock && document.pointerLockElement !== this.dom) {
-      this.dom.requestPointerLock();
-    }
-  };
-  onBlur = () => {
+  // Snap the capsule so its feet rest on the nearest floor below
+  snapToGround() {
+    const p = this.body.translation();
+    const origin = { x: p.x, y: p.y + 2, z: p.z };
+    const dir = { x: 0, y: -1, z: 0 };
+    const ray = new RAPIER.Ray(origin, dir);
+    const maxDist = 50;
+    const hit = this.castRayWithNormal(ray, maxDist);
+    if (!hit) return;
+    const toi = hit.timeOfImpact;
+    const hitY = origin.y - toi;
+    const newCenterY = hitY + (this.halfHeight + this.radius) + 0.02;
+    this.body.setTranslation({ x: p.x, y: newCenterY, z: p.z }, true);
+    this.resetVelocity();
+  }
+  // ---------------------------
+  // Input binding
+  // ---------------------------
+  bindInput() {
     if (this.usePointerLock) {
-      document.exitPointerLock();
+      this.dom.addEventListener("click", this.onClickBound);
+      window.addEventListener("mousemove", this.onMouseMoveBound);
     }
+    window.addEventListener("keydown", this.onKeyDownBound);
+    window.addEventListener("keyup", this.onKeyUpBound);
+    window.addEventListener("blur", this.onBlurBound);
+  }
+  unbindInput() {
+    this.dom.removeEventListener("click", this.onClickBound);
+    window.removeEventListener("mousemove", this.onMouseMoveBound);
+    window.removeEventListener("keydown", this.onKeyDownBound);
+    window.removeEventListener("keyup", this.onKeyUpBound);
+    window.removeEventListener("blur", this.onBlurBound);
+  }
+  onClick() {
+    if (!this.usePointerLock) return;
+    if (document.pointerLockElement !== this.dom) this.dom.requestPointerLock();
+  }
+  onBlur() {
     this.keys.clear();
-  };
-  onMouseMove = (e) => {
-    if (this.usePointerLock && document.pointerLockElement !== this.dom) return;
+    this.moveVec.set(0, 0);
+  }
+  onMouseMove(e) {
+    if (!this.usePointerLock) return;
+    if (document.pointerLockElement !== this.dom) return;
     this.yaw -= e.movementX * this.lookSensitivity;
     this.pitch -= e.movementY * this.lookSensitivity;
     this.pitch = THREE.MathUtils.clamp(
@@ -163,171 +188,86 @@ var WalkCapsuleController = class {
     this.camera.quaternion.setFromEuler(
       new THREE.Euler(this.pitch, this.yaw, 0, "YXZ")
     );
-  };
-  onKeyDown = (e) => {
+  }
+  onKeyDown(e) {
     this.keys.add(e.key.toLowerCase());
-  };
-  onKeyUp = (e) => {
+  }
+  onKeyUp(e) {
     this.keys.delete(e.key.toLowerCase());
-  };
-  onTouchStart = (e) => {
-    const t = e.touches[0];
-    this.lastTouchX = t.clientX;
-    this.lastTouchY = t.clientY;
-  };
-  onTouchMove = (e) => {
-    const t = e.touches[0];
-    const deltaX = t.clientX - this.lastTouchX;
-    const deltaY = t.clientY - this.lastTouchY;
-    this.lastTouchX = t.clientX;
-    this.lastTouchY = t.clientY;
-    this.yaw -= deltaX * 2e-3;
-    this.pitch -= deltaY * 2e-3;
-    this.pitch = Math.max(-Math.PI / 2, Math.min(Math.PI / 2, this.pitch));
-    this.camera.quaternion.setFromEuler(
-      new THREE.Euler(this.pitch, this.yaw, 0, "YXZ")
-    );
-  };
-  startGyro() {
-    this.useGyro = true;
-    window.addEventListener("deviceorientation", (e) => {
-      if (!e.alpha || !e.beta) return;
-      this.gyroAlpha = THREE.MathUtils.degToRad(e.alpha);
-      this.gyroBeta = THREE.MathUtils.degToRad(e.beta);
-      this.gyroGamma = THREE.MathUtils.degToRad(e.gamma ?? 0);
-    });
   }
-  // --------------------------------------------------
-  // Update loop
-  // --------------------------------------------------
-  update(dt) {
-    if (this.useGyro) {
-      this.yaw = THREE.MathUtils.lerp(this.yaw, -this.gyroAlpha, 0.1);
-      this.pitch = THREE.MathUtils.lerp(
-        this.pitch,
-        this.gyroBeta - Math.PI / 2,
-        0.1
-      );
-      this.camera.quaternion.setFromEuler(
-        new THREE.Euler(this.pitch, this.yaw, 0, "YXZ")
-      );
-    }
-    if (!Number.isFinite(this.camera.position.y)) return;
-    dt = Math.min(dt, 0.05);
-    const forward = new THREE.Vector3();
-    this.camera.getWorldDirection(forward);
-    forward.y = 0;
-    if (forward.lengthSq() < 0.01) {
-      forward.set(0, 0, -1).applyQuaternion(new THREE.Quaternion().setFromEuler(new THREE.Euler(0, this.yaw, 0)));
-    }
-    forward.normalize();
-    const right = new THREE.Vector3().crossVectors(forward, new THREE.Vector3(0, 1, 0)).normalize();
+  // ---------------------------
+  // Update
+  // ---------------------------
+  update(_dt) {
+    const forward = new THREE.Vector3(0, 0, -1).applyAxisAngle(
+      new THREE.Vector3(0, 1, 0),
+      this.yaw
+    );
+    const right = new THREE.Vector3(1, 0, 0).applyAxisAngle(
+      new THREE.Vector3(0, 1, 0),
+      this.yaw
+    );
     const wish = new THREE.Vector3();
     if (this.keys.has("w")) wish.add(forward);
     if (this.keys.has("s")) wish.sub(forward);
     if (this.keys.has("d")) wish.add(right);
     if (this.keys.has("a")) wish.sub(right);
-    if (this.externalMove.lengthSq() > 0) {
-      wish.addScaledVector(forward, this.externalMove.x);
-      wish.addScaledVector(right, this.externalMove.y);
-    }
-    if (wish.lengthSq() > 0) wish.normalize();
-    const speed = this.walkSpeed * (this.keys.has("shift") ? this.runMultiplier : 1);
-    this.velocity.x = wish.x * speed;
-    this.velocity.z = wish.z * speed;
-    this.velocity.y -= this.gravity * dt;
-    const nextPos = this.camera.position.clone();
-    nextPos.x += this.velocity.x * dt;
-    nextPos.z += this.velocity.z * dt;
-    nextPos.y += this.velocity.y * dt;
-    const resolved = this.resolveGroundAndCollisions(nextPos);
-    this.camera.position.copy(resolved);
-  }
-  snapToGround() {
-    const origin = this.camera.position.clone();
-    origin.y += 5;
-    this.raycaster.set(origin, new THREE.Vector3(0, -1, 0));
-    this.raycaster.far = 50;
-    const hits = this.raycaster.intersectObjects(this.colliders, true);
-    for (const hit of hits) {
-      if (!hit.face) continue;
-      const normalMatrix = new THREE.Matrix3().getNormalMatrix(
-        hit.object.matrixWorld
-      );
-      const worldNormal = hit.face.normal.clone().applyMatrix3(normalMatrix).normalize();
-      if (worldNormal.y > 0.5) {
-        this.lastGroundY = hit.point.y;
-        this.camera.position.y = this.lastGroundY + this.eyeHeight;
-        this.velocity.y = 0;
-        this.onGround = true;
-        return;
-      }
+    if (this.moveVec.lengthSq() > 1e-6) {
+      wish.addScaledVector(forward, this.moveVec.x);
+      wish.addScaledVector(right, this.moveVec.y);
     }
-    this.lastGroundY = this.camera.position.y - this.eyeHeight;
-  }
-  // --------------------------------------------------
-  // Collision & Ground
-  // --------------------------------------------------
-  resolveGroundAndCollisions(desiredCamPos) {
-    const camPos = desiredCamPos.clone();
-    const maxRayDown = 20;
-    const origin = camPos.clone();
-    origin.y += 5;
-    this.raycaster.set(origin, new THREE.Vector3(0, -1, 0));
-    this.raycaster.near = 0;
-    this.raycaster.far = maxRayDown;
-    const hits = this.raycaster.intersectObjects(this.colliders, true);
-    let groundHit = null;
-    for (const hit of hits) {
-      if (!hit.face) continue;
-      const normalMatrix = new THREE.Matrix3().getNormalMatrix(
-        hit.object.matrixWorld
-      );
-      const worldNormal = hit.face.normal.clone().applyMatrix3(normalMatrix).normalize();
-      if (worldNormal.y > 0.5) {
-        groundHit = hit;
-        break;
+    if (wish.lengthSq() > 1e-8) wish.normalize();
+    const vel = this.body.linvel();
+    const targetVX = wish.x * this.moveSpeed;
+    const targetVZ = wish.z * this.moveSpeed;
+    this.body.setLinvel(
+      {
+        x: targetVX,
+        y: vel.y,
+        z: targetVZ
+      },
+      true
+      // wake up
+    );
+    if (this.keys.has(" ")) {
+      if (this.isGrounded()) {
+        this.body.setLinvel(
+          { x: targetVX, y: this.jumpSpeed, z: targetVZ },
+          true
+        );
       }
     }
-    if (groundHit) {
-      const groundY = groundHit.point.y;
-      const targetY = groundY + this.eyeHeight;
-      this.lastGroundY = groundY;
-      const falling = this.velocity.y <= 0;
-      const maxSnap = 1;
-      if (falling && camPos.y <= targetY + maxSnap) {
-        camPos.y = targetY;
-        this.velocity.y = 0;
-        this.onGround = true;
-      } else {
-        this.onGround = false;
-      }
-    } else {
-      if (this.lastGroundY !== null) {
-        camPos.y = this.lastGroundY + this.eyeHeight;
-        this.velocity.y = 0;
-        this.onGround = true;
-      } else {
-        this.onGround = false;
+    const p = this.body.translation();
+    const feetY = p.y - (this.halfHeight + this.radius);
+    this.camera.position.set(p.x, feetY + this.eyeHeight, p.z);
+  }
+  // ---------------------------
+  // Grounding
+  // ---------------------------
+  isGrounded() {
+    const p = this.body.translation();
+    const origin = { x: p.x, y: p.y, z: p.z };
+    const dir = { x: 0, y: -1, z: 0 };
+    const ray = new RAPIER.Ray(origin, dir);
+    const maxDist = this.halfHeight + this.radius + this.groundProbeExtra;
+    const hit = this.castRayWithNormal(ray, maxDist);
+    if (!hit) return false;
+    const ny = hit.normal?.y ?? 0;
+    return ny > 0.35;
+  }
+  // Ray cast helper with “exclude self” when possible
+  castRayWithNormal(ray, maxDist) {
+    const anyRapier = RAPIER;
+    try {
+      if (anyRapier.QueryFilter) {
+        const filter = new anyRapier.QueryFilter();
+        if (filter.excludeCollider) filter.excludeCollider(this.collider);
+        else if (filter.excludeRigidBody) filter.excludeRigidBody(this.body);
+        return this.world.castRayAndGetNormal(ray, maxDist, true, filter);
       }
+    } catch {
     }
-    const center = camPos.clone();
-    center.y -= this.eyeHeight * 0.9;
-    const dirs = [
-      new THREE.Vector3(1, 0, 0),
-      new THREE.Vector3(-1, 0, 0),
-      new THREE.Vector3(0, 0, 1),
-      new THREE.Vector3(0, 0, -1)
-    ];
-    for (const d of dirs) {
-      this.raycaster.set(center, d);
-      this.raycaster.far = this.radius + 0.25;
-      const wallHits = this.raycaster.intersectObjects(this.colliders, true);
-      if (!wallHits.length) continue;
-      const overlap = this.radius + 0.25 - wallHits[0].distance;
-      if (overlap > 0) camPos.addScaledVector(d, -overlap);
-    }
-    return camPos;
+    return this.world.castRayAndGetNormal(ray, maxDist, true);
   }
 };
 
@@ -904,78 +844,255 @@ var MeasurementController = class {
   }
 };
 
+// src/viewers/three/controls/FloorplanController.ts
+import * as THREE4 from "three";
+var FloorplanController = class {
+  dom;
+  camera;
+  target;
+  height;
+  panSpeed;
+  zoomSpeed;
+  minHeight;
+  maxHeight;
+  isDragging = false;
+  lastX = 0;
+  lastY = 0;
+  // touch
+  touchMode = "none";
+  lastDist = 0;
+  constructor(opts) {
+    this.dom = opts.dom;
+    this.camera = opts.camera;
+    this.target = opts.target.clone();
+    this.height = opts.height;
+    this.panSpeed = opts.panSpeed ?? 0.01;
+    this.zoomSpeed = opts.zoomSpeed ?? 1.1;
+    this.minHeight = opts.minHeight ?? opts.height * 0.25;
+    this.maxHeight = opts.maxHeight ?? opts.height * 3;
+    this.applyCamera();
+    this.bind();
+  }
+  dispose() {
+    this.unbind();
+  }
+  update(_dt) {
+    this.applyCamera();
+  }
+  setTarget(t) {
+    this.target.copy(t);
+    this.applyCamera();
+  }
+  applyCamera() {
+    this.height = THREE4.MathUtils.clamp(
+      this.height,
+      this.minHeight,
+      this.maxHeight
+    );
+    this.camera.position.set(
+      this.target.x,
+      this.target.y + this.height,
+      this.target.z
+    );
+    this.camera.up.set(0, 0, -1);
+    this.camera.lookAt(this.target);
+  }
+  bind() {
+    this.dom.addEventListener("contextmenu", (e) => e.preventDefault());
+    this.dom.addEventListener("mousedown", this.onMouseDown);
+    window.addEventListener("mousemove", this.onMouseMove);
+    window.addEventListener("mouseup", this.onMouseUp);
+    this.dom.addEventListener("wheel", this.onWheel, { passive: false });
+    this.dom.addEventListener("touchstart", this.onTouchStart, {
+      passive: false
+    });
+    this.dom.addEventListener("touchmove", this.onTouchMove, {
+      passive: false
+    });
+    this.dom.addEventListener("touchend", this.onTouchEnd);
+  }
+  unbind() {
+    this.dom.removeEventListener("mousedown", this.onMouseDown);
+    window.removeEventListener("mousemove", this.onMouseMove);
+    window.removeEventListener("mouseup", this.onMouseUp);
+    this.dom.removeEventListener("wheel", this.onWheel);
+    this.dom.removeEventListener("touchstart", this.onTouchStart);
+    this.dom.removeEventListener("touchmove", this.onTouchMove);
+    this.dom.removeEventListener("touchend", this.onTouchEnd);
+  }
+  onMouseDown = (e) => {
+    if (e.button !== 0) return;
+    this.isDragging = true;
+    this.lastX = e.clientX;
+    this.lastY = e.clientY;
+  };
+  onMouseUp = () => {
+    this.isDragging = false;
+  };
+  onMouseMove = (e) => {
+    if (!this.isDragging) return;
+    const dx = e.clientX - this.lastX;
+    const dy = e.clientY - this.lastY;
+    this.lastX = e.clientX;
+    this.lastY = e.clientY;
+    this.target.x -= dx * this.panSpeed * this.height;
+    this.target.z += dy * this.panSpeed * this.height;
+    this.applyCamera();
+  };
+  onWheel = (e) => {
+    e.preventDefault();
+    const factor = Math.pow(this.zoomSpeed, e.deltaY / 100);
+    this.height *= factor;
+    this.applyCamera();
+  };
+  onTouchStart = (e) => {
+    if (e.touches.length === 1) {
+      this.touchMode = "pan";
+      this.lastX = e.touches[0].clientX;
+      this.lastY = e.touches[0].clientY;
+    } else if (e.touches.length === 2) {
+      this.touchMode = "pinch";
+      this.lastDist = this.touchDistance(e.touches[0], e.touches[1]);
+    }
+  };
+  onTouchMove = (e) => {
+    e.preventDefault();
+    if (this.touchMode === "pan" && e.touches.length === 1) {
+      const x = e.touches[0].clientX;
+      const y = e.touches[0].clientY;
+      const dx = x - this.lastX;
+      const dy = y - this.lastY;
+      this.lastX = x;
+      this.lastY = y;
+      this.target.x -= dx * this.panSpeed * this.height;
+      this.target.z += dy * this.panSpeed * this.height;
+      this.applyCamera();
+    }
+    if (this.touchMode === "pinch" && e.touches.length === 2) {
+      const dist = this.touchDistance(e.touches[0], e.touches[1]);
+      const ratio = this.lastDist / Math.max(1e-6, dist);
+      this.lastDist = dist;
+      this.height *= ratio;
+      this.applyCamera();
+    }
+  };
+  onTouchEnd = () => {
+    this.touchMode = "none";
+  };
+  touchDistance(a, b) {
+    const dx = a.clientX - b.clientX;
+    const dy = a.clientY - b.clientY;
+    return Math.sqrt(dx * dx + dy * dy);
+  }
+};
+
 // src/viewers/three/pgsg-three-viewer.ts
 var PGSGThreeViewer = class {
   constructor(options) {
     this.options = options;
     this.container = options.container;
-    this.options = options;
-    if (!this.container) {
+    if (!this.container)
       throw new Error("[PGSGThreeViewer] Container is required");
-    }
   }
-  scene = new THREE4.Scene();
+  scene = new THREE5.Scene();
   camera;
   renderer;
   splats;
+  gltfLoader = new GLTFLoader();
+  pendingPlacementUrl;
+  ghostModel;
+  raycaster = new THREE5.Raycaster();
+  mouse = new THREE5.Vector2();
+  placementRotation = 0;
+  transformControls;
   container;
   resizeObserver = null;
   controls;
   running = false;
-  orbitTarget = new THREE4.Vector3();
+  orbitTarget = new THREE5.Vector3();
   lastTime = performance.now();
-  colliders = [];
   persistentMeasurements = [];
   measurementController = null;
-  worldRoot = new THREE4.Object3D();
-  splatPivot = new THREE4.Object3D();
+  world;
+  // Roots
+  worldRoot = new THREE5.Object3D();
+  // identity
+  cvRoot = new THREE5.Object3D();
+  // ONLY place where we convert OpenCV->OpenGL
+  splatPivot = new THREE5.Object3D();
   colliderMesh;
-  modeButton;
+  // For raycasting / measurement only
+  colliderMeshes = [];
+  currentMode = "orbit";
+  acc = 0;
+  fixedDt = 1 / 60;
+  GLOBAL_SCALE = 0.7;
   async load() {
     this.initRenderer();
     this.initCamera();
     this.initScene();
     this.bindResize();
     this.resize();
+    this.transformControls = new TransformControls(
+      this.camera,
+      this.renderer.domElement
+    );
+    this.scene.add(this.transformControls);
+    console.log(this.transformControls instanceof THREE5.Object3D);
+    this.transformControls.addEventListener("dragging-changed", (event) => {
+      if (!this.controls) return;
+      this.controls.enabled = !event.value;
+    });
+    this.transformControls.addEventListener("mouseDown", () => {
+      document.exitPointerLock?.();
+    });
+    await RAPIER2.init();
+    this.world = new RAPIER2.World({
+      x: 0,
+      y: -9.81 * this.GLOBAL_SCALE,
+      z: 0
+    });
     this.scene.add(this.worldRoot);
+    this.cvRoot.scale.set(1, -1, -1);
+    this.worldRoot.add(this.cvRoot);
     this.splats = new SparkSplatRenderer();
-    const { mesh, bounds } = await this.splats.load(this.options.source);
+    const { mesh } = await this.splats.load(this.options.source);
     this.splatPivot.clear();
     this.splatPivot.add(mesh);
-    this.worldRoot.add(this.splatPivot);
-    this.worldRoot.rotation.x = Math.PI;
-    this.worldRoot.updateMatrixWorld(true);
+    this.cvRoot.add(this.splatPivot);
     if (this.options.colliderSource) {
       await this.loadCollider(this.options.colliderSource);
     }
-    this.scene.updateMatrixWorld(true);
+    this.cvRoot.updateMatrixWorld(true);
+    this.placeInitialCamera();
     if (this.isMobile()) {
       this.initJoystick();
-      this.initModeToggle();
       this.switchToWalk();
-      this.updateModeLabel("WALK");
-      const walk = this.controls;
-      window.addEventListener(
-        "keydown",
-        (e) => {
-          if (e.key === "g") {
-            walk.enableGyro();
-          }
-        },
-        { once: true }
-      );
     } else {
       this.switchToMeasure();
     }
     window.addEventListener("keydown", this.onKeyToggle);
+    window.addEventListener("keydown", (e) => {
+      if (!this.transformControls) return;
+      if (e.key === "r") this.transformControls.setMode("rotate");
+      if (e.key === "t") this.transformControls.setMode("translate");
+      if (e.key === "s") this.transformControls.setMode("scale");
+    });
+    this.renderer.domElement.addEventListener("click", this.onSceneClick);
   }
   start() {
     if (this.running) return;
     this.running = true;
-    this.renderer.setAnimationLoop((time) => {
+    this.renderer.setAnimationLoop(() => {
       const now = performance.now();
       const delta = (now - this.lastTime) / 1e3;
       this.lastTime = now;
+      this.acc += delta;
+      while (this.acc >= this.fixedDt) {
+        this.world.timestep = this.fixedDt;
+        this.world.step();
+        this.acc -= this.fixedDt;
+      }
       this.controls?.update?.(delta);
       this.renderer.render(this.scene, this.camera);
     });
@@ -994,55 +1111,121 @@ var PGSGThreeViewer = class {
   destroy() {
     this.running = false;
     this.renderer.setAnimationLoop(null);
+    this.renderer.domElement.removeEventListener("click", this.onSceneClick);
     this.resizeObserver?.disconnect();
     this.resizeObserver = null;
     this.controls?.dispose();
     this.renderer.dispose();
+    window.removeEventListener("keydown", this.onKeyToggle);
   }
   setCameraMode(mode) {
-    console.log("[PGSGThreeViewer] setCameraMode:", mode);
+    this.currentMode = mode;
     if (this.controls instanceof MeasurementController) {
       this.persistentMeasurements = this.controls.measurements;
       this.controls.setVisible(false);
     }
     switch (mode) {
       case "measure":
-        document.exitPointerLock();
+        document.exitPointerLock?.();
         this.switchToMeasure();
-        if (this.controls instanceof MeasurementController) {
+        if (this.controls instanceof MeasurementController)
           this.controls.setVisible(true);
-        }
         break;
       case "orbit":
-        document.exitPointerLock();
+        document.exitPointerLock?.();
         this.switchToOrbit();
         break;
       case "walk":
         this.switchToWalk();
         break;
-      default:
-        this.switchToMeasure();
+      case "floorplan":
+        this.switchToFloorplan();
         break;
     }
   }
   toggleCameraMode() {
-    if (this.controls instanceof WalkCapsuleController) {
-      this.switchToOrbit();
-      this.updateModeLabel("ORBIT");
-    } else {
-      this.switchToWalk();
-      this.updateModeLabel("WALK");
-    }
+    if (this.controls instanceof RapierWalkController) this.switchToOrbit();
+    else this.switchToWalk();
+  }
+  getMeasurements() {
+    return this.measurementController?.getMeasurements?.() ?? [];
+  }
+  clearMeasurements() {
+    if (!this.measurementController) return;
+    this.measurementController.clearAll();
+    this.persistentMeasurements = [];
+  }
+  finalizePolyline() {
+    if (this.controls instanceof MeasurementController)
+      this.controls.finalizePolyline();
   }
+  deleteMeasurement(index) {
+    this.measurementController?.deleteMeasurement?.(index);
+  }
+  async enablePlacementMode(url) {
+    this.pendingPlacementUrl = url;
+    this.placementRotation = 0;
+    console.log("[PGSG Viewer] Placement mode enabled");
+    const gltf = await this.gltfLoader.loadAsync(url);
+    this.ghostModel = gltf.scene;
+    const box = new THREE5.Box3().setFromObject(this.ghostModel);
+    const size = new THREE5.Vector3();
+    box.getSize(size);
+    const maxDim = Math.max(size.x, size.y, size.z);
+    const scale = 1.5 / maxDim;
+    this.ghostModel.scale.multiplyScalar(scale);
+    this.ghostModel.traverse((child) => {
+      if (!child.isMesh) return;
+      child.material = child.material.clone();
+      child.material.transparent = true;
+      child.material.opacity = 0.4;
+    });
+    this.scene.add(this.ghostModel);
+    this.renderer.domElement.addEventListener(
+      "mousemove",
+      this.onPlacementMove
+    );
+    this.renderer.domElement.addEventListener("wheel", this.onPlacementWheel);
+    this.renderer.domElement.addEventListener("click", this.onSceneClick);
+    window.addEventListener("keydown", this.onPlacementCancel);
+  }
+  async addModelFromUrl(url, position) {
+    return new Promise((resolve, reject) => {
+      this.gltfLoader.load(
+        url,
+        (gltf) => {
+          const model = gltf.scene;
+          const box = new THREE5.Box3().setFromObject(model);
+          const size = new THREE5.Vector3();
+          box.getSize(size);
+          const maxDim = Math.max(size.x, size.y, size.z);
+          const scale = 1.5 / maxDim;
+          model.scale.multiplyScalar(scale);
+          if (position) {
+            model.position.copy(position);
+          }
+          const floorBox = new THREE5.Box3().setFromObject(model);
+          model.position.y -= floorBox.min.y;
+          this.cvRoot.add(model);
+          resolve(model);
+        },
+        void 0,
+        reject
+      );
+    });
+  }
+  // ---------------------------
+  // Init
+  // ---------------------------
   initRenderer() {
     if (this.renderer) return;
-    this.renderer = new THREE4.WebGLRenderer({
+    this.renderer = new THREE5.WebGLRenderer({
       antialias: this.options.renderer?.antialias ?? false,
       alpha: false,
       powerPreference: "high-performance"
     });
     this.renderer.setClearColor(1118481, 1);
-    this.renderer.outputColorSpace = THREE4.SRGBColorSpace;
+    this.renderer.outputColorSpace = THREE5.SRGBColorSpace;
     this.renderer.setSize(
       this.container.clientWidth,
       this.container.clientHeight
@@ -1050,21 +1233,17 @@ var PGSGThreeViewer = class {
     this.renderer.setPixelRatio(
       this.options.renderer?.pixelRatio ?? window.devicePixelRatio
     );
+    this.renderer.localClippingEnabled = true;
     this.container.appendChild(this.renderer.domElement);
-    this.renderer.domElement.addEventListener("webglcontextlost", (e) => {
-      e.preventDefault();
-      console.log("[PGSG Viewer] WebGL context lost");
-    });
   }
   initScene() {
-    this.scene = new THREE4.Scene();
-    this.scene.background = new THREE4.Color(1118481);
-    const gridHelper = new THREE4.GridHelper(10, 10);
-    const light = new THREE4.HemisphereLight(16777215, 2236962, 1);
+    this.scene = new THREE5.Scene();
+    this.scene.background = new THREE5.Color(1118481);
+    const light = new THREE5.HemisphereLight(16777215, 2236962, 1);
     this.scene.add(light);
   }
   initCamera() {
-    this.camera = new THREE4.PerspectiveCamera(
+    this.camera = new THREE5.PerspectiveCamera(
       this.options.camera?.fov ?? 60,
       this.container.clientWidth / this.container.clientHeight,
       this.options.camera?.near ?? 0.01,
@@ -1073,109 +1252,105 @@ var PGSGThreeViewer = class {
     this.camera.position.set(2, 2, 5);
     this.camera.lookAt(0, 0, 0);
   }
-  initJoystick() {
-    const zone = document.createElement("div");
-    zone.style.position = "absolute";
-    zone.style.left = "20px";
-    zone.style.bottom = "20px";
-    zone.style.width = "150px";
-    zone.style.height = "150px";
-    zone.style.zIndex = "1000";
-    this.container.appendChild(zone);
-    const joystick = nipplejs.create({
-      zone,
-      mode: "static",
-      position: { left: "50px", bottom: "50px" },
-      color: "white"
-    });
-    joystick.on("move", (_, data) => {
-      const angle = data.angle.radian;
-      const force = data.force;
-      if (this.controls instanceof WalkCapsuleController || this.controls instanceof OrbitCameraController) {
-        this.controls.setMovementVector(
-          Math.sin(angle) * force,
-          Math.cos(angle) * force
-        );
-      }
-    });
-    joystick.on("end", () => {
-      if (this.controls instanceof WalkCapsuleController || this.controls instanceof OrbitCameraController) {
-        this.controls.setMovementVector(0, 0);
-      }
-    });
-  }
-  initModeToggle() {
-  }
-  updateModeLabel(mode) {
-    if (!this.modeButton) return;
-    this.modeButton.innerText = mode;
-  }
   bindResize() {
     this.resizeObserver?.disconnect();
     this.resizeObserver = new ResizeObserver(() => this.resize());
     this.resizeObserver.observe(this.container);
   }
+  isMobile() {
+    return "ontouchstart" in window || navigator.maxTouchPoints > 0 || window.innerWidth < 768;
+  }
+  // ---------------------------
+  // Collider (visual + rapier)
+  // ---------------------------
   async loadCollider(url) {
     console.log("[PGSG Viewer] Loading collider:", url);
     const loader = new GLTFLoader();
     const gltf = await loader.loadAsync(url);
-    this.colliderMesh = gltf.scene;
-    this.worldRoot.add(this.colliderMesh);
-    this.colliders.length = 0;
-    this.colliderMesh.traverse((child) => {
-      if (child.isMesh) {
-        child.material = new THREE4.MeshBasicMaterial({
-          visible: false,
-          side: THREE4.DoubleSide
-        });
-        child.updateMatrixWorld(true);
-        this.colliders.push(child);
+    const colliderRoot = new THREE5.Object3D();
+    colliderRoot.name = "colliderRoot";
+    colliderRoot.add(gltf.scene);
+    this.colliderMesh = colliderRoot;
+    this.cvRoot.add(colliderRoot);
+    this.cvRoot.updateMatrixWorld(true);
+    colliderRoot.updateWorldMatrix(true, true);
+    this.colliderMeshes.length = 0;
+    colliderRoot.traverse((child) => {
+      if (!child?.isMesh) return;
+      const geom = child.geometry.clone();
+      child.updateWorldMatrix(true, false);
+      geom.applyMatrix4(child.matrixWorld);
+      const vertices = new Float32Array(geom.attributes.position.array);
+      let indices;
+      if (geom.index) indices = new Uint32Array(geom.index.array);
+      else {
+        const count = geom.attributes.position.count;
+        indices = new Uint32Array(count);
+        for (let i = 0; i < count; i++) indices[i] = i;
       }
+      const rb = this.world.createRigidBody(RAPIER2.RigidBodyDesc.fixed());
+      const cd = RAPIER2.ColliderDesc.trimesh(vertices, indices);
+      cd.setFriction(0.9);
+      cd.setRestitution(0);
+      this.world.createCollider(cd, rb);
+      this.colliderMeshes.push(child);
     });
-    console.log("[PGSG Viewer] Colliders loaded:", this.colliders.length);
-    this.worldRoot.updateMatrixWorld(true);
-  }
-  isMobile() {
-    return "ontouchstart" in window || navigator.maxTouchPoints > 0 || window.innerWidth < 768;
+    const rawBox = new THREE5.Box3().setFromObject(colliderRoot);
+    console.log("OpenGL bounds Y:", rawBox.min.y, rawBox.max.y);
+    console.log("[PGSG Viewer] Colliders loaded:", this.colliderMeshes.length);
   }
+  // ---------------------------
+  // Mode switching
+  // ---------------------------
   onKeyToggle = (e) => {
     if (e.key !== "v") return;
-    if (this.controls instanceof WalkCapsuleController) {
-      this.switchToOrbit();
-    } else {
-      this.switchToWalk();
-    }
+    if (this.controls instanceof RapierWalkController) this.switchToOrbit();
+    else this.switchToWalk();
   };
   switchToMeasure() {
-    this.controls?.dispose();
+    this.controls?.dispose?.();
     this.measurementController = new MeasurementController({
       dom: this.renderer.domElement,
       camera: this.camera,
       scene: this.scene,
-      colliders: this.colliders
+      colliders: this.colliderMeshes
     });
-    this.measurementController.restoreMeasurements(this.persistentMeasurements);
+    this.measurementController.restoreMeasurements?.(
+      this.persistentMeasurements
+    );
     this.controls = this.measurementController;
   }
   switchToWalk() {
-    this.controls?.dispose();
-    const walk = new WalkCapsuleController({
+    this.controls?.dispose?.();
+    const walk = new RapierWalkController({
       camera: this.camera,
       dom: this.renderer.domElement,
-      colliders: this.colliders,
+      world: this.world,
       eyeHeight: 1.6,
-      radius: 0.35,
-      walkSpeed: 2.5,
-      runMultiplier: 2,
-      gravity: 9.8,
+      radius: 0.2,
+      halfHeight: 0.6,
+      moveSpeed: 3 * this.GLOBAL_SCALE,
+      jumpSpeed: 6 * this.GLOBAL_SCALE,
       usePointerLock: !this.isMobile()
     });
     this.controls = walk;
-    walk.snapToGround();
+    const euler = new THREE5.Euler().setFromQuaternion(
+      this.camera.quaternion,
+      "YXZ"
+    );
+    walk.setRotation(euler.y, euler.x);
+    walk.setPositionFromCamera();
+    walk.resetVelocity();
+    walk.snapToGround?.();
   }
   switchToOrbit() {
-    this.controls?.dispose();
-    const distance = 5;
+    this.controls?.dispose?.();
+    this.camera.up.set(0, 1, 0);
+    this.camera.updateMatrixWorld(true);
+    const box = new THREE5.Box3().setFromObject(this.cvRoot);
+    const center = box.getCenter(new THREE5.Vector3());
+    this.orbitTarget.copy(center);
+    const distance = Math.max(this.camera.position.distanceTo(center), 1);
     this.controls = new OrbitCameraController(
       this.camera,
       this.renderer.domElement,
@@ -1186,30 +1361,199 @@ var PGSGThreeViewer = class {
       }
     );
   }
-  getMeasurements() {
-    if (this.measurementController) {
-      return this.measurementController.getMeasurements();
-    }
-    return [];
+  switchToFloorplan() {
+    this.controls?.dispose?.();
+    const box = new THREE5.Box3().setFromObject(this.cvRoot);
+    const center = box.getCenter(new THREE5.Vector3());
+    const size = box.getSize(new THREE5.Vector3());
+    const height = Math.max(size.x, size.z) * 1.2;
+    this.orbitTarget.copy(center);
+    this.controls = new FloorplanController({
+      dom: this.renderer.domElement,
+      camera: this.camera,
+      target: center,
+      height,
+      panSpeed: 15e-4,
+      zoomSpeed: 1.15
+    });
   }
-  clearMeasurements() {
-    if (this.measurementController) {
-      this.measurementController.clearAll();
-      this.persistentMeasurements = [];
+  // ---------------------------
+  // Spawn
+  // ---------------------------
+  placeInitialCamera() {
+    const targetObj = this.colliderMesh ?? this.cvRoot;
+    const box = new THREE5.Box3().setFromObject(targetObj);
+    const center = box.getCenter(new THREE5.Vector3());
+    const size = box.getSize(new THREE5.Vector3());
+    const startY = box.max.y + 10;
+    const maxDist = box.max.y - box.min.y + 50;
+    const samples = [];
+    const sx = Math.max(0.2, size.x * 0.15);
+    const sz = Math.max(0.2, size.z * 0.15);
+    for (const dx of [-sx, 0, sx]) {
+      for (const dz of [-sz, 0, sz]) {
+        samples.push({ x: center.x + dx, z: center.z + dz });
+      }
     }
-  }
-  finalizePolyline() {
-    if (this.controls instanceof MeasurementController) {
-      this.controls.finalizePolyline();
+    let bestFloorY = null;
+    let bestXZ = null;
+    for (const s of samples) {
+      const hits = this.raycastDownMulti(s.x, s.z, startY, maxDist, 10);
+      if (hits.length === 0) continue;
+      let candidate = null;
+      for (let i = 1; i < hits.length; i++) {
+        const h = hits[i];
+        if (Math.abs(h.normalY) < 0.55) continue;
+        candidate = h;
+      }
+      if (!candidate) continue;
+      if (bestFloorY == null || candidate.y > bestFloorY) {
+        bestFloorY = candidate.y;
+        bestXZ = s;
+      }
     }
-  }
-  deleteMeasurement(index) {
-    if (this.measurementController) {
-      this.measurementController.deleteMeasurement(index);
+    const eye = 1.6;
+    if (bestFloorY != null && bestXZ) {
+      this.camera.position.set(bestXZ.x, bestFloorY + eye, bestXZ.z + 0.5);
+      this.orbitTarget.set(bestXZ.x, bestFloorY, bestXZ.z);
+    } else {
+      this.camera.position.set(center.x, box.max.y + eye, center.z + 2);
+      this.orbitTarget.copy(center);
     }
+    this.camera.up.set(0, 1, 0);
+    this.camera.lookAt(this.orbitTarget);
+    this.camera.updateMatrixWorld(true);
+  }
+  getWorldNormalSafe(hit) {
+    if (!hit.face) return null;
+    const m3 = new THREE5.Matrix3().getNormalMatrix(hit.object.matrixWorld);
+    return hit.face.normal.clone().applyMatrix3(m3).normalize();
+  }
+  // ---------------------------
+  // Mobile joystick
+  // ---------------------------
+  initJoystick() {
+    const zone = document.createElement("div");
+    zone.style.position = "absolute";
+    zone.style.left = "20px";
+    zone.style.bottom = "20px";
+    zone.style.width = "150px";
+    zone.style.height = "150px";
+    zone.style.zIndex = "1000";
+    this.container.appendChild(zone);
+    const joystick = nipplejs.create({
+      zone,
+      mode: "static",
+      position: { left: "50px", bottom: "50px" },
+      color: "white"
+    });
+    joystick.on("move", (_, data) => {
+      const angle = data.angle.radian;
+      const force = data.force;
+      if (this.controls instanceof RapierWalkController || this.controls instanceof OrbitCameraController) {
+        this.controls.setMovementVector(
+          Math.sin(angle) * force,
+          Math.cos(angle) * force
+        );
+      }
+    });
+    joystick.on("end", () => {
+      if (this.controls instanceof RapierWalkController || this.controls instanceof OrbitCameraController) {
+        this.controls.setMovementVector(0, 0);
+      }
+    });
   }
+  raycastDownMulti(x, z, startY, maxDist, maxHits = 8) {
+    const hits = [];
+    let originY = startY;
+    let remaining = maxDist;
+    for (let i = 0; i < maxHits; i++) {
+      const ray = new RAPIER2.Ray({ x, y: originY, z }, { x: 0, y: -1, z: 0 });
+      const hit = this.world.castRayAndGetNormal(ray, remaining, true);
+      if (!hit) break;
+      const y = originY - hit.timeOfImpact;
+      const normalY = hit.normal?.y ?? 0;
+      hits.push({ y, normalY });
+      const eps = 0.02;
+      originY = y - eps;
+      remaining = remaining - hit.timeOfImpact - eps;
+      if (remaining <= 0) break;
+    }
+    return hits;
+  }
+  onSceneClick = async (event) => {
+    if (!this.pendingPlacementUrl || !this.ghostModel) return;
+    const position = this.ghostModel.position.clone();
+    const placed = await this.addModelFromUrl(
+      this.pendingPlacementUrl,
+      position
+    );
+    if (placed && this.transformControls) {
+      placed.rotation.y = this.placementRotation;
+      this.transformControls.attach(placed);
+    }
+    this.scene.remove(this.ghostModel);
+    this.ghostModel = void 0;
+    this.pendingPlacementUrl = void 0;
+    this.renderer.domElement.removeEventListener(
+      "mousemove",
+      this.onPlacementMove
+    );
+    this.renderer.domElement.removeEventListener(
+      "wheel",
+      this.onPlacementWheel
+    );
+    this.renderer.domElement.removeEventListener("click", this.onSceneClick);
+    window.removeEventListener("keydown", this.onPlacementCancel);
+  };
+  onPlacementMove = (event) => {
+    if (!this.pendingPlacementUrl || !this.ghostModel) return;
+    const rect = this.renderer.domElement.getBoundingClientRect();
+    this.mouse.set(
+      (event.clientX - rect.left) / rect.width * 2 - 1,
+      -((event.clientY - rect.top) / rect.height) * 2 + 1
+    );
+    this.raycaster.setFromCamera(this.mouse, this.camera);
+    const intersects = this.raycaster.intersectObjects(
+      this.colliderMeshes,
+      true
+    );
+    if (!intersects.length) return;
+    const point = intersects[0].point;
+    this.ghostModel.position.copy(point);
+  };
+  onPlacementWheel = (event) => {
+    if (!this.ghostModel) return;
+    event.preventDefault();
+    const step = Math.PI / 12;
+    if (event.deltaY > 0) {
+      this.placementRotation += step;
+    } else {
+      this.placementRotation -= step;
+    }
+    this.ghostModel.rotation.y = this.placementRotation;
+  };
+  onPlacementCancel = (event) => {
+    if (event.key !== "Escape") return;
+    if (!this.ghostModel) return;
+    console.log("[PGSG Viewer] Placement cancelled");
+    this.scene.remove(this.ghostModel);
+    this.ghostModel = void 0;
+    this.pendingPlacementUrl = void 0;
+    this.renderer.domElement.style.cursor = "default";
+    this.renderer.domElement.removeEventListener(
+      "mousemove",
+      this.onPlacementMove
+    );
+    this.renderer.domElement.removeEventListener("click", this.onSceneClick);
+    this.renderer.domElement.removeEventListener(
+      "wheel",
+      this.onPlacementWheel
+    );
+    window.removeEventListener("keydown", this.onPlacementCancel);
+  };
 };
 export {
   PGSGThreeViewer
 };
-//# sourceMappingURL=pgsg-three-viewer-TOCXQMZQ.js.map
+//# sourceMappingURL=pgsg-three-viewer-KBOYGHT3.js.map