@ifc-lite/viewer 1.18.0 → 1.19.0

package/src/hooks/useIfcLoader.ts

@@ -46,6 +46,8 @@ import { useIfcCache, getCached } from './useIfcCache.js';
 import { useIfcServer } from './useIfcServer.js';
 
 import { getMaxExpressId, parseGlbViewerModel, parseIfcxViewerModel } from './ingest/viewerModelIngest.js';
+import { detectPointCloudFormat, ingestPointCloud } from './ingest/pointCloudIngest.js';
+import { getGlobalRenderer } from './useBCF.js';
 
 /**
  * Compute a fast content fingerprint from the first and last 4KB of a buffer.
@@ -253,7 +255,7 @@ export function useIfcLoader() {
         dataStore: IfcDataStore | null,
         geometryResult: { meshes: MeshData[]; totalVertices: number; totalTriangles: number; coordinateInfo: CoordinateInfo } | null,
         schemaVersion: 'IFC2X3' | 'IFC4' | 'IFC4X3' | 'IFC5',
-        patch?: { loadState?: 'pending' | 'streaming-geometry' | 'hydrating-metadata' | 'complete' | 'error'; cacheState?: 'none' | 'hit' | 'miss' | 'writing'; loadError?: string | null },
+        patch?: { loadState?: 'pending' | 'streaming-geometry' | 'hydrating-metadata' | 'complete' | 'error'; cacheState?: 'none' | 'hit' | 'miss' | 'writing'; loadError?: string | null; pointCloudHandleId?: number },
       ) => {
         let idOffset = 0;
         let maxExpressId = 0;
@@ -271,6 +273,7 @@ export function useIfcLoader() {
           loadState: patch?.loadState ?? 'complete',
           cacheState: patch?.cacheState ?? 'none',
           loadError: patch?.loadError ?? null,
+          pointCloudHandleId: patch?.pointCloudHandleId,
         });
       };
       const getSchemaVersion = (dataStore: IfcDataStore | null): 'IFC2X3' | 'IFC4' | 'IFC4X3' | 'IFC5' => {
@@ -1560,8 +1563,69 @@ export function useIfcLoader() {
       const fileReadMs = performance.now() - fileReadStart;
       console.log(`[useIfc] File: ${file.name}, size: ${fileSizeMB.toFixed(2)}MB, read in ${fileReadMs.toFixed(0)}ms`);
 
-      // Detect file format (IFCX/IFC5 vs IFC4 STEP vs GLB)
-      const format = detectFormat(buffer);
+      // Detect file format (IFCX/IFC5 vs IFC4 STEP vs GLB vs LAS/LAZ)
+      const pointCloudFormat = detectPointCloudFormat(file.name, buffer);
+      const format = pointCloudFormat ?? detectFormat(buffer);
+
+      // LAS / LAZ point clouds: stream chunks straight to the renderer.
+      // No on-disk cache, no server upload — the data goes worker → GPU.
+      if (format === 'las' || format === 'laz' || format === 'ply' || format === 'pcd' || format === 'e57') {
+        const renderer = getGlobalRenderer();
+        if (!renderer) {
+          setError('Renderer not initialised — try again after the viewer mounts.');
+          updateModel(primaryModelId, { loadState: 'error', loadError: 'renderer-missing' });
+          setLoading(false);
+          return;
+        }
+        setProgress({ phase: `Streaming ${format.toUpperCase()}`, percent: 5 });
+        setGeometryStreamingActive(false);
+        const blob = isNativeFileHandle(file) ? new Blob([buffer]) : (file as File);
+        const incCount = useViewerStore.getState().incrementPointCloudAssetCount;
+        const ingest = ingestPointCloud({
+          format,
+          blob,
+          fileName: file.name,
+          buffer,
+          renderer,
+          onProgress: setProgress,
+          onAssetCountDelta: incCount,
+        });
+        // ingestPointCloud's onError callback already runs renderer cleanup
+        // + incCount(-1); the outer catch must NOT repeat them or the
+        // pointCloudAssetCount will go negative.
+        try {
+          await ingest.done;
+        } catch (err) {
+          // Bail without touching store/UI state if a newer load
+          // session has already started — the more recent flow owns
+          // the spinner / model record now. Free the renderer handle
+          // so we don't leak the half-streamed asset.
+          if (loadSessionRef.current !== currentSession) {
+            renderer.removePointCloudAsset(ingest.rendererHandle);
+            return;
+          }
+          const message = err instanceof Error ? err.message : String(err);
+          updateModel(primaryModelId, { loadState: 'error', loadError: message });
+          setError(`${format.toUpperCase()} parsing failed: ${message}`);
+          setLoading(false);
+          return;
+        }
+        if (loadSessionRef.current !== currentSession) {
+          // A newer load already began. Drop our streamed asset and
+          // skip every store/UI mutation so we don't overwrite the
+          // newer model's state.
+          renderer.removePointCloudAsset(ingest.rendererHandle);
+          return;
+        }
+        setGeometryResult(ingest.geometryResult);
+        setIfcDataStore(ingest.dataStore);
+        finalizePrimaryModel(ingest.dataStore, ingest.geometryResult, ingest.schemaVersion, {
+          pointCloudHandleId: ingest.rendererHandle.id,
+        });
+        setProgress({ phase: 'Complete', percent: 100 });
+        setLoading(false);
+        return;
+      }
 
       // IFCX files must be parsed client-side (server only supports IFC4 STEP)
       if (format === 'ifcx') {

package/src/services/file-dialog.ts

@@ -80,9 +80,11 @@ export async function openIfcFileDialog(): Promise<NativeFileHandle | null> {
     const selected = await dialog.open({
       multiple: false,
       directory: false,
-      title: 'Open IFC File',
+      title: 'Open IFC, Mesh or Point Cloud File',
       filters: [
-        { name: 'IFC Files', extensions: ['ifc', 'ifczip', 'ifcxml'] },
+        { name: 'IFC Files', extensions: ['ifc', 'ifczip', 'ifcxml', 'ifcx'] },
+        { name: 'Mesh Files', extensions: ['glb'] },
+        { name: 'Point Clouds', extensions: ['las', 'laz', 'ply', 'pcd', 'e57'] },
         { name: 'All Files', extensions: ['*'] },
       ],
     });

package/src/store/index.ts

@@ -40,6 +40,7 @@ import { createOverlaySlice, type OverlaySlice } from './slices/overlaySlice.js'
 import { createSearchSlice, type SearchSlice } from './slices/searchSlice.js';
 import { createAnnotationsSlice, type AnnotationsSlice } from './slices/annotationsSlice.js';
 import { createAddElementSlice, type AddElementSlice } from './slices/addElementSlice.js';
+import { createPointCloudSlice, type PointCloudSlice, POINT_CLOUD_DEFAULTS } from './slices/pointCloudSlice.js';
 import { invalidateVisibleBasketCache } from './basketVisibleSet.js';
 
 // Import constants for reset function
@@ -132,7 +133,8 @@ export type ViewerState = LoadingSlice &
   OverlaySlice &
   SearchSlice &
   AnnotationsSlice &
-  AddElementSlice & {
+  AddElementSlice &
+  PointCloudSlice & {
     resetViewerState: () => void;
   };
 
@@ -169,6 +171,7 @@ const createViewerStore = () => create<ViewerState>()((...args) => ({
   ...createSearchSlice(...args),
   ...createAnnotationsSlice(...args),
   ...createAddElementSlice(...args),
+  ...createPointCloudSlice(...args),
 
   // Reset all viewer state when loading new file
   // Note: Does NOT clear models - use clearAllModels() for that
@@ -415,6 +418,12 @@ const createViewerStore = () => create<ViewerState>()((...args) => ({
       // pins themselves stay in localStorage (cross-file workspace).
       draft: null,
       selectedAnnotationId: null,
+
+      // Point cloud — clear runtime fields so a new file doesn't
+      // inherit the previous file's color mode / size / EDL state.
+      // Single-source-of-truth defaults shared with createPointCloudSlice.
+      ...POINT_CLOUD_DEFAULTS,
+      pointCloudFixedColor: [...POINT_CLOUD_DEFAULTS.pointCloudFixedColor] as [number, number, number, number],
     });
   },
 }));

package/src/store/slices/pointCloudSlice.ts

@@ -0,0 +1,102 @@
+/* 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/. */
+
+/**
+ * Point cloud rendering preferences.
+ *
+ * The renderer reads these via `usePointCloudSync`; UI components write
+ * them via the actions below. EDL is opt-in (default on) — costs ~5
+ * extra texture taps per pixel.
+ */
+
+import type { StateCreator } from 'zustand';
+
+export type PointColorModeUi = 'rgb' | 'classification' | 'intensity' | 'height' | 'fixed';
+export type PointSizeModeUi = 'fixed-px' | 'adaptive-world' | 'attenuated';
+
+export interface PointCloudSlice {
+  pointCloudColorMode: PointColorModeUi;
+  pointCloudFixedColor: [number, number, number, number];
+  /** Splat sizing strategy. Default: 'fixed-px' (sized by the px slider). */
+  pointCloudSizeMode: PointSizeModeUi;
+  /** Splat size in pixels (fixed/attenuated) or upper cap (attenuated). 1..20. */
+  pointCloudPointSize: number;
+  /** World-space splat radius in metres for adaptive/attenuated modes.
+   *  Typical scans: 0.005–0.05. Default 0.02. */
+  pointCloudWorldRadius: number;
+  /** Render splats as discs vs squares. Default true. */
+  pointCloudRoundShape: boolean;
+  /** Enable Eye-Dome Lighting post-pass. Default true. */
+  pointCloudEdlEnabled: boolean;
+  /** EDL strength multiplier. 0..3, default 1. */
+  pointCloudEdlStrength: number;
+  /**
+   * Best-effort count of point cloud assets currently uploaded to the
+   * renderer. Updated by ingest paths; UI uses it to show/hide the
+   * controls panel and the EDL post-pass.
+   */
+  pointCloudAssetCount: number;
+  setPointCloudColorMode: (mode: PointColorModeUi) => void;
+  setPointCloudFixedColor: (rgba: [number, number, number, number]) => void;
+  setPointCloudSizeMode: (mode: PointSizeModeUi) => void;
+  setPointCloudPointSize: (px: number) => void;
+  setPointCloudWorldRadius: (m: number) => void;
+  setPointCloudRoundShape: (enabled: boolean) => void;
+  setPointCloudEdlEnabled: (enabled: boolean) => void;
+  setPointCloudEdlStrength: (strength: number) => void;
+  setPointCloudAssetCount: (count: number) => void;
+  incrementPointCloudAssetCount: (n?: number) => void;
+}
+
+/**
+ * Single source of truth for the slice's runtime field defaults.
+ * Both the slice initializer and `resetViewerState` consume this so
+ * the two paths can't drift.
+ */
+export const POINT_CLOUD_DEFAULTS = {
+  // Fixed-px is the default so the size slider feels responsive on first
+  // contact. `attenuated` is nicer at extreme zooms but its "slider =
+  // upper cap" semantic confuses users at typical wide views because the
+  // projected world radius sits well below the cap.
+  pointCloudColorMode: 'rgb' as PointColorModeUi,
+  pointCloudFixedColor: [1, 1, 1, 1] as [number, number, number, number],
+  pointCloudSizeMode: 'fixed-px' as PointSizeModeUi,
+  pointCloudPointSize: 4,
+  pointCloudWorldRadius: 0.02,
+  pointCloudRoundShape: true,
+  pointCloudEdlEnabled: true,
+  pointCloudEdlStrength: 1,
+  pointCloudAssetCount: 0,
+} as const;
+
+export const createPointCloudSlice: StateCreator<PointCloudSlice, [], [], PointCloudSlice> = (set) => ({
+  ...POINT_CLOUD_DEFAULTS,
+  // Re-spread typed-array fields so consumers get fresh references
+  // instead of the readonly literal in POINT_CLOUD_DEFAULTS.
+  pointCloudFixedColor: [...POINT_CLOUD_DEFAULTS.pointCloudFixedColor] as [number, number, number, number],
+  setPointCloudColorMode: (mode) => set({ pointCloudColorMode: mode }),
+  setPointCloudFixedColor: (rgba) => set({ pointCloudFixedColor: rgba }),
+  setPointCloudSizeMode: (mode) => set({ pointCloudSizeMode: mode }),
+  // NaN/Infinity slip past Math.max+min unchanged ((NaN < x) === false),
+  // so guard with isFinite to keep invalid values out of GPU uniforms.
+  setPointCloudPointSize: (px) => set({
+    pointCloudPointSize: Number.isFinite(px) ? Math.max(1, Math.min(20, px)) : 4,
+  }),
+  setPointCloudWorldRadius: (m) => set({
+    pointCloudWorldRadius: Number.isFinite(m) ? Math.max(1e-4, m) : 0.02,
+  }),
+  setPointCloudRoundShape: (enabled) => set({ pointCloudRoundShape: enabled }),
+  setPointCloudEdlEnabled: (enabled) => set({ pointCloudEdlEnabled: enabled }),
+  setPointCloudEdlStrength: (strength) => set({
+    pointCloudEdlStrength: Number.isFinite(strength) ? Math.max(0, Math.min(3, strength)) : 1,
+  }),
+  setPointCloudAssetCount: (count) => set({
+    pointCloudAssetCount: Number.isFinite(count) ? Math.max(0, count) : 0,
+  }),
+  incrementPointCloudAssetCount: (n = 1) => set((s) => ({
+    pointCloudAssetCount: Number.isFinite(n)
+      ? Math.max(0, s.pointCloudAssetCount + n)
+      : s.pointCloudAssetCount,
+  })),
+});

