@ifc-lite/renderer 1.47.0 → 1.48.1

package/dist/clash-solid-pipeline.d.ts

@@ -0,0 +1,34 @@
+/** One flat opaque colour for the whole solid — BIMcollab-style, not per-triangle. */
+export interface ClashSolidInput {
+    /** World-space vertex positions, flat `[x, y, z, …]`. */
+    positions: Float32Array | Float64Array;
+    /** Triangle indices into `positions / 3`. */
+    indices: Uint32Array;
+    /** Straight-alpha RGBA in [0..1]. Alpha 1 renders fully opaque. */
+    color: [number, number, number, number];
+}
+/**
+ * Expand an indexed triangle mesh + single colour into the flat
+ * pos+color-per-vertex stream `SYMBOLIC_FILL_WGSL` expects, matching
+ * `triangulateFillTo`'s non-indexed triangle-list convention.
+ */
+export declare function expandTriangles(input: ClashSolidInput): Float32Array;
+export declare class ClashSolidPipeline {
+    private readonly device;
+    private readonly format;
+    private readonly sampleCount;
+    private pipeline;
+    private bindGroupLayout;
+    private uniformBuffer;
+    private bindGroup;
+    private vertexBuffer;
+    private vertexCount;
+    constructor(device: GPUDevice, presentationFormat: GPUTextureFormat, sampleCount?: number);
+    private init;
+    /** Upload the solid mesh. Pass `null` to clear. */
+    upload(input: ClashSolidInput | null): void;
+    hasGeometry(): boolean;
+    render(pass: GPURenderPassEncoder, viewProj: Float32Array): void;
+    destroy(): void;
+}
+//# sourceMappingURL=clash-solid-pipeline.d.ts.map

package/dist/clash-solid-pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clash-solid-pipeline.d.ts","sourceRoot":"","sources":["../src/clash-solid-pipeline.ts"],"names":[],"mappings":"AA+BA,sFAAsF;AACtF,MAAM,WAAW,eAAe;IAC9B,yDAAyD;IACzD,SAAS,EAAE,YAAY,GAAG,YAAY,CAAC;IACvC,6CAA6C;IAC7C,OAAO,EAAE,WAAW,CAAC;IACrB,mEAAmE;IACnE,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CACzC;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,eAAe,GAAG,YAAY,CAkBpE;AAED,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAY;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAmB;IAC1C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAkC;IAClD,OAAO,CAAC,eAAe,CAAmC;IAC1D,OAAO,CAAC,aAAa,CAA0B;IAC/C,OAAO,CAAC,SAAS,CAA6B;IAC9C,OAAO,CAAC,YAAY,CAA0B;IAC9C,OAAO,CAAC,WAAW,CAAK;gBAEZ,MAAM,EAAE,SAAS,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,WAAW,GAAE,MAAU;IAM5F,OAAO,CAAC,IAAI;IAmFZ,mDAAmD;IACnD,MAAM,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,GAAG,IAAI;IAuB3C,WAAW,IAAI,OAAO;IAItB,MAAM,CAAC,IAAI,EAAE,oBAAoB,EAAE,QAAQ,EAAE,YAAY,GAAG,IAAI;IAUhE,OAAO,IAAI,IAAI;CAUhB"}

package/dist/clash-solid-pipeline.js

