@ifc-lite/viewer 1.21.0 → 1.22.1

package/src/store/slices/dataSlice.ts

@@ -30,6 +30,14 @@ export interface DataSlice {
   ifcDataStore: IfcDataStore | null;
   geometryResult: GeometryResult | null;
   geometryUpdateTick: number;
+  /**
+   * Monotonic counter bumped whenever existing mesh vertex/normal data has
+   * been mutated in-place (e.g. by `realignFederation`). Length/visibility
+   * triggers don't catch in-place mutation, so this is a separate signal that
+   * the merged-geometry cache and the renderer's GPU buffers both subscribe
+   * to in order to force a re-process.
+   */
+  geometryContentVersion: number;
   boundedGeometryMode: boolean;
   /** Transient overlay colors (lens/IDS/sdk overlays). */
   pendingColorUpdates: Map<number, [number, number, number, number]> | null;
@@ -41,9 +49,40 @@ export interface DataSlice {
   setGeometryResult: (result: GeometryResult | null) => void;
   setBoundedGeometryMode: (enabled: boolean) => void;
   appendGeometryBatch: (meshes: GeometryResult['meshes'], coordinateInfo?: CoordinateInfo) => void;
+  /** Signal that mesh positions/normals have been mutated in place — see
+   *  `geometryContentVersion` for why this is separate from setGeometryResult. */
+  bumpGeometryContentVersion: () => void;
   releaseGeometryMemory: () => void;
   /** Persist mesh color changes in geometryResult (used for IFC style/material updates). */
   updateMeshColors: (updates: Map<number, [number, number, number, number]>) => void;
+  /**
+   * Pending mesh removals for the renderer. Authoring actions
+   * (split, delete) push globalIds here; `useGeometryStreaming`
+   * flushes them on the next frame via
+   * `scene.removeMeshesForEntities` and then prunes the matching
+   * meshes out of `geometryResult.meshes` so picking + bounds
+   * recomputation stay consistent.
+   *
+   * Stored as a Set on the slice rather than a transient ref so
+   * tests + headless workflows can observe it directly.
+   */
+  pendingMeshRemovals: Set<number> | null;
+  setPendingMeshRemovals: (ids: Set<number>) => void;
+  clearPendingMeshRemovals: () => void;
+  /**
+   * Pending per-entity translations for the renderer. Authoring
+   * actions (translateEntity, setEntityPosition, gizmo drag) push
+   * `globalId → [dx, dy, dz]` in *renderer* frame (Y-up). The
+   * streaming hook drains via `scene.translateMeshesForEntities`
+   * on the next frame, which mutates vertex positions in place
+   * and marks the affected buckets for re-batch.
+   *
+   * The delta is renderer-frame; the IFC → renderer conversion
+   * lives in the action that produces the entry.
+   */
+  pendingMeshTranslations: Map<number, [number, number, number]> | null;
+  setPendingMeshTranslations: (updates: Map<number, [number, number, number]>) => void;
+  clearPendingMeshTranslations: () => void;
   /** Set pending color updates for the renderer without cloning mesh data.
    *  Use this for transient overlays (lens, IDS) where the source-of-truth
    *  mesh colors should remain unchanged. */
@@ -76,9 +115,12 @@ export const createDataSlice: StateCreator<DataSlice & DataCrossSliceState, [],
   ifcDataStore: null,
   geometryResult: null,
   geometryUpdateTick: 0,
+  geometryContentVersion: 0,
   boundedGeometryMode: false,
   pendingColorUpdates: null,
   pendingMeshColorUpdates: null,
+  pendingMeshRemovals: null,
+  pendingMeshTranslations: null,
 
   // Actions
   setIfcDataStore: (ifcDataStore) => set((state) => {
@@ -115,6 +157,10 @@ export const createDataSlice: StateCreator<DataSlice & DataCrossSliceState, [],
 
   setBoundedGeometryMode: (boundedGeometryMode) => set({ boundedGeometryMode }),
 
+  bumpGeometryContentVersion: () => set((state) => ({
+    geometryContentVersion: state.geometryContentVersion + 1,
+  })),
+
   appendGeometryBatch: (meshes, coordinateInfo) => set((state) => {
     // Incremental totals: O(batch_size) instead of O(total_accumulated) .reduce()
     let batchTriangles = 0;
@@ -236,6 +282,40 @@ export const createDataSlice: StateCreator<DataSlice & DataCrossSliceState, [],
 
   clearPendingMeshColorUpdates: () => set({ pendingMeshColorUpdates: null }),
 
+  setPendingMeshRemovals: (ids) => set((state) => {
+    // Accumulate across calls — the streaming loop drains in one
+    // pass per frame, but split / delete actions may fire several
+    // times between frames.
+    const merged = new Set<number>(state.pendingMeshRemovals ?? []);
+    for (const id of ids) merged.add(id);
+    return { pendingMeshRemovals: merged };
+  }),
+
+  clearPendingMeshRemovals: () => set({ pendingMeshRemovals: null }),
+
+  setPendingMeshTranslations: (updates) => set((state) => {
+    // Accumulate deltas across calls — a single drag-frame may
+    // bump translateEntity many times before the streaming hook
+    // drains. Existing entries get their delta summed; the
+    // renderer sees one combined translation per entity.
+    const merged = new Map<number, [number, number, number]>(state.pendingMeshTranslations ?? []);
+    for (const [id, delta] of updates) {
+      const existing = merged.get(id);
+      if (existing) {
+        merged.set(id, [
+          existing[0] + delta[0],
+          existing[1] + delta[1],
+          existing[2] + delta[2],
+        ]);
+      } else {
+        merged.set(id, [delta[0], delta[1], delta[2]]);
+      }
+    }
+    return { pendingMeshTranslations: merged };
+  }),
+
+  clearPendingMeshTranslations: () => set({ pendingMeshTranslations: null }),
+
   updateCoordinateInfo: (coordinateInfo) => set((state) => {
     if (!state.geometryResult) return {};
     const geometryResult = {

package/src/store/slices/levelDisplaySlice.ts

@@ -0,0 +1,105 @@
+/* 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/. */
+
+/**
+ * Level display mode — Pascal Editor's Stacked / Exploded / Solo
+ * pattern, adapted to ifc-lite's spatial hierarchy.
+ *
+ *   - Stacked   (default): every storey at its native elevation.
+ *   - Exploded            : each storey lifted along world +Y by
+ *                           `storey-index × explodedGap`, indexed
+ *                           after sorting storeys by elevation
+ *                           ascending. Index 0 stays at its
+ *                           native Y; subsequent storeys move up
+ *                           by `gap`.
+ *   - Solo                : only entities in the chosen `soloStorey`
+ *                           render. Driven by the existing
+ *                           visibilitySlice.setIsolatedEntities so
+ *                           we don't ship a second isolation
+ *                           channel.
+ *
+ * The slice owns mode + parameters only. The actual mesh
+ * translation (Exploded) and isolation (Solo) are applied by a
+ * separate hook in the viewer — `useLevelDisplayEffect` — which
+ * watches the slice and the active model's spatial hierarchy and
+ * flushes per-entity updates to the renderer via
+ * `pendingMeshTranslations` and `setIsolatedEntities`.
+ *
+ * Reversibility: the slice keeps the LAST APPLIED offset per
+ * storey so the effect can compute the delta between target and
+ * applied when the user toggles modes — no "remember the original
+ * positions" gymnastics. Switching Exploded → Stacked subtracts
+ * the applied offset; switching gap mid-Exploded shifts by the
+ * difference.
+ */
+
+import type { StateCreator } from 'zustand';
+
+export type LevelDisplayMode = 'stacked' | 'exploded' | 'solo';
+
+/** Per-model snapshot of the currently-applied storey offsets. */
+export type AppliedStoreyOffsets = Map<
+  string /* modelId */,
+  Map<number /* storey express id */, number /* applied Y offset (m, renderer frame) */>
+>;
+
+/**
+ * Solo target — must carry both modelId and expressId because
+ * express ids are scoped per model. In a federated session two
+ * different models often have storeys with overlapping ids, so a
+ * bare expressId would silently pick the wrong storey on the
+ * wrong model.
+ */
+export interface SoloStoreyRef {
+  modelId: string;
+  expressId: number;
+}
+
+export interface LevelDisplaySlice {
+  levelDisplayMode: LevelDisplayMode;
+  /** Storey for Solo. Null = effect picks the lowest storey on
+   * the active model on activation. */
+  soloStorey: SoloStoreyRef | null;
+  /** Per-storey gap in metres for Exploded. Default 4 m. */
+  explodedGap: number;
+  /**
+   * Bookkeeping — last applied Y offset per storey, per model.
+   * Read by the effect to compute deltas without re-doing the
+   * "what was the previous gap?" math; written by the effect
+   * after each successful flush. Tests can probe this directly.
+   */
+  appliedStoreyOffsets: AppliedStoreyOffsets;
+
+  setLevelDisplayMode: (mode: LevelDisplayMode) => void;
+  setSoloStorey: (ref: SoloStoreyRef | null) => void;
+  setExplodedGap: (metres: number) => void;
+  /** Effect-only: record the offsets that were just flushed to
+   * the renderer so the next toggle knows what to subtract. */
+  setAppliedStoreyOffsets: (next: AppliedStoreyOffsets) => void;
+}
+
+const LEVEL_DISPLAY_DEFAULTS = {
+  mode: 'stacked' as LevelDisplayMode,
+  gap: 4,
+  soloStorey: null as SoloStoreyRef | null,
+};
+
+export const createLevelDisplaySlice: StateCreator<LevelDisplaySlice, [], [], LevelDisplaySlice> = (set) => ({
+  levelDisplayMode: LEVEL_DISPLAY_DEFAULTS.mode,
+  soloStorey: LEVEL_DISPLAY_DEFAULTS.soloStorey,
+  explodedGap: LEVEL_DISPLAY_DEFAULTS.gap,
+  appliedStoreyOffsets: new Map(),
+
+  setLevelDisplayMode: (levelDisplayMode) => set({ levelDisplayMode }),
+  setSoloStorey: (soloStorey) => set({ soloStorey }),
+  setExplodedGap: (metres) => {
+    // Guard against non-finite / non-positive — UI lets the user
+    // type, but a 0 gap means "Exploded = Stacked" and a negative
+    // gap inverts the sort, which is rarely useful. Clamp to
+    // [0, 100] to keep behaviour sane.
+    const clamped = Math.max(0, Math.min(100, Number.isFinite(metres) ? metres : 0));
+    set({ explodedGap: clamped });
+  },
+  setAppliedStoreyOffsets: (appliedStoreyOffsets) => set({ appliedStoreyOffsets }),
+});

package/src/store/slices/modelSlice.test.ts

@@ -127,6 +127,25 @@ describe('ModelSlice', () => {
       state.addModel(model);
       assert.strictEqual(state.hasModels(), true);
     });
+
+    // Regression for issue #661.
+    it('keeps each model entry distinct when a second model is added', () => {
+      const firstStore = { tag: 'first' } as unknown as IfcDataStore;
+      const firstGeometry = { tag: 'first' } as unknown as GeometryResult;
+      const secondStore = { tag: 'second' } as unknown as IfcDataStore;
+      const secondGeometry = { tag: 'second' } as unknown as GeometryResult;
+
+      const model1 = { ...createMockModel('model-1', 'First'), ifcDataStore: firstStore, geometryResult: firstGeometry };
+      const model2 = { ...createMockModel('model-2', 'Second'), ifcDataStore: secondStore, geometryResult: secondGeometry };
+
+      state.addModel(model1);
+      state.addModel(model2);
+
+      assert.strictEqual(state.models.get('model-1')?.ifcDataStore, firstStore);
+      assert.strictEqual(state.models.get('model-1')?.geometryResult, firstGeometry);
+      assert.strictEqual(state.models.get('model-2')?.ifcDataStore, secondStore);
+      assert.strictEqual(state.models.get('model-2')?.geometryResult, secondGeometry);
+    });
   });
 
   describe('removeModel', () => {