@collabdt/core 0.0.40

package/dist/core/components/viewers/bim/src/lib/drawingProjection.d.ts

@@ -0,0 +1,101 @@
+import * as OBC from '@thatopen/components';
+import * as THREE from 'three';
+import { DrawingLayerInfo } from './drawingLayers';
+export declare const FONT_URL = "https://thatopen.github.io/engine_components/resources/fonts/PlusJakartaSans-Medium.ttf";
+export declare const VISIBLE_LAYER = "Visible";
+export declare const HIDDEN_LAYER = "Hidden";
+export declare const ANNOTATIONS_LAYER = "Annotations";
+export interface DrawingViewportConfig {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    scale?: number;
+    name?: string;
+}
+export interface DrawingConfig {
+    /** Direction the drawing's "camera" looks. Top-down floorplan: (0,-1,0).
+     *  North elevation: (0,0,-1). Etc. */
+    orientation: THREE.Vector3;
+    /** World position of the drawing plane. */
+    position: THREE.Vector3;
+    /** Depth captured from the plane along the orientation. */
+    far: number;
+    viewport: DrawingViewportConfig;
+}
+/**
+ * Lazy, idempotent setup of `OBF.DrawingEditor` (font + source world).
+ * Call before any drawing-projection work.
+ */
+export declare class DrawingEditorReady {
+    private components;
+    private _fontLoaded;
+    private _editorSourceSet;
+    constructor(components: OBC.Components);
+    ensure(): Promise<void>;
+}
+/** Create a new TechnicalDrawing pre-configured with the standard
+ *  visible/hidden/annotations layers + viewport. Caller still needs to
+ *  add projection items (`addProjectionFromItems`). */
+export declare function createDrawing(components: OBC.Components, config: DrawingConfig): OBC.TechnicalDrawing | null;
+/** Force ProjectionGenerator off the WebGPU path (it silently returns 0
+ *  edges when WebGPU is unavailable in the browser, which @thatopen
+ *  components 3.4 hits). Idempotent. */
+export declare function disableProjectorWebGPU(components: OBC.Components): void;
+/** Patch a model's `getItemsGeometry` to give every entry a unique
+ *  representationId. EdgeProjector at index.mjs:11228 uses
+ *  `!geomData.representationId` to validate, so id=0 is incorrectly
+ *  skipped — and the fragments worker for our models returns 0 for every
+ *  entry. Idempotent per model via a flag on the model itself. */
+export declare function patchModelGeometryRepresentationIds(model: any): void;
+/** Add the projection lines for the given item ids to a drawing. Lays
+ *  them into the standard visible/hidden layers. */
+export declare function addItemsProjection(drawing: OBC.TechnicalDrawing, modelId: string, itemIds: number[]): Promise<void>;
+/**
+ * Project items grouped by IFC class into per-class drawing layers. Each
+ * class gets its own visible layer with a default color (cut classes black,
+ * everything else mid-gray); the hidden side of every class shares the
+ * standard `HIDDEN_LAYER`.
+ *
+ * Returns metadata used by the sidebar UI (visibility toggles + color
+ * pickers) and the future DXF export. Skipping classes whose projection
+ * fails — one broken class shouldn't strand the rest of the drawing.
+ */
+export declare function addItemsProjectionByClass(drawing: OBC.TechnicalDrawing, modelId: string, itemIdsByClass: Map<string, number[]>, onClassDone?: (className: string) => void): Promise<DrawingLayerInfo[]>;
+/**
+ * Group a model's geometric item ids by IFC class. Optional `idFilter`
+ * narrows the result to a specific subset (e.g. items in a single storey).
+ */
+export declare function getItemIdsByClass(model: any, idFilter?: Set<number>): Promise<Map<string, number[]>>;
+/**
+ * Project items into per-IFC-class drawing layers using a SINGLE
+ * EdgeProjector pass. The visibility culler then sees the union of all
+ * meshes and classifies each edge against the full scene — so a wall in
+ * front of a chair correctly hides the chair's edges, even though they
+ * end up on different layers.
+ *
+ * Use this for elevation drawings, where the entire building depth is
+ * visible. {@link addItemsProjectionByClass} stays appropriate for
+ * floorplans, where the section clip already limits depth and the per-
+ * class path is faster.
+ *
+ * Hidden edges are intentionally discarded — the elevation should only
+ * show the lines of objects immediately visible to the camera.
+ */
+export declare function addItemsProjectionByClassOccluded(drawing: OBC.TechnicalDrawing, components: OBC.Components, modelId: string, itemIdsByClass: Map<string, number[]>): Promise<DrawingLayerInfo[]>;
+export declare function disposeDrawing(components: OBC.Components, drawing: OBC.TechnicalDrawing | null): void;
+export declare const DOOR_SWING_LAYER = "Door Swings";
+/**
+ * Add a quarter-circle swing arc for every IFCDOOR in `idFilter` whose
+ * bbox sits at the active storey's elevation. Returns a `DrawingLayerInfo`
+ * for the new `Door Swings` layer (or null if no doors qualified), so the
+ * caller can append it to the sidebar's toggleable layer list.
+ *
+ * The arc radius matches the door's widest horizontal dimension;
+ * orientation is inferred from the bbox — the larger horizontal extent
+ * is the door width direction, the smaller is wall thickness.
+ *
+ * Best-effort: missing bbox or implausibly-sized doors are skipped silently.
+ */
+export declare function addDoorSwingsToDrawing(drawing: OBC.TechnicalDrawing, model: any, idFilter: Set<number> | null, storeyY: number): Promise<DrawingLayerInfo | null>;
+//# sourceMappingURL=drawingProjection.d.ts.map

package/dist/core/components/viewers/bim/src/lib/drawingProjection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drawingProjection.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/components/viewers/bim/src/lib/drawingProjection.ts"],"names":[],"mappings":"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"}

package/dist/core/components/viewers/bim/src/lib/drawingProjection.js

