@ifc-lite/viewer 1.25.0 → 1.25.1

package/src/hooks/useBCF.ts

@@ -13,13 +13,15 @@
 
 import { useCallback, useRef } from 'react';
 import { useViewerStore } from '@/store';
-import type { BCFViewpoint } from '@ifc-lite/bcf';
+import type { BCFTopic, BCFViewpoint } from '@ifc-lite/bcf';
 import {
   createViewpoint,
   extractViewpointState,
+  computeMarkerPositions,
   type ViewerCameraState,
   type ViewerSectionPlane,
   type ViewerBounds,
+  type OverlayBBox,
 } from '@ifc-lite/bcf';
 import type { Renderer } from '@ifc-lite/renderer';
 import {
@@ -52,6 +54,10 @@ interface UseBCFResult {
   createViewpointFromState: (options?: CreateViewpointOptions) => Promise<BCFViewpoint | null>;
   /** Apply a viewpoint to the viewer */
   applyViewpoint: (viewpoint: BCFViewpoint, animate?: boolean) => void;
+  /** Animate the camera to a BCF topic's 3D location (without changing selection/visibility) */
+  zoomToTopic: (topic: BCFTopic) => void;
+  /** Whether a topic has enough data to zoom to */
+  canZoomToTopic: (topic: BCFTopic) => boolean;
   /** Capture a snapshot from the canvas */
   captureSnapshot: () => Promise<string | null>;
   /** Set the canvas ref for snapshot capture */
@@ -96,6 +102,21 @@ export function clearGlobalRefs(): void {
   globalRendererRef = null;
 }
 
+/** Apply extracted BCF camera state without touching selection, visibility, or section plane. */
+function applyCameraState(
+  renderer: Renderer,
+  camera: NonNullable<ReturnType<typeof extractViewpointState>['camera']>,
+  animate: boolean,
+): void {
+  const rendererCamera = renderer.getCamera();
+  if (animate) {
+    rendererCamera.animateTo(camera.position, camera.target, 300);
+  } else {
+    rendererCamera.setPosition(camera.position.x, camera.position.y, camera.position.z);
+    rendererCamera.setTarget(camera.target.x, camera.target.y, camera.target.z);
+  }
+}
+
 // ============================================================================
 // Hook
 // ============================================================================
@@ -351,6 +372,28 @@ export function useBCF(options: UseBCFOptions = {}): UseBCFResult {
     ]
   );
 
+  /** Restore only the viewpoint camera (used by zoom-to-topic fallback). */
+  const applyViewpointCamera = useCallback(
+    (viewpoint: BCFViewpoint, animate = true) => {
+      const renderer = getRenderer();
+      if (!renderer) {
+        console.warn('[useBCF] Cannot apply viewpoint camera: no renderer');
+        return;
+      }
+
+      const bounds = getBounds() ?? undefined;
+      const state = extractViewpointState(
+        viewpoint,
+        bounds,
+        renderer.getCamera().getDistance(),
+      );
+      if (state.camera) {
+        applyCameraState(renderer, state.camera, animate);
+      }
+    },
+    [getRenderer, getBounds],
+  );
+
   /**
    * Apply a viewpoint to the viewer
    */
@@ -372,22 +415,8 @@ export function useBCF(options: UseBCFOptions = {}): UseBCFResult {
       );
       const { camera, sectionPlane: viewpointSectionPlane } = state;
 
-      // Apply camera
       if (camera) {
-        const rendererCamera = renderer.getCamera();
-
-        if (animate) {
-          // Animate to new position
-          rendererCamera.animateTo(
-            camera.position,
-            camera.target,
-            300 // 300ms animation
-          );
-        } else {
-          // Set immediately
-          rendererCamera.setPosition(camera.position.x, camera.position.y, camera.position.z);
-          rendererCamera.setTarget(camera.target.x, camera.target.y, camera.target.z);
-        }
+        applyCameraState(renderer, camera, animate);
       }
 
       // Apply section plane
@@ -482,9 +511,62 @@ export function useBCF(options: UseBCFOptions = {}): UseBCFResult {
     ]
   );
 
