@ifc-lite/renderer 1.48.0 → 1.48.1

package/dist/index.js

@@ -84,29 +84,9 @@ import { resolveEnvironment } from './environment.js';
 import { shouldRouteMeshTransparent, shouldRouteBatchTransparent, splitVisibleIdsByPromotion, DEFAULT_GHOST_ALPHA } from './overlay-routing.js';
 import { colorSaltByte, packEntityLane } from './scene-geometry.js';
 import { PointCloudRenderer } from './pointcloud/point-cloud-renderer.js';
-import { DeviationPipeline } from './deviation/deviation-pipeline.js';
-import { buildTriangleBVH } from './deviation/triangle-bvh.js';
+import { DeviationComputer } from './deviation/deviation-computer.js';
 const MAX_ENCODED_ENTITY_ID = 0xFFFFFF;
 let warnedEntityIdRange = false;
-/**
- * Build a deterministic fingerprint of the BVH input mesh set so
- * `Renderer.computeDeviations` can skip the rebuild when the source
- * geometry hasn't changed. Folds in expressId / modelIndex / position
- * + index lengths per mesh so two distinct mesh sets that happen to
- * share the same aggregate position-length total can't collide on the
- * same fingerprint and reuse a stale BVH.
- */
-function computeBvhFingerprint(meshes) {
-    const parts = [String(meshes.length)];
-    for (const m of meshes) {
-        const id = m.expressId ?? -1;
-        const mi = m.modelIndex ?? -1;
-        const posLen = m.positions?.length ?? 0;
-        const idxLen = m.indices?.length ?? 0;
-        parts.push(`${id}:${mi}:${posLen}:${idxLen}`);
-    }
-    return parts.join('|');
-}
 /**
  * Is this throw the GPU device telling us it is gone?
  *
@@ -301,15 +281,8 @@ export class Renderer {
     /** Retained so a listener registered AFTER the loss still learns of it. */
     deviceLostInfo = null;
     deviceLostListeners = new Set();
-    deviationPipeline = null;
-    /**
-     * Cache of which mesh-set the BVH was built from. We rebuild on
-     * `computeDeviations` only when the cached "fingerprint" misses,
-     * so re-running deviation against the same model is a fast
-     * dispatch — the BVH is multi-second on big BIMs and we don't
-     * want to pay that on every slider drag.
-     */
-    deviationBvhFingerprint = null;
+    /** BIM ↔ scan deviation: owns the compute pipeline + its BVH cache. */
+    deviationComputer = new DeviationComputer();
     visualEnhancementResolver = new VisualEnhancementResolver();
     // Model bounds for fitToView, section planes, camera. The value itself
     // lives in ModelBoundsTracker (issue #2425) so the four writers — point
