@sequent-org/ifc-viewer 1.2.4-ci.45.0 → 1.2.4-ci.47.0

package/src/model-loading/ModelLoaderRegistry.js

@@ -0,0 +1,252 @@
+/**
+ * ModelLoaderRegistry
+ * Central registry for model loaders (IFC/FBX/...) with a stable API.
+ *
+ * Design goals:
+ * - Open/Closed: add new formats by registering a loader, without touching UI code.
+ * - Single Responsibility: registry selects loader + orchestrates loading + optional viewer integration.
+ *
+ * Loader contract (duck-typing, documented via JSDoc):
+ * - loader.id: string (e.g. "ifc", "fbx")
+ * - loader.extensions: string[] (lowercase, with leading dot, e.g. [".ifc",".ifczip"])
+ * - loader.associatedExtensions?: string[] (optional; affects accept= only, not loader selection)
+ * - loader.loadFile(file, ctx): Promise<LoadResult>
+ * - loader.loadFiles?(files, ctx): Promise<LoadResult> (optional, for multi-file cases like OBJ+MTL)
+ * - loader.loadUrl(url, ctx): Promise<LoadResult>
+ *
+ * LoadResult:
+ * - object3D: THREE.Object3D (required)
+ * - format: string (loader id)
+ * - name: string (file name or URL)
+ * - capabilities?: object (optional, format-specific)
+ * - replacedInViewer?: boolean (optional, true if loader already called viewer.replaceWithModel)
+ */
+export class ModelLoaderRegistry {
+  constructor() {
+    /** @type {Array<any>} */
+    this._loaders = [];
+  }
+
+  /**
+   * @param {any} loader
+   * @returns {ModelLoaderRegistry}
+   */
+  register(loader) {
+    if (!loader || typeof loader !== 'object') {
+      throw new Error('ModelLoaderRegistry.register: loader must be an object');
+    }
+    if (!loader.id || typeof loader.id !== 'string') {
+      throw new Error('ModelLoaderRegistry.register: loader.id must be a string');
+    }
+    if (!Array.isArray(loader.extensions) || loader.extensions.some((x) => typeof x !== 'string')) {
+      throw new Error(`ModelLoaderRegistry.register: loader.extensions must be string[] (${loader.id})`);
+    }
+    if (typeof loader.loadFile !== 'function' && typeof loader.loadUrl !== 'function') {
+      throw new Error(`ModelLoaderRegistry.register: loader must implement loadFile and/or loadUrl (${loader.id})`);
+    }
+    this._loaders.push(loader);
+    return this;
+  }
+
+  /**
+   * @returns {string[]} unique extensions (lowercase) like [".ifc",".fbx"]
+   */
+  getAllExtensions() {
+    const out = new Set();
+    for (const l of this._loaders) {
+      for (const ext of (l.extensions || [])) out.add(String(ext).toLowerCase());
+      for (const ext of (l.associatedExtensions || [])) out.add(String(ext).toLowerCase());
+    }
+    return Array.from(out).sort();
+  }
+
+  /**
+   * @returns {string} accept string for <input type="file" accept="...">
+   */
+  getAcceptString() {
+    const exts = this.getAllExtensions();
+    return exts.length ? exts.join(',') : '';
+  }
+
+  /**
+   * @param {string} nameOrUrl
+   * @returns {any|null} loader
+   */
+  getLoaderForName(nameOrUrl) {
+    const s = String(nameOrUrl || '').toLowerCase();
+    if (!s) return null;
+    // Prefer longest extension match (e.g. ".ifczip" over ".zip")
+    let best = null;
+    let bestLen = -1;
+    for (const l of this._loaders) {
+      for (const ext of (l.extensions || [])) {
+        const e = String(ext).toLowerCase();
+        if (!e || !e.startsWith('.')) continue;
+        if (s.endsWith(e) && e.length > bestLen) {
+          best = l;
+          bestLen = e.length;
+        }
+      }
+    }
+    return best;
+  }
+
+  /**
+   * Loads a model from File and (optionally) integrates into viewer.
+   *
+   * @param {File} file
+   * @param {{ viewer?: any, logger?: any }} [ctx]
+   * @returns {Promise<any|null>} LoadResult or null on error
+   */
+  async loadFile(file, ctx = {}) {
+    const name = file?.name || '';
+    const loader = this.getLoaderForName(name);
+    if (!loader) {
+      throw new Error(`Формат не поддерживается: ${name || 'unknown file'}`);
+    }
+
+    const logger = ctx?.logger || console;
+    const t0 = (typeof performance !== 'undefined' && performance.now) ? performance.now() : Date.now();
+
+    try {
+      logger?.log?.('[ModelLoaderRegistry] loadFile', { name, loader: loader.id });
+      const result = await loader.loadFile(file, ctx);
+      this._validateResult(result, loader.id);
+
+      this._maybeReplaceInViewer(result, ctx);
+      this._logResultSummary(result, t0, logger);
+      return result;
+    } catch (e) {
+      logger?.error?.('[ModelLoaderRegistry] loadFile error', { name, loader: loader.id, error: e });
+      throw e;
+    }
+  }
+
+  /**
+   * Loads a model from multiple selected files (e.g. .obj + .mtl + textures).
+   *
+   * Rules:
+   * - Choose ONE "primary" model file among the selection by best extension match.
+   * - Pass all selected files to loader via ctx.files.
+   * - If the chosen loader supports loadFiles(), it will be used; otherwise falls back to loadFile(primary).
+   *
+   * @param {File[]|FileList} files
+   * @param {{ viewer?: any, logger?: any }} [ctx]
+   */
+  async loadFiles(files, ctx = {}) {
+    const arr = Array.from(files || []).filter(Boolean);
+    const logger = ctx?.logger || console;
+    if (!arr.length) throw new Error('Нет выбранных файлов');
+
+    // Find best primary file among selection
+    let best = null;
+    let bestLoader = null;
+    let bestLen = -1;
+
+    for (const f of arr) {
+      const name = f?.name || '';
+      const l = this.getLoaderForName(name);
+      if (!l) continue;
+      // score: longest extension match
+      const lower = name.toLowerCase();
+      for (const ext of (l.extensions || [])) {
+        const e = String(ext).toLowerCase();
+        if (e && lower.endsWith(e) && e.length > bestLen) {
+          best = f;
+          bestLoader = l;
+          bestLen = e.length;
+        }
+      }
+    }
+
+    if (!best || !bestLoader) {
+      throw new Error(`Формат не поддерживается: ${arr.map((f) => f?.name).filter(Boolean).join(', ')}`);
+    }
+
+    const t0 = (typeof performance !== 'undefined' && performance.now) ? performance.now() : Date.now();
+    const names = arr.map((f) => f?.name).filter(Boolean);
+
+    try {
+      logger?.log?.('[ModelLoaderRegistry] loadFiles', { primary: best.name, loader: bestLoader.id, files: names });
+      const nextCtx = { ...ctx, files: arr };
+      const result = (typeof bestLoader.loadFiles === 'function')
+        ? await bestLoader.loadFiles(arr, nextCtx)
+        : await bestLoader.loadFile(best, nextCtx);
+
+      this._validateResult(result, bestLoader.id);
+      this._maybeReplaceInViewer(result, ctx);
+      this._logResultSummary(result, t0, logger);
+      return result;
+    } catch (e) {
+      logger?.error?.('[ModelLoaderRegistry] loadFiles error', { primary: best.name, loader: bestLoader.id, files: names, error: e });
+      throw e;
+    }
+  }
+
+  /**
+   * Loads a model from URL and (optionally) integrates into viewer.
+   *
+   * @param {string} url
+   * @param {{ viewer?: any, logger?: any }} [ctx]
+   * @returns {Promise<any|null>} LoadResult or null on error
+   */
+  async loadUrl(url, ctx = {}) {
+    const loader = this.getLoaderForName(url);
+    if (!loader) {
+      throw new Error(`Формат не поддерживается: ${url || 'unknown url'}`);
+    }
+
+    const logger = ctx?.logger || console;
+    const t0 = (typeof performance !== 'undefined' && performance.now) ? performance.now() : Date.now();
+
+    try {
+      logger?.log?.('[ModelLoaderRegistry] loadUrl', { url, loader: loader.id });
+      const result = await loader.loadUrl(url, ctx);
+      this._validateResult(result, loader.id);
+
+      this._maybeReplaceInViewer(result, ctx);
+      this._logResultSummary(result, t0, logger);
+      return result;
+    } catch (e) {
+      logger?.error?.('[ModelLoaderRegistry] loadUrl error', { url, loader: loader.id, error: e });
+      throw e;
+    }
+  }
+
+  _validateResult(result, loaderId) {
+    if (!result || typeof result !== 'object') {
+      throw new Error(`Loader "${loaderId}" returned invalid result`);
+    }
+    if (!result.object3D) {
+      throw new Error(`Loader "${loaderId}" returned result without object3D`);
+    }
+    if (!result.format) result.format = loaderId;
+    if (!result.name) result.name = '';
+  }
+
+  _maybeReplaceInViewer(result, ctx) {
+    if (result?.replacedInViewer) return;
+    const viewer = ctx?.viewer;
+    if (!viewer || typeof viewer.replaceWithModel !== 'function') return;
+    try {
+      viewer.replaceWithModel(result.object3D);
+    } catch (e) {
+      const logger = ctx?.logger || console;
+      logger?.warn?.('[ModelLoaderRegistry] viewer.replaceWithModel failed', e);
+    }
+  }
+
+  _logResultSummary(result, t0, logger) {
+    const t1 = (typeof performance !== 'undefined' && performance.now) ? performance.now() : Date.now();
+    const ms = Math.round((t1 - t0) * 10) / 10;
+    const obj = result?.object3D;
+    const summary = {
+      format: result?.format,
+      name: result?.name,
+      ms,
+      object3D: obj ? { type: obj.type, children: Array.isArray(obj.children) ? obj.children.length : undefined } : null,
+    };
+    logger?.log?.('[ModelLoaderRegistry] loaded', summary);
+  }
+}
+