+  const canZoomToTopic = useCallback((topic: BCFTopic): boolean => {
+    return topic.viewpoints.length > 0;
+  }, []);
+
+  const zoomToTopic = useCallback(
+    (topic: BCFTopic) => {
+      const renderer = getRenderer();
+      if (!renderer || topic.viewpoints.length === 0) return;
+
+      const boundsLookup = (ifcGuid: string): OverlayBBox | null => {
+        const result = globalIdToExpressId(ifcGuid);
+        if (!result) return null;
+        return renderer.getScene().getEntityBoundingBox(result.expressId);
+      };
+
+      const markers = computeMarkerPositions([topic], boundsLookup, {
+        targetDistance: renderer.getCamera().getDistance(),
+      });
+
+      if (markers.length > 0) {
+        const marker = markers[0];
+
+        if (marker.positionSource === 'component') {
+          for (let i = topic.viewpoints.length - 1; i >= 0; i--) {
+            const vp = topic.viewpoints[i];
+            const guids = [
+              ...(vp.components?.selection ?? []),
+              ...(vp.components?.visibility?.exceptions ?? []),
+            ];
+            for (const comp of guids) {
+              if (!comp.ifcGuid) continue;
+              const bbox = boundsLookup(comp.ifcGuid);
+              if (bbox) {
+                void renderer.getCamera().frameBounds(bbox.min, bbox.max);
+                return;
+              }
+            }
+          }
+        }
+
+        const point = marker.connectorAnchor ?? marker.position;
+        void renderer.getCamera().framePoint(point);
+        return;
+      }
+
+      // Fallback: camera from latest viewpoint only — preserve selection/visibility
+      applyViewpointCamera(topic.viewpoints[topic.viewpoints.length - 1], true);
+    },
+    [applyViewpointCamera, getRenderer, globalIdToExpressId],
+  );
+
   return {
     createViewpointFromState,
     applyViewpoint,
+    zoomToTopic,
+    canZoomToTopic,
     captureSnapshot,
     setCanvasRef,
     setRendererRef,

package/src/hooks/useDrawingGeneration.ts

@@ -32,6 +32,14 @@ export const AXIS_MAP: Record<'down' | 'front' | 'side', 'x' | 'y' | 'z'> = {
   side: 'x',
 };
 
+// Depth of the slab IN FRONT of the section plane (in shifted-world
+// metres) within which IFC annotation/grid primitives are kept. Beyond
+// the slab they're culled — matches a typical plan-view "view depth"
+// where dimensions for the next storey shouldn't bleed through. The
+// shifted-bounds coordinate system the centroids and `position` both
+// live in is already in metres (WASM applies `unit_scale` upstream).
+export const ANNOTATION_VIEW_DEPTH = 1.2;
+
 interface UseDrawingGenerationParams {
   geometryResult: GeometryResult | null | undefined;
   ifcDataStore: { source: Uint8Array } | null;
@@ -92,10 +100,28 @@ export function useDrawingGeneration({
   // Track if this is a regeneration (vs initial generation)
   const isRegeneratingRef = useRef(false);
 
+  // Symbolic lines carry the parent primitive's world-space centroid so the
+  // 2D Section filter below can cull them against the active cut plane —
+  // cardinal axis OR a face-picked custom plane. The drawing-2d package's
+  // DrawingLine has no per-line position slot; attaching the centroid as
+  // extra fields keeps the change local since the canvas ignores anything
+  // beyond DrawingLine's declared fields.
+  //
+  // Coordinate space matches the section cutter's input (shifted bounds):
+  // - worldX: read from the polyline's 2D x (already RTC-shifted by WASM)
+  // - worldZ: -(polyline 2D y) — WASM negates Z into the 2D y axis to
+  //   match section-cut output handedness, so flip back here
+  // - worldY: from the WASM `worldY` accessor (vertical elevation)
+  type SymbolicDrawingLine = DrawingLine & {
+    worldX?: number;
+    worldY?: number;
+    worldZ?: number;
+  };
+
   // Cache for symbolic representations - these don't change with section position
   // Only re-parse when model or display options change
   const symbolicCacheRef = useRef<{
-    lines: DrawingLine[];
+    lines: SymbolicDrawingLine[];
     entities: Set<number>;
     sourceId: string | null;
     useSymbolic: boolean;
@@ -120,7 +146,7 @@ export function useDrawingGeneration({
 
     // Parse symbolic representations if enabled (for hybrid mode)
     // OPTIMIZATION: Cache symbolic data - it doesn't change with section position
-    let symbolicLines: DrawingLine[] = [];
+    let symbolicLines: SymbolicDrawingLine[] = [];
     let entitiesWithSymbols = new Set<number>();
 
     // For multi-model: create cache key from model count and visible model IDs
@@ -167,6 +193,26 @@ export function useDrawingGeneration({
                 entitiesWithSymbols.add(poly.expressId);
                 const points = poly.points;
                 const pointCount = poly.pointCount;
+                // WASM exposes `worldY` on every symbolic primitive — the
+                // elevation of its parent placement (Z-up IFC, world-Y here).
+                // The .d.ts shipped with the @ifc-lite/wasm package lags
+                // behind the Rust source; read defensively so a stale build
+                // returns undefined instead of throwing.
+                const polyWorldY = (poly as unknown as { worldY?: number }).worldY;
+                // Centroid in shifted world coords — derived from the 2D
+                // points the WASM extractor already emits in section-cut
+                // space. point.x = world X (RTC-shifted); point.y =
+                // -world Z (negated to match cut-output handedness), so
+                // flip the sign back to recover world Z. Computed once
+                // per source polyline and shared across its segments.
+                let sumX = 0;
+                let sumY = 0;
+                for (let p = 0; p < pointCount; p++) {
+                  sumX += points[p * 2];
+                  sumY += points[p * 2 + 1];
+                }
+                const polyWorldX = pointCount > 0 ? sumX / pointCount : undefined;
+                const polyWorldZ = pointCount > 0 ? -sumY / pointCount : undefined;
 
                 for (let j = 0; j < pointCount - 1; j++) {
                   symbolicLines.push({
@@ -180,6 +226,9 @@ export function useDrawingGeneration({
                     ifcType: poly.ifcType,
                     modelIndex: symbolicModelIndex,
                     depth: 0,
+                    worldX: polyWorldX,
+                    worldY: polyWorldY,
+                    worldZ: polyWorldZ,
                   });
                 }
 
@@ -195,6 +244,9 @@ export function useDrawingGeneration({
                     ifcType: poly.ifcType,
                     modelIndex: symbolicModelIndex,
                     depth: 0,
+                    worldX: polyWorldX,
+                    worldY: polyWorldY,
+                    worldZ: polyWorldZ,
                   });
                 }
               }
@@ -206,6 +258,12 @@ export function useDrawingGeneration({
 
                 entitiesWithSymbols.add(circle.expressId);
                 const numSegments = circle.isFullCircle ? 32 : 16;
+                const circleWorldY = (circle as unknown as { worldY?: number }).worldY;
+                // Centre in shifted world coords. circle.centerX is
+                // already RTC-shifted X; circle.centerY carries the
+                // negated Z (see polyline note above) — flip to recover.
+                const circleWorldX = circle.centerX;
+                const circleWorldZ = -circle.centerY;
 
                 for (let j = 0; j < numSegments; j++) {
                   const t1 = j / numSegments;
@@ -230,6 +288,9 @@ export function useDrawingGeneration({
                     ifcType: circle.ifcType,
                     modelIndex: symbolicModelIndex,
                     depth: 0,
+                    worldX: circleWorldX,
+                    worldY: circleWorldY,
+                    worldZ: circleWorldZ,
                   });
                 }
               }
@@ -375,9 +436,94 @@ export function useDrawingGeneration({
           }
         }
 
+        // When the user toggles `sectionPlane.flipped` on a cardinal axis,
+        // the cutter negates the 2D U axis (see `projectTo2D` in
+        // @ifc-lite/drawing-2d/math.ts and `data[6] = flipU` in the GPU
+        // cutter). Symbolic primitives come out of WASM in the cutter's
+        // UNFLIPPED basis — for the plan ('y') case `(line.x = worldX − rtc,
+        // line.y = −worldY + rtc)` — so on a flipped section the cut
+        // polygons land at −X while the symbolic lines stay at +X. The
+        // result the user reported: annotations sitting NEXT TO the model
+        // as if they were mirrored across the model's centre, instead of
+        // staying with the cut. Mirror symbolic X here to match the cutter
+        // for cardinal flipped sections. Custom face-pick planes use
+        // `projectTo2DBasis` (no U flip), so leave them untouched —
+        // symbolic alignment on an arbitrary basis is a separate problem
+        // and out of scope for this fix.
+        const mirrorSymbolicX = sectionPlane.flipped && !sectionPlane.custom;
+        const orientedSymbolicLines: SymbolicDrawingLine[] = mirrorSymbolicX
+          ? symbolicLines.map((line) => ({
+              ...line,
+              line: {
+                start: { x: -line.line.start.x, y: line.line.start.y },
+                end:   { x: -line.line.end.x,   y: line.line.end.y   },
+              },
+            }))
+          : symbolicLines;
+
+        // Cull annotations to a thin view-depth slab IN FRONT of the cut.
+        //
+        // IfcAnnotation / IfcGridAxis polylines (dimensions, room tags, grid
+        // bubbles) live at a single elevation but have no body geometry —
+        // the `cutEntityIds.has(line.entityId)` filter below never matches
+        // them, so without this they render regardless of where the
+        // section sits.
+        //
+        // Reduce every cut mode (cardinal X/Y/Z + face-pick custom plane)
+        // to a single half-space test against a unit normal + signed
+        // distance. For cardinal axes the normal is the basis vector and
+        // distance is `position` (already in shifted-bounds coords, the
+        // same space the symbolic centroids land in). For custom planes
+        // the WASM cutter already uses `normal`/`distance` verbatim, so
+        // re-use both here for consistency with the cap.
+        //
+        // The kept window is `−ANNOTATION_VIEW_DEPTH ≤ signedDist ≤ 0` on
+        // the −normal side — the side BELOW a down-looking camera, where
+        // IFC dimensions live (authored at the storey's floor elevation,
+        // not at the cut height). This DIVERGES from
+        // `EdgeExtractor.filterEdgesByDepth`, which projects above the
+        // cut: annotations and projection edges are naturally on opposite
+        // sides of the cut plane. Flipped sections look at the same world
+        // from the opposite side, so the slab mirrors to
+        // `0 ≤ signedDist ≤ ANNOTATION_VIEW_DEPTH`.
+        //
+        // Anything on the wrong side of the cut, or farther than the view
+        // depth on the right side, is dropped — without the upper bound,
+        // dimensions from every storey beyond the cut stacked on top of
+        // each other because the half-space alone is unbounded along the
+        // camera axis.
+        //
+        // Annotations missing a recoverable centroid (older WASM build,
+        // or a degenerate polyline) are kept — over-rendering is preferable
+        // to silently dropping authored dimensions when the runtime can't
+        // classify them.
+        const cullNormal: [number, number, number] = sectionPlane.custom
+          ? sectionPlane.custom.normal
+          : axis === 'x' ? [1, 0, 0]
+          : axis === 'y' ? [0, 1, 0]
+          : [0, 0, 1];
+        const cullDistance = sectionPlane.custom ? sectionPlane.custom.distance : position;
+        const annotationCulled = orientedSymbolicLines.filter((line) => {
+          const isAnnotationLike = line.ifcType === 'IfcAnnotation' || line.ifcType === 'IfcGridAxis';
+          if (!isAnnotationLike) return true;
+          const wx = line.worldX;
+          const wy = line.worldY;
+          const wz = line.worldZ;
+          if (wx === undefined || wy === undefined || wz === undefined) return true;
+          const signedDist =
+            wx * cullNormal[0] +
+            wy * cullNormal[1] +
+            wz * cullNormal[2] -
+            cullDistance;
+          if (sectionPlane.flipped) {
+            return signedDist >= 0 && signedDist <= ANNOTATION_VIEW_DEPTH;
+          }
+          return signedDist <= 0 && signedDist >= -ANNOTATION_VIEW_DEPTH;
+        });
+
         // Only include symbolic lines for entities that are ACTUALLY being cut
         // This filters out symbols from other floors/levels not intersected by the section plane
-        const relevantSymbolicLines = symbolicLines.filter(line =>
+        const relevantSymbolicLines = annotationCulled.filter(line =>
           line.entityId !== undefined && cutEntityIds.has(line.entityId)
         );
 

package/src/hooks/useSymbolicAnnotations.ts

@@ -60,10 +60,9 @@ export interface AnnotationText2D {
   /**
    * When true, the renderer rebuilds the glyph quad in screen-aligned
    * (cameraRight, cameraUp) basis so the text always faces the camera.
-   * Set for IfcGridAxis tags — they must stay readable in top-down/ground
-   * views where the authored world-Y up axis collapses to zero on-screen.
-   * Defaults to false (authored, in-plane text — matches BIMvision for
-   * dimension/leader annotations that lie flat on the floor).
+   * Set for every annotation literal (grid bubbles, dimension callouts,
+   * leader labels) so they stay legible in any view — flat-in-plane text
+   * collapses to a sliver at oblique angles (issue #812). Defaults to false.
    */
   billboard?: boolean;
   /** sRGB straight-alpha tint (0..1). Defaults to renderer near-black. */
@@ -337,12 +336,13 @@ async function parseAnnotations(
       // a little air between rows so descenders don't kiss the next cap.
       const lineSpacing = perLineHeight * 1.2;
       const bucket = ensureBucket(text.expressId, text.worldY);
-      // IfcGridAxis bubble tags must stay readable in any view orientation
-      // (top-down, eye-level, oblique). Tag them as billboard so the text
-      // shader rebuilds the quad in screen-aligned basis at render time.
-      // Other annotation text (dimensions, leader labels) keeps authored
-      // orientation — those are meant to lie flat in the floor plane.
-      const isGridTag = text.ifcType === 'IfcGridAxis';
+      // All annotation text — grid bubbles, dimension callouts, leader labels —
+      // billboards to the camera so it stays legible in any view orientation
+      // (top-down, eye-level, oblique). The shader rebuilds the quad in the
+      // screen-aligned basis at render time. Authored orientation is intentionally
+      // dropped: at oblique viewing angles, flat-in-plane text becomes a smeared
+      // sliver of pixels (issue #812). Anchor + alignment are preserved, so each
+      // label still sits at its authored insertion point.
       // Read per-instance style metadata. WASM emits these for grid
       // bubble parts (● fill / ○ outline / tag) and reserves them for
       // future IfcTextStyle resolution on regular annotation text.
@@ -362,7 +362,7 @@ async function parseAnnotations(
           content: lines[li],
           alignment: text.alignment,
           lineYOffset: -li * lineSpacing,
-          billboard: isGridTag,
+          billboard: true,
           color: textColor,
           targetPx,
         };
@@ -658,21 +658,65 @@ export function useSymbolicAnnotationsForDrawing(params: {
     if (axis !== 'down') return EMPTY_DRAWING_ANNOTATIONS;
     void version;
 
-    // Section view range in world Y. Matches the convention used by
-    // `profile-projector.isInProjectionRange`:
-    //   not flipped → [sectionPos, sectionPos + viewDepth]
-    //   flipped     → [sectionPos - viewDepth, sectionPos]
-    // We expand the range by a small tolerance so annotations sitting
-    // exactly on the cut plane still match (storey elevations are
-    // typically the cut Y).
+    // Section view range in world Y.
+    //
+    // For a floor-plan cut at axis='down' the camera looks DOWN through the
+    // cut. "In front of the camera" is therefore the side BELOW the cut —
+    // where the floor and authored dimensions sit (IFC convention places
+    // dimension annotations at the storey's floor elevation, not at the
+    // cut height). The user's complaint: with the slab on the +normal
+    // side, you had to scrub the section DOWN into the floor before
+    // anything showed, and then the dimensions appeared one storey BELOW
+    // the cut. Mirror that — keep the slab on the −normal side for the
+    // unflipped down section, and flip it for the reflected-ceiling case.
+    //
+    // Note this DIVERGES from `profile-projector.isInProjectionRange`,
+    // which projects above the cut by default. Annotations live with the
+    // storey floor, the projection lives with the upper-storey volume —
+    // they're naturally on opposite sides of the cut plane.
+    //
+    // Tolerance lets annotations authored exactly on the cut plane (e.g.
+    // a storey at Z=0 with a section right at the storey datum) survive.
     const TOL = 1e-3;
-    const rangeMin = (flipped ? sectionPosWorld - viewDepth : sectionPosWorld) - TOL;
-    const rangeMax = (flipped ? sectionPosWorld : sectionPosWorld + viewDepth) + TOL;
+    const rangeMin = (flipped ? sectionPosWorld : sectionPosWorld - viewDepth) - TOL;
+    const rangeMax = (flipped ? sectionPosWorld + viewDepth : sectionPosWorld) + TOL;
 
     const lines: DrawingLine2D[] = [];
     const texts: AnnotationText2D[] = [];
     const fills: AnnotationFill2D[] = [];
 
+    // The drawing-2d cutter negates the 2D U axis on flipped cardinal cuts
+    // (see `projectTo2D` in @ifc-lite/drawing-2d/math.ts and `flipU` in the
+    // GPU cutter). Annotation primitives come out of WASM in the cutter's
+    // UNFLIPPED basis, so on a flipped section they'd sit beside the model
+    // (mirrored across X=0) instead of on top of it — exactly the
+    // "dimensions floating to the right of the floor plan" symptom. Mirror
+    // X for lines/texts/fills here so they line up with the section cut
+    // output drawn underneath. Y stays put (the cutter only flips U).
+    const pushLine = flipped
+      ? (ln: DrawingLine2D) => lines.push({
+          line: {
+            start: { x: -ln.line.start.x, y: ln.line.start.y },
+            end:   { x: -ln.line.end.x,   y: ln.line.end.y   },
+          },
+          category: ln.category,
+        })
+      : (ln: DrawingLine2D) => lines.push(ln);
+    const pushText = flipped
+      ? (t: AnnotationText2D) => texts.push({ ...t, x: -t.x, dirX: -t.dirX })
+      : (t: AnnotationText2D) => texts.push(t);
+    const pushFill = flipped
+      ? (f: AnnotationFill2D) => {
+          const src = f.points;
+          const dst = new Float32Array(src.length);
+          for (let i = 0; i < src.length; i += 2) {
+            dst[i]     = -src[i];
+            dst[i + 1] =  src[i + 1];
+          }
+          fills.push({ ...f, points: dst });
+        }
+      : (f: AnnotationFill2D) => fills.push(f);
+
     for (const store of stores) {
       const key = sourceKey(store);
       if (!key) continue;
@@ -682,9 +726,9 @@ export function useSymbolicAnnotationsForDrawing(params: {
       for (const bucket of cached.byStorey.values()) {
         const bucketY = resolveBucketY(bucket.storeyElevation, fallbackY);
         if (bucketY < rangeMin || bucketY > rangeMax) continue;
-        for (const ln of bucket.lines) lines.push(ln);
-        for (const t of bucket.texts) texts.push(t);
-        for (const f of bucket.fills) fills.push(f);
+        for (const ln of bucket.lines) pushLine(ln);
+        for (const t of bucket.texts) pushText(t);
+        for (const f of bucket.fills) pushFill(f);
       }
 
       // Loose annotations have no resolvable storey — include them if the
@@ -692,9 +736,9 @@ export function useSymbolicAnnotationsForDrawing(params: {
       // (e.g. 3DEXPERIENCE files with orphaned storeys) usable when the
       // user is looking at the storey the fallback resolves to.
       if (fallbackY >= rangeMin && fallbackY <= rangeMax) {
-        for (const ln of cached.loose) lines.push(ln);
-        for (const t of cached.looseTexts) texts.push(t);
-        for (const f of cached.looseFills) fills.push(f);
+        for (const ln of cached.loose) pushLine(ln);
+        for (const t of cached.looseTexts) pushText(t);
+        for (const f of cached.looseFills) pushFill(f);
       }
     }
 

package/dist/assets/raw-CoIXstQ-.js

@@ -1 +0,0 @@
-import{B as o}from"./geotiff-y0ZxbRJd.js";import"./sandbox-DETNEyQb.js";import"./lens-PYsLu_MA.js";import"./__vite-browser-external-B1O5LaIO.js";class c extends o{decodeBlock(e){return e}}export{c as default};