@ifc-lite/viewer 1.21.0 → 1.22.1

package/src/components/viewer/BasepointOverlay.tsx

@@ -0,0 +1,239 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * BasepointOverlay — renders a small XYZ triad + label at the viewer-space
+ * position of each loaded model's IFC (0,0,0) point.
+ *
+ * Helps users diagnose federation alignment problems by showing where each
+ * model THINKS its origin is in the displayed scene. For a correctly
+ * federated set with shared CRS, the origins land at distinct points spaced
+ * by their (eastings, northings, orthogonalHeight) differences. When the
+ * pipeline collapses everything onto one point, you'll see all the markers
+ * stacked.
+ *
+ * Origins are derived from each model's IfcMapConversion + the anchor's
+ * MapConversion via `computeIfcOriginViewerPosition` — independent of any
+ * vertex-baked alignment, so it stays correct after re-aligns and across
+ * cross-CRS reprojections.
+ */
+
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { useViewerStore } from '@/store';
+import { getGlobalRenderer } from '@/hooks/useBCF';
+import {
+  computeIfcOriginViewerPosition,
+  type IfcOriginPlacement,
+  type ModelGeorefInput,
+} from '@/lib/geo/ifc-origin';
+import { getEffectiveGeoreference } from '@/lib/geo/effective-georef';
+import type { FederatedModel } from '@/store/types';
+import type { IfcDataStore } from '@ifc-lite/parser';
+import type { Renderer } from '@ifc-lite/renderer';
+
+interface BasepointDot {
+  modelId: string;
+  modelName: string;
+  status: FederatedModel['federationAlignmentStatus'];
+  /** Viewer-space (Y-up) position of the model's IFC (0,0,0) point. */
+  viewer: { x: number; y: number; z: number };
+  /** Source flag from computeIfcOriginViewerPosition (debug colour hint). */
+  origin: IfcOriginPlacement['source'];
+}
+
+const STATUS_COLOURS: Record<NonNullable<FederatedModel['federationAlignmentStatus']> | 'none', { stroke: string; fill: string }> = {
+  anchor:      { stroke: '#f59e0b', fill: '#fef3c7' }, // amber
+  'same-crs':  { stroke: '#10b981', fill: '#d1fae5' }, // emerald
+  reprojected: { stroke: '#10b981', fill: '#d1fae5' }, // emerald
+  identity:    { stroke: '#10b981', fill: '#d1fae5' }, // emerald
+  failed:      { stroke: '#ef4444', fill: '#fee2e2' }, // red
+  none:        { stroke: '#a1a1aa', fill: '#f4f4f5' }, // zinc
+};
+
+export function BasepointOverlay() {
+  const showModelBasepoints = useViewerStore((s) => s.showModelBasepoints);
+  const models = useViewerStore((s) => s.models);
+  const anchorModelIdOverride = useViewerStore((s) => s.anchorModelIdOverride);
+  const georefMutations = useViewerStore((s) => s.georefMutations);
+  // Re-derive origins when any georef edit lands.
+  useViewerStore((s) => s.mutationVersion);
+
+  // Cached origin world positions in viewer Y-up space; rebuilt only when the
+  // upstream georef data changes, NOT every camera frame.
+  const dotsRef = useRef<BasepointDot[]>([]);
+  const [version, setVersion] = useState(0);
+
+  const containerRef = useRef<HTMLDivElement>(null);
+  const svgRef = useRef<SVGSVGElement>(null);
+  const rendererRef = useRef<Renderer | null>(null);
+  const canvasRef = useRef<HTMLCanvasElement | null>(null);
+  const rafRef = useRef<number | null>(null);
+
+  // Compute the anchor's georef input once per dependency change.
+  const anchorInput = useMemo((): { id: string | null; input: ModelGeorefInput | null } => {
+    if (models.size === 0) return { id: null, input: null };
+    // Honour the user-pinned anchor first; fall back to earliest-loaded model
+    // with a valid georef. Matches findReferenceGeorefModel in useIfcFederation.
+    const buildInput = (model: FederatedModel): ModelGeorefInput | null => {
+      const ds = model.ifcDataStore;
+      if (!ds) return null;
+      const eff = getEffectiveGeoreference(
+        ds as IfcDataStore,
+        model.geometryResult?.coordinateInfo,
+        georefMutations.get(model.id),
+      );
+      if (!eff?.mapConversion || !eff.projectedCRS?.name) return null;
+      return {
+        coordinateInfo: model.geometryResult?.coordinateInfo,
+        mapConversion: eff.mapConversion,
+        projectedCRS: eff.projectedCRS,
+        lengthUnitScale: eff.lengthUnitScale,
+        preAlignmentCoordinateInfo: model.preAlignmentCoordinateInfo,
+      };
+    };
+
+    if (anchorModelIdOverride) {
+      const m = models.get(anchorModelIdOverride);
+      if (m) {
+        const input = buildInput(m);
+        if (input) return { id: anchorModelIdOverride, input };
+      }
+    }
+    const sorted = Array.from(models.values()).sort((a, b) => (a.loadedAt ?? 0) - (b.loadedAt ?? 0));
+    for (const m of sorted) {
+      const input = buildInput(m);
+      if (input) return { id: m.id, input };
+    }
+    return { id: null, input: null };
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [models, anchorModelIdOverride, georefMutations]);
+
+  // Recompute every model's IFC-origin viewer position when the inputs change.
+  useEffect(() => {
+    if (!showModelBasepoints) {
+      dotsRef.current = [];
+      setVersion((v) => v + 1);
+      return;
+    }
+
+    let cancelled = false;
+
+    (async () => {
+      const results: BasepointDot[] = [];
+      for (const [modelId, model] of models) {
+        if (!model.visible) continue;
+        const ds = model.ifcDataStore;
+        if (!ds) continue;
+        const eff = getEffectiveGeoreference(
+          ds as IfcDataStore,
+          model.geometryResult?.coordinateInfo,
+          georefMutations.get(modelId),
+        );
+        const modelInput: ModelGeorefInput = {
+          coordinateInfo: model.geometryResult?.coordinateInfo,
+          mapConversion: eff?.mapConversion,
+          projectedCRS: eff?.projectedCRS,
+          lengthUnitScale: eff?.lengthUnitScale,
+          preAlignmentCoordinateInfo: model.preAlignmentCoordinateInfo,
+        };
+        const anchorIsThis = anchorInput.id === modelId;
+        const placement = await computeIfcOriginViewerPosition(
+          modelInput,
+          anchorIsThis ? null : anchorInput.input,
+        );
+        if (!placement) continue;
+        results.push({
+          modelId,
+          modelName: model.name,
+          status: anchorIsThis ? 'anchor' : (model.federationAlignmentStatus ?? 'none'),
+          viewer: placement.viewer,
+          origin: placement.source,
+        });
+      }
+      if (cancelled) return;
+      dotsRef.current = results;
+      setVersion((v) => v + 1);
+    })();
+
+    return () => { cancelled = true; };
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [showModelBasepoints, models, anchorInput, georefMutations]);
+
+  // Lazy renderer/canvas lookup + per-frame projection. We poll on RAF
+  // (matching BCFOverlay) since the WebGPU renderer doesn't expose a
+  // camera-change event we can subscribe to from React.
+  useEffect(() => {
+    if (!showModelBasepoints) return;
+    const container = containerRef.current;
+    if (!container) return;
+    const renderer = getGlobalRenderer();
+    if (!renderer) return;
+    const canvas = container.closest('[data-viewport]')?.querySelector('canvas') as HTMLCanvasElement | null;
+    if (!canvas) return;
+    rendererRef.current = renderer;
+    canvasRef.current = canvas;
+
+    function paint() {
+      const r = rendererRef.current;
+      const cv = canvasRef.current;
+      const svg = svgRef.current;
+      if (!r || !cv || !svg) {
+        rafRef.current = requestAnimationFrame(paint);
+        return;
+      }
+      const w = cv.clientWidth;
+      const h = cv.clientHeight;
+      const camera = r.getCamera();
+      // Build the SVG content procedurally to avoid React re-renders on every
+      // frame. Each dot is a triad + label + circle.
+      const fragments: string[] = [];
+      for (const dot of dotsRef.current) {
+        const screen = camera.projectToScreen(dot.viewer, w, h);
+        if (!screen) continue;
+        const colours = STATUS_COLOURS[dot.status ?? 'none'];
+        const cx = Math.round(screen.x);
+        const cy = Math.round(screen.y);
+        // Axes: 12px arms in viewer-Y-up screen space. X right, Y up (screen
+        // up = -y), Z toward viewer (approximated as 45° offset on screen for
+        // a clear distinction from X/Y).
+        fragments.push(`
+          <g transform="translate(${cx} ${cy})">
+            <line x1="0" y1="0" x2="12" y2="0" stroke="#ef4444" stroke-width="2" />
+            <line x1="0" y1="0" x2="0" y2="-12" stroke="#22c55e" stroke-width="2" />
+            <line x1="0" y1="0" x2="-8" y2="8" stroke="#3b82f6" stroke-width="2" />
+            <circle cx="0" cy="0" r="3.5" fill="${colours.fill}" stroke="${colours.stroke}" stroke-width="1.5" />
+            <text x="14" y="-6" font-family="ui-monospace, monospace" font-size="10" fill="${colours.stroke}" stroke="white" stroke-width="3" paint-order="stroke" stroke-linejoin="round">${escapeXml(dot.modelName)}</text>
+          </g>
+        `);
+      }
+      svg.innerHTML = fragments.join('');
+      rafRef.current = requestAnimationFrame(paint);
+    }
+
+    rafRef.current = requestAnimationFrame(paint);
+    return () => {
+      if (rafRef.current !== null) {
+        cancelAnimationFrame(rafRef.current);
+        rafRef.current = null;
+      }
+    };
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [showModelBasepoints, version]);
+
+  if (!showModelBasepoints) return null;
+  return (
+    <div ref={containerRef} className="absolute inset-0 pointer-events-none z-30">
+      <svg ref={svgRef} className="absolute inset-0 w-full h-full" />
+    </div>
+  );
+}
+
+function escapeXml(s: string): string {
+  return s
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}

package/src/components/viewer/CesiumOverlay.tsx

@@ -3,9 +3,8 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 /**
- * CesiumOverlay — renders a CesiumJS globe behind the WebGPU canvas,
- * providing real-world 3D context (terrain, buildings, imagery) for
- * georeferenced IFC models.
+ * CesiumOverlay — renders Google Photorealistic 3D Tiles behind the WebGPU
+ * canvas, providing real-world 3D context for georeferenced IFC models.
  *
  * Architecture:
  *   - A separate <div> behind the WebGPU <canvas> (z-index layering)
@@ -26,8 +25,11 @@ import type { MapConversion, ProjectedCRS } from '@ifc-lite/parser';
 import type { CoordinateInfo, GeometryResult } from '@ifc-lite/geometry';
 import { getGlobalRenderer } from '@/hooks/useBCF';
 import { createCesiumBridge, type CesiumBridge } from '@/lib/geo/cesium-bridge';
-import { findClampAnchorY } from '@/lib/geo/clamp-anchor';
-import { getEffectiveHorizontalScale } from '@/lib/geo/effective-georef';
+import {
+  computeCesiumPlacement,
+  shouldPreferOrthometricTerrain,
+} from '@/lib/geo/cesium-placement';
+import { getEffectiveHorizontalScale, resolveMapUnitToMetreScale } from '@/lib/geo/geo-scale';
 
 // Lazy-loaded Cesium module and CSS
 let cesiumPromise: Promise<typeof import('cesium')> | null = null;
@@ -177,7 +179,7 @@ function buildModelMatrix(
   // extraction). IfcMapConversion.Scale is defined per IFC spec relative to
   // the project length unit, so applying it raw to metre-converted geometry
   // double-scales the model — see issue #595. Use the effective scale.
-  const mapUnitScale = projectedCRS?.mapUnitScale ?? lengthUnitScale;
+  const mapUnitScale = resolveMapUnitToMetreScale(projectedCRS?.mapUnitScale, lengthUnitScale);
   const hScale = getEffectiveHorizontalScale(mapConversion?.scale, mapUnitScale, lengthUnitScale);
   const absc = mapConversion?.xAxisAbscissa ?? 1.0;
   const ordi = mapConversion?.xAxisOrdinate ?? 0.0;
@@ -210,6 +212,7 @@ function buildModelMatrix(
 
 export interface CesiumOverlayProps {
   mapConversion?: MapConversion;
+  cameraMapConversion?: MapConversion;
   projectedCRS?: ProjectedCRS;
   coordinateInfo?: CoordinateInfo;
   geometryResult?: GeometryResult | null;
@@ -223,6 +226,7 @@ export interface CesiumOverlayProps {
 
 export function CesiumOverlay({
   mapConversion,
+  cameraMapConversion,
   projectedCRS,
   coordinateInfo,
   geometryResult,
@@ -232,6 +236,7 @@ export function CesiumOverlay({
   const containerRef = useRef<HTMLDivElement>(null);
   const viewerRef = useRef<InstanceType<typeof import('cesium').Viewer> | null>(null);
   const bridgeRef = useRef<CesiumBridge | null>(null);
+  const cameraBridgeRef = useRef<CesiumBridge | null>(null);
   const rafRef = useRef<number | null>(null);
   const [status, setStatus] = useState<'idle' | 'loading' | 'ready' | 'error'>('idle');
   const [error, setError] = useState<string | null>(null);
@@ -242,9 +247,9 @@ export function CesiumOverlay({
   const dataSource = useViewerStore((s) => s.cesiumDataSource);
   const ionToken = useViewerStore((s) => s.cesiumIonToken);
   const terrainEnabled = useViewerStore((s) => s.cesiumTerrainEnabled);
-  const terrainClamp = useViewerStore((s) => s.cesiumTerrainClamp);
-  const terrainHeight = useViewerStore((s) => s.cesiumTerrainHeight);
+  const terrainClipY = useViewerStore((s) => s.cesiumTerrainClipY);
   const setCesiumTerrainHeight = useViewerStore((s) => s.setCesiumTerrainHeight);
+  const setCesiumTerrainSource = useViewerStore((s) => s.setCesiumTerrainSource);
   const setCesiumTerrainClipY = useViewerStore((s) => s.setCesiumTerrainClipY);
   const setCesiumGlbLoaded = useViewerStore((s) => s.setCesiumGlbLoaded);
 
@@ -341,18 +346,7 @@ export function CesiumOverlay({
         scene.globe.showGroundAtmosphere = false;
         scene.backgroundColor = Cesium.Color.TRANSPARENT;
         scene.globe.baseColor = Cesium.Color.TRANSPARENT;
-
-        // Add imagery
-        try {
-          const imageryProvider = await Cesium.IonImageryProvider.fromAssetId(2);
-          viewer.imageryLayers.addImageryProvider(imageryProvider);
-        } catch {
-          viewer.imageryLayers.addImageryProvider(
-            new Cesium.OpenStreetMapImageryProvider({
-              url: 'https://a.tile.openstreetmap.org/',
-            })
-          );
-        }
+        scene.globe.show = false;
 
         // Add terrain
         if (terrainEnabled && ionToken) {
@@ -397,7 +391,8 @@ export function CesiumOverlay({
   }, [cesiumEnabled, ionToken, terrainEnabled, dataSource]);
 
   // ─── Effect 2: Build the coordinate bridge with terrain-aware placement ─
-  // Precomputes the model placement (terrain-clamped if applicable) BEFORE
+  // Precomputes the model placement (floored to the visible surface when
+  // necessary) BEFORE
   // building the bridge that the GLB and camera will share. This way the
   // model loads into Cesium at its final altitude — no post-load shifting,
   // no camera/model frame divergence, no compensation gymnastics.
@@ -405,14 +400,15 @@ export function CesiumOverlay({
   // Sequence:
   //   1. Build a tentative bridge to recover the model's WGS84 lat/lon.
   //   2. Query terrain at that lat/lon (sync first, async with retry next).
-  //   3. Decide whether to clamp (user toggle OR model authored below terrain).
+  //   3. Auto-floor the model if its authored base sits below the visible surface.
   //   4. Rebuild the bridge with placementHeight baked into its enuToEcef
   //      origin so model matrix and camera frame share a single altitude.
-  //   5. Push terrain-derived state (height, clip Y, clamp toggle) and
+  //   5. Push terrain-derived state (height, clip Y) and
   //      install the bridge.
   useEffect(() => {
     if (status !== 'ready' || !mapConversion || !projectedCRS) {
       bridgeRef.current = null;
+      cameraBridgeRef.current = null;
       prevPlacementRef.current = null;
       return;
     }
@@ -424,12 +420,15 @@ export function CesiumOverlay({
       const viewer = viewerRef.current;
       if (!Cesium || !viewer) return;
 
-      const tentative = await createCesiumBridge(
-        mapConversion, projectedCRS, coordinateInfo, lengthUnitScale,
+      const cameraConversion = cameraMapConversion ?? mapConversion;
+      const usesSeparateCameraBridge = cameraConversion !== mapConversion;
+      const cameraTentative = await createCesiumBridge(
+        cameraConversion, projectedCRS, coordinateInfo, lengthUnitScale,
       );
       if (cancelled) return;
-      if (!tentative) {
+      if (!cameraTentative) {
         bridgeRef.current = null;
+        cameraBridgeRef.current = null;
         return;
       }
 
@@ -438,99 +437,104 @@ export function CesiumOverlay({
       // then Open-Meteo as a fast network fallback that works even with
       // Google Photorealistic 3D Tiles (where there's no Cesium terrain
       // provider for getHeight to read). Cached per-session.
-      const t0 = performance.now();
-      let terrainH: number | null = null;
-      try { terrainH = await tentative.queryTerrainHeight(Cesium, viewer); }
+      const preferOrthometricTerrain = shouldPreferOrthometricTerrain(projectedCRS);
+      let terrainSample = null;
+      try {
+        terrainSample = await cameraTentative.queryTerrainHeight(Cesium, viewer, {
+          cacheNamespace: [
+            terrainEnabled ? 'terrain' : 'ellipsoid',
+            dataSource,
+            preferOrthometricTerrain ? 'orthometric' : 'visual-surface',
+          ].join(':'),
+          preferOrthometric: preferOrthometricTerrain,
+        });
+      }
       catch (err) { console.warn('[CesiumOverlay] terrain query failed:', err); }
       if (cancelled) return;
-      const terrainMs = performance.now() - t0;
-
-      const bounds = coordinateInfo?.originalBounds;
-      const mvy = bounds ? (bounds.min.y + bounds.max.y) / 2 : 0;
-      const minY = bounds?.min.y ?? 0;
-      // Clamp anchor: viewer-Y of the storey nearest elevation 0 (typical
-      // ground floor), falling back to bounds.min.y. Without this, basements
-      // and foundations drag the model deep below terrain.
-      const clampAnchorY = findClampAnchorY(bounds, storeyElevations);
-      const anchorOffset = mvy - clampAnchorY;
-      const ifcOHeight = tentative.modelOrigin.height;
-      // Clamp is purely the user's choice. We do NOT auto-clamp on top of
-      // the user's setting — that would reactivate the toggle the moment
-      // the user disables it (since terrain is almost always above sea-level
-      // OrthogonalHeights, the auto condition would re-fire forever and the
-      // checkbox becomes un-uncheckable).
-      const placementHeight =
-        terrainClamp && terrainH !== null
-          ? terrainH + anchorOffset
-          : ifcOHeight;
-
-      console.debug(
-        `[CesiumOverlay] placement decision: terrain=${terrainH?.toFixed(2) ?? 'null'}m`
-        + ` ifcOHeight=${ifcOHeight.toFixed(2)}m anchorY=${clampAnchorY.toFixed(2)}m`
-        + ` (minY=${minY.toFixed(2)}m, ${storeyElevations?.size ?? 0} storeys)`
-        + ` clamp=${terrainClamp} placement=${placementHeight.toFixed(2)}m`
-        + ` (terrain query: ${terrainMs.toFixed(0)}ms)`
-      );
-
-      // Build the final bridge with the placement baked in (or reuse the
-      // tentative one when the placement matches its IFC-derived origin).
-      let bridge = tentative;
-      if (Math.abs(placementHeight - ifcOHeight) > 1e-6) {
-        const final = await createCesiumBridge(
-          mapConversion, projectedCRS, coordinateInfo, lengthUnitScale,
-          placementHeight,
-        );
-        if (cancelled) return;
-        if (!final) {
-          bridgeRef.current = null;
-          return;
-        }
-        bridge = final;
+      const terrainH = terrainSample?.height ?? null;
+      const modelTentative = usesSeparateCameraBridge
+        ? await createCesiumBridge(mapConversion, projectedCRS, coordinateInfo, lengthUnitScale)
+        : cameraTentative;
+      if (cancelled) return;
+      if (!modelTentative) {
+        bridgeRef.current = null;
+        return;
       }
-
-      if (terrainH !== null) {
+      // Placement is purely IFC-authored — no terrain/storey clamp. The
+      // tentative bridges already carry the model's authored altitude
+      // (IfcMapConversion.OrthogonalHeight + geometry origin), so they ARE
+      // the final bridges. computeCesiumPlacement is still called for the
+      // clip-plane Y; placementHeight == ifcOriginHeight.
+      const placement = computeCesiumPlacement({
+        coordinateInfo,
+        projectedCRS,
+        ifcOriginHeight: modelTentative.modelOrigin.height,
+        terrainHeight: terrainH,
+        storeyElevations,
+      });
+      const cameraPlacement = usesSeparateCameraBridge
+        ? computeCesiumPlacement({
+            coordinateInfo,
+            projectedCRS,
+            ifcOriginHeight: cameraTentative.modelOrigin.height,
+            terrainHeight: terrainH,
+            storeyElevations,
+          })
+        : placement;
+
+      // The model bridge is the tentative one — placement == authored origin.
+      const bridge = modelTentative;
+
+      if (terrainSample) {
         setCesiumTerrainHeight(terrainH);
+        setCesiumTerrainSource(
+          `${terrainSample.source}${terrainSample.reference === 'orthometric' ? ' (orthometric)' : ''}`,
+        );
         // terrainClipY stays in viewer-space; it represents the world terrain
-        // altitude expressed in the bridge's frame so a clip plane at that Y
-        // matches the terrain surface. Use the clamp anchor (ground floor)
-        // rather than minY so the clip plane matches the user's ground level
-        // rather than the basement floor.
-        const terrainClipY = clampAnchorY + (terrainH - ifcOHeight);
-        setCesiumTerrainClipY(terrainClipY);
+        // altitude expressed in the camera bridge's committed frame. Draft
+        // placement edits must not move this floor, or the camera will drift.
+        setCesiumTerrainClipY(cameraPlacement.terrainClipY);
       } else {
         // Failed re-query (offline, API down) — clear stale store fields so
         // the clip plane doesn't drift relative to the new bridge.
         setCesiumTerrainHeight(null);
+        setCesiumTerrainSource(null);
         setCesiumTerrainClipY(null);
       }
 
       // World-camera stability: when this rebuild changes the placement
-      // altitude (clamp toggled, OrthogonalHeight edited), shift the IFC
+      // altitude (surface floor or OrthogonalHeight edited), shift the IFC
       // viewer-space camera Y by the inverse delta so the user's WORLD
       // camera ECEF position stays put. Without this, the entire frame
       // translates with the model and edits feel like the camera is
       // moving instead of the model — exactly what the user reported.
       const prevPlacement = prevPlacementRef.current;
-      prevPlacementRef.current = placementHeight;
-      if (prevPlacement !== null) {
-        const dh = placementHeight - prevPlacement;
+      if (!usesSeparateCameraBridge) {
+        prevPlacementRef.current = placement.placementHeight;
+      }
+      if (!usesSeparateCameraBridge && prevPlacement !== null) {
+        const dh = placement.placementHeight - prevPlacement;
         // 5 cm threshold — rejects float jitter from cached terrain reads
         // re-flowing through the same effect, while a real placement edit
-        // (clamp toggle, OrthogonalHeight change) is always far larger.
+        // is always far larger.
         if (Math.abs(dh) > 0.05) {
           const renderer = getGlobalRenderer();
           if (renderer) {
             const cam = renderer.getCamera();
             const pos = cam.getPosition();
             cam.setPosition(pos.x, pos.y - dh, pos.z);
-            console.debug(
-              `[CesiumOverlay] placement Δh=${dh.toFixed(2)}m → shifted IFC camera Y by ${(-dh).toFixed(2)}m to hold world camera`,
-            );
           }
         }
       }
 
+      // Camera bridge: the separate camera-tentative when a placement draft
+      // is previewing (camera holds the base frame while the model moves),
+      // otherwise the model bridge itself. Both are already at their
+      // authored altitude — no placement-override rebuild.
+      const cameraBridge = usesSeparateCameraBridge ? cameraTentative : bridge;
+
       bridgeRef.current = bridge;
+      cameraBridgeRef.current = cameraBridge;
       setBridgeVersion((v) => v + 1);
     })();
 
@@ -539,7 +543,20 @@ export function CesiumOverlay({
     // owns those (it destroys/recreates the viewer when they change), and
     // listing them here would cause a redundant bridge rebuild while the
     // viewer is being torn down.
-  }, [status, mapConversion, projectedCRS, coordinateInfo, lengthUnitScale, terrainClamp, storeyElevations]);
+  }, [
+    status,
+    mapConversion,
+    cameraMapConversion,
+    projectedCRS,
+    coordinateInfo,
+    lengthUnitScale,
+    terrainEnabled,
+    dataSource,
+    storeyElevations,
+    setCesiumTerrainHeight,
+    setCesiumTerrainSource,
+    setCesiumTerrainClipY,
+  ]);
 
   // ─── Effect 2c: Load GLB into Cesium (only when geometry changes) ───────
   // This is the heavy operation — only re-runs when geometry actually changes.
@@ -630,7 +647,7 @@ export function CesiumOverlay({
   }, [status, bridgeVersion, geometryResult]);
 
   // ─── Effect 2d: Update model matrix (instant, no reload) ────────────────
-  // When terrain clamp, terrain height, or georef changes, just update the
+  // When terrain placement or georef changes, just update the
   // existing model's matrix — no GLB re-export, no flicker.
   useEffect(() => {
     const model = cesiumModelRef.current;
@@ -643,10 +660,8 @@ export function CesiumOverlay({
     model.modelMatrix = newMatrix;
     viewer.scene.requestRender();
     // Depend on bridgeVersion so the matrix is rebuilt with the *new* bridge
-    // after async createCesiumBridge replaces it. Placement (terrain clamp)
-    // is now baked into bridge.modelOrigin.height by Effect 2, so terrain
-    // clamp/height changes drive a bridge rebuild instead of a per-frame
-    // matrix recomputation here.
+    // after async createCesiumBridge replaces it. Placement is baked into
+    // bridge.modelOrigin.height by Effect 2.
   }, [mapConversion, projectedCRS, coordinateInfo, lengthUnitScale, bridgeVersion]);
 
   // ─── Effect 3: Camera sync loop ─────────────────────────────────────────
@@ -662,23 +677,32 @@ export function CesiumOverlay({
       if (cancelled) return;
 
       const bridge = bridgeRef.current;
+      const cameraBridge = cameraBridgeRef.current ?? bridge;
       const renderer = getGlobalRenderer();
       const Cesium = cesiumModule;
-      if (!viewer || !bridge || !renderer || !Cesium) {
+      if (!viewer || !bridge || !cameraBridge || !renderer || !Cesium) {
         rafRef.current = requestAnimationFrame(syncCamera);
         return;
       }
 
       const camera = renderer.getCamera();
-      const camPos = camera.getPosition();
-      const camTarget = camera.getTarget();
+      let camPos = camera.getPosition();
+      let camTarget = camera.getTarget();
       const camUp = camera.getUp();
       const fov = camera.getFOV();
 
-      // bridge.modelOrigin.height already has the placement baked in (terrain
-      // clamp resolved at bridge creation by Effect 2), so the camera frame
-      // and the model matrix share the same enuToEcef origin altitude.
-      bridge.syncCamera(Cesium, viewer, camPos, camTarget, camUp, fov);
+      if (terrainClipY !== null) {
+        const minCameraY = terrainClipY + 0.05;
+        if (camPos.y < minCameraY) {
+          const dy = minCameraY - camPos.y;
+          camPos = { ...camPos, y: minCameraY };
+          camTarget = { ...camTarget, y: camTarget.y + dy };
+        }
+      }
+
+      // bridge.modelOrigin.height already has the placement baked in, so the
+      // camera frame and the model matrix share the same enuToEcef origin altitude.
+      cameraBridge.syncCamera(Cesium, viewer, camPos, camTarget, camUp, fov);
 
       rafRef.current = requestAnimationFrame(syncCamera);
     }
@@ -692,7 +716,7 @@ export function CesiumOverlay({
         rafRef.current = null;
       }
     };
-  }, [status]);
+  }, [status, terrainClipY]);
 
   if (!cesiumEnabled || !mapConversion || !projectedCRS) {
     return null;
@@ -721,7 +745,7 @@ export function CesiumOverlay({
 }
 
 /**
- * Add the selected 3D data source layer to the Cesium viewer.
+ * Add the Google Photorealistic 3D Tiles layer to the Cesium viewer.
  */
 async function addDataSourceLayer(
   Cesium: typeof import('cesium'),
@@ -731,16 +755,11 @@ async function addDataSourceLayer(
 ) {
   try {
     switch (dataSource) {
-      case 'osm-buildings': {
-        if (!ionToken) return;
-        const tileset = await Cesium.Cesium3DTileset.fromIonAssetId(96188);
-        viewer.scene.primitives.add(tileset);
-        break;
-      }
-      case 'google-photorealistic': {
+      case 'google-photorealistic':
+      default: {
         try {
           const tileset = await Cesium.createGooglePhotorealistic3DTileset();
-          viewer.scene.primitives.add(tileset);
+        viewer.scene.primitives.add(tileset);
         } catch {
           if (ionToken) {
             const tileset = await Cesium.Cesium3DTileset.fromIonAssetId(2275207);
@@ -749,10 +768,6 @@ async function addDataSourceLayer(
         }
         break;
       }
-      case 'bing-aerial':
-      default:
-        // No 3D tileset for Bing — imagery is added separately via imageryLayers
-        break;
     }
   } catch (err) {
     console.warn('[CesiumOverlay] Failed to add data source:', dataSource, err);