@@ -0,0 +1,362 @@
+import * as OBC from "@thatopen/components";
+import * as OBF from "@thatopen/components-front";
+import * as THREE from "three";
+import { CurrentWorld } from "../CurrentWorld";
+import {
+  defaultLayerColor,
+  sortClassesByPriority
+} from "./drawingLayers";
+const FONT_URL = "https://thatopen.github.io/engine_components/resources/fonts/PlusJakartaSans-Medium.ttf";
+const VISIBLE_LAYER = "Visible";
+const HIDDEN_LAYER = "Hidden";
+const ANNOTATIONS_LAYER = "Annotations";
+class DrawingEditorReady {
+  constructor(components) {
+    this.components = components;
+    this._fontLoaded = false;
+    this._editorSourceSet = false;
+  }
+  async ensure() {
+    const editor = this.components.get(OBF.DrawingEditor);
+    if (!this._fontLoaded) {
+      try {
+        await editor.fonts.load(FONT_URL);
+      } catch (error) {
+        console.warn("[drawingProjection] Font load failed:", error);
+      }
+      this._fontLoaded = true;
+    }
+    if (!this._editorSourceSet) {
+      const sourceWorld = this.components.get(CurrentWorld).world;
+      if (sourceWorld) {
+        editor.setSource(sourceWorld);
+        this._editorSourceSet = true;
+      }
+    }
+  }
+}
+function createDrawing(components, config) {
+  var _a, _b;
+  const sourceWorld = components.get(CurrentWorld).world;
+  if (!sourceWorld) return null;
+  const techDrawings = components.get(OBC.TechnicalDrawings);
+  const drawing = techDrawings.create(sourceWorld);
+  drawing.orientTo(config.orientation.clone());
+  drawing.three.position.copy(config.position);
+  drawing.three.visible = false;
+  drawing.far = config.far;
+  drawing.layers.create(VISIBLE_LAYER, {
+    material: new THREE.LineBasicMaterial({ color: 0 })
+  });
+  drawing.layers.create(HIDDEN_LAYER, {
+    material: new THREE.LineDashedMaterial({
+      color: 8947848,
+      dashSize: 0.2,
+      gapSize: 0.1
+    }),
+    visible: false
+  });
+  drawing.layers.create(ANNOTATIONS_LAYER, {
+    material: new THREE.LineBasicMaterial({ color: 0 })
+  });
+  drawing.activeLayer = ANNOTATIONS_LAYER;
+  drawing.viewports.create({
+    left: config.viewport.left,
+    right: config.viewport.right,
+    top: config.viewport.top,
+    bottom: config.viewport.bottom,
+    scale: (_a = config.viewport.scale) != null ? _a : 100,
+    name: (_b = config.viewport.name) != null ? _b : "Drawing"
+  });
+  return drawing;
+}
+function disableProjectorWebGPU(components) {
+  const projector = components.get(OBC.EdgeProjector);
+  projector.generator.useWebGPU = false;
+}
+function patchModelGeometryRepresentationIds(model) {
+  if (model._floorplanGeometryPatched) return;
+  const original = model.getItemsGeometry.bind(model);
+  let counter = 1;
+  model.getItemsGeometry = async (ids) => {
+    const data = await original(ids);
+    if (data && typeof data === "object") {
+      const arrays = Array.isArray(data) ? data : Object.values(data);
+      for (const arr of arrays) {
+        if (!Array.isArray(arr)) continue;
+        for (const g of arr) {
+          if (g && (g.representationId === 0 || g.representationId == null || g.representationId === "")) {
+            g.representationId = `cdt-rep-${counter++}`;
+          }
+        }
+      }
+    }
+    return data;
+  };
+  model._floorplanGeometryPatched = true;
+}
+async function addItemsProjection(drawing, modelId, itemIds) {
+  if (itemIds.length === 0) return;
+  const modelIdMap = { [modelId]: new Set(itemIds) };
+  await drawing.addProjectionFromItems(modelIdMap, {
+    layers: { visible: VISIBLE_LAYER, hidden: HIDDEN_LAYER }
+  });
+}
+async function addItemsProjectionByClass(drawing, modelId, itemIdsByClass, onClassDone) {
+  const layers = [];
+  for (const [className, ids] of itemIdsByClass) {
+    if (ids.length === 0) continue;
+    const color = defaultLayerColor(className);
+    if (!drawing.layers.has(className)) {
+      drawing.layers.create(className, {
+        material: new THREE.LineBasicMaterial({ color })
+      });
+    }
+    const modelIdMap = { [modelId]: new Set(ids) };
+    try {
+      await drawing.addProjectionFromItems(modelIdMap, {
+        layers: { visible: className, hidden: HIDDEN_LAYER }
+      });
+    } catch (error) {
+      console.warn(
+        `[drawingProjection] projection for ${className} failed:`,
+        error
+      );
+      continue;
+    }
+    layers.push({
+      className,
+      layerName: className,
+      visible: true,
+      color,
+      itemCount: ids.length
+    });
+    onClassDone == null ? void 0 : onClassDone(className);
+  }
+  return layers;
+}
+async function getItemIdsByClass(model, idFilter) {
+  const all = await model.getItemsOfCategories([/^IFC/]);
+  const result = /* @__PURE__ */ new Map();
+  for (const [className, ids] of Object.entries(all)) {
+    const filtered = idFilter ? ids.filter((id) => idFilter.has(id)) : ids;
+    if (filtered.length > 0) result.set(className, filtered);
+  }
+  return sortClassesByPriority(result);
+}
+async function addItemsProjectionByClassOccluded(drawing, components, modelId, itemIdsByClass) {
+  const world = components.get(CurrentWorld).world;
+  if (!world) return [];
+  const allIds = /* @__PURE__ */ new Set();
+  const idToClass = /* @__PURE__ */ new Map();
+  for (const [className, ids] of itemIdsByClass) {
+    for (const id of ids) {
+      allIds.add(id);
+      idToClass.set(id, className);
+    }
+  }
+  if (allIds.size === 0) return [];
+  const projector = components.get(OBC.EdgeProjector);
+  projector.generator.useWebGPU = false;
+  const savedDir = projector.projectionDirection.clone();
+  const savedNear = projector.nearPlane;
+  const savedFar = projector.farPlane;
+  let result;
+  try {
+    drawing.three.updateWorldMatrix(true, false);
+    const projDir = new THREE.Vector3(0, -1, 0).transformDirection(drawing.three.matrixWorld).normalize();
+    projector.projectionDirection.copy(projDir);
+    const rotMat = new THREE.Matrix4().makeRotationFromQuaternion(
+      new THREE.Quaternion().setFromUnitVectors(
+        projDir,
+        new THREE.Vector3(0, -1, 0)
+      )
+    );
+    const planeY = new THREE.Vector3().setFromMatrixPosition(drawing.three.matrixWorld).applyMatrix4(rotMat).y;
+    projector.farPlane = planeY;
+    projector.nearPlane = planeY - drawing.far;
+    const modelIdMap = { [modelId]: allIds };
+    result = await projector.get(modelIdMap, world);
+  } finally {
+    projector.projectionDirection.copy(savedDir);
+    projector.nearPlane = savedNear;
+    projector.farPlane = savedFar;
+  }
+  for (const className of itemIdsByClass.keys()) {
+    if (!drawing.layers.has(className)) {
+      drawing.layers.create(className, {
+        material: new THREE.LineBasicMaterial({
+          color: defaultLayerColor(className)
+        })
+      });
+    }
+  }
+  return splitVisibleByClass(drawing, result, idToClass, itemIdsByClass);
+}
+function splitVisibleByClass(drawing, result, idToClass, itemIdsByClass) {
+  const visibleGeom = result.visible;
+  const positionsAttr = visibleGeom.getAttribute("position");
+  const groupAttr = visibleGeom.getAttribute("group");
+  if (!positionsAttr) return [];
+  const buf = /* @__PURE__ */ new Map();
+  const items = /* @__PURE__ */ new Map();
+  for (const className of itemIdsByClass.keys()) {
+    buf.set(className, []);
+    items.set(className, /* @__PURE__ */ new Set());
+  }
+  if (!groupAttr) return [];
+  const positionArr = positionsAttr.array;
+  const groupArr = groupAttr.array;
+  const vertexCount = positionsAttr.count;
+  for (let i = 0; i < vertexCount; i += 2) {
+    const groupIndex = Number(groupArr[i]);
+    const groupInfo = result.groups[groupIndex];
+    if (!groupInfo) continue;
+    const className = idToClass.get(groupInfo.localId);
+    if (!className) continue;
+    const verts = buf.get(className);
+    if (!verts) continue;
+    const start = i * 3;
+    verts.push(
+      positionArr[start],
+      positionArr[start + 1],
+      positionArr[start + 2],
+      positionArr[start + 3],
+      positionArr[start + 4],
+      positionArr[start + 5]
+    );
+    items.get(className).add(groupInfo.localId);
+  }
+  const layers = [];
+  for (const [className, verts] of buf) {
+    if (verts.length === 0) continue;
+    const geom = new THREE.BufferGeometry();
+    geom.setAttribute(
+      "position",
+      new THREE.Float32BufferAttribute(new Float32Array(verts), 3)
+    );
+    const sourceLine = new THREE.LineSegments(geom);
+    const projected = OBC.TechnicalDrawing.toDrawingSpace(sourceLine, drawing);
+    drawing.addProjectionLines(projected, className);
+    layers.push({
+      className,
+      layerName: className,
+      visible: true,
+      color: defaultLayerColor(className),
+      itemCount: items.get(className).size
+    });
+  }
+  return layers;
+}
+function disposeDrawing(components, drawing) {
+  if (!drawing) return;
+  try {
+    const techDrawings = components.get(OBC.TechnicalDrawings);
+    techDrawings.list.delete(drawing.uuid);
+  } catch (e) {
+  }
+}
+const DOOR_SWING_LAYER = "Door Swings";
+const DOOR_SWING_COLOR = 6710886;
+const DOOR_SWING_SEGMENTS = 16;
+const DOOR_STOREY_Y_TOLERANCE = 0.6;
+async function addDoorSwingsToDrawing(drawing, model, idFilter, storeyY) {
+  var _a, _b;
+  const doorMap = await model.getItemsOfCategories([/IFCDOOR/]);
+  let doorIds = Object.values(doorMap).flat();
+  if (idFilter) doorIds = doorIds.filter((id) => idFilter.has(id));
+  if (doorIds.length === 0) return null;
+  const boxes = await model.getBoxes(doorIds);
+  if (!boxes || boxes.length === 0) return null;
+  const geomDataPerDoor = await model.getItemsGeometry(doorIds);
+  if (!drawing.layers.has(DOOR_SWING_LAYER)) {
+    drawing.layers.create(DOOR_SWING_LAYER, {
+      material: new THREE.LineBasicMaterial({ color: DOOR_SWING_COLOR })
+    });
+  }
+  const modelMatrix = (_a = model.object) == null ? void 0 : _a.matrixWorld;
+  const verts = [];
+  let drawnCount = 0;
+  for (let i = 0; i < boxes.length; i++) {
+    const box = boxes[i];
+    if (!box || box.isEmpty()) continue;
+    const worldBox = box;
+    if (Math.abs(worldBox.min.y - storeyY) > DOOR_STOREY_Y_TOLERANCE) continue;
+    const size = new THREE.Vector3();
+    worldBox.getSize(size);
+    const bboxWidth = Math.max(size.x, size.z);
+    if (bboxWidth < 0.6 || bboxWidth > 2.5) continue;
+    const center = new THREE.Vector3();
+    worldBox.getCenter(center);
+    const itemMeshes = geomDataPerDoor == null ? void 0 : geomDataPerDoor[i];
+    const localTransform = (_b = itemMeshes == null ? void 0 : itemMeshes[0]) == null ? void 0 : _b.transform;
+    let widthDir;
+    let swingDir;
+    if (localTransform) {
+      const worldTransform = new THREE.Matrix4();
+      if (modelMatrix) worldTransform.copy(modelMatrix);
+      worldTransform.multiply(localTransform);
+      widthDir = new THREE.Vector3().setFromMatrixColumn(worldTransform, 0).setY(0);
+      if (widthDir.lengthSq() < 1e-6) {
+        widthDir = size.x >= size.z ? new THREE.Vector3(1, 0, 0) : new THREE.Vector3(0, 0, 1);
+      } else {
+        widthDir.normalize();
+      }
+      swingDir = new THREE.Vector3(-widthDir.z, 0, widthDir.x);
+    } else {
+      const widthAlongX = size.x >= size.z;
+      widthDir = widthAlongX ? new THREE.Vector3(1, 0, 0) : new THREE.Vector3(0, 0, 1);
+      swingDir = widthAlongX ? new THREE.Vector3(0, 0, 1) : new THREE.Vector3(1, 0, 0);
+    }
+    const width = Math.abs(size.x * widthDir.x) + Math.abs(size.z * widthDir.z);
+    if (width < 0.6 || width > 2.5) continue;
+    const hinge = new THREE.Vector3().copy(center).addScaledVector(widthDir, -width / 2);
+    let prev = null;
+    for (let s = 0; s <= DOOR_SWING_SEGMENTS; s++) {
+      const t = s / DOOR_SWING_SEGMENTS * (Math.PI / 2);
+      const point = new THREE.Vector3().copy(hinge).addScaledVector(widthDir, Math.cos(t) * width).addScaledVector(swingDir, Math.sin(t) * width);
+      if (prev) {
+        verts.push(prev.x, prev.y, prev.z, point.x, point.y, point.z);
+      }
+      prev = point;
+    }
+    const open = new THREE.Vector3().copy(hinge).addScaledVector(swingDir, width);
+    verts.push(hinge.x, hinge.y, hinge.z, open.x, open.y, open.z);
+    drawnCount++;
+  }
+  if (verts.length === 0) return null;
+  const geometry = new THREE.BufferGeometry();
+  geometry.setAttribute(
+    "position",
+    new THREE.Float32BufferAttribute(new Float32Array(verts), 3)
+  );
+  const sourceLine = new THREE.LineSegments(geometry);
+  const projected = OBC.TechnicalDrawing.toDrawingSpace(sourceLine, drawing);
+  drawing.addProjectionLines(projected, DOOR_SWING_LAYER);
+  return {
+    className: DOOR_SWING_LAYER,
+    layerName: DOOR_SWING_LAYER,
+    visible: true,
+    color: DOOR_SWING_COLOR,
+    itemCount: drawnCount,
+    displayKey: "DrawingLayers.doorSwings"
+  };
+}
+export {
+  ANNOTATIONS_LAYER,
+  DOOR_SWING_LAYER,
+  DrawingEditorReady,
+  FONT_URL,
+  HIDDEN_LAYER,
+  VISIBLE_LAYER,
+  addDoorSwingsToDrawing,
+  addItemsProjection,
+  addItemsProjectionByClass,
+  addItemsProjectionByClassOccluded,
+  createDrawing,
+  disableProjectorWebGPU,
+  disposeDrawing,
+  getItemIdsByClass,
+  patchModelGeometryRepresentationIds
+};
+//# sourceMappingURL=drawingProjection.js.map

