@ifc-lite/renderer 1.17.0 → 1.18.0

package/dist/index.js

@@ -26,6 +26,10 @@ export { ZeroCopyGpuUploader, createZeroCopyUploader, } from './zero-copy-upload
 // Extracted manager classes
 export { PickingManager } from './picking-manager.js';
 export { RaycastEngine } from './raycast-engine.js';
+export { PointPicker, decodePickSample } from './point-picker.js';
+// Point cloud rendering (Phase 0: IFCx inline; Phase 1+: streaming LAS/LAZ)
+export { PointCloudRenderer } from './pointcloud/point-cloud-renderer.js';
+export { PointRenderPipeline } from './pointcloud/point-pipeline.js';
 import { WebGPUDevice } from './device.js';
 import { RenderPipeline, InstancedRenderPipeline } from './pipeline.js';
 import { Camera } from './camera.js';
@@ -40,6 +44,8 @@ import { DEFAULT_CAP_STYLE, HATCH_PATTERN_IDS } from './section-cap-style.js';
 import { PickingManager } from './picking-manager.js';
 import { RaycastEngine } from './raycast-engine.js';
 import { PostProcessor } from './post-processor.js';
+import { EdlPass } from './edl-pass.js';
+import { PointCloudRenderer } from './pointcloud/point-cloud-renderer.js';
 const MAX_ENCODED_ENTITY_ID = 0xFFFFFF;
 let warnedEntityIdRange = false;
 /**
@@ -56,6 +62,14 @@ export class Renderer {
     sectionPlaneRenderer = null;
     section2DOverlayRenderer = null;
     postProcessor = null;
+    edlPass = null;
+    edlOptions = {
+        enabled: false,
+        strength: 1,
+        radiusPx: 1,
+        highQuality: true,
+    };
+    pointCloudRenderer = null;
     visualEnhancementState = {
         enabled: true,
         edgeContrast: { enabled: true, intensity: 1.0 },
@@ -113,9 +127,217 @@ export class Renderer {
             contactRadius: 1.0,
             contactIntensity: 0.3,
         }, this.pipeline.getSampleCount());
+        this.pointCloudRenderer = new PointCloudRenderer(this.device.getDevice(), this.device.getFormat(), 'depth24plus-stencil8', this.pipeline.getSampleCount());
+        this.edlPass = new EdlPass(this.device, this.pipeline.getSampleCount());
         this.camera.setAspect(width / height);
         // Update picking manager with initialized picker
         this.pickingManager.setPicker(this.picker);
+        // Provide a snapshot of pickable point nodes per pick. The
+        // sizing must mirror the live splat shader so click hit-testing
+        // matches what the user actually sees on screen.
+        this.pickingManager.setPointPickProvider(() => {
+            const pcr = this.pointCloudRenderer;
+            if (!pcr || !pcr.hasAssets())
+                return null;
+            const opts = pcr.getOptions();
+            const sizeMode = opts.sizeMode === 'fixed-px' ? 0 : opts.sizeMode === 'adaptive-world' ? 1 : 2;
+            return {
+                nodes: pcr.getPickNodes(),
+                sizing: {
+                    sizeMode: sizeMode,
+                    worldRadius: opts.worldRadius,
+                    pointSizePx: opts.pointSize,
+                    clickTolerancePx: 2,
+                },
+            };
+        });
+    }
+    /**
+     * Replace all loaded point clouds with `assets`.
+     *
+     * Phase 0 entry point — single-chunk inline assets from IFCx
+     * (`pcd::base64`, `points::array`, `points::base64`). Future phases
+     * accept streaming sources via a different overload.
+     */
+    setPointClouds(assets) {
+        if (!this.pointCloudRenderer) {
+            throw new Error('Renderer not initialized. Call init() first.');
+        }
+        this.pointCloudRenderer.setAssets(assets);
+        // Replace, not append — bounds may have shrunk (e.g. an IFCx
+        // reload with a smaller scan). `expandModelBoundsForPointClouds`
+        // alone only grows; recompute from scratch to keep
+        // fit-to-view + section-plane sliders accurate.
+        this.recomputeModelBounds();
+        this.camera.setSceneBounds(this.modelBounds);
+        this.requestRender();
+    }
+    /** Append additional point clouds without clearing existing ones. */
+    addPointClouds(assets) {
+        if (!this.pointCloudRenderer) {
+            throw new Error('Renderer not initialized. Call init() first.');
+        }
+        for (const asset of assets) {
+            this.pointCloudRenderer.addAsset(asset);
+        }
+        this.expandModelBoundsForPointClouds();
+        this.camera.setSceneBounds(this.modelBounds);
+        this.requestRender();
+    }
+    /** Total number of point cloud assets currently uploaded. */
+    getPointCloudAssetCount() {
+        return this.pointCloudRenderer?.getNodeCount() ?? 0;
+    }
+    /** Total number of points across all point cloud assets. */
+    getPointCloudPointCount() {
+        return this.pointCloudRenderer?.getPointCount() ?? 0;
+    }
+    /** Drop all point cloud GPU resources. */
+    clearPointClouds() {
+        this.pointCloudRenderer?.clear();
+        this.recomputeModelBounds();
+        this.camera.setSceneBounds(this.modelBounds);
+        this.requestRender();
+    }
+    /**
+     * Streaming entry: open an empty asset that will receive chunks via
+     * `appendPointCloudChunk`. Call `endPointCloudStream` when no more
+     * chunks will arrive (currently a no-op but kept for symmetry).
+     */
+    beginPointCloudStream(meta) {
+        if (!this.pointCloudRenderer) {
+            throw new Error('Renderer not initialized. Call init() first.');
+        }
+        return this.pointCloudRenderer.beginAsset(meta);
+    }
+    appendPointCloudChunk(handle, chunk) {
+        if (!this.pointCloudRenderer)
+            return;
+        this.pointCloudRenderer.appendChunk(handle, chunk);
+        this.expandModelBoundsForPointClouds();
+        this.camera.setSceneBounds(this.modelBounds);
+        this.requestRender();
+    }
+    endPointCloudStream(handle) {
+        this.pointCloudRenderer?.endAsset(handle);
+        this.requestRender();
+    }
+    removePointCloudAsset(handle) {
+        this.pointCloudRenderer?.removeAsset(handle);
+        // Bounds may have shrunk — recompute from scratch so fit-to-view
+        // and section-plane sliders see fresh extents.
+        this.recomputeModelBounds();
+        this.camera.setSceneBounds(this.modelBounds);
+        this.requestRender();
+    }
+    /**
+     * Reassign a streamed point-cloud's expressId after upload. Use
+     * this when the federation registry assigns a new model offset and
+     * the renderer needs to emit the post-offset globalId in picking
+     * outputs. The change takes effect on the next render — no GPU
+     * buffer rewrite needed.
+     */
+    relabelPointCloudAsset(handle, newExpressId) {
+        this.pointCloudRenderer?.relabelAsset(handle, newExpressId);
+        this.requestRender();
+    }
+    /**
+     * Compute model bounds from triangle meshes + remaining point clouds.
+     * Called from removeAsset / clear paths so bounds shrink correctly.
+     * Triangle meshes still drive the bounds when present (existing
+     * Scene-driven path), so this only re-folds in the point cloud
+     * extents over whatever the mesh path left.
+     */
+    recomputeModelBounds() {
+        // Always recompute from scratch: take mesh bounds as the
+        // baseline, then fold in the CURRENT point-cloud bounds on
+        // top. Folding only-up via expandModelBoundsForPointClouds()
+        // is correct when pc bounds grow but never shrinks them when
+        // an asset is removed, leaving stale oversized extents until
+        // every point cloud is gone.
+        const meshBounds = this.computeMeshBounds();
+        const pcBounds = this.pointCloudRenderer?.getBounds() ?? null;
+        if (!meshBounds && !pcBounds) {
+            this.modelBounds = null;
+            return;
+        }
+        this.modelBounds = meshBounds ?? {
+            min: { x: pcBounds.min[0], y: pcBounds.min[1], z: pcBounds.min[2] },
+            max: { x: pcBounds.max[0], y: pcBounds.max[1], z: pcBounds.max[2] },
+        };
+        if (meshBounds && pcBounds) {
+            this.expandModelBoundsForPointClouds();
+        }
+    }
+    /** Aggregate bounds across all batched + individual meshes. Returns
+     *  null if the scene has no mesh geometry. */
+    computeMeshBounds() {
+        let minX = Infinity, minY = Infinity, minZ = Infinity;
+        let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+        let any = false;
+        for (const batch of this.scene.getBatchedMeshes()) {
+            if (!batch.bounds)
+                continue;
+            any = true;
+            if (batch.bounds.min[0] < minX)
+                minX = batch.bounds.min[0];
+            if (batch.bounds.min[1] < minY)
+                minY = batch.bounds.min[1];
+            if (batch.bounds.min[2] < minZ)
+                minZ = batch.bounds.min[2];
+            if (batch.bounds.max[0] > maxX)
+                maxX = batch.bounds.max[0];
+            if (batch.bounds.max[1] > maxY)
+                maxY = batch.bounds.max[1];
+            if (batch.bounds.max[2] > maxZ)
+                maxZ = batch.bounds.max[2];
+        }
+        if (!any)
+            return null;
+        return { min: { x: minX, y: minY, z: minZ }, max: { x: maxX, y: maxY, z: maxZ } };
+    }
+    /** Apply rendering options (color mode, fixed override, point size). */
+    setPointCloudOptions(opts) {
+        this.pointCloudRenderer?.setOptions(opts);
+        this.requestRender();
+    }
+    /**
+     * Toggle Eye-Dome Lighting and tune its strength.
+     *
+     * EDL adds depth perception to point clouds (and meshes) via screen-
+     * space depth gradient — silhouette pixels get a soft black halo.
+     * Cheap: ~9 texture taps per pixel. Only runs when point clouds are
+     * loaded.
+     */
+    setEdlOptions(opts) {
+        if (opts.enabled !== undefined)
+            this.edlOptions.enabled = opts.enabled;
+        if (opts.strength !== undefined)
+            this.edlOptions.strength = Math.max(0, Math.min(3, opts.strength));
+        if (opts.radiusPx !== undefined)
+            this.edlOptions.radiusPx = Math.max(1, Math.min(4, opts.radiusPx));
+        if (opts.highQuality !== undefined)
+            this.edlOptions.highQuality = opts.highQuality;
+        this.requestRender();
+    }
+    expandModelBoundsForPointClouds() {
+        const pcBounds = this.pointCloudRenderer?.getBounds();
+        if (!pcBounds)
+            return;
+        if (!this.modelBounds) {
+            this.modelBounds = {
+                min: { x: pcBounds.min[0], y: pcBounds.min[1], z: pcBounds.min[2] },
+                max: { x: pcBounds.max[0], y: pcBounds.max[1], z: pcBounds.max[2] },
+            };
+            return;
+        }
+        const m = this.modelBounds;
+        m.min.x = Math.min(m.min.x, pcBounds.min[0]);
+        m.min.y = Math.min(m.min.y, pcBounds.min[1]);
+        m.min.z = Math.min(m.min.z, pcBounds.min[2]);
+        m.max.x = Math.max(m.max.x, pcBounds.max[0]);
+        m.max.y = Math.max(m.max.y, pcBounds.max[1]);
+        m.max.z = Math.max(m.max.z, pcBounds.max[2]);
     }
     /**
      * Load geometry from GeometryResult or MeshData array
@@ -553,29 +775,66 @@ export class Renderer {
         const hasHiddenFilter = options.hiddenIds && options.hiddenIds.size > 0;
         const hasIsolatedFilter = options.isolatedIds !== null && options.isolatedIds !== undefined;
         const hasVisibilityFiltering = hasHiddenFilter || hasIsolatedFilter;
+        // Build the selected-id set once per frame so the X-Ray override paths
+        // can keep highlighted entities at full alpha without per-site checks.
+        const selectedId = options.selectedId;
+        const selectedIds = options.selectedIds;
+        const selectedModelIndex = options.selectedModelIndex;
+        const selectedExpressIds = new Set();
+        if (selectedId !== undefined && selectedId !== null) {
+            selectedExpressIds.add(selectedId);
+        }
+        if (selectedIds) {
+            for (const id of selectedIds) {
+                selectedExpressIds.add(id);
+            }
+        }
+        const hasSelected = selectedExpressIds.size > 0;
         // Per-frame alpha overrides for X-Ray mode. See RenderOptions.transparencyOverrides.
-        // Callers supply a fresh Map when contents change (same convention as hiddenIds/isolatedIds).
-        const txOverrides = options.transparencyOverrides;
-        const hasTxOverrides = txOverrides != null && txOverrides.size > 0;
+        // Snapshot the caller's map so mid-frame mutation can't desync classification
+        // and uniform-write decisions for the same batch/mesh.
+        const txOverridesSrc = options.transparencyOverrides;
+        const hasTxOverrides = txOverridesSrc != null && txOverridesSrc.size > 0;
+        const txOverrides = hasTxOverrides ? new Map(txOverridesSrc) : null;
         const alphaForMesh = (expressId, fallback) => {
             if (!hasTxOverrides)
                 return fallback;
+            // Selected meshes are exempt — the highlight pass renders them last,
+            // but exempting here also keeps mesh classification + uniform writes
+            // consistent so a selected mesh never enters the transparent pipeline
+            // because of its own override entry.
+            if (hasSelected && selectedExpressIds.has(expressId))
+                return fallback;
             const a = txOverrides.get(expressId);
             return a !== undefined ? a : fallback;
         };
-        // alphaForBatch walks batch.expressIds per frame. For typical batch sizes
-        // the cost is well below noise vs. the GPU work, and avoiding a cache
-        // removes the stale-on-mutation bug class entirely.
+        // Cache resolved batch alpha for the frame: classification needs it
+        // (opaque vs transparent routing) and renderBatch needs it for the
+        // uniform write. Without the cache we'd walk batch.expressIds twice
+        // per batch per frame, which becomes the dominant JS cost in X-Ray.
+        const batchAlphaCache = hasTxOverrides
+            ? new WeakMap()
+            : null;
         const alphaForBatch = (batch, fallback) => {
             if (!hasTxOverrides)
                 return fallback;
+            const cached = batchAlphaCache.get(batch);
+            if (cached !== undefined)
+                return cached;
             let minAlpha = Infinity;
             for (const eid of batch.expressIds) {
+                // Selected ids never drag down a batch's alpha — the highlight
+                // pass redraws them on top, but excluding here also means a
+                // batch made entirely of selected entities stays opaque.
+                if (hasSelected && selectedExpressIds.has(eid))
+                    continue;
                 const a = txOverrides.get(eid);
                 if (a !== undefined && a < minAlpha)
                     minAlpha = a;
             }
-            return minAlpha === Infinity ? fallback : minAlpha;
+            const resolved = minAlpha === Infinity ? fallback : minAlpha;
+            batchAlphaCache.set(batch, resolved);
+            return resolved;
         };
         // PERFORMANCE FIX: Use batch-level visibility filtering instead of creating individual meshes
         // Only create individual meshes for selected elements (for highlighting)
@@ -645,9 +904,6 @@ export class Renderer {
             // Write uniform data to each mesh's buffer BEFORE recording commands
             // This ensures each mesh has its own color data
             const allMeshes = [...opaqueMeshes, ...transparentMeshes];
-            const selectedId = options.selectedId;
-            const selectedIds = options.selectedIds;
-            const selectedModelIndex = options.selectedModelIndex;
             // Calculate section plane parameters and model bounds
             // Always calculate bounds when sectionPlane is provided (for preview and active mode)
             let sectionPlaneData;
@@ -682,6 +938,21 @@ export class Renderer {
                         boundsMax.z = Math.max(boundsMax.z, batch.bounds.max[2]);
                     }
                 }
+                // Fold in point-cloud bounds too — without this, a
+                // pure point-cloud scene falls through to the default
+                // [-100,100], and a mixed scene clips against a
+                // smaller mesh-only range while the point pipeline
+                // (which honours the same sectionPlaneData) keeps
+                // drawing points outside the slider's reach.
+                const pcBoundsForSection = this.pointCloudRenderer?.getBounds();
+                if (pcBoundsForSection) {
+                    boundsMin.x = Math.min(boundsMin.x, pcBoundsForSection.min[0]);
+                    boundsMin.y = Math.min(boundsMin.y, pcBoundsForSection.min[1]);
+                    boundsMin.z = Math.min(boundsMin.z, pcBoundsForSection.min[2]);
+                    boundsMax.x = Math.max(boundsMax.x, pcBoundsForSection.max[0]);
+                    boundsMax.y = Math.max(boundsMax.y, pcBoundsForSection.max[1]);
+                    boundsMax.z = Math.max(boundsMax.z, pcBoundsForSection.max[2]);
+                }
                 // If no batched meshes have bounds yet (streaming, degenerate
                 // models), fall back to individual meshes so at least the
                 // slider has a workable range.
@@ -961,15 +1232,6 @@ export class Renderer {
                         opaqueBatches.push(batch);
                     }
                 }
-                const selectedExpressIds = new Set();
-                if (selectedId !== undefined && selectedId !== null) {
-                    selectedExpressIds.add(selectedId);
-                }
-                if (selectedIds) {
-                    for (const id of selectedIds) {
-                        selectedExpressIds.add(id);
-                    }
-                }
                 // Build a uniform template ONCE per frame — shared across all batches.
                 // Only the 4-float color (offset 32) differs per batch; everything else
                 // (viewProj, identity model, material, section plane, flags) is identical.
@@ -1308,6 +1570,19 @@ export class Renderer {
                     }
                 }
             }
+            // Draw point clouds (IFCx inline + streamed LAS/LAZ).
+            // Shares the depth buffer + section plane state with the mesh pipeline so
+            // points occlude triangles and vice versa. The splat shader needs the
+            // viewport size to convert pixel sizes into clip-space offsets.
+            if (this.pointCloudRenderer && this.pointCloudRenderer.hasAssets()) {
+                this.pointCloudRenderer.draw(pass, {
+                    viewProj,
+                    sectionPlane: sectionPlaneData
+                        ? { ...sectionPlaneData, flipped: options.sectionPlane?.flipped === true }
+                        : null,
+                    viewport: { width: this.canvas.width, height: this.canvas.height },
+                });
+            }
             // Draw section plane visual BEFORE pass.end() (within same MSAA render pass)
             // Always show plane when sectionPlane options are provided (as preview or active)
             const modelBounds = this.getModelBounds();
@@ -1380,6 +1655,21 @@ export class Renderer {
                     enableSeparationLines: separationEnabled,
                 });
             }
+            // Eye-Dome Lighting — runs AFTER contact/separation so it darkens
+            // every layer uniformly. Cheap (~9 depth taps), only active when
+            // there are point clouds in the scene and the user has enabled it.
+            if (this.edlPass
+                && this.edlOptions.enabled
+                && this.pointCloudRenderer?.hasAssets()) {
+                this.edlPass.apply(encoder, {
+                    targetView: textureView,
+                    depthView: this.pipeline.getDepthOnlyTextureView(),
+                }, {
+                    strength: this.edlOptions.strength,
+                    radiusPx: this.edlOptions.radiusPx,
+                    highQuality: this.edlOptions.highQuality,
+                });
+            }
             device.queue.submit([encoder.finish()]);
         }
         catch (error) {
@@ -1601,11 +1891,16 @@ export class Renderer {
         // Post-processor uniform buffer
         this.postProcessor?.destroy();
         this.postProcessor = null;
+        this.edlPass?.destroy();
+        this.edlPass = null;
         // Section-plane renderers
         this.sectionPlaneRenderer?.destroy();
         this.sectionPlaneRenderer = null;
         this.section2DOverlayRenderer?.dispose();
         this.section2DOverlayRenderer = null;
+        // Point cloud GPU resources
+        this.pointCloudRenderer?.clear();
+        this.pointCloudRenderer = null;
         // Snap detector geometry cache
         this.raycastEngine.clearCaches();
     }