@seatlayer/core 0.50.0 → 0.50.1

package/dist/view3d/index.cjs

@@ -476,9 +476,9 @@ var OrbitCamera = class {
     const halfV = this.fovY * DEG / 2;
     const aspect = portraitCrop ? Math.max(0.82, this.camera.aspect || 1) : this.camera.aspect || 1;
     const halfH = Math.atan(Math.tan(halfV) * aspect);
-    const fit = Math.max(r / Math.tan(halfV), r / Math.tan(halfH));
     this.azT = stageAzimuth ?? -30 * DEG;
     this.polT = 55 * DEG;
+    const fit = this.fitDistance(bounds, halfV, halfH, this.azT, this.polT);
     this.distT = fit * FRAME_MARGIN;
     this.minDist = Math.max(2, r * 0.12);
     this.maxDist = fit * 4;
@@ -508,15 +508,59 @@ var OrbitCamera = class {
     this.panLimit = Math.max(1, bounds.radius) * 1.5;
     this.syncFromCamera();
     this.camera.perspective({ fov: this.fovY, aspect: this.camera.aspect });
-    const r = Math.max(1, bounds.radius);
     const halfV = this.fovY * DEG / 2;
     const aspect = portraitCrop ? Math.max(0.82, this.camera.aspect || 1) : this.camera.aspect || 1;
     const halfH = Math.atan(Math.tan(halfV) * aspect);
-    const fit = Math.max(r / Math.tan(halfV), r / Math.tan(halfH));
     this.azT = stageAzimuth ?? this.azimuth;
     this.polT = 55 * DEG;
+    const fit = this.fitDistance(bounds, halfV, halfH, this.azT, this.polT);
     this.distT = fit * FRAME_MARGIN;
   }
+  /**
+   * Distance from the bounds centre at which the venue fits the frustum at
+   * the given pose.
+   *
+   * Radius-only callers (section / zone / row focus) get the sphere fit —
+   * exact enough for chunky targets, and their radii are hand-tuned to it.
+   * When the caller supplies the venue's axis-aligned box, fit the box's
+   * PROJECTED corners instead: a flat banquet floor's enclosing sphere is
+   * nearly all horizontal extent, and sphere-fitting it backed the camera off
+   * until the venue used a fraction of the canvas. Each corner demands
+   * `lateral/tan(half-angle) − depth` of camera distance; the venue fits when
+   * every corner does. Clamped to the sphere fit (which always contains the
+   * box) and floored so a degenerate box cannot glue the camera to the floor.
+   */
+  fitDistance(bounds, halfV, halfH, azimuth, polar) {
+    const r = Math.max(1, bounds.radius);
+    const sphereFit = Math.max(r / Math.tan(halfV), r / Math.tan(halfH));
+    const box = bounds.box;
+    if (!box) return sphereFit;
+    const sp = Math.sin(polar);
+    const fx = -sp * Math.sin(azimuth);
+    const fy = -Math.cos(polar);
+    const fz = -sp * Math.cos(azimuth);
+    if (Math.abs(fy) > 0.999) return sphereFit;
+    let rx = -fz, rz = fx;
+    const rl = Math.hypot(rx, rz);
+    rx /= rl;
+    rz /= rl;
+    const ux = -rz * fy;
+    const uy = rz * fx - rx * fz;
+    const uz = rx * fy;
+    const tanH = Math.tan(halfH);
+    const tanV = Math.tan(halfV);
+    let fit = 1;
+    for (let i = 0; i < 8; i++) {
+      const px = (i & 1 ? box.max[0] : box.min[0]) - bounds.center[0];
+      const py = (i & 2 ? box.max[1] : box.min[1]) - bounds.center[1];
+      const pz = (i & 4 ? box.max[2] : box.min[2]) - bounds.center[2];
+      const depth = px * fx + py * fy + pz * fz;
+      const lx = Math.abs(px * rx + pz * rz);
+      const ly = Math.abs(px * ux + py * uy + pz * uz);
+      fit = Math.max(fit, lx / tanH - depth, ly / tanV - depth);
+    }
+    return Math.min(sphereFit, Math.max(fit, r * 0.35));
+  }
   /**
    * Tighten the depth range around the actual venue bounds for the current pose.
    *
@@ -3987,10 +4031,44 @@ function buildSceneModel(input) {
     renderMaxY - renderMinY,
     renderMaxZ - renderMinZ
   ));
+  let contentMinX = Infinity, contentMinZ = Infinity, contentMaxX = -Infinity, contentMaxZ = -Infinity;
+  for (let i = 0; i < seatData.count; i++) {
+    const o = i * 3;
+    const x = seatData.iPosition[o], z = seatData.iPosition[o + 2];
+    if (x < contentMinX) contentMinX = x;
+    if (x > contentMaxX) contentMaxX = x;
+    if (z < contentMinZ) contentMinZ = z;
+    if (z > contentMaxZ) contentMaxZ = z;
+  }
+  for (const s of stageBounds) {
+    contentMinX = Math.min(contentMinX, s.cx - s.halfX);
+    contentMaxX = Math.max(contentMaxX, s.cx + s.halfX);
+    contentMinZ = Math.min(contentMinZ, s.cz - s.halfZ);
+    contentMaxZ = Math.max(contentMaxZ, s.cz + s.halfZ);
+  }
+  const fpMinX = fp.minX * M, fpMaxX = fp.maxX * M, fpMinZ = fp.minY * M, fpMaxZ = fp.maxY * M;
+  let boxMinX = fpMinX, boxMaxX = fpMaxX, boxMinZ = fpMinZ, boxMaxZ = fpMaxZ;
+  if (Number.isFinite(contentMinX)) {
+    const pad = Math.max(2, 0.06 * Math.hypot(contentMaxX - contentMinX, contentMaxZ - contentMinZ));
+    boxMinX = Math.max(fpMinX, contentMinX - pad);
+    boxMaxX = Math.min(fpMaxX, contentMaxX + pad);
+    boxMinZ = Math.max(fpMinZ, contentMinZ - pad);
+    boxMaxZ = Math.min(fpMaxZ, contentMaxZ + pad);
+  }
   return {
     solids,
     seats: seatData,
-    bounds: { center: [cx, radius * 0.08, cz], radius, groundY: 0 },
+    bounds: {
+      // Centred on the CONTENT box, so an off-centre table cluster arrives
+      // centred on screen instead of wherever the floor's midpoint put it.
+      center: [(boxMinX + boxMaxX) / 2, radius * 0.08, (boxMinZ + boxMaxZ) / 2],
+      radius,
+      groundY: 0,
+      box: {
+        min: [boxMinX, Math.min(0, renderMinY), boxMinZ],
+        max: [boxMaxX, Math.max(renderMaxY, radius * 0.05), boxMaxZ]
+      }
+    },
     renderBounds: { center: renderCenter, radius: renderRadius },
     stateColorLUT: themeSeatColorLUT(theme, SEAT_STATES),
     theme,