package/src/store/types.ts

@@ -340,6 +340,13 @@ export interface FederatedModel {
   cacheState?: 'none' | 'hit' | 'miss' | 'writing';
   /** Optional load error for this model. */
   loadError?: string | null;
+  /**
+   * Renderer handle for a streamed point cloud (LAS/LAZ) attached to
+   * this model. Stored as a plain number so the field stays JSON-safe.
+   * The viewport's removal effect calls `renderer.removePointCloudAsset`
+   * when the model is dropped from the store.
+   */
+  pointCloudHandleId?: number;
 }
 
 /** Convert EntityRef to string for use as Map/Set key */

package/vite.config.ts

@@ -253,6 +253,7 @@ export default defineConfig({
       '@ifc-lite/export': path.resolve(__dirname, '../../packages/export/src'),
       '@ifc-lite/cache': path.resolve(__dirname, '../../packages/cache/src'),
       '@ifc-lite/ifcx': path.resolve(__dirname, '../../packages/ifcx/src'),
+      '@ifc-lite/pointcloud': path.resolve(__dirname, '../../packages/pointcloud/src'),
       '@ifc-lite/wasm': path.resolve(__dirname, '../../packages/wasm/pkg/ifc-lite.js'),
       '@ifc-lite/sdk': path.resolve(__dirname, '../../packages/sdk/src'),
       '@ifc-lite/create': path.resolve(__dirname, '../../packages/create/src'),