@@ -0,0 +1,193 @@
+/* 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/. */
+/**
+ * The focused clash's INTERSECTION SOLID — the true overlap volume of a
+ * clashing pair, rendered opaque so it reads as a distinct shape rather than
+ * an abstract wireframe box (the BIMcollab Zoom / Solibri presentation the
+ * viewer's own overlap-box overlay was compared against and found "not
+ * helpful, hard to see").
+ *
+ * Deliberately its own tiny pipeline rather than a reuse of
+ * `SymbolicFillPipeline`: the vertex layout and shader (`SYMBOLIC_FILL_WGSL`,
+ * pos.xyz + color.rgba, straight `viewProj * pos`) are identical and shared,
+ * but the depth/blend state cannot be — the fill pipeline is a coplanar DECAL
+ * (`depthWriteEnabled: false`, negative bias, alpha-blended) for flat
+ * annotation regions that sit ON a real surface. The intersection solid is a
+ * real enclosed 3D volume: it must depth-test AND depth-write like ordinary
+ * opaque geometry so its own front/back triangles resolve correctly and it is
+ * properly occluded by unrelated opaque geometry in front of it, while still
+ * drawing on top of (and being visible through) the two ghosted parent
+ * elements — ghosted geometry renders with `depthWriteEnabled: false`
+ * (`pipeline.ts`), so it never occludes anything drawn after it in the same
+ * pass, including this.
+ */
+import { SYMBOLIC_FILL_WGSL } from './shaders/symbolic-overlay.wgsl.js';
+import { PIPELINE_CONSTANTS } from './constants.js';
+const VERTEX_STRIDE_BYTES = (3 + 4) * 4; // pos.xyz + color.rgba, 4 bytes each
+/**
+ * Expand an indexed triangle mesh + single colour into the flat
+ * pos+color-per-vertex stream `SYMBOLIC_FILL_WGSL` expects, matching
+ * `triangulateFillTo`'s non-indexed triangle-list convention.
+ */
+export function expandTriangles(input) {
+    const { positions, indices, color } = input;
+    const triCount = Math.floor(indices.length / 3);
+    const out = new Float32Array(triCount * 3 * 7);
+    let w = 0;
+    for (let t = 0; t < triCount; t += 1) {
+        for (let k = 0; k < 3; k += 1) {
+            const vi = indices[t * 3 + k] * 3;
+            out[w++] = positions[vi];
+            out[w++] = positions[vi + 1];
+            out[w++] = positions[vi + 2];
+            out[w++] = color[0];
+            out[w++] = color[1];
+            out[w++] = color[2];
+            out[w++] = color[3];
+        }
+    }
+    return out;
+}
+export class ClashSolidPipeline {
+    device;
+    format;
+    sampleCount;
+    pipeline = null;
+    bindGroupLayout = null;
+    uniformBuffer = null;
+    bindGroup = null;
+    vertexBuffer = null;
+    vertexCount = 0;
+    constructor(device, presentationFormat, sampleCount = 1) {
+        this.device = device;
+        this.format = presentationFormat;
+        this.sampleCount = sampleCount;
+    }
+    init() {
+        if (this.pipeline)
+            return;
+        this.bindGroupLayout = this.device.createBindGroupLayout({
+            label: 'clash-solid-bgl',
+            entries: [
+                { binding: 0, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform' } },
+            ],
+        });
+        const module = this.device.createShaderModule({
+            label: 'clash-solid-shader',
+            code: SYMBOLIC_FILL_WGSL,
+        });
+        this.pipeline = this.device.createRenderPipeline({
+            label: 'clash-solid-pipeline',
+            layout: this.device.createPipelineLayout({ bindGroupLayouts: [this.bindGroupLayout] }),
+            vertex: {
+                module,
+                entryPoint: 'vs_main',
+                buffers: [
+                    {
+                        arrayStride: VERTEX_STRIDE_BYTES,
+                        attributes: [
+                            { shaderLocation: 0, offset: 0, format: 'float32x3' },
+                            { shaderLocation: 1, offset: 3 * 4, format: 'float32x4' },
+                        ],
+                    },
+                ],
+            },
+            fragment: {
+                module,
+                entryPoint: 'fs_main',
+                // Same two-target layout as every other overlay pipeline sharing this
+                // pass: presentation colour + the picker objectId, write-masked off so
+                // the opaque pass's picker IDs underneath survive.
+                targets: [
+                    {
+                        format: this.format,
+                        blend: {
+                            color: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+                            alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+                        },
+                        writeMask: GPUColorWrite.ALL,
+                    },
+                    { format: 'rgba8unorm', writeMask: 0 },
+                ],
+            },
+            // `cullMode: 'none'`: the intersection kernel's output winding isn't a
+            // contract the renderer depends on (mirrors the main opaque pipeline's
+            // own "IFC winding order varies" choice), and a double-sided draw still
+            // looks correct for a convex-ish overlap volume viewed from outside.
+            primitive: { topology: 'triangle-list', cullMode: 'none' },
+            depthStencil: {
+                format: PIPELINE_CONSTANTS.DEPTH_FORMAT,
+                // Unlike the fill pipeline's decal, this is a real volume: it must
+                // write depth so its own triangles sort against each other and so it
+                // is correctly occluded by opaque geometry drawn earlier in the pass.
+                depthWriteEnabled: true,
+                depthCompare: 'greater', // Reverse-Z, matches the main opaque pipeline.
+                // Small decal bias so a face that lands exactly on a parent's own
+                // surface (a flush overlap boundary) doesn't z-fight with it.
+                depthBias: -2,
+                depthBiasSlopeScale: -0.25,
+                depthBiasClamp: 0,
+            },
+            multisample: { count: this.sampleCount },
+        });
+        this.uniformBuffer = this.device.createBuffer({
+            label: 'clash-solid-camera',
+            size: 64,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        });
+        this.bindGroup = this.device.createBindGroup({
+            label: 'clash-solid-bg',
+            layout: this.bindGroupLayout,
+            entries: [{ binding: 0, resource: { buffer: this.uniformBuffer } }],
+        });
+    }
+    /** Upload the solid mesh. Pass `null` to clear. */
+    upload(input) {
+        this.init();
+        if (this.vertexBuffer) {
+            this.vertexBuffer.destroy();
+            this.vertexBuffer = null;
+        }
+        this.vertexCount = 0;
+        if (!input || input.indices.length === 0)
+            return;
+        const data = expandTriangles(input);
+        if (data.length === 0)
+            return;
+        this.vertexBuffer = this.device.createBuffer({
+            label: 'clash-solid-vbuf',
+            size: data.byteLength,
+            usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+        });
+        this.device.queue.writeBuffer(this.vertexBuffer, 0, data);
+        this.vertexCount = data.length / (VERTEX_STRIDE_BYTES / 4);
+    }
+    hasGeometry() {
+        return this.vertexCount > 0;
+    }
+    render(pass, viewProj) {
+        if (!this.pipeline || !this.uniformBuffer || !this.bindGroup || !this.vertexBuffer)
+            return;
+        if (this.vertexCount === 0)
+            return;
+        this.device.queue.writeBuffer(this.uniformBuffer, 0, viewProj);
+        pass.setPipeline(this.pipeline);
+        pass.setBindGroup(0, this.bindGroup);
+        pass.setVertexBuffer(0, this.vertexBuffer);
+        pass.draw(this.vertexCount);
+    }
+    destroy() {
+        if (this.vertexBuffer)
+            this.vertexBuffer.destroy();
+        if (this.uniformBuffer)
+            this.uniformBuffer.destroy();
+        this.vertexBuffer = null;
+        this.uniformBuffer = null;
+        this.bindGroup = null;
+        this.bindGroupLayout = null;
+        this.pipeline = null;
+        this.vertexCount = 0;
+    }
+}
+//# sourceMappingURL=clash-solid-pipeline.js.map

package/dist/clash-solid-pipeline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clash-solid-pipeline.js","sourceRoot":"","sources":["../src/clash-solid-pipeline.ts"],"names":[],"mappings":"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"}

package/dist/deviation/deviation-computer.d.ts

@@ -0,0 +1,87 @@
+import type { WebGPUDevice } from '../device.js';
+import type { Scene } from '../scene.js';
+import type { PointCloudRenderer } from '../pointcloud/point-cloud-renderer.js';
+/** Tuning knobs for a single `DeviationComputer.compute` run. */
+export interface DeviationComputeOptions {
+    /** Clip range applied during compute. 0 → no clip. Default 1m. */
+    maxRange?: number;
+    forceRebuild?: boolean;
+}
+/**
+ * Everything the compute pass borrows from the `Renderer` for the
+ * duration of one call. None of it is retained.
+ */
+export interface DeviationComputeContext {
+    device: WebGPUDevice;
+    scene: Scene;
+    pointCloudRenderer: PointCloudRenderer | null;
+    requestRender: () => void;
+}
+/** Metadata a completed deviation pass reports back to the UI. */
+export interface DeviationComputeResult {
+    bvhTriangles: number;
+    bvhNodes: number;
+    chunksProcessed: number;
+    pointsProcessed: number;
+    bounds: {
+        min: [number, number, number];
+        max: [number, number, number];
+    } | null;
+    suggestedHalfRange: number;
+}
+/**
+ * Owns the deviation compute pipeline and its BVH cache.
+ *
+ * Lifecycle mirrors the `Renderer`'s: `init()` on device creation,
+ * `destroy()` before the device goes away.
+ */
+export declare class DeviationComputer {
+    private pipeline;
+    /**
+     * 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.
+     */
+    private bvhFingerprint;
+    /**
+     * Create the compute pipeline for the BIM↔scan deviation heatmap.
+     * Lazily owns the per-triangle BVH GPU buffers; idle until the
+     * first `compute` call.
+     *
+     * Idempotent: a second `init()` without an intervening `destroy()`
+     * tears down the previous pipeline (releasing its GPU buffers
+     * instead of orphaning them) and clears `bvhFingerprint`. Without
+     * this, the stale fingerprint would match the next `compute()`
+     * call's input, skip re-uploading the BVH into the NEW pipeline,
+     * and `dispatch()` would silently no-op every chunk (no BVH
+     * uploaded) — reporting a plausible-looking deviation of zero
+     * instead of failing loudly.
+     */
+    init(device: GPUDevice): void;
+    /**
+     * 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.
+     */
+    compute(opts: DeviationComputeOptions, ctx: DeviationComputeContext): Promise<DeviationComputeResult>;
+    /**
+     * Release the compute pipeline + cached BVH GPU buffers and forget
+     * the fingerprint, so a re-`init()` on a fresh device rebuilds.
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=deviation-computer.d.ts.map

package/dist/deviation/deviation-computer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deviation-computer.d.ts","sourceRoot":"","sources":["../../src/deviation/deviation-computer.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AA2ChF,iEAAiE;AACjE,MAAM,WAAW,uBAAuB;IACpC,kEAAkE;IAClE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACpC,MAAM,EAAE,YAAY,CAAC;IACrB,KAAK,EAAE,KAAK,CAAC;IACb,kBAAkB,EAAE,kBAAkB,GAAG,IAAI,CAAC;IAC9C,aAAa,EAAE,MAAM,IAAI,CAAC;CAC7B;AAED,kEAAkE;AAClE,MAAM,WAAW,sBAAsB;IACnC,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE;QAAE,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QAAC,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,GAAG,IAAI,CAAC;IAChF,kBAAkB,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;GAKG;AACH,qBAAa,iBAAiB;IAC1B,OAAO,CAAC,QAAQ,CAAkC;IAClD;;;;;;OAMG;IACH,OAAO,CAAC,cAAc,CAAuB;IAE7C;;;;;;;;;;;;;OAaG;IACH,IAAI,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI;IAM7B;;;;;;;;;;;;;;;;OAgBG;IACG,OAAO,CACT,IAAI,EAAE,uBAAuB,EAC7B,GAAG,EAAE,uBAAuB,GAC7B,OAAO,CAAC,sBAAsB,CAAC;IAuFlC;;;OAGG;IACH,OAAO,IAAI,IAAI;CAKlB"}

package/dist/deviation/deviation-computer.js

@@ -0,0 +1,201 @@
+/* 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/. */
+/**
+ * BIM ↔ scan deviation as a composed collaborator (issue #2425).
+ *
+ * Owns the whole deviation concern's state — the `DeviationPipeline`
+ * and the BVH-reuse fingerprint — so the `Renderer` holds one field
+ * instead of two and `computeDeviations` becomes a delegation. Nothing
+ * outside this file reads either piece of state: the render loop, the
+ * diagnostics counters and the bounds tracker are all untouched by it,
+ * which is what makes this seam separable at all.
+ *
+ * The collaborator borrows (never owns) the device, the point-cloud
+ * renderer and the scene — they arrive per call in `DeviationComputeContext`.
+ */
+import { DeviationPipeline } from './deviation-pipeline.js';
+import { buildTriangleBVH } from './triangle-bvh.js';
+/**
+ * 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('|');
+}
+/**
+ * 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.
+ */
+function collectAllSceneMeshes(scene) {
+    // 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 = [];
+    scene.forEachMeshData((md) => {
+        if (md.positions && md.positions.length > 0)
+            out.push(md);
+    });
+    return out;
+}
+/**
+ * Owns the deviation compute pipeline and its BVH cache.
+ *
+ * Lifecycle mirrors the `Renderer`'s: `init()` on device creation,
+ * `destroy()` before the device goes away.
+ */
+export class DeviationComputer {
+    pipeline = 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.
+     */
+    bvhFingerprint = null;
+    /**
+     * Create the compute pipeline for the BIM↔scan deviation heatmap.
+     * Lazily owns the per-triangle BVH GPU buffers; idle until the
+     * first `compute` call.
+     *
+     * Idempotent: a second `init()` without an intervening `destroy()`
+     * tears down the previous pipeline (releasing its GPU buffers
+     * instead of orphaning them) and clears `bvhFingerprint`. Without
+     * this, the stale fingerprint would match the next `compute()`
+     * call's input, skip re-uploading the BVH into the NEW pipeline,
+     * and `dispatch()` would silently no-op every chunk (no BVH
+     * uploaded) — reporting a plausible-looking deviation of zero
+     * instead of failing loudly.
+     */
+    init(device) {
+        this.pipeline?.destroy();
+        this.pipeline = new DeviationPipeline(device);
+        this.bvhFingerprint = null;
+    }
+    /**
+     * 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.
+     */
+    async compute(opts, ctx) {
+        if (!this.pipeline || !ctx.pointCloudRenderer) {
+            throw new Error('Renderer not initialised — call init() first.');
+        }
+        const meshes = collectAllSceneMeshes(ctx.scene);
+        // 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.bvhFingerprint) {
+            const bvh = buildTriangleBVH(meshes);
+            this.pipeline.uploadBvh(bvh);
+            this.bvhFingerprint = fingerprint;
+        }
+        const stats = this.pipeline.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 = ctx.device.getDevice().createCommandEncoder({ label: 'pointcloud-deviation' });
+        let chunksProcessed = 0;
+        let pointsProcessed = 0;
+        const nodes = ctx.pointCloudRenderer.getInternalNodes();
+        for (const node of nodes) {
+            for (const chunk of node.chunks) {
+                const ok = this.pipeline.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;
+                }
+            }
+        }
+        ctx.device.getDevice().queue.submit([encoder.finish()]);
+        try {
+            // 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 ctx.device.getDevice().queue.onSubmittedWorkDone();
+        }
+        finally {
+            // The GPU is done reading each chunk's params uniform — free
+            // them. Must run even when the await above rejects (e.g. the
+            // device is lost mid-submit): the transient params buffers
+            // were already created and pushed onto `transientParamsBuffers`
+            // above, so skipping this on the rejection path would leak
+            // them.
+            this.pipeline.releaseTransientParams();
+        }
+        ctx.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,
+        };
+    }
+    /**
+     * Release the compute pipeline + cached BVH GPU buffers and forget
+     * the fingerprint, so a re-`init()` on a fresh device rebuilds.
+     */
+    destroy() {
+        this.pipeline?.destroy();
+        this.pipeline = null;
+        this.bvhFingerprint = null;
+    }
+}
+//# sourceMappingURL=deviation-computer.js.map