package/dist/core/components/viewers/bim/src/lib/drawingProjection.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/core/components/viewers/bim/src/lib/drawingProjection.ts"],"sourcesContent":["import * as OBC from '@thatopen/components'\r\nimport * as OBF from '@thatopen/components-front'\r\nimport * as THREE from 'three'\r\nimport { CurrentWorld } from '../CurrentWorld'\r\nimport {\r\n  defaultLayerColor,\r\n  DrawingLayerInfo,\r\n  sortClassesByPriority,\r\n} from './drawingLayers'\r\n\r\nexport const FONT_URL =\r\n  'https://thatopen.github.io/engine_components/resources/fonts/PlusJakartaSans-Medium.ttf'\r\n\r\nexport const VISIBLE_LAYER = 'Visible'\r\nexport const HIDDEN_LAYER = 'Hidden'\r\nexport const ANNOTATIONS_LAYER = 'Annotations'\r\n\r\nexport interface DrawingViewportConfig {\r\n  left: number\r\n  right: number\r\n  top: number\r\n  bottom: number\r\n  scale?: number\r\n  name?: string\r\n}\r\n\r\nexport interface DrawingConfig {\r\n  /** Direction the drawing's \"camera\" looks. Top-down floorplan: (0,-1,0).\r\n   *  North elevation: (0,0,-1). Etc. */\r\n  orientation: THREE.Vector3\r\n  /** World position of the drawing plane. */\r\n  position: THREE.Vector3\r\n  /** Depth captured from the plane along the orientation. */\r\n  far: number\r\n  viewport: DrawingViewportConfig\r\n}\r\n\r\n/**\r\n * Lazy, idempotent setup of `OBF.DrawingEditor` (font + source world).\r\n * Call before any drawing-projection work.\r\n */\r\nexport class DrawingEditorReady {\r\n  private _fontLoaded = false\r\n  private _editorSourceSet = false\r\n\r\n  constructor(private components: OBC.Components) {}\r\n\r\n  async ensure() {\r\n    const editor = this.components.get(OBF.DrawingEditor)\r\n\r\n    if (!this._fontLoaded) {\r\n      try {\r\n        await editor.fonts.load(FONT_URL)\r\n      } catch (error) {\r\n        console.warn('[drawingProjection] Font load failed:', error)\r\n      }\r\n      this._fontLoaded = true\r\n    }\r\n\r\n    if (!this._editorSourceSet) {\r\n      const sourceWorld = this.components.get(CurrentWorld).world\r\n      if (sourceWorld) {\r\n        editor.setSource(sourceWorld)\r\n        this._editorSourceSet = true\r\n      }\r\n    }\r\n  }\r\n}\r\n\r\n/** Create a new TechnicalDrawing pre-configured with the standard\r\n *  visible/hidden/annotations layers + viewport. Caller still needs to\r\n *  add projection items (`addProjectionFromItems`). */\r\nexport function createDrawing(\r\n  components: OBC.Components,\r\n  config: DrawingConfig,\r\n): OBC.TechnicalDrawing | null {\r\n  const sourceWorld = components.get(CurrentWorld).world\r\n  if (!sourceWorld) return null\r\n\r\n  const techDrawings = components.get(OBC.TechnicalDrawings)\r\n  const drawing = techDrawings.create(sourceWorld)\r\n  drawing.orientTo(config.orientation.clone())\r\n  drawing.three.position.copy(config.position)\r\n  drawing.three.visible = false\r\n  drawing.far = config.far\r\n\r\n  drawing.layers.create(VISIBLE_LAYER, {\r\n    material: new THREE.LineBasicMaterial({ color: 0x000000 }),\r\n  })\r\n  drawing.layers.create(HIDDEN_LAYER, {\r\n    material: new THREE.LineDashedMaterial({\r\n      color: 0x888888,\r\n      dashSize: 0.2,\r\n      gapSize: 0.1,\r\n    }),\r\n    visible: false,\r\n  } as any)\r\n  drawing.layers.create(ANNOTATIONS_LAYER, {\r\n    material: new THREE.LineBasicMaterial({ color: 0x000000 }),\r\n  })\r\n  drawing.activeLayer = ANNOTATIONS_LAYER\r\n\r\n  drawing.viewports.create({\r\n    left: config.viewport.left,\r\n    right: config.viewport.right,\r\n    top: config.viewport.top,\r\n    bottom: config.viewport.bottom,\r\n    scale: config.viewport.scale ?? 100,\r\n    name: config.viewport.name ?? 'Drawing',\r\n  })\r\n\r\n  return drawing\r\n}\r\n\r\n/** Force ProjectionGenerator off the WebGPU path (it silently returns 0\r\n *  edges when WebGPU is unavailable in the browser, which @thatopen\r\n *  components 3.4 hits). Idempotent. */\r\nexport function disableProjectorWebGPU(components: OBC.Components) {\r\n  const projector = components.get(OBC.EdgeProjector)\r\n  ;(projector as any).generator.useWebGPU = false\r\n}\r\n\r\n/** Patch a model's `getItemsGeometry` to give every entry a unique\r\n *  representationId. EdgeProjector at index.mjs:11228 uses\r\n *  `!geomData.representationId` to validate, so id=0 is incorrectly\r\n *  skipped — and the fragments worker for our models returns 0 for every\r\n *  entry. Idempotent per model via a flag on the model itself. */\r\nexport function patchModelGeometryRepresentationIds(model: any) {\r\n  if (model._floorplanGeometryPatched) return\r\n  const original = model.getItemsGeometry.bind(model)\r\n  let counter = 1\r\n  model.getItemsGeometry = async (ids: number[]) => {\r\n    const data = await original(ids)\r\n    if (data && typeof data === 'object') {\r\n      const arrays = Array.isArray(data) ? data : Object.values(data)\r\n      for (const arr of arrays) {\r\n        if (!Array.isArray(arr)) continue\r\n        for (const g of arr) {\r\n          if (\r\n            g &&\r\n            (g.representationId === 0 ||\r\n              g.representationId == null ||\r\n              g.representationId === '')\r\n          ) {\r\n            g.representationId = `cdt-rep-${counter++}`\r\n          }\r\n        }\r\n      }\r\n    }\r\n    return data\r\n  }\r\n  model._floorplanGeometryPatched = true\r\n}\r\n\r\n/** Add the projection lines for the given item ids to a drawing. Lays\r\n *  them into the standard visible/hidden layers. */\r\nexport async function addItemsProjection(\r\n  drawing: OBC.TechnicalDrawing,\r\n  modelId: string,\r\n  itemIds: number[],\r\n): Promise<void> {\r\n  if (itemIds.length === 0) return\r\n  const modelIdMap: OBC.ModelIdMap = { [modelId]: new Set(itemIds) }\r\n  await drawing.addProjectionFromItems(modelIdMap, {\r\n    layers: { visible: VISIBLE_LAYER, hidden: HIDDEN_LAYER },\r\n  })\r\n}\r\n\r\n/**\r\n * Project items grouped by IFC class into per-class drawing layers. Each\r\n * class gets its own visible layer with a default color (cut classes black,\r\n * everything else mid-gray); the hidden side of every class shares the\r\n * standard `HIDDEN_LAYER`.\r\n *\r\n * Returns metadata used by the sidebar UI (visibility toggles + color\r\n * pickers) and the future DXF export. Skipping classes whose projection\r\n * fails — one broken class shouldn't strand the rest of the drawing.\r\n */\r\nexport async function addItemsProjectionByClass(\r\n  drawing: OBC.TechnicalDrawing,\r\n  modelId: string,\r\n  itemIdsByClass: Map<string, number[]>,\r\n  onClassDone?: (className: string) => void,\r\n): Promise<DrawingLayerInfo[]> {\r\n  const layers: DrawingLayerInfo[] = []\r\n  for (const [className, ids] of itemIdsByClass) {\r\n    if (ids.length === 0) continue\r\n    const color = defaultLayerColor(className)\r\n    if (!drawing.layers.has(className)) {\r\n      drawing.layers.create(className, {\r\n        material: new THREE.LineBasicMaterial({ color }),\r\n      })\r\n    }\r\n    const modelIdMap: OBC.ModelIdMap = { [modelId]: new Set(ids) }\r\n    try {\r\n      await drawing.addProjectionFromItems(modelIdMap, {\r\n        layers: { visible: className, hidden: HIDDEN_LAYER },\r\n      })\r\n    } catch (error) {\r\n      console.warn(\r\n        `[drawingProjection] projection for ${className} failed:`,\r\n        error,\r\n      )\r\n      continue\r\n    }\r\n    layers.push({\r\n      className,\r\n      layerName: className,\r\n      visible: true,\r\n      color,\r\n      itemCount: ids.length,\r\n    })\r\n    onClassDone?.(className)\r\n  }\r\n  return layers\r\n}\r\n\r\n/**\r\n * Group a model's geometric item ids by IFC class. Optional `idFilter`\r\n * narrows the result to a specific subset (e.g. items in a single storey).\r\n */\r\nexport async function getItemIdsByClass(\r\n  model: any,\r\n  idFilter?: Set<number>,\r\n): Promise<Map<string, number[]>> {\r\n  const all = (await model.getItemsOfCategories([/^IFC/])) as Record<\r\n    string,\r\n    number[]\r\n  >\r\n  const result = new Map<string, number[]>()\r\n  for (const [className, ids] of Object.entries(all)) {\r\n    const filtered = idFilter ? ids.filter((id) => idFilter.has(id)) : ids\r\n    if (filtered.length > 0) result.set(className, filtered)\r\n  }\r\n  // Walls, columns, slabs, curtain-walls render first so they appear early\r\n  // during progressive projection; everything else follows.\r\n  return sortClassesByPriority(result)\r\n}\r\n\r\n/**\r\n * Project items into per-IFC-class drawing layers using a SINGLE\r\n * EdgeProjector pass. The visibility culler then sees the union of all\r\n * meshes and classifies each edge against the full scene — so a wall in\r\n * front of a chair correctly hides the chair's edges, even though they\r\n * end up on different layers.\r\n *\r\n * Use this for elevation drawings, where the entire building depth is\r\n * visible. {@link addItemsProjectionByClass} stays appropriate for\r\n * floorplans, where the section clip already limits depth and the per-\r\n * class path is faster.\r\n *\r\n * Hidden edges are intentionally discarded — the elevation should only\r\n * show the lines of objects immediately visible to the camera.\r\n */\r\nexport async function addItemsProjectionByClassOccluded(\r\n  drawing: OBC.TechnicalDrawing,\r\n  components: OBC.Components,\r\n  modelId: string,\r\n  itemIdsByClass: Map<string, number[]>,\r\n): Promise<DrawingLayerInfo[]> {\r\n  const world = components.get(CurrentWorld).world\r\n  if (!world) return []\r\n\r\n  // Build flat id set + reverse map (localId → className) so we can bin the\r\n  // resulting line segments by their source class.\r\n  const allIds = new Set<number>()\r\n  const idToClass = new Map<number, string>()\r\n  for (const [className, ids] of itemIdsByClass) {\r\n    for (const id of ids) {\r\n      allIds.add(id)\r\n      idToClass.set(id, className)\r\n    }\r\n  }\r\n  if (allIds.size === 0) return []\r\n\r\n  const projector = components.get(OBC.EdgeProjector)\r\n  ;(projector as any).generator.useWebGPU = false\r\n\r\n  // Mirror the projection-direction + near/far plane setup that\r\n  // `TechnicalDrawing.addProjectionFromItems` uses internally — see\r\n  // node_modules/@thatopen/components/dist/index.mjs::addProjectionFromItems.\r\n  const savedDir = projector.projectionDirection.clone()\r\n  const savedNear = projector.nearPlane\r\n  const savedFar = projector.farPlane\r\n  let result: OBC.EdgeProjectionResult\r\n  try {\r\n    drawing.three.updateWorldMatrix(true, false)\r\n    const projDir = new THREE.Vector3(0, -1, 0)\r\n      .transformDirection(drawing.three.matrixWorld)\r\n      .normalize()\r\n    projector.projectionDirection.copy(projDir)\r\n    const rotMat = new THREE.Matrix4().makeRotationFromQuaternion(\r\n      new THREE.Quaternion().setFromUnitVectors(\r\n        projDir,\r\n        new THREE.Vector3(0, -1, 0),\r\n      ),\r\n    )\r\n    const planeY = new THREE.Vector3()\r\n      .setFromMatrixPosition(drawing.three.matrixWorld)\r\n      .applyMatrix4(rotMat).y\r\n    projector.farPlane = planeY\r\n    projector.nearPlane = planeY - drawing.far\r\n\r\n    const modelIdMap: OBC.ModelIdMap = { [modelId]: allIds }\r\n    result = await projector.get(modelIdMap, world)\r\n  } finally {\r\n    projector.projectionDirection.copy(savedDir)\r\n    projector.nearPlane = savedNear\r\n    projector.farPlane = savedFar\r\n  }\r\n\r\n  // Pre-create empty layers so the panel UI lists every class even if its\r\n  // edges all ended up occluded (count = 0 for hidden classes).\r\n  for (const className of itemIdsByClass.keys()) {\r\n    if (!drawing.layers.has(className)) {\r\n      drawing.layers.create(className, {\r\n        material: new THREE.LineBasicMaterial({\r\n          color: defaultLayerColor(className),\r\n        }),\r\n      })\r\n    }\r\n  }\r\n\r\n  return splitVisibleByClass(drawing, result, idToClass, itemIdsByClass)\r\n}\r\n\r\n/** Walk the per-vertex `group` attribute of `result.visible`, look up the\r\n *  IFC class of the source item, and emit one `LineSegments` per class\r\n *  (transformed into drawing-local space and assigned to its layer). */\r\nfunction splitVisibleByClass(\r\n  drawing: OBC.TechnicalDrawing,\r\n  result: OBC.EdgeProjectionResult,\r\n  idToClass: Map<number, string>,\r\n  itemIdsByClass: Map<string, number[]>,\r\n): DrawingLayerInfo[] {\r\n  const visibleGeom = result.visible\r\n  const positionsAttr = visibleGeom.getAttribute('position') as\r\n    | THREE.BufferAttribute\r\n    | undefined\r\n  const groupAttr = visibleGeom.getAttribute('group') as\r\n    | THREE.BufferAttribute\r\n    | undefined\r\n  if (!positionsAttr) return []\r\n\r\n  const buf = new Map<string, number[]>()\r\n  const items = new Map<string, Set<number>>()\r\n  for (const className of itemIdsByClass.keys()) {\r\n    buf.set(className, [])\r\n    items.set(className, new Set())\r\n  }\r\n\r\n  if (!groupAttr) return [] // No group info — can't bin.\r\n\r\n  const positionArr = positionsAttr.array as Float32Array\r\n  const groupArr = groupAttr.array as ArrayLike<number>\r\n  const vertexCount = positionsAttr.count\r\n\r\n  // Each line segment = 2 consecutive vertices that share a group index\r\n  // (see ProjectedEdgeCollector::toLineGeometry in OBC's bundle).\r\n  for (let i = 0; i < vertexCount; i += 2) {\r\n    const groupIndex = Number(groupArr[i])\r\n    const groupInfo = result.groups[groupIndex]\r\n    if (!groupInfo) continue\r\n    const className = idToClass.get(groupInfo.localId)\r\n    if (!className) continue\r\n    const verts = buf.get(className)\r\n    if (!verts) continue\r\n    const start = i * 3\r\n    verts.push(\r\n      positionArr[start],\r\n      positionArr[start + 1],\r\n      positionArr[start + 2],\r\n      positionArr[start + 3],\r\n      positionArr[start + 4],\r\n      positionArr[start + 5],\r\n    )\r\n    items.get(className)!.add(groupInfo.localId)\r\n  }\r\n\r\n  const layers: DrawingLayerInfo[] = []\r\n  for (const [className, verts] of buf) {\r\n    if (verts.length === 0) continue\r\n    const geom = new THREE.BufferGeometry()\r\n    geom.setAttribute(\r\n      'position',\r\n      new THREE.Float32BufferAttribute(new Float32Array(verts), 3),\r\n    )\r\n    // Wrap in LineSegments at world origin so toDrawingSpace transforms the\r\n    // (already world-space) positions into the drawing's local XZ plane.\r\n    const sourceLine = new THREE.LineSegments(geom)\r\n    const projected = OBC.TechnicalDrawing.toDrawingSpace(sourceLine, drawing)\r\n    drawing.addProjectionLines(projected, className)\r\n    layers.push({\r\n      className,\r\n      layerName: className,\r\n      visible: true,\r\n      color: defaultLayerColor(className),\r\n      itemCount: items.get(className)!.size,\r\n    })\r\n  }\r\n  return layers\r\n}\r\n\r\nexport function disposeDrawing(\r\n  components: OBC.Components,\r\n  drawing: OBC.TechnicalDrawing | null,\r\n) {\r\n  if (!drawing) return\r\n  try {\r\n    const techDrawings = components.get(OBC.TechnicalDrawings)\r\n    techDrawings.list.delete(drawing.uuid)\r\n  } catch {\r\n    // best-effort\r\n  }\r\n}\r\n\r\nexport const DOOR_SWING_LAYER = 'Door Swings'\r\nconst DOOR_SWING_COLOR = 0x666666\r\nconst DOOR_SWING_SEGMENTS = 16\r\nconst DOOR_STOREY_Y_TOLERANCE = 0.6\r\n\r\n/**\r\n * Add a quarter-circle swing arc for every IFCDOOR in `idFilter` whose\r\n * bbox sits at the active storey's elevation. Returns a `DrawingLayerInfo`\r\n * for the new `Door Swings` layer (or null if no doors qualified), so the\r\n * caller can append it to the sidebar's toggleable layer list.\r\n *\r\n * The arc radius matches the door's widest horizontal dimension;\r\n * orientation is inferred from the bbox — the larger horizontal extent\r\n * is the door width direction, the smaller is wall thickness.\r\n *\r\n * Best-effort: missing bbox or implausibly-sized doors are skipped silently.\r\n */\r\nexport async function addDoorSwingsToDrawing(\r\n  drawing: OBC.TechnicalDrawing,\r\n  model: any,\r\n  idFilter: Set<number> | null,\r\n  storeyY: number,\r\n): Promise<DrawingLayerInfo | null> {\r\n  const doorMap = (await model.getItemsOfCategories([/IFCDOOR/])) as Record<\r\n    string,\r\n    number[]\r\n  >\r\n  let doorIds = Object.values(doorMap).flat() as number[]\r\n  if (idFilter) doorIds = doorIds.filter((id) => idFilter.has(id))\r\n  if (doorIds.length === 0) return null\r\n\r\n  // Fetch boxes (world-space AABB, used for size + Y filter) and geometry\r\n  // (per-item transform, used to recover REAL orientation — bboxes can't,\r\n  // which is why doors in curved walls or at non-axis-aligned angles get\r\n  // mis-oriented swings).\r\n  const boxes: THREE.Box3[] = await model.getBoxes(doorIds)\r\n  if (!boxes || boxes.length === 0) return null\r\n  const geomDataPerDoor = await model.getItemsGeometry(doorIds)\r\n\r\n  if (!drawing.layers.has(DOOR_SWING_LAYER)) {\r\n    drawing.layers.create(DOOR_SWING_LAYER, {\r\n      material: new THREE.LineBasicMaterial({ color: DOOR_SWING_COLOR }),\r\n    })\r\n  }\r\n\r\n  const modelMatrix = model.object?.matrixWorld as THREE.Matrix4 | undefined\r\n  const verts: number[] = []\r\n  let drawnCount = 0\r\n  for (let i = 0; i < boxes.length; i++) {\r\n    const box = boxes[i]\r\n    if (!box || box.isEmpty()) continue\r\n    // `model.getBoxes` already applies `model.object.matrixWorld` internally\r\n    // (BoxManager.getAllBoxes in @thatopen/fragments). Don't double-transform.\r\n    const worldBox = box\r\n    // Storey-Y filter: a door's bottom should sit at the active storey's\r\n    // elevation. Filters out doors that leak through from upper storeys.\r\n    if (Math.abs(worldBox.min.y - storeyY) > DOOR_STOREY_Y_TOLERANCE) continue\r\n    const size = new THREE.Vector3()\r\n    worldBox.getSize(size)\r\n    // Tighter sanity range — a typical leaf door is 0.7-1.2 m; >2.5 m is\r\n    // almost certainly a stacked / double-swing / wall-segment bbox.\r\n    const bboxWidth = Math.max(size.x, size.z)\r\n    if (bboxWidth < 0.6 || bboxWidth > 2.5) continue\r\n    const center = new THREE.Vector3()\r\n    worldBox.getCenter(center)\r\n\r\n    // Recover the door's actual orientation from its geometry transform.\r\n    // `geomData.transform` is the local-to-model matrix; combine with\r\n    // `model.object.matrixWorld` (which `getBoxes` already applied to the\r\n    // bbox) to get the world-space transform. The first column of that\r\n    // matrix is the door's local +X axis in world space — for IFC doors\r\n    // that's the width direction along the wall.\r\n    const itemMeshes = geomDataPerDoor?.[i]\r\n    const localTransform: THREE.Matrix4 | undefined = itemMeshes?.[0]?.transform\r\n    let widthDir: THREE.Vector3\r\n    let swingDir: THREE.Vector3\r\n    if (localTransform) {\r\n      const worldTransform = new THREE.Matrix4()\r\n      if (modelMatrix) worldTransform.copy(modelMatrix)\r\n      worldTransform.multiply(localTransform)\r\n      // Local +X in world space, projected to the horizontal plane.\r\n      widthDir = new THREE.Vector3()\r\n        .setFromMatrixColumn(worldTransform, 0)\r\n        .setY(0)\r\n      if (widthDir.lengthSq() < 1e-6) {\r\n        // Degenerate — door's local X points straight up. Fall back to bbox.\r\n        widthDir = size.x >= size.z\r\n          ? new THREE.Vector3(1, 0, 0)\r\n          : new THREE.Vector3(0, 0, 1)\r\n      } else {\r\n        widthDir.normalize()\r\n      }\r\n      // Swing direction = 90° rotation of width in the horizontal plane.\r\n      swingDir = new THREE.Vector3(-widthDir.z, 0, widthDir.x)\r\n    } else {\r\n      // No transform available — fall back to the original bbox heuristic\r\n      // (correct for axis-aligned doors, wrong for angled ones).\r\n      const widthAlongX = size.x >= size.z\r\n      widthDir = widthAlongX\r\n        ? new THREE.Vector3(1, 0, 0)\r\n        : new THREE.Vector3(0, 0, 1)\r\n      swingDir = widthAlongX\r\n        ? new THREE.Vector3(0, 0, 1)\r\n        : new THREE.Vector3(1, 0, 0)\r\n    }\r\n\r\n    // Door width = bbox extent projected onto widthDir. Use abs since the\r\n    // signed projection of (size.x, size.z) along widthDir can be negative.\r\n    const width = Math.abs(size.x * widthDir.x) + Math.abs(size.z * widthDir.z)\r\n    if (width < 0.6 || width > 2.5) continue\r\n\r\n    // Hinge sits at one end of the door. Step backward along widthDir by\r\n    // half the width from the center.\r\n    const hinge = new THREE.Vector3()\r\n      .copy(center)\r\n      .addScaledVector(widthDir, -width / 2)\r\n\r\n    // Build quarter-arc from angle 0 (closed-door end) → π/2 (perpendicular).\r\n    // `prev` MUST reset per door so segments don't leak between doors.\r\n    let prev: THREE.Vector3 | null = null\r\n    for (let s = 0; s <= DOOR_SWING_SEGMENTS; s++) {\r\n      const t = (s / DOOR_SWING_SEGMENTS) * (Math.PI / 2)\r\n      const point = new THREE.Vector3()\r\n        .copy(hinge)\r\n        .addScaledVector(widthDir, Math.cos(t) * width)\r\n        .addScaledVector(swingDir, Math.sin(t) * width)\r\n      if (prev) {\r\n        verts.push(prev.x, prev.y, prev.z, point.x, point.y, point.z)\r\n      }\r\n      prev = point\r\n    }\r\n    // Straight edge from hinge to swing endpoint (the open-door line).\r\n    const open = new THREE.Vector3()\r\n      .copy(hinge)\r\n      .addScaledVector(swingDir, width)\r\n    verts.push(hinge.x, hinge.y, hinge.z, open.x, open.y, open.z)\r\n    drawnCount++\r\n  }\r\n\r\n  if (verts.length === 0) return null\r\n\r\n  const geometry = new THREE.BufferGeometry()\r\n  geometry.setAttribute(\r\n    'position',\r\n    new THREE.Float32BufferAttribute(new Float32Array(verts), 3),\r\n  )\r\n  const sourceLine = new THREE.LineSegments(geometry)\r\n  const projected = OBC.TechnicalDrawing.toDrawingSpace(sourceLine, drawing)\r\n  drawing.addProjectionLines(projected, DOOR_SWING_LAYER)\r\n  return {\r\n    className: DOOR_SWING_LAYER,\r\n    layerName: DOOR_SWING_LAYER,\r\n    visible: true,\r\n    color: DOOR_SWING_COLOR,\r\n    itemCount: drawnCount,\r\n    displayKey: 'DrawingLayers.doorSwings',\r\n  }\r\n}\r\n"],"mappings":"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","names":[]}

package/dist/core/components/viewers/bim/src/lib/exportDrawingToDxf.d.ts

@@ -0,0 +1,18 @@
+import * as OBC from '@thatopen/components';
+/**
+ * Serialize a {@link OBC.TechnicalDrawing} to DXF and trigger a browser
+ * download. Each per-IFC-class drawing layer becomes a DXF layer, so the
+ * downloaded file is editable layer-by-layer in CAD software.
+ *
+ * `rotationDeg` rotates the exported geometry around the drawing's local Y
+ * axis (XZ plane) so the DXF lands in the same orientation the user sees
+ * on screen — typically the building's true-north angle. The transform is
+ * applied to a temporary clone of each `LineSegments`'s position buffer
+ * and reverted before the function returns, so the live drawing is never
+ * mutated.
+ *
+ * Uses {@link OBC.DxfManager}'s exporter — see the `OBC.DxfExporter` class
+ * documentation for the full set of supported entities.
+ */
+export declare function exportDrawingToDxf(components: OBC.Components, drawing: OBC.TechnicalDrawing, fileName: string, rotationDeg?: number): void;
+//# sourceMappingURL=exportDrawingToDxf.d.ts.map

package/dist/core/components/viewers/bim/src/lib/exportDrawingToDxf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exportDrawingToDxf.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/components/viewers/bim/src/lib/exportDrawingToDxf.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,sBAAsB,CAAA;AAG3C;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,GAAG,CAAC,UAAU,EAC1B,OAAO,EAAE,GAAG,CAAC,gBAAgB,EAC7B,QAAQ,EAAE,MAAM,EAChB,WAAW,SAAI,QAWhB"}

package/dist/core/components/viewers/bim/src/lib/exportDrawingToDxf.js

@@ -0,0 +1,56 @@
+import * as OBC from "@thatopen/components";
+import * as THREE from "three";
+function exportDrawingToDxf(components, drawing, fileName, rotationDeg = 0) {
+  const restore = applyRotationInPlace(drawing, rotationDeg);
+  try {
+    const manager = components.get(OBC.DxfManager);
+    const dxf = manager.exporter.export([{ drawing, viewports: [{}] }]);
+    triggerDownload(dxf, fileName);
+  } finally {
+    restore == null ? void 0 : restore();
+  }
+}
+function triggerDownload(dxf, fileName) {
+  const blob = new Blob([dxf], { type: "application/dxf" });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = fileName.toLowerCase().endsWith(".dxf") ? fileName : `${fileName}.dxf`;
+  document.body.appendChild(a);
+  a.click();
+  document.body.removeChild(a);
+  URL.revokeObjectURL(url);
+}
+function applyRotationInPlace(drawing, degrees) {
+  if (!degrees) return null;
+  const rad = degrees * Math.PI / 180;
+  const cos = Math.cos(rad);
+  const sin = Math.sin(rad);
+  const restorers = [];
+  drawing.three.traverse((child) => {
+    if (!(child instanceof THREE.LineSegments)) return;
+    const pos = child.geometry.attributes.position;
+    if (!pos) return;
+    const arr = pos.array;
+    const original = new Float32Array(arr.length);
+    original.set(arr);
+    for (let i = 0; i < pos.count; i++) {
+      const x = arr[i * 3];
+      const z = arr[i * 3 + 2];
+      arr[i * 3] = x * cos + z * sin;
+      arr[i * 3 + 2] = -x * sin + z * cos;
+    }
+    pos.needsUpdate = true;
+    restorers.push(() => {
+      arr.set(original);
+      pos.needsUpdate = true;
+    });
+  });
+  return () => {
+    for (const r of restorers) r();
+  };
+}
+export {
+  exportDrawingToDxf
+};
+//# sourceMappingURL=exportDrawingToDxf.js.map

package/dist/core/components/viewers/bim/src/lib/exportDrawingToDxf.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/core/components/viewers/bim/src/lib/exportDrawingToDxf.ts"],"sourcesContent":["import * as OBC from '@thatopen/components'\r\nimport * as THREE from 'three'\r\n\r\n/**\r\n * Serialize a {@link OBC.TechnicalDrawing} to DXF and trigger a browser\r\n * download. Each per-IFC-class drawing layer becomes a DXF layer, so the\r\n * downloaded file is editable layer-by-layer in CAD software.\r\n *\r\n * `rotationDeg` rotates the exported geometry around the drawing's local Y\r\n * axis (XZ plane) so the DXF lands in the same orientation the user sees\r\n * on screen — typically the building's true-north angle. The transform is\r\n * applied to a temporary clone of each `LineSegments`'s position buffer\r\n * and reverted before the function returns, so the live drawing is never\r\n * mutated.\r\n *\r\n * Uses {@link OBC.DxfManager}'s exporter — see the `OBC.DxfExporter` class\r\n * documentation for the full set of supported entities.\r\n */\r\nexport function exportDrawingToDxf(\r\n  components: OBC.Components,\r\n  drawing: OBC.TechnicalDrawing,\r\n  fileName: string,\r\n  rotationDeg = 0,\r\n) {\r\n  const restore = applyRotationInPlace(drawing, rotationDeg)\r\n  try {\r\n    const manager = components.get(OBC.DxfManager)\r\n    // Export the full drawing (no viewport clipping).\r\n    const dxf = manager.exporter.export([{ drawing, viewports: [{}] }])\r\n    triggerDownload(dxf, fileName)\r\n  } finally {\r\n    restore?.()\r\n  }\r\n}\r\n\r\nfunction triggerDownload(dxf: string, fileName: string) {\r\n  const blob = new Blob([dxf], { type: 'application/dxf' })\r\n  const url = URL.createObjectURL(blob)\r\n  const a = document.createElement('a')\r\n  a.href = url\r\n  a.download = fileName.toLowerCase().endsWith('.dxf')\r\n    ? fileName\r\n    : `${fileName}.dxf`\r\n  document.body.appendChild(a)\r\n  a.click()\r\n  document.body.removeChild(a)\r\n  URL.revokeObjectURL(url)\r\n}\r\n\r\n/**\r\n * Rotate every `LineSegments` position attribute on the drawing by\r\n * `degrees` around the drawing's local Y axis, returning a `restore()`\r\n * callback that puts the original buffers back. The rotation matches\r\n * `controls.rotateAzimuthTo` direction (positive degrees → CCW when\r\n * viewed from above), so the DXF reads as the on-screen orientation.\r\n *\r\n * Returns `null` for the no-rotation case so callers can skip the\r\n * try/finally bookkeeping.\r\n */\r\nfunction applyRotationInPlace(\r\n  drawing: OBC.TechnicalDrawing,\r\n  degrees: number,\r\n): null | (() => void) {\r\n  if (!degrees) return null\r\n  const rad = (degrees * Math.PI) / 180\r\n  const cos = Math.cos(rad)\r\n  const sin = Math.sin(rad)\r\n  const restorers: Array<() => void> = []\r\n\r\n  drawing.three.traverse((child) => {\r\n    if (!(child instanceof THREE.LineSegments)) return\r\n    const pos = child.geometry.attributes.position as\r\n      | THREE.BufferAttribute\r\n      | undefined\r\n    if (!pos) return\r\n    const arr = pos.array as Float32Array\r\n    const original = new Float32Array(arr.length)\r\n    original.set(arr)\r\n    for (let i = 0; i < pos.count; i++) {\r\n      const x = arr[i * 3]\r\n      const z = arr[i * 3 + 2]\r\n      arr[i * 3] = x * cos + z * sin\r\n      arr[i * 3 + 2] = -x * sin + z * cos\r\n    }\r\n    pos.needsUpdate = true\r\n    restorers.push(() => {\r\n      arr.set(original)\r\n      pos.needsUpdate = true\r\n    })\r\n  })\r\n\r\n  return () => {\r\n    for (const r of restorers) r()\r\n  }\r\n}\r\n"],"mappings":"AAAA,YAAY,SAAS;AACrB,YAAY,WAAW;AAiBhB,SAAS,mBACd,YACA,SACA,UACA,cAAc,GACd;AACA,QAAM,UAAU,qBAAqB,SAAS,WAAW;AACzD,MAAI;AACF,UAAM,UAAU,WAAW,IAAI,IAAI,UAAU;AAE7C,UAAM,MAAM,QAAQ,SAAS,OAAO,CAAC,EAAE,SAAS,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;AAClE,oBAAgB,KAAK,QAAQ;AAAA,EAC/B,UAAE;AACA;AAAA,EACF;AACF;AAEA,SAAS,gBAAgB,KAAa,UAAkB;AACtD,QAAM,OAAO,IAAI,KAAK,CAAC,GAAG,GAAG,EAAE,MAAM,kBAAkB,CAAC;AACxD,QAAM,MAAM,IAAI,gBAAgB,IAAI;AACpC,QAAM,IAAI,SAAS,cAAc,GAAG;AACpC,IAAE,OAAO;AACT,IAAE,WAAW,SAAS,YAAY,EAAE,SAAS,MAAM,IAC/C,WACA,GAAG,QAAQ;AACf,WAAS,KAAK,YAAY,CAAC;AAC3B,IAAE,MAAM;AACR,WAAS,KAAK,YAAY,CAAC;AAC3B,MAAI,gBAAgB,GAAG;AACzB;AAYA,SAAS,qBACP,SACA,SACqB;AACrB,MAAI,CAAC,QAAS,QAAO;AACrB,QAAM,MAAO,UAAU,KAAK,KAAM;AAClC,QAAM,MAAM,KAAK,IAAI,GAAG;AACxB,QAAM,MAAM,KAAK,IAAI,GAAG;AACxB,QAAM,YAA+B,CAAC;AAEtC,UAAQ,MAAM,SAAS,CAAC,UAAU;AAChC,QAAI,EAAE,iBAAiB,MAAM,cAAe;AAC5C,UAAM,MAAM,MAAM,SAAS,WAAW;AAGtC,QAAI,CAAC,IAAK;AACV,UAAM,MAAM,IAAI;AAChB,UAAM,WAAW,IAAI,aAAa,IAAI,MAAM;AAC5C,aAAS,IAAI,GAAG;AAChB,aAAS,IAAI,GAAG,IAAI,IAAI,OAAO,KAAK;AAClC,YAAM,IAAI,IAAI,IAAI,CAAC;AACnB,YAAM,IAAI,IAAI,IAAI,IAAI,CAAC;AACvB,UAAI,IAAI,CAAC,IAAI,IAAI,MAAM,IAAI;AAC3B,UAAI,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,MAAM,IAAI;AAAA,IAClC;AACA,QAAI,cAAc;AAClB,cAAU,KAAK,MAAM;AACnB,UAAI,IAAI,QAAQ;AAChB,UAAI,cAAc;AAAA,IACpB,CAAC;AAAA,EACH,CAAC;AAED,SAAO,MAAM;AACX,eAAW,KAAK,UAAW,GAAE;AAAA,EAC/B;AACF;","names":[]}

package/dist/core/components/viewers/bim/src/lib/safeRun.d.ts

@@ -0,0 +1,7 @@
+/** Run a side-effect helper; log and swallow errors so one failure can't
+ *  abort the surrounding sequence. Used in tool activate/deactivate paths
+ *  where every cleanup step needs to run independently. */
+export declare function safeRun(fn: () => void, label: string): void;
+/** Async variant — awaits the promise and swallows rejections. */
+export declare function safeRunAsync(fn: () => Promise<unknown>, label: string): Promise<void>;
+//# sourceMappingURL=safeRun.d.ts.map

package/dist/core/components/viewers/bim/src/lib/safeRun.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safeRun.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/components/viewers/bim/src/lib/safeRun.ts"],"names":[],"mappings":"AAAA;;2DAE2D;AAC3D,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,KAAK,EAAE,MAAM,QAMpD;AAED,kEAAkE;AAClE,wBAAsB,YAAY,CAChC,EAAE,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,EAC1B,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CAMf"}