@ifc-lite/viewer 1.19.0 → 1.21.0

package/src/store/slices/idsSlice.ts

@@ -10,6 +10,7 @@
 
 import type { StateCreator } from 'zustand';
 import type {
+  IDSAuditReport,
   IDSDocument,
   IDSValidationReport,
   IDSSpecificationResult,
@@ -40,6 +41,15 @@ export type IDSFilterMode = 'all' | 'failed' | 'passed';
 export interface IDSSliceState {
   /** Loaded IDS document */
   idsDocument: IDSDocument | null;
+  /**
+   * Audit report for the loaded IDS document itself — flags authoring
+   * issues (missing attributes, invalid IFC entity references, regex
+   * errors, etc.). Distinct from `idsValidationReport`, which describes
+   * how an IFC model conforms to the IDS.
+   */
+  idsAuditReport: IDSAuditReport | null;
+  /** Whether the audit pipeline is currently running. */
+  idsAuditing: boolean;
   /** Validation report after running validation */
   idsValidationReport: IDSValidationReport | null;
   /** Currently active specification (for filtering results) */
@@ -71,6 +81,10 @@ export interface IDSSlice extends IDSSliceState {
   setIdsDocument: (document: IDSDocument | null) => void;
   clearIdsDocument: () => void;
 
+  // Audit actions
+  setIdsAuditReport: (report: IDSAuditReport | null) => void;
+  setIdsAuditing: (auditing: boolean) => void;
+
   // Validation actions
   setIdsValidationReport: (report: IDSValidationReport | null) => void;
   clearIdsValidationReport: () => void;
@@ -158,6 +172,8 @@ function buildEntityIdSets(
 export const createIdsSlice: StateCreator<IDSSlice, [], [], IDSSlice> = (set, get) => ({
   // Initial state
   idsDocument: null,
+  idsAuditReport: null,
+  idsAuditing: false,
   idsValidationReport: null,
   idsActiveSpecificationId: null,
   idsActiveEntityId: null,
@@ -175,6 +191,9 @@ export const createIdsSlice: StateCreator<IDSSlice, [], [], IDSSlice> = (set, ge
   setIdsDocument: (idsDocument) =>
     set({
       idsDocument,
+      // Loading a new document invalidates any previous audit/validation
+      // results — they were tied to a specific document instance.
+      idsAuditReport: null,
       idsValidationReport: null,
       idsActiveSpecificationId: null,
       idsActiveEntityId: null,
@@ -186,6 +205,7 @@ export const createIdsSlice: StateCreator<IDSSlice, [], [], IDSSlice> = (set, ge
   clearIdsDocument: () =>
     set({
       idsDocument: null,
+      idsAuditReport: null,
       idsValidationReport: null,
       idsActiveSpecificationId: null,
       idsActiveEntityId: null,
@@ -194,6 +214,10 @@ export const createIdsSlice: StateCreator<IDSSlice, [], [], IDSSlice> = (set, ge
       idsPassedEntityIds: new Set(),
     }),
 
+  // Audit actions
+  setIdsAuditReport: (idsAuditReport) => set({ idsAuditReport }),
+  setIdsAuditing: (idsAuditing) => set({ idsAuditing }),
+
   // Validation actions
   setIdsValidationReport: (report) => {
     const { failed, passed } = buildEntityIdSets(report);

package/src/store/slices/loadingSlice.ts

@@ -16,6 +16,15 @@ export interface LoadingSlice {
   geometryProgress: { phase: string; percent: number; indeterminate?: boolean } | null;
   metadataProgress: { phase: string; percent: number; indeterminate?: boolean } | null;
   error: string | null;
+  /**
+   * Cancellation hook for an in-flight long-running operation (e.g.
+   * streaming a 100M-point scan). UI components can show a Cancel
+   * button while this is non-null. The loader hooks register the
+   * canceller after starting the stream and clear it on success /
+   * error. Kept on the loading slice (not its own slice) since it
+   * tracks lifecycle alongside `progress`.
+   */
+  activeStreamCanceller: (() => void) | null;
 
   // Actions
   setLoading: (loading: boolean) => void;
@@ -24,6 +33,7 @@ export interface LoadingSlice {
   setGeometryProgress: (progress: { phase: string; percent: number; indeterminate?: boolean } | null) => void;
   setMetadataProgress: (progress: { phase: string; percent: number; indeterminate?: boolean } | null) => void;
   setError: (error: string | null) => void;
+  setActiveStreamCanceller: (cancel: (() => void) | null) => void;
 }
 
 export const createLoadingSlice: StateCreator<LoadingSlice, [], [], LoadingSlice> = (set) => ({
@@ -34,6 +44,7 @@ export const createLoadingSlice: StateCreator<LoadingSlice, [], [], LoadingSlice
   geometryProgress: null,
   metadataProgress: null,
   error: null,
+  activeStreamCanceller: null,
 
   // Actions
   setLoading: (loading) => set({ loading }),
@@ -42,4 +53,5 @@ export const createLoadingSlice: StateCreator<LoadingSlice, [], [], LoadingSlice
   setGeometryProgress: (geometryProgress) => set({ geometryProgress }),
   setMetadataProgress: (metadataProgress) => set({ metadataProgress }),
   setError: (error) => set({ error }),
+  setActiveStreamCanceller: (activeStreamCanceller) => set({ activeStreamCanceller }),
 });

package/src/store/slices/pointCloudSlice.ts

@@ -12,7 +12,7 @@
 
 import type { StateCreator } from 'zustand';
 
-export type PointColorModeUi = 'rgb' | 'classification' | 'intensity' | 'height' | 'fixed';
+export type PointColorModeUi = 'rgb' | 'classification' | 'intensity' | 'height' | 'fixed' | 'deviation';
 export type PointSizeModeUi = 'fixed-px' | 'adaptive-world' | 'attenuated';
 
 export interface PointCloudSlice {
@@ -31,6 +31,35 @@ export interface PointCloudSlice {
   pointCloudEdlEnabled: boolean;
   /** EDL strength multiplier. 0..3, default 1. */
   pointCloudEdlStrength: number;
+  /**
+   * Per-ASPRS-class visibility bitmask (32 bits = covers classes
+   * 0..31, the LAS 1.4 standard range). Bit `i` set → class `i`
+   * visible. Default `0xFFFFFFFF` (all visible). Only point clouds
+   * carry classifications; meshes ignore this.
+   */
+  pointCloudClassMask: number;
+  /**
+   * Stride-cull factor for the splat shader. 1 = render every point,
+   * N>1 = render every Nth point. Used by the section-plane slider's
+   * drag-preview path so dragging over a 100M-point scan stays
+   * responsive. Defaults to 1 (full density).
+   */
+  pointCloudPreviewStride: number;
+  /**
+   * BIM↔scan deviation heatmap range. `centerOffset` shifts the
+   * "white" point off zero (handy when a scan has a global offset
+   * from the model); `halfRange` is the metres mapped to ±1 on the
+   * blue-white-red ramp. Defaults to (0, 0.05) — ±5cm.
+   */
+  pointCloudDeviationCenterOffset: number;
+  pointCloudDeviationHalfRange: number;
+  /**
+   * True once `Renderer.computeDeviations` has populated the deviation
+   * buffers for the current point cloud + mesh set. UI gates the
+   * "Deviation" colour-mode option on this flag so users don't get a
+   * confusing all-blue rendering when nothing has been computed.
+   */
+  pointCloudDeviationComputed: boolean;
   /**
    * Best-effort count of point cloud assets currently uploaded to the
    * renderer. Updated by ingest paths; UI uses it to show/hide the
@@ -45,6 +74,14 @@ export interface PointCloudSlice {
   setPointCloudRoundShape: (enabled: boolean) => void;
   setPointCloudEdlEnabled: (enabled: boolean) => void;
   setPointCloudEdlStrength: (strength: number) => void;
+  setPointCloudClassMask: (mask: number) => void;
+  /** Toggle a single ASPRS class. `classId` is clamped to 0..31. */
+  togglePointCloudClass: (classId: number) => void;
+  /** Set the stride-cull factor (1 = full density). */
+  setPointCloudPreviewStride: (stride: number) => void;
+  setPointCloudDeviationCenterOffset: (m: number) => void;
+  setPointCloudDeviationHalfRange: (m: number) => void;
+  setPointCloudDeviationComputed: (computed: boolean) => void;
   setPointCloudAssetCount: (count: number) => void;
   incrementPointCloudAssetCount: (n?: number) => void;
 }
@@ -67,6 +104,14 @@ export const POINT_CLOUD_DEFAULTS = {
   pointCloudRoundShape: true,
   pointCloudEdlEnabled: true,
   pointCloudEdlStrength: 1,
+  // 0xFFFFFFFF — all 32 classes visible. Stored as `-1 >>> 0` to
+  // keep the value as an unsigned 32-bit integer; JS doesn't have
+  // a u32 literal type so we round-trip through `>>> 0`.
+  pointCloudClassMask: 0xFFFFFFFF,
+  pointCloudPreviewStride: 1,
+  pointCloudDeviationCenterOffset: 0,
+  pointCloudDeviationHalfRange: 0.05,
+  pointCloudDeviationComputed: false,
   pointCloudAssetCount: 0,
 } as const;
 
@@ -91,6 +136,32 @@ export const createPointCloudSlice: StateCreator<PointCloudSlice, [], [], PointC
   setPointCloudEdlStrength: (strength) => set({
     pointCloudEdlStrength: Number.isFinite(strength) ? Math.max(0, Math.min(3, strength)) : 1,
   }),
+  setPointCloudClassMask: (mask) => set({
+    // Coerce through `>>> 0` to keep the stored value as an unsigned
+    // 32-bit integer; non-finite / negative inputs reset to "all on".
+    pointCloudClassMask: Number.isFinite(mask) ? (mask >>> 0) : 0xFFFFFFFF,
+  }),
+  togglePointCloudClass: (classId) => set((s) => {
+    const c = Math.max(0, Math.min(31, classId | 0));
+    const bit = 1 << c;
+    // XOR flips the bit; coerce through `>>> 0` so the stored value
+    // stays in the unsigned 32-bit range.
+    return { pointCloudClassMask: (s.pointCloudClassMask ^ bit) >>> 0 };
+  }),
+  setPointCloudPreviewStride: (stride) => set({
+    pointCloudPreviewStride: Number.isFinite(stride)
+      ? Math.max(1, Math.min(256, Math.floor(stride) || 1))
+      : 1,
+  }),
+  setPointCloudDeviationCenterOffset: (m) => set({
+    pointCloudDeviationCenterOffset: Number.isFinite(m) ? m : 0,
+  }),
+  setPointCloudDeviationHalfRange: (m) => set({
+    // halfRange must stay strictly positive — a zero or negative value
+    // would NaN the GPU ramp's division. Clamp to 0.1 mm minimum.
+    pointCloudDeviationHalfRange: Number.isFinite(m) ? Math.max(1e-4, m) : 0.05,
+  }),
+  setPointCloudDeviationComputed: (computed) => set({ pointCloudDeviationComputed: computed }),
   setPointCloudAssetCount: (count) => set({
     pointCloudAssetCount: Number.isFinite(count) ? Math.max(0, count) : 0,
   }),