@@ -549,7 +522,7 @@ export class Renderer {
         // Compute pipeline for the BIM↔scan deviation heatmap. Lazily
         // owns the per-triangle BVH GPU buffers; idle until the first
         // `computeDeviations` call.
-        this.deviationPipeline = new DeviationPipeline(this.device.getDevice());
+        this.deviationComputer.init(this.device.getDevice());
         this.edlPass = new EdlPass(this.device, this.pipeline.getSampleCount());
         this.camera.setAspect(width / height);
         // Update picking manager with initialized picker
@@ -977,111 +950,17 @@ export class Renderer {
     /**
      * Compute BIM ↔ scan deviation for every loaded point cloud asset.
      *
-     * Walks every triangle in the scene (individual + batched meshes,
-     * regardless of which IFC ingest path produced them — STEP, IFCx,
-     * GLB, or federated combinations), builds a per-triangle BVH on
-     * the GPU, then runs a closest-point compute pass per chunk that
-     * writes signed distance into each chunk's deviation buffer.
-     *
-     * Returns metadata so the UI can populate a histogram + auto-range:
-     * the per-asset point count, the suggested ±range from the 95th
-     * percentile, and the bbox the BVH was built from.
-     *
-     * Idempotent: re-running with the same mesh set reuses the GPU
-     * BVH (the BVH build dominates wall time on big BIMs). Pass
-     * `forceRebuild: true` to invalidate.
+     * Delegates to the `DeviationComputer` collaborator, which owns the
+     * compute pipeline and the BVH-reuse fingerprint; see
+     * `deviation/deviation-computer.ts` for the full contract.
      */
     async computeDeviations(opts = {}) {
-        if (!this.deviationPipeline || !this.pointCloudRenderer) {
-            throw new Error('Renderer not initialised — call init() first.');
-        }
-        const meshes = this.collectAllSceneMeshes();
-        // Fingerprint folds in per-mesh expressId / modelIndex /
-        // positions length / triangle count, so two distinct meshes
-        // that happen to share an aggregate position-length total
-        // can't alias each other. A federation reload that swaps one
-        // model for another with the same total triangle count would
-        // otherwise reuse the previous BVH and report wrong distances.
-        const fingerprint = computeBvhFingerprint(meshes);
-        if (opts.forceRebuild || fingerprint !== this.deviationBvhFingerprint) {
-            const bvh = buildTriangleBVH(meshes);
-            this.deviationPipeline.uploadBvh(bvh);
-            this.deviationBvhFingerprint = fingerprint;
-        }
-        const stats = this.deviationPipeline.getBvhStats();
-        const maxRange = opts.maxRange ?? 1.0;
-        // Encode every chunk into a single command submit so the GPU
-        // can pipeline the dispatches without a CPU round-trip per
-        // chunk. Histogram readback is a follow-up — for v1 we emit
-        // the deviation buffers and let the splat shader visualise.
-        const encoder = this.device.getDevice().createCommandEncoder({ label: 'pointcloud-deviation' });
-        let chunksProcessed = 0;
-        let pointsProcessed = 0;
-        const nodes = this.pointCloudRenderer.getInternalNodes();
-        for (const node of nodes) {
-            for (const chunk of node.chunks) {
-                const ok = this.deviationPipeline.dispatch(encoder, {
-                    positionsBuffer: chunk.vertexBuffer,
-                    deviationsBuffer: chunk.deviationBuffer,
-                    pointCount: chunk.pointCount,
-                    maxRange,
-                    // #1804: chunk positions are stored in the asset's
-                    // decode-shifted local frame when IfcMapConversion
-                    // alignment is active; the BVH triangles are world
-                    // space, so the compute pass must apply the same
-                    // per-asset matrix the splat shader renders with.
-                    model: node.model,
-                });
-                if (ok) {
-                    chunksProcessed++;
-                    pointsProcessed += chunk.pointCount;
-                }
-            }
-        }
-        this.device.getDevice().queue.submit([encoder.finish()]);
-        // Wait until the GPU finishes the dispatches before resolving.
-        // Otherwise the caller's "compute done" callback fires before
-        // the deviation buffers are actually populated.
-        await this.device.getDevice().queue.onSubmittedWorkDone();
-        // The GPU is done reading each chunk's params uniform — free them.
-        this.deviationPipeline.releaseTransientParams();
-        this.requestRender();
-        // Suggest a default half-range = max(0.01m, max-extent / 1000).
-        // Tighter than the maxRange clip; gives the user a reasonable
-        // starting slider position without a histogram readback.
-        const bb = stats.bounds;
-        const suggestedHalfRange = bb
-            ? Math.max(0.01, Math.max(bb.max[0] - bb.min[0], bb.max[1] - bb.min[1], bb.max[2] - bb.min[2]) / 1000)
-            : 0.05;
-        return {
-            bvhTriangles: stats.triangleCount,
-            bvhNodes: stats.nodeCount,
-            chunksProcessed,
-            pointsProcessed,
-            bounds: stats.bounds,
-            suggestedHalfRange,
-        };
-    }
-    /**
-     * Aggregate every triangle source the scene exposes — individual
-     * meshes (created on demand by picking / highlights) AND batched
-     * meshes (the streaming geometry path's compact GPU buffers).
-     * Both formats arrive as `MeshData`; the BVH builder doesn't care
-     * which source they came from.
-     */
-    collectAllSceneMeshes() {
-        // The Scene keeps every CPU-side MeshData regardless of which
-        // ingest path produced it (STEP / IFCx / GLB). One iteration
-        // covers individual + batched + multi-piece + multi-model.
-        // `forEachMeshData` deduplicates by identity so a colour-merged
-        // batch is only added once even if it's indexed under multiple
-        // contributor expressIds.
-        const out = [];
-        this.scene.forEachMeshData((md) => {
-            if (md.positions && md.positions.length > 0)
-                out.push(md);
+        return this.deviationComputer.compute(opts, {
+            device: this.device,
+            scene: this.scene,
+            pointCloudRenderer: this.pointCloudRenderer,
+            requestRender: () => this.requestRender(),
         });
-        return out;
     }
     /**
      * Toggle Eye-Dome Lighting and tune its strength.
@@ -1939,13 +1818,14 @@ export class Renderer {
                     stencilStoreOp: 'store',
                 },
             });
-            // Global lighting environment: write the uniform once per frame
-            // and bind at group(1) — every pipeline derived from the main
-            // shader shares this layout, and bind groups persist across
-            // setPipeline calls within the pass.
+            // Global lighting environment: write the uniform once per frame.
+            // The group(1) bind is deferred until AFTER the sky pass below —
+            // the sky pipeline has an incompatible layout (its own group(0),
+            // no group(1)), so drawing the sky invalidates a group(1) binding
+            // on conformant WebGPU implementations (see the rebind after the
+            // sky block).
             const environment = resolveEnvironment(options.environment);
             this.pipeline.updateEnvironment(options.environment);
-            pass.setBindGroup(1, this.pipeline.getEnvironmentBindGroup());
             // Procedural sky background — replaces the flat clear colour.
             // Drawn before any geometry at the reverse-Z far plane with depth
             // writes off, so it never occludes anything and transparent
@@ -1981,6 +1861,17 @@ export class Renderer {
                 }, environment);
             }
             pass.setPipeline(this.pipeline.getPipeline());
+            // Bind the global lighting environment at group(1) AFTER any sky
+            // draw. The sky pipeline's layout (its own group(0), no group(1))
+            // is incompatible with the main layout, so drawing the sky
+            // invalidates the group(1) binding on strict WebGPU
+            // implementations. The flat batch loops below re-set only group(0)
+            // per batch (the instanced passes re-bind group(1) themselves), so
+            // without this rebind every non-'default' lighting preset — the
+            // only presets that enable the sky — blanked the model on those
+            // drivers. Binding while the main pipeline is current keeps it
+            // valid for every main-family draw that follows.
+            pass.setBindGroup(1, this.pipeline.getEnvironmentBindGroup());
             // Check if we have batched meshes (preferred for performance)
             const allBatchedMeshes = this.scene.getBatchedMeshes();
             // PERFORMANCE FIX: Always use batch rendering when we have batches
@@ -3300,9 +3191,7 @@ export class Renderer {
         // BIM ↔ scan deviation pipeline + cached BVH GPU buffers.
         // Done before queue.destroy() so the GPU calls inside
         // `destroy()` still have a valid device.
-        this.deviationPipeline?.destroy();
-        this.deviationPipeline = null;
-        this.deviationBvhFingerprint = null;
+        this.deviationComputer.destroy();
         // Snap detector geometry cache
         this.raycastEngine.clearCaches();
         // Finally, release the GPU device itself. Every buffer/pipeline/texture