package/dist/deviation/deviation-computer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deviation-computer.js","sourceRoot":"","sources":["../../src/deviation/deviation-computer.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -69,6 +69,7 @@ import { SnapDetector, type SnapTarget, type SnapOptions, type EdgeLockInput, ty
 import { type RenderDegradationInfo } from './render-degradation.js';
 import type { FrameStats } from './render-stats.js';
 import type { PointCloudAsset } from '@ifc-lite/geometry';
+import { type DeviationComputeOptions, type DeviationComputeResult } from './deviation/deviation-computer.js';
 /**
  * Main renderer class
  */
@@ -185,15 +186,8 @@ export declare class Renderer {
     /** Retained so a listener registered AFTER the loss still learns of it. */
     private deviceLostInfo;
     private deviceLostListeners;
-    private deviationPipeline;
-    /**
-     * 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.
-     */
-    private deviationBvhFingerprint;
+    /** BIM ↔ scan deviation: owns the compute pipeline + its BVH cache. */
+    private readonly deviationComputer;
     private readonly visualEnhancementResolver;
     private readonly modelBoundsTracker;
     /** Read-only view of the tracked scene AABB (live reference, not a copy). */
@@ -444,43 +438,11 @@ export declare 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.
-     */
-    computeDeviations(opts?: {
-        /** Clip range applied during compute. 0 → no clip. Default 1m. */
-        maxRange?: number;
-        forceRebuild?: boolean;
-    }): Promise<{
-        bvhTriangles: number;
-        bvhNodes: number;
-        chunksProcessed: number;
-        pointsProcessed: number;
-        bounds: {
-            min: [number, number, number];
-            max: [number, number, number];
-        } | null;
-        suggestedHalfRange: number;
-    }>;
-    /**
-     * 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.
-     */
-    private collectAllSceneMeshes;
+     * Delegates to the `DeviationComputer` collaborator, which owns the
+     * compute pipeline and the BVH-reuse fingerprint; see
+     * `deviation/deviation-computer.ts` for the full contract.
+     */
+    computeDeviations(opts?: DeviationComputeOptions): Promise<DeviationComputeResult>;
     /**
      * Toggle Eye-Dome Lighting and tune its strength.
      *
@@ -866,6 +828,20 @@ export declare class Renderer {
         vertices: Float32Array;
         color: [number, number, number, number];
     } | null): void;
+    /**
+     * Draw the focused clash's TRUE INTERSECTION VOLUME — the actual overlap
+     * mesh from `clashIntersectionSolid` — as an opaque solid, so the clash
+     * reads as a shape rather than a wireframe box or contact line (the
+     * BIMcollab Zoom / Solibri presentation). Pass `null` to clear. Independent
+     * of `setClashOverlapBox` / `setClashContactLines`: the caller decides
+     * which one is current for a given clash (solid when the kernel resolved
+     * one, box/lines as the fallback when it didn't).
+     */
+    setClashIntersectionSolid(solid: {
+        positions: Float32Array | Float64Array;
+        indices: Uint32Array;
+        color: [number, number, number, number];
+    } | null): void;
     /**
      * Upload filled IfcAnnotation regions for the symbolic overlay
      * (issue #653). Pass an empty array to clear.