package/src/model-loading/loaders/DaeModelLoader.js

@@ -0,0 +1,275 @@
+import { Box3, LoadingManager, Vector3 } from "three";
+import { ColladaLoader } from "three/examples/jsm/loaders/ColladaLoader.js";
+
+/**
+ * COLLADA (.dae) loader with optional textures via multi-file selection.
+ *
+ * Multi-file behavior:
+ * - User may select:
+ *   - only .dae -> load scene, external images may be missing
+ *   - .dae + images -> resolve images by basename via LoadingManager URL modifier
+ *
+ * Notes:
+ * - ColladaLoader typically handles up-axis conversion based on <asset><up_axis>.
+ */
+export class DaeModelLoader {
+  /**
+   * @param {{ rotateXNeg90?: boolean, alignToGround?: boolean }} [options]
+   * rotateXNeg90:
+   * - Some DAE assets are effectively Z-up; viewer is Y-up. This rotates into Y-up.
+   * alignToGround:
+   * - Moves model so its bbox.min.y becomes ~0 (helps shadow receiver positioning).
+   */
+  constructor(options = {}) {
+    this.id = 'dae';
+    this.extensions = ['.dae'];
+    this.associatedExtensions = ['.png', '.jpg', '.jpeg', '.webp', '.bmp', '.gif', '.tga'];
+    this._loader = null;
+    this._rotateXNeg90 = options.rotateXNeg90 !== false; // default true
+    this._alignToGround = options.alignToGround !== false; // default true
+  }
+
+  async loadFile(file, ctx) {
+    return await this.loadFiles([file], ctx);
+  }
+
+  /**
+   * @param {File[]|FileList} files
+   * @param {any} ctx
+   */
+  async loadFiles(files, ctx) {
+    const logger = ctx?.logger || console;
+    const arr = Array.from(files || []).filter(Boolean);
+    if (!arr.length) throw new Error('DaeModelLoader: no files');
+
+    const daeFile = arr.find((f) => this._isExt(f?.name, '.dae'));
+    if (!daeFile) {
+      throw new Error(`DaeModelLoader: .dae not found in selection: ${arr.map((f) => f?.name).filter(Boolean).join(', ')}`);
+    }
+
+    const fileMap = this._buildFileMap(arr);
+    const urlMap = new Map();
+    const revokeAll = () => {
+      try { for (const u of urlMap.values()) URL.revokeObjectURL(u); } catch (_) {}
+    };
+    const getBlobUrl = (key) => {
+      const k = String(key || '').toLowerCase();
+      if (!k) return null;
+      if (urlMap.has(k)) return urlMap.get(k);
+      const f = fileMap.get(k);
+      if (!f) return null;
+      const u = URL.createObjectURL(f);
+      urlMap.set(k, u);
+      return u;
+    };
+
+    const manager = new LoadingManager();
+    /** @type {Set<string>} */
+    const failedUrls = new Set();
+    /** @type {Set<string>} */
+    const requestedBasenames = new Set();
+
+    manager.onError = (url) => {
+      try {
+        const raw = String(url || '');
+        const clean = raw.split('#')[0].split('?')[0];
+        const parts = clean.replace(/\\/g, '/').split('/');
+        const last = (parts[parts.length - 1] || '').trim();
+        if (last) failedUrls.add(last);
+      } catch (_) {}
+    };
+
+    manager.setURLModifier((url) => {
+      try {
+        const raw = String(url || '');
+        const clean = raw.split('#')[0].split('?')[0];
+        const parts = clean.replace(/\\/g, '/').split('/');
+        const last = (parts[parts.length - 1] || '').trim();
+        if (!last) return raw;
+        requestedBasenames.add(last);
+        const blob = getBlobUrl(last);
+        return blob || raw;
+      } catch (_) {
+        return url;
+      }
+    });
+
+    try {
+      logger?.log?.('[DaeModelLoader] loadFiles', { dae: daeFile.name, files: arr.map((f) => f?.name).filter(Boolean) });
+      const daeText = await daeFile.text();
+
+      // Diagnostics: inspect raw DAE for image references and textures
+      try {
+        const diag = this._diagnoseDaeText(daeText);
+        // eslint-disable-next-line no-console
+        logger?.log?.('[DaeModelLoader] dae diagnostics', diag);
+      } catch (e) {
+        logger?.warn?.('[DaeModelLoader] dae diagnostics failed', e);
+      }
+
+      const loader = new ColladaLoader(manager);
+      const collada = loader.parse(daeText, '');
+
+      // Wait for async texture loads (if any) before revoking blob URLs.
+      await this._waitManagerIdle(manager, 2500);
+
+      const scene = collada?.scene;
+      if (!scene) throw new Error('DaeModelLoader: parsed without scene');
+      try { scene.updateMatrixWorld?.(true); } catch (_) {}
+
+      // Axis + grounding BEFORE Viewer.replaceWithModel(): ensures bbox/shadowReceiver computed correctly.
+      try {
+        if (this._rotateXNeg90) {
+          scene.rotation.x = -Math.PI / 2;
+          scene.updateMatrixWorld?.(true);
+        }
+        if (this._alignToGround) {
+          const box = new Box3().setFromObject(scene);
+          const minY = box.min.y;
+          if (Number.isFinite(minY)) {
+            // Bring model to "floor" level
+            scene.position.y -= minY;
+            // Tiny epsilon to avoid z-fighting with receiver
+            scene.position.y += 0.001;
+            scene.updateMatrixWorld?.(true);
+          }
+        }
+      } catch (_) {}
+
+      const missingAll = Array.from(new Set([...Array.from(failedUrls.values())]));
+      if (missingAll.length) {
+        logger?.warn?.('[DaeModelLoader] missing assets (select these files too):', missingAll);
+      } else if (requestedBasenames.size) {
+        // If images referenced but none failed, still helpful to log what was requested
+        logger?.log?.('[DaeModelLoader] referenced assets', { requested: Array.from(requestedBasenames.values()).slice(0, 30) });
+      }
+
+      // Diagnostics: meshes/materials
+      try {
+        let meshes = 0;
+        let mats = 0;
+        let withMap = 0;
+        scene.traverse?.((n) => {
+          if (!n?.isMesh) return;
+          meshes++;
+          const m = n.material;
+          const arrM = Array.isArray(m) ? m : [m];
+          for (const mi of arrM) {
+            if (!mi) continue;
+            mats++;
+            if (mi.map) withMap++;
+          }
+        });
+        // BBox after axis/grounding for diagnostics
+        let bbox = null;
+        try {
+          const b = new Box3().setFromObject(scene);
+          const size = b.getSize(new Vector3());
+          const center = b.getCenter(new Vector3());
+          bbox = {
+            size: { x: +size.x.toFixed(3), y: +size.y.toFixed(3), z: +size.z.toFixed(3) },
+            center: { x: +center.x.toFixed(3), y: +center.y.toFixed(3), z: +center.z.toFixed(3) },
+            minY: +b.min.y.toFixed(3),
+          };
+        } catch (_) {}
+        logger?.log?.('[DaeModelLoader] parsed', {
+          dae: daeFile.name,
+          meshes,
+          materials: mats,
+          withMap,
+          animations: collada?.animations?.length || 0,
+          bbox,
+          axisFix: { rotateXNeg90: this._rotateXNeg90, alignToGround: this._alignToGround },
+        });
+      } catch (_) {}
+
+      return {
+        object3D: scene,
+        format: this.id,
+        name: daeFile.name,
+        replacedInViewer: false,
+        capabilities: { kind: 'generic', missingAssets: missingAll, animations: collada?.animations || [] },
+      };
+    } finally {
+      revokeAll();
+    }
+  }
+
+  _isExt(name, ext) {
+    const n = String(name || '').toLowerCase();
+    return n.endsWith(String(ext).toLowerCase());
+  }
+
+  _buildFileMap(arr) {
+    const map = new Map();
+    for (const f of arr) {
+      const full = String(f?.name || '');
+      if (!full) continue;
+      const base = (full.split(/[/\\]/).pop() || full).toLowerCase();
+      if (!map.has(base)) map.set(base, f);
+    }
+    return map;
+  }
+
+  _waitManagerIdle(manager, timeoutMs = 2000) {
+    return new Promise((resolve) => {
+      let done = false;
+      const finish = () => {
+        if (done) return;
+        done = true;
+        resolve();
+      };
+      try {
+        const prevOnLoad = manager.onLoad;
+        manager.onLoad = () => {
+          try { prevOnLoad?.(); } catch (_) {}
+          finish();
+        };
+      } catch (_) {}
+      setTimeout(finish, Math.max(0, Number(timeoutMs) || 0));
+    });
+  }
+
+  _diagnoseDaeText(daeText) {
+    const text = String(daeText || '');
+    // Up-axis (if present)
+    const upAxisMatch = text.match(/<up_axis>\s*([^<]+)\s*<\/up_axis>/i);
+    const upAxis = upAxisMatch ? upAxisMatch[1].trim() : null;
+
+    // <init_from> values inside library_images
+    const initFrom = [];
+    const reInit = /<init_from>\s*([^<]+?)\s*<\/init_from>/gi;
+    let m;
+    while ((m = reInit.exec(text)) !== null) {
+      const raw = (m[1] || '').trim();
+      if (raw) initFrom.push(raw);
+      if (initFrom.length >= 200) break; // cap
+    }
+
+    // Extract basenames and file extensions (for comparing to selected files)
+    const basenames = initFrom.map((p) => (p.replace(/\\/g, '/').split('/').pop() || p).trim()).filter(Boolean);
+    const jpgs = basenames.filter((b) => /\.(jpe?g)$/i.test(b));
+    const pngs = basenames.filter((b) => /\.png$/i.test(b));
+
+    // Look for <texture ...> occurrences (typical COLLADA material binding)
+    const texTags = [];
+    const reTex = /<texture\b[^>]*>/gi;
+    while ((m = reTex.exec(text)) !== null) {
+      texTags.push(m[0]);
+      if (texTags.length >= 50) break;
+    }
+
+    return {
+      upAxis,
+      initFromCount: initFrom.length,
+      initFromSample: initFrom.slice(0, 12),
+      imageBasenameCount: basenames.length,
+      imageBasenameSample: basenames.slice(0, 12),
+      jpgCount: jpgs.length,
+      pngCount: pngs.length,
+      textureTagCount: texTags.length,
+      textureTagSample: texTags.slice(0, 6),
+    };
+  }
+}
+

