@sequent-org/ifc-viewer 1.2.4-ci.35.0 → 1.2.4-ci.37.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sequent-org/ifc-viewer",
   "private": false,
-  "version": "1.2.4-ci.35.0",
+  "version": "1.2.4-ci.37.0",
   "type": "module",
   "description": "IFC 3D model viewer component for web applications - fully self-contained with local IFCLoader",
   "main": "src/index.js",
@@ -13,6 +13,7 @@
   },
   "files": [
     "src/",
+    "scripts/",
     "README.md"
   ],
   "keywords": [
@@ -31,6 +32,7 @@
     "access": "public"
   },
   "scripts": {
+    "postinstall": "node scripts/copy-web-ifc-wasm.mjs",
     "dev": "vite",
     "build": "vite build",
     "preview": "vite preview",
@@ -41,6 +43,6 @@
   },
   "dependencies": {
     "three": "^0.149.0",
-    "web-ifc": "^0.0.39"
+    "web-ifc": "^0.0.74"
   }
 }

package/scripts/copy-web-ifc-wasm.mjs

@@ -0,0 +1,55 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+function ensureDir(p) {
+  fs.mkdirSync(p, { recursive: true });
+}
+
+function copyFile(src, dst) {
+  ensureDir(path.dirname(dst));
+  fs.copyFileSync(src, dst);
+}
+
+function main() {
+  // npm sets INIT_CWD to the original working directory where `npm install` was invoked.
+  // That is the app root we need to copy into.
+  const appRoot = process.env.INIT_CWD || process.cwd();
+
+  // Resolve actual installed web-ifc location (hoisted or nested).
+  const req = createRequire(import.meta.url);
+  let webIfcPkgJson = null;
+  try {
+    webIfcPkgJson = req.resolve('web-ifc/package.json', { paths: [appRoot, process.cwd()] });
+  } catch (_) {
+    webIfcPkgJson = null;
+  }
+
+  const src = webIfcPkgJson
+    ? path.join(path.dirname(webIfcPkgJson), 'web-ifc.wasm')
+    : path.join(appRoot, 'node_modules', 'web-ifc', 'web-ifc.wasm');
+
+  const dst = path.join(appRoot, 'public', 'wasm', 'web-ifc.wasm');
+
+  if (!fs.existsSync(src)) {
+    console.error(`[copy-web-ifc-wasm] Source not found: ${src}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  copyFile(src, dst);
+
+  const s = fs.statSync(src);
+  const d = fs.statSync(dst);
+  console.log('[copy-web-ifc-wasm] OK', {
+    appRoot: appRoot,
+    src: src,
+    dst: dst,
+    bytes: d.size,
+    sameSize: s.size === d.size,
+  });
+}
+
+main();
+
+

package/src/compat/IFCLoader.js

@@ -5,6 +5,87 @@ import { mergeBufferGeometries } from 'three/examples/jsm/utils/BufferGeometryUt
 
 const nullIfcManagerErrorMessage = 'IfcManager is null!';
 
+// ===== Diagnostics / optional geometry cleanup (query-params) =====
+function __getQueryParam(name) {
+  try {
+    if (typeof window === 'undefined' || window?.location?.search == null) return null;
+    const params = new URLSearchParams(window.location.search);
+    const v = params.get(name);
+    return (v == null) ? null : String(v);
+  } catch (_) {
+    return null;
+  }
+}
+
+function __parseBoolParam(name) {
+  const v = __getQueryParam(name);
+  if (v == null) return false;
+  const s = v.toLowerCase();
+  return v === '1' || s === 'true' || s === 'yes';
+}
+
+function __parseNumberParam(name, fallback) {
+  const v = __getQueryParam(name);
+  if (v == null || v === '') return fallback;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : fallback;
+}
+
+/**
+ * Removes duplicate triangles from indexed geometry by comparing quantized vertex positions.
+ * Query params:
+ *   ?dedupe=1
+ *   ?dedupeEps=1e-5
+ */
+function __dedupeTrianglesByPosition(geom, eps) {
+  try {
+    const posAttr = geom?.attributes?.position;
+    const idxAttr = geom?.index;
+    if (!posAttr?.array || !idxAttr?.array) return { changed: false, removed: 0, kept: 0 };
+
+    const pos = posAttr.array;
+    const idx = idxAttr.array;
+    const triCount = Math.floor(idx.length / 3);
+    if (triCount <= 0) return { changed: false, removed: 0, kept: 0 };
+
+    const q = (v) => Math.round(v / eps);
+    const vkey = (vi) => {
+      const x = q(pos[vi * 3]);
+      const y = q(pos[vi * 3 + 1]);
+      const z = q(pos[vi * 3 + 2]);
+      return `${x},${y},${z}`;
+    };
+
+    const seen = new Set();
+    const out = new Uint32Array(idx.length);
+    let outI = 0;
+    let removed = 0;
+
+    for (let i = 0; i < idx.length; i += 3) {
+      const a = idx[i], b = idx[i + 1], c = idx[i + 2];
+      const ka = vkey(a), kb = vkey(b), kc = vkey(c);
+      const arr = [ka, kb, kc];
+      arr.sort();
+      const k = `${arr[0]}|${arr[1]}|${arr[2]}`;
+      if (seen.has(k)) {
+        removed++;
+        continue;
+      }
+      seen.add(k);
+      out[outI++] = a;
+      out[outI++] = b;
+      out[outI++] = c;
+    }
+
+    if (removed === 0) return { changed: false, removed: 0, kept: triCount };
+
+    geom.setIndex(new BufferAttribute(out.subarray(0, outI), 1));
+    return { changed: true, removed, kept: Math.floor(outI / 3) };
+  } catch (_) {
+    return { changed: false, removed: 0, kept: 0 };
+  }
+}
+
 class IFCModel extends Mesh {
 
   constructor() {
@@ -167,6 +248,19 @@ class IFCParser {
       this.streamMesh(modelID, mesh);
     });
     this.notifyLoadingEnded();
+
+    // A/B диагностика: отключить общий merge (между материалами), чтобы проверить,
+    // теряются ли треугольники на стадии mergeBufferGeometries(geometries, true).
+    // ?mergeMode=perMaterial  -> создаём IFCModel-обёртку с дочерними Mesh по материалам
+    let mergeMode = 'combined';
+    try {
+      if (typeof window !== 'undefined' && window?.location?.search != null) {
+        const params = new URLSearchParams(window.location.search);
+        const v = params.get('mergeMode');
+        if (v) mergeMode = String(v);
+      }
+    } catch (_) {}
+
     const geometries = [];
     const materials = [];
     Object.keys(this.geometriesByMaterials).forEach((key) => {
@@ -175,7 +269,61 @@ class IFCParser {
       materials.push(this.geometriesByMaterials[key].material);
       geometries.push(merged);
     });
+
+    const dedupeEnabled = __parseBoolParam('dedupe');
+    const dedupeEps = Math.max(1e-12, __parseNumberParam('dedupeEps', 1e-5));
+
+    if (mergeMode === 'perMaterial') {
+      // ВАЖНО: не делаем общий merge; вместо этого создаём IFCModel (Mesh) без геометрии
+      // и добавляем внутрь дочерние Mesh по каждому материалу.
+      const root = new IFCModel(new BufferGeometry(), new MeshLambertMaterial({ transparent: true, opacity: 0 }));
+      try { root.material.depthWrite = false; } catch (_) {}
+      try { root.material.depthTest = false; } catch (_) {}
+      root.name = 'ifc-model-perMaterial';
+      try { root.userData.__mergeMode = 'perMaterial'; } catch (_) {}
+      // Сохраним modelID как у обычного IFCModel, но подменим на текущий
+      root.modelID = this.currentModelID;
+      root.mesh = root;
+
+      for (let i = 0; i < geometries.length; i++) {
+        const g = geometries[i];
+        const m = materials[i];
+        if (!g || !m) continue;
+        if (dedupeEnabled) {
+          const r = __dedupeTrianglesByPosition(g, dedupeEps);
+          if (r.changed) {
+            // eslint-disable-next-line no-console
+            console.log('[IFCLoader][dedupe][perMaterial]', { part: i, eps: dedupeEps, removed: r.removed, kept: r.kept });
+          }
+        }
+        const child = new Mesh(g, m);
+        child.name = `ifc-material-part-${i}`;
+        root.add(child);
+      }
+
+      // В этой ветке не используем BVH по объединённой геометрии (её нет).
+      // Память: освободим оригинальные (до-merge) геометрии, но НЕ трогаем merged-геометрию (она в child Mesh).
+      try {
+        Object.keys(this.geometriesByMaterials).forEach((materialID) => {
+          const bucket = this.geometriesByMaterials[materialID];
+          const list = bucket?.geometries || [];
+          list.forEach((g) => g && g.dispose && g.dispose());
+          if (bucket) bucket.geometries = [];
+        });
+        this.geometriesByMaterials = {};
+      } catch (_) {
+        // fallback: оставим как есть
+      }
+      this.state.models[this.currentModelID].mesh = root;
+      return root;
+    }
+
     const combinedGeometry = mergeBufferGeometries(geometries, true);
+    if (dedupeEnabled) {
+      const r = __dedupeTrianglesByPosition(combinedGeometry, dedupeEps);
+      // eslint-disable-next-line no-console
+      console.log('[IFCLoader][dedupe][combined]', { eps: dedupeEps, removed: r.removed, kept: r.kept });
+    }
     this.cleanUpGeometryMemory(geometries);
     if (this.BVH)
       this.BVH.applyThreeMeshBVH(combinedGeometry);

package/src/ifc/IfcService.js

@@ -22,6 +22,7 @@ export class IfcService {
     this.selectionMaterial = null;
     this.selectionCustomID = 'ifc-selection';
     this.isolateMode = false;
+    this._webIfcConfig = null; // для диагностики: фактически применённый конфиг web-ifc
   }
 
   init() {
@@ -104,17 +105,72 @@ export class IfcService {
    */
   _setupWebIfcConfig() {
     try {
-      this.loader.ifcManager.applyWebIfcConfig?.({
+      // ВАЖНО: web-ifc (>=0.0.74) принимает только LoaderSettings (см. web-ifc-api.d.ts).
+      // Ранее используемые флаги вроде USE_FAST_BOOLS/SMALL_TRIANGLE_THRESHOLD библиотекой web-ifc не используются.
+      const config = {
         COORDINATE_TO_ORIGIN: true,
-        USE_FAST_BOOLS: true,
-        // Порог игнорирования очень мелких полигонов (уменьшаем шум)
-        SMALL_TRIANGLE_THRESHOLD: 1e-9,
-      });
+        CIRCLE_SEGMENTS: 12,
+        // Tolerances: см. web-ifc CreateSettings defaults
+        TOLERANCE_PLANE_INTERSECTION: 1e-4,
+        TOLERANCE_PLANE_DEVIATION: 1e-4,
+        TOLERANCE_BACK_DEVIATION_DISTANCE: 1e-4,
+        TOLERANCE_INSIDE_OUTSIDE_PERIMETER: 1e-10,
+        TOLERANCE_SCALAR_EQUALITY: 1e-4,
+        PLANE_REFIT_ITERATIONS: 1,
+        BOOLEAN_UNION_THRESHOLD: 150,
+      };
+
+      // Диагностика / A-B: allow override via query params
+      try {
+        if (typeof window !== 'undefined' && window?.location?.search != null) {
+          const params = new URLSearchParams(window.location.search);
+          // ?coordToOrigin=0/1 -> COORDINATE_TO_ORIGIN
+          const cto = params.get('coordToOrigin');
+          if (cto === '0') config.COORDINATE_TO_ORIGIN = false;
+          if (cto === '1') config.COORDINATE_TO_ORIGIN = true;
+
+          // ?circleSeg=NUMBER -> CIRCLE_SEGMENTS
+          const cs = params.get('circleSeg');
+          if (cs != null && cs !== '') {
+            const n = Number(cs);
+            if (Number.isFinite(n) && n >= 3) config.CIRCLE_SEGMENTS = Math.round(n);
+          }
+
+          // Tolerances / iterations / threshold
+          const setNum = (key, name, min = -Infinity, max = Infinity) => {
+            const raw = params.get(name);
+            if (raw == null || raw === '') return;
+            const n = Number(raw);
+            if (!Number.isFinite(n)) return;
+            config[key] = Math.min(max, Math.max(min, n));
+          };
+          setNum('TOLERANCE_PLANE_INTERSECTION', 'tolPlaneInter', 0);
+          setNum('TOLERANCE_PLANE_DEVIATION', 'tolPlaneDev', 0);
+          setNum('TOLERANCE_BACK_DEVIATION_DISTANCE', 'tolBackDev', 0);
+          setNum('TOLERANCE_INSIDE_OUTSIDE_PERIMETER', 'tolInside', 0);
+          setNum('TOLERANCE_SCALAR_EQUALITY', 'tolScalar', 0);
+          setNum('PLANE_REFIT_ITERATIONS', 'planeRefit', 0, 1000);
+          setNum('BOOLEAN_UNION_THRESHOLD', 'boolUnion', 0, 1e9);
+        }
+      } catch (_) {}
+
+      this._webIfcConfig = { ...config };
+      this.loader.ifcManager.applyWebIfcConfig?.(config);
+
+      // eslint-disable-next-line no-console
+      console.log('IfcService: web-ifc config applied', this._webIfcConfig);
     } catch (error) {
       console.warn('IfcService: не удалось применить конфигурацию web-ifc:', error.message);
     }
   }
 
+  /**
+   * Возвращает фактически применённый web-ifc config (для диагностики).
+   */
+  getWebIfcConfig() {
+    return this._webIfcConfig ? { ...this._webIfcConfig } : null;
+  }
+
 
   /**
    * Обработка критических ошибок инициализации

package/src/main.js

@@ -11,12 +11,17 @@ if (app) {
 
   // ===== Диагностика (включается через query-параметры) =====
   // ?debugViewer=1  -> window.__viewer = viewer
+  // ?debugViewer=1  -> window.__ifcService = ifc
   // ?zoomDebug=1    -> включает логирование zoom-to-cursor
   // ?zoomCursor=0   -> отключает zoom-to-cursor (для сравнения с OrbitControls)
+  let __debugViewerEnabled = false;
+  let __startupParams = null;
   try {
     const params = new URLSearchParams(location.search);
+    __startupParams = params;
     const debugViewer = params.get("debugViewer") === "1" || params.get("zoomDebug") === "1";
     if (debugViewer) {
+      __debugViewerEnabled = true;
       // eslint-disable-next-line no-undef
       window.__viewer = viewer;
     }
@@ -304,8 +309,28 @@ if (app) {
    * - realtime-quality UI lock + test UI lock snapshots
    */
   // IFC загрузка
-  const ifc = new IfcService(viewer);
+  // ?wasm=/wasm/  -> переопределяет директорию, из которой web-ifc будет грузить web-ifc.wasm
+  // ВАЖНО: параметр должен указывать ДИРЕКТОРИЮ (web-ifc сам добавляет 'web-ifc.wasm')
+  let wasmOverride = null;
+  try {
+    const p = __startupParams || new URLSearchParams(location.search);
+    const w = p.get('wasm');
+    if (w != null && w !== '') {
+      wasmOverride = String(w);
+      // нормализуем: web-ifc ожидает путь-директорию
+      if (!wasmOverride.endsWith('/')) wasmOverride += '/';
+    }
+  } catch (_) {}
+
+  const ifc = new IfcService(viewer, wasmOverride);
   ifc.init();
+  // Экспортируем сервис только после инициализации (иначе ifc ещё не определён)
+  if (__debugViewerEnabled) {
+    try {
+      // eslint-disable-next-line no-undef
+      window.__ifcService = ifc;
+    } catch (_) {}
+  }
   const ifcTreeEl = document.getElementById("ifcTree");
   const ifcInfoEl = document.getElementById("ifcInfo");
   const ifcTree = ifcTreeEl ? new IfcTreeView(ifcTreeEl) : null;