@ifc-lite/viewer 1.17.2 → 1.17.4

package/src/hooks/ingest/viewerModelIngest.ts

@@ -0,0 +1,275 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import { IfcParser, parseIfcx, type IfcDataStore } from '@ifc-lite/parser';
+import { GeometryProcessor, GeometryQuality, type CoordinateInfo, type GeometryResult, type MeshData } from '@ifc-lite/geometry';
+import { loadGLBToMeshData } from '@ifc-lite/cache';
+import type { SchemaVersion } from '../../store/types.js';
+import { calculateMeshBounds, calculateStoreyHeights, createCoordinateInfo, normalizeColor } from '../../utils/localParsingUtils.js';
+
+type RgbaColor = [number, number, number, number];
+
+interface RawIfcxMesh {
+  expressId?: number;
+  express_id?: number;
+  id?: number;
+  positions: Float32Array | number[];
+  indices: Uint32Array | number[];
+  normals: Float32Array | number[];
+  color?: [number, number, number, number] | [number, number, number];
+  ifcType?: string;
+  ifc_type?: string;
+}
+
+export interface ViewerModelPayload {
+  dataStore: IfcDataStore;
+  geometryResult: GeometryResult;
+  schemaVersion: SchemaVersion;
+}
+
+export interface StepBatchEvent {
+  batchIndex: number;
+  estimatedTotal: number;
+  totalSoFar: number;
+  meshes: MeshData[];
+  coordinateInfo?: CoordinateInfo | null;
+}
+
+export interface StepRtcOffsetEvent {
+  rtcOffset: { x: number; y: number; z: number };
+}
+
+export interface StepBufferIngestOptions {
+  fileName: string;
+  buffer: ArrayBuffer;
+  fileSizeMB: number;
+  getDynamicBatchSize: (fileSizeMB: number) => number | { initial: number; subsequent: number };
+  onProgress?: (progress: { phase: string; percent: number }) => void;
+  onBatch?: (event: StepBatchEvent) => void;
+  onColorUpdate?: (updates: Map<number, RgbaColor>) => void;
+  onSpatialReady?: (dataStore: IfcDataStore) => void;
+  onRtcOffset?: (event: StepRtcOffsetEvent) => void;
+  shouldAbort?: () => boolean;
+}
+
+export interface StepBufferIngestResult extends ViewerModelPayload {
+  allMeshes: MeshData[];
+  cumulativeColorUpdates: Map<number, RgbaColor>;
+}
+
+export function convertIfcxMeshes(rawMeshes: RawIfcxMesh[]): MeshData[] {
+  return rawMeshes.map((mesh) => {
+    const positions = mesh.positions instanceof Float32Array ? mesh.positions : new Float32Array(mesh.positions || []);
+    const indices = mesh.indices instanceof Uint32Array ? mesh.indices : new Uint32Array(mesh.indices || []);
+    const normals = mesh.normals instanceof Float32Array ? mesh.normals : new Float32Array(mesh.normals || []);
+
+    return {
+      expressId: mesh.expressId ?? mesh.express_id ?? mesh.id ?? 0,
+      positions,
+      indices,
+      normals,
+      color: normalizeColor(mesh.color),
+      ifcType: mesh.ifcType ?? mesh.ifc_type ?? 'IfcProduct',
+    };
+  }).filter((mesh) => mesh.positions.length > 0 && mesh.indices.length > 0);
+}
+
+export function createMinimalGlbDataStore(buffer: ArrayBuffer, meshCount: number): IfcDataStore {
+  return {
+    fileSize: buffer.byteLength,
+    schemaVersion: 'IFC4' as const,
+    entityCount: meshCount,
+    parseTime: 0,
+    source: new Uint8Array(0),
+    entityIndex: { byId: new Map(), byType: new Map() },
+    strings: { getString: () => undefined, getStringId: () => undefined, count: 0 } as unknown as IfcDataStore['strings'],
+    entities: { count: 0, getId: () => 0, getType: () => 0, getName: () => undefined, getGlobalId: () => undefined } as unknown as IfcDataStore['entities'],
+    properties: { count: 0, getPropertiesForEntity: () => [], getPropertySetForEntity: () => [] } as unknown as IfcDataStore['properties'],
+    quantities: { count: 0, getQuantitiesForEntity: () => [] } as unknown as IfcDataStore['quantities'],
+    relationships: { count: 0, getRelationships: () => [], getRelated: () => [] } as unknown as IfcDataStore['relationships'],
+    spatialHierarchy: null as unknown as IfcDataStore['spatialHierarchy'],
+  } as unknown as IfcDataStore;
+}
+
+export function normalizeDataStoreStoreys(dataStore: IfcDataStore): IfcDataStore {
+  if (dataStore.spatialHierarchy && dataStore.spatialHierarchy.storeyHeights.size === 0 && dataStore.spatialHierarchy.storeyElevations.size > 1) {
+    const calculatedHeights = calculateStoreyHeights(dataStore.spatialHierarchy.storeyElevations);
+    for (const [storeyId, height] of calculatedHeights) {
+      dataStore.spatialHierarchy.storeyHeights.set(storeyId, height);
+    }
+  }
+  return dataStore;
+}
+
+export function getMaxExpressId(dataStore: IfcDataStore, meshes: MeshData[]): number {
+  const maxExpressIdFromMeshes = meshes.reduce((max, mesh) => Math.max(max, mesh.expressId), 0);
+  let maxExpressIdFromEntities = 0;
+  if (dataStore.entityIndex?.byId) {
+    for (const key of dataStore.entityIndex.byId.keys()) {
+      if (key > maxExpressIdFromEntities) {
+        maxExpressIdFromEntities = key;
+      }
+    }
+  }
+  return Math.max(maxExpressIdFromMeshes, maxExpressIdFromEntities);
+}
+
+export async function parseIfcxViewerModel(
+  buffer: ArrayBuffer,
+  onProgress?: (progress: { phase: string; percent: number }) => void,
+): Promise<ViewerModelPayload> {
+  const ifcxResult = await parseIfcx(buffer, {
+    onProgress: (progress) => {
+      onProgress?.({
+        phase: `IFCX ${progress.phase}`,
+        percent: 10 + (progress.percent * 0.8),
+      });
+    },
+  });
+
+  const meshes = convertIfcxMeshes(ifcxResult.meshes);
+  if (meshes.length === 0 && ifcxResult.entityCount > 0) {
+    throw new Error('overlay-only-ifcx');
+  }
+
+  const { bounds, stats } = calculateMeshBounds(meshes);
+  return {
+    dataStore: {
+      fileSize: ifcxResult.fileSize,
+      schemaVersion: 'IFC5' as const,
+      entityCount: ifcxResult.entityCount,
+      parseTime: ifcxResult.parseTime,
+      source: new Uint8Array(buffer),
+      entityIndex: { byId: new Map(), byType: new Map() },
+      strings: ifcxResult.strings,
+      entities: ifcxResult.entities,
+      properties: ifcxResult.properties,
+      quantities: ifcxResult.quantities,
+      relationships: ifcxResult.relationships,
+      spatialHierarchy: ifcxResult.spatialHierarchy,
+    } as unknown as IfcDataStore,
+    geometryResult: {
+      meshes,
+      totalVertices: stats.totalVertices,
+      totalTriangles: stats.totalTriangles,
+      coordinateInfo: createCoordinateInfo(bounds),
+    },
+    schemaVersion: 'IFC5',
+  };
+}
+
+export async function parseGlbViewerModel(buffer: ArrayBuffer): Promise<ViewerModelPayload> {
+  const meshes = loadGLBToMeshData(new Uint8Array(buffer));
+  if (meshes.length === 0) {
+    throw new Error('glb-empty');
+  }
+
+  const { bounds, stats } = calculateMeshBounds(meshes);
+  return {
+    dataStore: createMinimalGlbDataStore(buffer, meshes.length),
+    geometryResult: {
+      meshes,
+      totalVertices: stats.totalVertices,
+      totalTriangles: stats.totalTriangles,
+      coordinateInfo: createCoordinateInfo(bounds),
+    },
+    schemaVersion: 'IFC4',
+  };
+}
+
+export async function parseStepBufferViewerModel(options: StepBufferIngestOptions): Promise<StepBufferIngestResult> {
+  const geometryProcessor = new GeometryProcessor({ quality: GeometryQuality.Balanced });
+  await geometryProcessor.init();
+
+  const parser = new IfcParser();
+  const wasmApi = geometryProcessor.getApi();
+  const allMeshes: MeshData[] = [];
+  const cumulativeColorUpdates = new Map<number, RgbaColor>();
+  let finalCoordinateInfo: CoordinateInfo | null = null;
+  let batchIndex = 0;
+  let estimatedTotal = 0;
+  let capturedRtcOffset: { x: number; y: number; z: number } | null = null;
+
+  const dataStorePromise = parser.parseColumnar(options.buffer, {
+    wasmApi,
+    onSpatialReady: (partialStore) => {
+      if (options.shouldAbort?.()) {
+        return;
+      }
+      options.onSpatialReady?.(normalizeDataStoreStoreys(partialStore));
+    },
+  });
+
+  for await (const event of geometryProcessor.processAdaptive(new Uint8Array(options.buffer), {
+    sizeThreshold: 2 * 1024 * 1024,
+    batchSize: options.getDynamicBatchSize(options.fileSizeMB),
+  })) {
+    if (options.shouldAbort?.()) {
+      break;
+    }
+    switch (event.type) {
+      case 'start':
+        estimatedTotal = event.totalEstimate;
+        break;
+      case 'colorUpdate':
+        for (const [expressId, color] of event.updates) {
+          cumulativeColorUpdates.set(expressId, color);
+        }
+        options.onColorUpdate?.(event.updates);
+        break;
+      case 'rtcOffset':
+        if (event.hasRtc) {
+          capturedRtcOffset = event.rtcOffset;
+          options.onRtcOffset?.({ rtcOffset: event.rtcOffset });
+        }
+        break;
+      case 'batch':
+        batchIndex += 1;
+        for (let i = 0; i < event.meshes.length; i++) {
+          allMeshes.push(event.meshes[i]);
+        }
+        finalCoordinateInfo = event.coordinateInfo ?? null;
+        options.onBatch?.({
+          batchIndex,
+          estimatedTotal,
+          totalSoFar: event.totalSoFar,
+          meshes: event.meshes,
+          coordinateInfo: event.coordinateInfo ?? null,
+        });
+        options.onProgress?.({
+          phase: `Processing geometry (${event.totalSoFar} meshes)`,
+          percent: 10 + Math.min(80, (allMeshes.length / 1000) * 0.8),
+        });
+        break;
+      case 'complete':
+        finalCoordinateInfo = event.coordinateInfo ?? null;
+        break;
+    }
+  }
+
+  const dataStore = normalizeDataStoreStoreys(await dataStorePromise);
+  if (!finalCoordinateInfo) {
+    finalCoordinateInfo = createCoordinateInfo(calculateMeshBounds(allMeshes).bounds);
+  }
+  if (capturedRtcOffset) {
+    finalCoordinateInfo.wasmRtcOffset = capturedRtcOffset;
+  }
+
+  return {
+    dataStore,
+    geometryResult: {
+      meshes: allMeshes,
+      totalVertices: allMeshes.reduce((sum, mesh) => sum + mesh.positions.length / 3, 0),
+      totalTriangles: allMeshes.reduce((sum, mesh) => sum + mesh.indices.length / 3, 0),
+      coordinateInfo: finalCoordinateInfo,
+    },
+    schemaVersion: dataStore.schemaVersion === 'IFC4X3'
+      ? 'IFC4X3'
+      : dataStore.schemaVersion === 'IFC4'
+        ? 'IFC4'
+        : 'IFC2X3',
+    allMeshes,
+    cumulativeColorUpdates,
+  };
+}