package/src/model-loading/loaders/FbxModelLoader.js

@@ -0,0 +1,68 @@
+import { FBXLoader } from "three/examples/jsm/loaders/FBXLoader.js";
+
+/**
+ * FBX loader.
+ *
+ * Implementation detail:
+ * - For File: uses FBXLoader.parse(ArrayBuffer, path).
+ * - For URL: uses FBXLoader.loadAsync(url).
+ *
+ * Known limitations to be aware of (diagnose via logs):
+ * - External texture references near a local File are not resolved automatically.
+ */
+export class FbxModelLoader {
+  constructor() {
+    this.id = 'fbx';
+    this.extensions = ['.fbx'];
+    this._loader = new FBXLoader();
+  }
+
+  /**
+   * @param {File} file
+   * @param {any} ctx
+   */
+  async loadFile(file, ctx) {
+    const logger = ctx?.logger || console;
+    const name = file?.name || '';
+    logger?.log?.('[FbxModelLoader] loadFile', { name, size: file?.size });
+
+    const buf = await file.arrayBuffer();
+    const obj = this._loader.parse(buf, '');
+    // Useful diagnostics: count meshes quickly
+    try {
+      let meshes = 0;
+      obj.traverse?.((n) => { if (n?.isMesh) meshes++; });
+      logger?.log?.('[FbxModelLoader] parsed', { name, type: obj?.type, meshes });
+    } catch (_) {}
+
+    return {
+      object3D: obj,
+      format: this.id,
+      name,
+      replacedInViewer: false,
+      capabilities: {
+        kind: 'generic',
+      },
+    };
+  }
+
+  /**
+   * @param {string} url
+   * @param {any} ctx
+   */
+  async loadUrl(url, ctx) {
+    const logger = ctx?.logger || console;
+    logger?.log?.('[FbxModelLoader] loadUrl', { url });
+    const obj = await this._loader.loadAsync(url);
+    return {
+      object3D: obj,
+      format: this.id,
+      name: String(url || ''),
+      replacedInViewer: false,
+      capabilities: {
+        kind: 'generic',
+      },
+    };
+  }
+}
+