package/src/hooks/useIDS.ts

@@ -213,12 +213,28 @@ export function useIDS(options: UseIDSOptions = {}): UseIDSResult {
   const setSelectedEntityId = useViewerStore((s) => s.setSelectedEntityId);
   const setSelectedEntity = useViewerStore((s) => s.setSelectedEntity);
   const setIsolatedEntities = useViewerStore((s) => s.setIsolatedEntities);
+  const toGlobalId = useViewerStore((s) => s.toGlobalId);
   const cameraCallbacks = useViewerStore((s) => s.cameraCallbacks);
   const geometryResult = useViewerStore((s) => s.geometryResult);
 
   // Ref to store original colors before IDS color overrides
   const originalColorsRef = useRef<Map<number, ColorTuple>>(new Map());
 
+  const toViewerGlobalId = useCallback((modelId: string, expressId: number): number | undefined => {
+    if (
+      modelId === '__legacy__'
+      || modelId === 'legacy'
+      || models.size === 0
+      || (models.size === 1 && !models.has(modelId))
+    ) {
+      return expressId;
+    }
+    if (!models.has(modelId)) {
+      return undefined;
+    }
+    return toGlobalId(modelId, expressId);
+  }, [models, toGlobalId]);
+
   // Ref to access geometryResult without creating callback dependencies (prevents infinite loops)
   const geometryResultRef = useRef(geometryResult);
   geometryResultRef.current = geometryResult;
@@ -357,7 +373,7 @@ export function useIDS(options: UseIDSOptions = {}): UseIDSResult {
 
     // Sync to viewer selection
     // Handle legacy mode vs federation mode
-    const isLegacyMode = modelId === '__legacy__' || models.size === 0;
+    const isLegacyMode = modelId === '__legacy__' || modelId === 'legacy' || models.size === 0;
 
     if (isLegacyMode) {
       // Legacy mode: globalId equals expressId, use 'legacy' for selection
@@ -365,9 +381,9 @@ export function useIDS(options: UseIDSOptions = {}): UseIDSResult {
       // Use 'legacy' as the modelId for PropertiesPanel compatibility
       setSelectedEntity({ modelId: 'legacy', expressId });
     } else {
-      // Federation mode: convert to globalId using model offset
-      const model = models.get(modelId);
-      const globalId = model ? expressId + (model.idOffset ?? 0) : expressId;
+      // Federation mode: use the store helper so ID resolution stays centralized.
+      const globalId = toViewerGlobalId(modelId, expressId);
+      if (globalId == null) return;
       setSelectedEntityId(globalId);
       setSelectedEntity({ modelId, expressId });
     }
@@ -378,7 +394,7 @@ export function useIDS(options: UseIDSOptions = {}): UseIDSResult {
         cameraCallbacks.frameSelection?.();
       }, 50);
     }
-  }, [setIdsActiveEntity, setSelectedEntityId, setSelectedEntity, models, cameraCallbacks]);
+  }, [setIdsActiveEntity, setSelectedEntityId, setSelectedEntity, models, cameraCallbacks, toViewerGlobalId]);
 
   const clearEntitySelection = useCallback(() => {
     setIdsActiveEntity(null);
@@ -462,15 +478,14 @@ export function useIDS(options: UseIDSOptions = {}): UseIDSResult {
       const modelId = key.substring(0, lastColonIndex);
       const expressIdStr = key.substring(lastColonIndex + 1);
       const expressId = parseInt(expressIdStr, 10);
-      const model = models.get(modelId);
-      const globalId = model ? expressId + (model.idOffset ?? 0) : expressId;
-      failedIds.add(globalId);
+      const globalId = toViewerGlobalId(modelId, expressId);
+      if (globalId != null) failedIds.add(globalId);
     }
 
     if (failedIds.size > 0) {
       setIsolatedEntities(failedIds);
     }
-  }, [idsFailedEntityIds, models, setIsolatedEntities]);
+  }, [idsFailedEntityIds, setIsolatedEntities, toViewerGlobalId]);
 
   const isolatePassed = useCallback(() => {
     const passedIds = new Set<number>();
@@ -480,15 +495,14 @@ export function useIDS(options: UseIDSOptions = {}): UseIDSResult {
       const modelId = key.substring(0, lastColonIndex);
       const expressIdStr = key.substring(lastColonIndex + 1);
       const expressId = parseInt(expressIdStr, 10);
-      const model = models.get(modelId);
-      const globalId = model ? expressId + (model.idOffset ?? 0) : expressId;
-      passedIds.add(globalId);
+      const globalId = toViewerGlobalId(modelId, expressId);
+      if (globalId != null) passedIds.add(globalId);
     }
 
     if (passedIds.size > 0) {
       setIsolatedEntities(passedIds);
     }
-  }, [idsPassedEntityIds, models, setIsolatedEntities]);
+  }, [idsPassedEntityIds, setIsolatedEntities, toViewerGlobalId]);
 
   const clearIsolation = useCallback(() => {
     setIsolatedEntities(null);
@@ -632,7 +646,8 @@ export function useIDS(options: UseIDSOptions = {}): UseIDSResult {
           // Find matching model geometry
           for (const modelData of allMeshData) {
             if (modelData.modelId === entity.modelId || allMeshData.length === 1) {
-              const globalExpressId = entity.expressId + modelData.idOffset;
+              const globalExpressId = toViewerGlobalId(entity.modelId, entity.expressId);
+              if (globalExpressId == null) break;
               const bounds = getEntityBounds(
                 modelData.meshes as Parameters<typeof getEntityBounds>[0],
                 globalExpressId,
@@ -700,8 +715,8 @@ export function useIDS(options: UseIDSOptions = {}): UseIDSResult {
           if (!bounds) continue;
 
           // Find the global expressId for isolation (direct Map lookup)
-          const model = models.get(entity.modelId);
-          const globalExpressId = entity.expressId + (model?.idOffset ?? 0);
+          const globalExpressId = toViewerGlobalId(entity.modelId, entity.expressId);
+          if (globalExpressId == null) continue;
 
           // Frame the entity bounds directly via camera (properly centers the object)
           // duration=1 (not 0) because the animator skips updates when duration===0,
@@ -778,7 +793,7 @@ export function useIDS(options: UseIDSOptions = {}): UseIDSResult {
     const url = URL.createObjectURL(blob);
     const a = globalThis.document.createElement('a');
     a.href = url;
-    a.download = `ids-report-${new Date().toISOString().split('T')[0]}.bcf`;
+    a.download = `ids-report-${new Date().toISOString().split('T')[0]}.bcfzip`;
     a.click();
     URL.revokeObjectURL(url);
 

package/src/hooks/useIfc.ts

@@ -14,7 +14,7 @@
 
 import { useMemo, useRef } from 'react';
 import { useShallow } from 'zustand/react/shallow';
-import { useViewerStore } from '../store.js';
+import { useViewerStore } from '@/store';
 import { IfcQuery } from '@ifc-lite/query';
 import type { IfcDataStore } from '@ifc-lite/parser';
 
@@ -26,6 +26,8 @@ export function useIfc() {
   const {
     loading,
     progress,
+    geometryProgress,
+    metadataProgress,
     error,
     ifcDataStore,
     geometryResult,
@@ -45,6 +47,8 @@ export function useIfc() {
   } = useViewerStore(useShallow((s) => ({
     loading: s.loading,
     progress: s.progress,
+    geometryProgress: s.geometryProgress,
+    metadataProgress: s.metadataProgress,
     error: s.error,
     ifcDataStore: s.ifcDataStore,
     geometryResult: s.geometryResult,
@@ -94,6 +98,8 @@ export function useIfc() {
     // Legacy single-model API (backward compatibility)
     loading,
     progress,
+    geometryProgress,
+    metadataProgress,
     error,
     ifcDataStore,
     geometryResult,

package/src/hooks/useIfcCache.ts

@@ -16,7 +16,7 @@ import {
   type IfcDataStore as CacheDataStore,
   type GeometryData,
 } from '@ifc-lite/cache';
-import { SpatialHierarchyBuilder, StepTokenizer, buildCompactEntityIndex, extractLengthUnitScale, type IfcDataStore } from '@ifc-lite/parser';
+import { SpatialHierarchyBuilder, StepTokenizer, CompactEntityIndexBuilder, extractLengthUnitScale, type IfcDataStore } from '@ifc-lite/parser';
 import { buildSpatialIndexGuarded } from '../utils/loadingUtils.js';
 import type { MeshData } from '@ifc-lite/geometry';
 
@@ -55,6 +55,13 @@ export interface CacheGeometryResult {
   };
 }
 
+export interface CacheLoadResult {
+  success: boolean;
+  meshCount: number;
+  totalVertices: number;
+  totalTriangles: number;
+}
+
 // ============================================================================
 // Hook
 // ============================================================================
@@ -81,7 +88,7 @@ export function useIfcCache() {
     cacheResult: CacheResult,
     fileName: string,
     cacheKey?: string
-  ): Promise<boolean> => {
+  ): Promise<CacheLoadResult> => {
     try {
       const cacheLoadStart = performance.now();
       setProgress({ phase: 'Loading from cache', percent: 10 });
@@ -100,19 +107,16 @@ export function useIfcCache() {
       if (cacheResult.sourceBuffer) {
         dataStore.source = new Uint8Array(cacheResult.sourceBuffer);
 
-        // Quick scan to rebuild entity index with byte offsets (needed for on-demand extraction)
+        // Quick scan to rebuild entity index with byte offsets (needed for on-demand extraction).
+        // Uses CompactEntityIndexBuilder to fill typed arrays directly during the scan,
+        // avoiding a temporary array of 4.4M+ objects (~350MB for large files).
         const tokenizer = new StepTokenizer(dataStore.source);
-        const entityRefs: Array<{ expressId: number; type: string; byteOffset: number; byteLength: number; lineNumber: number }> = [];
+        const estimatedCount = dataStore.entities?.count ?? 100_000;
+        const indexBuilder = new CompactEntityIndexBuilder(estimatedCount);
         const byType = new Map<string, number[]>();
 
         for (const ref of tokenizer.scanEntitiesFast()) {
-          entityRefs.push({
-            expressId: ref.expressId,
-            type: ref.type,
-            byteOffset: ref.offset,
-            byteLength: ref.length,
-            lineNumber: ref.line,
-          });
+          indexBuilder.add(ref.expressId, ref.type, ref.offset, ref.length);
           let typeList = byType.get(ref.type);
           if (!typeList) {
             typeList = [];
@@ -120,8 +124,7 @@ export function useIfcCache() {
           }
           typeList.push(ref.expressId);
         }
-        // Use compact entity index (typed arrays) for lower memory usage
-        const compactByIdIndex = buildCompactEntityIndex(entityRefs);
+        const compactByIdIndex = indexBuilder.build();
         dataStore.entityIndex = { byId: compactByIdIndex, byType };
 
         // Rebuild on-demand maps from relationships
@@ -201,7 +204,12 @@ export function useIfcCache() {
       const meshCount = result.geometry?.meshes.length || 0;
       console.log(`[useIfcCache] ✓ ${fileName} (cached) → ${meshCount} meshes | ${totalCacheTime.toFixed(0)}ms`);
 
-      return true;
+      return {
+        success: true,
+        meshCount,
+        totalVertices: result.geometry?.totalVertices || 0,
+        totalTriangles: result.geometry?.totalTriangles || 0,
+      };
     } catch (err) {
       console.error('[useIfcCache] Failed to load from cache:', err);
       // Clear corrupted cache entry if we have the key
@@ -213,7 +221,12 @@ export function useIfcCache() {
           // Ignore cleanup errors
         }
       }
-      return false;
+      return {
+        success: false,
+        meshCount: 0,
+        totalVertices: 0,
+        totalTriangles: 0,
+      };
     }
   }, [setProgress, setIfcDataStore, setGeometryResult]);