@ifc-lite/renderer 1.17.0 → 1.20.0

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

@@ -0,0 +1,48 @@
+import type { TriangleBVHResult } from './triangle-bvh.js';
+export interface DeviationDispatchInput {
+    /** Storage-usage GPU buffer holding interleaved point vertices.
+     *  Must be the same buffer used as the splat pipeline's vertex
+     *  buffer for this chunk; the compute shader reads positions
+     *  directly from it (no copy). */
+    positionsBuffer: GPUBuffer;
+    /** Output buffer — one f32 per point. Must allow STORAGE. */
+    deviationsBuffer: GPUBuffer;
+    /** Number of points to process. */
+    pointCount: number;
+    /** Optional clip range in metres. 0 / negative → no clip. */
+    maxRange: number;
+}
+export declare class DeviationPipeline {
+    private device;
+    private pipeline;
+    private bindGroupLayout;
+    private bvhNodesBuffer;
+    private trianglesBuffer;
+    private bvhTriangleCount;
+    private bvhNodeCount;
+    private bvhBounds;
+    constructor(device: GPUDevice);
+    /**
+     * Upload the per-triangle BVH to the GPU. Replaces any previous
+     * upload; safe to call repeatedly when the mesh set changes (load,
+     * federation update, isolation toggle).
+     */
+    uploadBvh(bvh: TriangleBVHResult): void;
+    hasBvh(): boolean;
+    getBvhStats(): {
+        nodeCount: number;
+        triangleCount: number;
+        bounds: TriangleBVHResult['bounds'] | null;
+    };
+    /**
+     * Run the compute pass for one point chunk. Encoder-based so the
+     * caller can dispatch many chunks back-to-back in one submit.
+     *
+     * Returns false when there's no BVH uploaded yet — caller should
+     * skip the chunk in that case.
+     */
+    dispatch(encoder: GPUCommandEncoder, input: DeviationDispatchInput): boolean;
+    private disposeBvh;
+    destroy(): void;
+}
+//# sourceMappingURL=deviation-pipeline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deviation-pipeline.d.ts","sourceRoot":"","sources":["../../src/deviation/deviation-pipeline.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAc3D,MAAM,WAAW,sBAAsB;IACrC;;;sCAGkC;IAClC,eAAe,EAAE,SAAS,CAAC;IAC3B,6DAA6D;IAC7D,gBAAgB,EAAE,SAAS,CAAC;IAC5B,mCAAmC;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,6DAA6D;IAC7D,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,QAAQ,CAAqB;IACrC,OAAO,CAAC,eAAe,CAAqB;IAC5C,OAAO,CAAC,cAAc,CAA0B;IAChD,OAAO,CAAC,eAAe,CAA0B;IACjD,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,SAAS,CAA4C;gBAEjD,MAAM,EAAE,SAAS;IAqB7B;;;;OAIG;IACH,SAAS,CAAC,GAAG,EAAE,iBAAiB,GAAG,IAAI;IAuCvC,MAAM,IAAI,OAAO;IAIjB,WAAW,IAAI;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,iBAAiB,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAA;KAAE;IAQvG;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,EAAE,iBAAiB,EAAE,KAAK,EAAE,sBAAsB,GAAG,OAAO;IA4C5E,OAAO,CAAC,UAAU;IAOlB,OAAO,IAAI,IAAI;CAGhB"}

package/dist/deviation/deviation-pipeline.js

@@ -0,0 +1,163 @@
+/* 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/. */
+/**
+ * Compute pipeline for BIM ↔ scan deviation. Owns the GPU-resident
+ * triangle BVH, builds bind groups per chunk on demand, and dispatches
+ * the closest-point-on-triangle compute shader.
+ *
+ * The BVH lives in two storage buffers (nodes + triangles); both are
+ * uploaded once per mesh-set change and reused across every chunk in
+ * every point cloud asset. Per-chunk bind groups are created lazily
+ * because a chunk's vertex buffer is the `positions` storage source
+ * for the compute pass.
+ */
+import { deviationShaderSource } from './deviation-shader.wgsl.js';
+import { POINT_VERTEX_BYTES } from '../pointcloud/point-pipeline.js';
+/** Bytes per BVH node — 8 floats / 8 u32s laid out per the shader. */
+const BVH_NODE_BYTES = 32;
+/** Bytes per triangle — 12 floats (3 verts + face normal). */
+const TRIANGLE_BYTES = 48;
+/**
+ * Uniform block size for `DeviationParams`. WGSL std140 packs the
+ * struct compactly; we add 4 padding u32s to round to 32 bytes which
+ * matches a single uniform alignment slot on every WebGPU impl.
+ */
+const PARAMS_UNIFORM_BYTES = 32;
+export class DeviationPipeline {
+    device;
+    pipeline;
+    bindGroupLayout;
+    bvhNodesBuffer = null;
+    trianglesBuffer = null;
+    bvhTriangleCount = 0;
+    bvhNodeCount = 0;
+    bvhBounds = null;
+    constructor(device) {
+        this.device = device;
+        this.bindGroupLayout = device.createBindGroupLayout({
+            entries: [
+                { binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'read-only-storage' } },
+                { binding: 1, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'read-only-storage' } },
+                { binding: 2, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'read-only-storage' } },
+                { binding: 3, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage' } },
+                { binding: 4, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'uniform' } },
+            ],
+        });
+        const layout = device.createPipelineLayout({ bindGroupLayouts: [this.bindGroupLayout] });
+        this.pipeline = device.createComputePipeline({
+            layout,
+            compute: {
+                module: device.createShaderModule({ code: deviationShaderSource }),
+                entryPoint: 'cs_main',
+            },
+        });
+    }
+    /**
+     * Upload the per-triangle BVH to the GPU. Replaces any previous
+     * upload; safe to call repeatedly when the mesh set changes (load,
+     * federation update, isolation toggle).
+     */
+    uploadBvh(bvh) {
+        this.disposeBvh();
+        if (bvh.triangleCount === 0) {
+            this.bvhNodeCount = 0;
+            this.bvhTriangleCount = 0;
+            this.bvhBounds = bvh.bounds;
+            return;
+        }
+        // Nodes: pack into a STORAGE buffer. The Float32Array view also
+        // contains u32 fields (childA, childB) but they were already
+        // written via Uint32Array aliasing during the build, so a single
+        // write of the underlying ArrayBuffer carries them too.
+        const nodeBuf = this.device.createBuffer({
+            size: bvh.nodeCount * BVH_NODE_BYTES,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+        });
+        this.device.queue.writeBuffer(nodeBuf, 0, 
+        // Pass the typed-array view directly — TS widens `.buffer` to
+        // ArrayBufferLike on a function-parameter Float32Array which
+        // doesn't satisfy writeBuffer's signature. The view form has
+        // size in elements (so we slice down to the populated head).
+        bvh.nodes.subarray(0, bvh.nodeCount * BVH_NODE_BYTES / 4));
+        const triBuf = this.device.createBuffer({
+            size: bvh.triangleCount * TRIANGLE_BYTES,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+        });
+        this.device.queue.writeBuffer(triBuf, 0, bvh.triangles.subarray(0, bvh.triangleCount * TRIANGLE_BYTES / 4));
+        this.bvhNodesBuffer = nodeBuf;
+        this.trianglesBuffer = triBuf;
+        this.bvhNodeCount = bvh.nodeCount;
+        this.bvhTriangleCount = bvh.triangleCount;
+        this.bvhBounds = bvh.bounds;
+    }
+    hasBvh() {
+        return this.bvhNodesBuffer !== null && this.trianglesBuffer !== null && this.bvhTriangleCount > 0;
+    }
+    getBvhStats() {
+        return {
+            nodeCount: this.bvhNodeCount,
+            triangleCount: this.bvhTriangleCount,
+            bounds: this.bvhBounds,
+        };
+    }
+    /**
+     * Run the compute pass for one point chunk. Encoder-based so the
+     * caller can dispatch many chunks back-to-back in one submit.
+     *
+     * Returns false when there's no BVH uploaded yet — caller should
+     * skip the chunk in that case.
+     */
+    dispatch(encoder, input) {
+        if (!this.bvhNodesBuffer || !this.trianglesBuffer)
+            return false;
+        if (input.pointCount === 0)
+            return true;
+        // Per-chunk uniform buffer with the dispatch params. Created
+        // fresh each call — 32 bytes is too small to bother caching.
+        const paramsBuffer = this.device.createBuffer({
+            size: PARAMS_UNIFORM_BYTES,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        });
+        const params = new Uint32Array(PARAMS_UNIFORM_BYTES / 4);
+        const paramsF = new Float32Array(params.buffer);
+        params[0] = input.pointCount;
+        // Each point in the splat vertex layout occupies POINT_VERTEX_BYTES
+        // (24 bytes). The shader walks `positions` as a flat f32 array; one
+        // point = 6 floats; the vec3 position is at offset 0.
+        params[1] = POINT_VERTEX_BYTES / 4; // pointStrideF32
+        params[2] = 0; // positionOffsetF32
+        paramsF[3] = Math.max(0, input.maxRange);
+        // params[4..7] reserved padding; left zero.
+        this.device.queue.writeBuffer(paramsBuffer, 0, params.buffer, 0, PARAMS_UNIFORM_BYTES);
+        const bindGroup = this.device.createBindGroup({
+            layout: this.bindGroupLayout,
+            entries: [
+                { binding: 0, resource: { buffer: this.bvhNodesBuffer } },
+                { binding: 1, resource: { buffer: this.trianglesBuffer } },
+                { binding: 2, resource: { buffer: input.positionsBuffer } },
+                { binding: 3, resource: { buffer: input.deviationsBuffer } },
+                { binding: 4, resource: { buffer: paramsBuffer } },
+            ],
+        });
+        const pass = encoder.beginComputePass();
+        pass.setPipeline(this.pipeline);
+        pass.setBindGroup(0, bindGroup);
+        // Workgroup size 64; ceil division. Most GPUs handle ~10⁵
+        // workgroups in one dispatch without trouble.
+        const groupCount = Math.ceil(input.pointCount / 64);
+        pass.dispatchWorkgroups(groupCount);
+        pass.end();
+        return true;
+    }
+    disposeBvh() {
+        this.bvhNodesBuffer?.destroy();
+        this.trianglesBuffer?.destroy();
+        this.bvhNodesBuffer = null;
+        this.trianglesBuffer = null;
+    }
+    destroy() {
+        this.disposeBvh();
+    }
+}
+//# sourceMappingURL=deviation-pipeline.js.map

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

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

package/dist/deviation/deviation-shader.wgsl.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Compute shader for BIM ↔ scan deviation.
+ *
+ * For each scan point, walk a per-triangle BVH and compute the signed
+ * distance to the nearest mesh surface. Sign is positive on the side
+ * the triangle's outward normal points to.
+ *
+ * Bind group layout:
+ *   @binding(0) bvhNodes: array<vec4<f32>, 2>   — 32-byte nodes (read)
+ *                                                 packed: [aabbMin, leafOrLeft]
+ *                                                         [aabbMax, leafOrRight]
+ *   @binding(1) triangles: array<f32>           — 12 floats per triangle
+ *   @binding(2) positions: array<f32>           — 6 floats per point
+ *                                                 (matches POINT_VERTEX_BYTES
+ *                                                  layout: vec3 + colorPacked)
+ *   @binding(3) deviations: array<f32>          — output, one float per point
+ *   @binding(4) params: DeviationParams
+ *
+ * Workgroup size 64 (one wavefront / warp on most desktop GPUs).
+ * Each invocation processes one point.
+ */
+export declare const deviationShaderSource = "\nstruct BvhNode {\n  aabbMinX: f32, aabbMinY: f32, aabbMinZ: f32,\n  // High bit: leaf flag. Low 31 bits: leaf=triStart, internal=leftChildIdx.\n  leafOrLeft: u32,\n  aabbMaxX: f32, aabbMaxY: f32, aabbMaxZ: f32,\n  // Leaf=triCount, internal=rightChildIdx.\n  countOrRight: u32,\n}\n\nstruct DeviationParams {\n  pointCount: u32,\n  pointStrideF32: u32,    // floats between successive points in positions buffer\n  positionOffsetF32: u32, // float offset of vec3 position within a point\n  // Optional clip range \u2014 when nonzero, signs above + below are kept\n  // but values past \u00B1maxRange are clamped (saves shader work for\n  // points far outside the model).\n  maxRange: f32,\n  // Reserved padding to keep the struct 16-byte aligned for std140.\n  _pad0: u32, _pad1: u32, _pad2: u32, _pad3: u32,\n}\n\n@group(0) @binding(0) var<storage, read> bvhNodes: array<BvhNode>;\n@group(0) @binding(1) var<storage, read> triangles: array<f32>;\n@group(0) @binding(2) var<storage, read> positions: array<f32>;\n@group(0) @binding(3) var<storage, read_write> deviations: array<f32>;\n@group(0) @binding(4) var<uniform> params: DeviationParams;\n\nconst LEAF_FLAG: u32 = 0x80000000u;\nconst STACK_SIZE: u32 = 64u;\n\n// Squared distance from point p to AABB [aabbMin, aabbMax].\n// Returns 0 if p is inside the box.\nfn distSqPointAabb(\n  px: f32, py: f32, pz: f32,\n  ax: f32, ay: f32, az: f32,\n  bx: f32, by: f32, bz: f32,\n) -> f32 {\n  let dx = max(max(ax - px, 0.0), px - bx);\n  let dy = max(max(ay - py, 0.0), py - by);\n  let dz = max(max(az - pz, 0.0), pz - bz);\n  return dx * dx + dy * dy + dz * dz;\n}\n\nstruct ClosestResult {\n  point: vec3<f32>,\n  distSq: f32,\n}\n\n// Ericson, Real-Time Collision Detection \u00A75.1.5: closest point on\n// a triangle to an arbitrary point in space. Branches over the\n// Voronoi regions of the triangle (3 verts, 3 edges, interior).\nfn closestPointOnTriangle(p: vec3<f32>, a: vec3<f32>, b: vec3<f32>, c: vec3<f32>) -> ClosestResult {\n  let ab = b - a;\n  let ac = c - a;\n  let ap = p - a;\n  let d1 = dot(ab, ap);\n  let d2 = dot(ac, ap);\n  if (d1 <= 0.0 && d2 <= 0.0) {\n    let diff = p - a;\n    return ClosestResult(a, dot(diff, diff));\n  }\n  let bp = p - b;\n  let d3 = dot(ab, bp);\n  let d4 = dot(ac, bp);\n  if (d3 >= 0.0 && d4 <= d3) {\n    let diff = p - b;\n    return ClosestResult(b, dot(diff, diff));\n  }\n  let vc = d1 * d4 - d3 * d2;\n  if (vc <= 0.0 && d1 >= 0.0 && d3 <= 0.0) {\n    let v = d1 / (d1 - d3);\n    let q = a + v * ab;\n    let diff = p - q;\n    return ClosestResult(q, dot(diff, diff));\n  }\n  let cp = p - c;\n  let d5 = dot(ab, cp);\n  let d6 = dot(ac, cp);\n  if (d6 >= 0.0 && d5 <= d6) {\n    let diff = p - c;\n    return ClosestResult(c, dot(diff, diff));\n  }\n  let vb = d5 * d2 - d1 * d6;\n  if (vb <= 0.0 && d2 >= 0.0 && d6 <= 0.0) {\n    let w = d2 / (d2 - d6);\n    let q = a + w * ac;\n    let diff = p - q;\n    return ClosestResult(q, dot(diff, diff));\n  }\n  let va = d3 * d6 - d5 * d4;\n  if (va <= 0.0 && (d4 - d3) >= 0.0 && (d5 - d6) >= 0.0) {\n    let w = (d4 - d3) / ((d4 - d3) + (d5 - d6));\n    let q = b + w * (c - b);\n    let diff = p - q;\n    return ClosestResult(q, dot(diff, diff));\n  }\n  // Inside the face: barycentric (v, w).\n  let denom = 1.0 / (va + vb + vc);\n  let v = vb * denom;\n  let w = vc * denom;\n  let q = a + ab * v + ac * w;\n  let diff = p - q;\n  return ClosestResult(q, dot(diff, diff));\n}\n\n@compute @workgroup_size(64)\nfn cs_main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let pi = gid.x;\n  if (pi >= params.pointCount) {\n    return;\n  }\n  let posOff = pi * params.pointStrideF32 + params.positionOffsetF32;\n  let p = vec3<f32>(positions[posOff], positions[posOff + 1u], positions[posOff + 2u]);\n\n  // Best squared distance across all triangles. Stored squared so\n  // we can prune AABBs without taking sqrt every step.\n  var bestDistSq: f32 = 1.0e30;\n  var bestPoint: vec3<f32> = vec3<f32>(0.0);\n  var bestNormal: vec3<f32> = vec3<f32>(0.0, 1.0, 0.0);\n\n  // Stack-based BVH descent. Workgroup-uniform stack would let\n  // siblings cooperate; for v1 a per-thread stack in private memory\n  // is simpler and fast enough.\n  var stack: array<u32, STACK_SIZE>;\n  var sp: u32 = 0u;\n  stack[sp] = 0u;\n  sp = sp + 1u;\n\n  loop {\n    if (sp == 0u) { break; }\n    sp = sp - 1u;\n    let nodeIdx = stack[sp];\n    let node = bvhNodes[nodeIdx];\n\n    let aabbDistSq = distSqPointAabb(\n      p.x, p.y, p.z,\n      node.aabbMinX, node.aabbMinY, node.aabbMinZ,\n      node.aabbMaxX, node.aabbMaxY, node.aabbMaxZ,\n    );\n    if (aabbDistSq >= bestDistSq) {\n      continue;\n    }\n\n    let leafFlag = node.leafOrLeft & LEAF_FLAG;\n    if (leafFlag != 0u) {\n      let triStart = node.leafOrLeft & (~LEAF_FLAG);\n      let triCount = node.countOrRight;\n      var i: u32 = 0u;\n      loop {\n        if (i >= triCount) { break; }\n        let triOff = (triStart + i) * 12u;\n        let v0 = vec3<f32>(triangles[triOff],      triangles[triOff + 1u],  triangles[triOff + 2u]);\n        let v1 = vec3<f32>(triangles[triOff + 3u], triangles[triOff + 4u],  triangles[triOff + 5u]);\n        let v2 = vec3<f32>(triangles[triOff + 6u], triangles[triOff + 7u],  triangles[triOff + 8u]);\n        let n  = vec3<f32>(triangles[triOff + 9u], triangles[triOff + 10u], triangles[triOff + 11u]);\n        let res = closestPointOnTriangle(p, v0, v1, v2);\n        if (res.distSq < bestDistSq) {\n          bestDistSq = res.distSq;\n          bestPoint = res.point;\n          bestNormal = n;\n        }\n        i = i + 1u;\n      }\n    } else {\n      // Internal node: push both children. Sibling that's closer to\n      // p first (top of stack) so we hit the tighter bound earlier.\n      let leftIdx = node.leafOrLeft;\n      let rightIdx = node.countOrRight;\n      let lNode = bvhNodes[leftIdx];\n      let rNode = bvhNodes[rightIdx];\n      let lDist = distSqPointAabb(\n        p.x, p.y, p.z,\n        lNode.aabbMinX, lNode.aabbMinY, lNode.aabbMinZ,\n        lNode.aabbMaxX, lNode.aabbMaxY, lNode.aabbMaxZ,\n      );\n      let rDist = distSqPointAabb(\n        p.x, p.y, p.z,\n        rNode.aabbMinX, rNode.aabbMinY, rNode.aabbMinZ,\n        rNode.aabbMaxX, rNode.aabbMaxY, rNode.aabbMaxZ,\n      );\n      // Push the farther child first \u2192 closer popped first.\n      if (sp + 2u <= STACK_SIZE) {\n        if (lDist < rDist) {\n          stack[sp] = rightIdx; sp = sp + 1u;\n          stack[sp] = leftIdx;  sp = sp + 1u;\n        } else {\n          stack[sp] = leftIdx;  sp = sp + 1u;\n          stack[sp] = rightIdx; sp = sp + 1u;\n        }\n      }\n    }\n  }\n\n  // Signed distance: project (p - closestPoint) onto the closest\n  // triangle's normal. Positive \u21D2 p is on the outward side.\n  let toPoint = p - bestPoint;\n  let dist = sqrt(bestDistSq);\n  let s = sign(dot(toPoint, bestNormal));\n  var signed: f32 = s * dist;\n\n  // Optional clip: keeps the histogram + ramp focused on near-surface\n  // points. Past \u00B1maxRange the value pegs at the edge.\n  if (params.maxRange > 0.0) {\n    let mr = params.maxRange;\n    if (signed > mr) { signed = mr; }\n    if (signed < -mr) { signed = -mr; }\n  }\n\n  deviations[pi] = signed;\n}\n";
+//# sourceMappingURL=deviation-shader.wgsl.d.ts.map

package/dist/deviation/deviation-shader.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deviation-shader.wgsl.d.ts","sourceRoot":"","sources":["../../src/deviation/deviation-shader.wgsl.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,eAAO,MAAM,qBAAqB,8kOAmNjC,CAAC"}

package/dist/deviation/deviation-shader.wgsl.js

@@ -0,0 +1,237 @@
+/* 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/. */
+/**
+ * Compute shader for BIM ↔ scan deviation.
+ *
+ * For each scan point, walk a per-triangle BVH and compute the signed
+ * distance to the nearest mesh surface. Sign is positive on the side
+ * the triangle's outward normal points to.
+ *
+ * Bind group layout:
+ *   @binding(0) bvhNodes: array<vec4<f32>, 2>   — 32-byte nodes (read)
+ *                                                 packed: [aabbMin, leafOrLeft]
+ *                                                         [aabbMax, leafOrRight]
+ *   @binding(1) triangles: array<f32>           — 12 floats per triangle
+ *   @binding(2) positions: array<f32>           — 6 floats per point
+ *                                                 (matches POINT_VERTEX_BYTES
+ *                                                  layout: vec3 + colorPacked)
+ *   @binding(3) deviations: array<f32>          — output, one float per point
+ *   @binding(4) params: DeviationParams
+ *
+ * Workgroup size 64 (one wavefront / warp on most desktop GPUs).
+ * Each invocation processes one point.
+ */
+export const deviationShaderSource = /* wgsl */ `
+struct BvhNode {
+  aabbMinX: f32, aabbMinY: f32, aabbMinZ: f32,
+  // High bit: leaf flag. Low 31 bits: leaf=triStart, internal=leftChildIdx.
+  leafOrLeft: u32,
+  aabbMaxX: f32, aabbMaxY: f32, aabbMaxZ: f32,
+  // Leaf=triCount, internal=rightChildIdx.
+  countOrRight: u32,
+}
+
+struct DeviationParams {
+  pointCount: u32,
+  pointStrideF32: u32,    // floats between successive points in positions buffer
+  positionOffsetF32: u32, // float offset of vec3 position within a point
+  // Optional clip range — when nonzero, signs above + below are kept
+  // but values past ±maxRange are clamped (saves shader work for
+  // points far outside the model).
+  maxRange: f32,
+  // Reserved padding to keep the struct 16-byte aligned for std140.
+  _pad0: u32, _pad1: u32, _pad2: u32, _pad3: u32,
+}
+
+@group(0) @binding(0) var<storage, read> bvhNodes: array<BvhNode>;
+@group(0) @binding(1) var<storage, read> triangles: array<f32>;
+@group(0) @binding(2) var<storage, read> positions: array<f32>;
+@group(0) @binding(3) var<storage, read_write> deviations: array<f32>;
+@group(0) @binding(4) var<uniform> params: DeviationParams;
+
+const LEAF_FLAG: u32 = 0x80000000u;
+const STACK_SIZE: u32 = 64u;
+
+// Squared distance from point p to AABB [aabbMin, aabbMax].
+// Returns 0 if p is inside the box.
+fn distSqPointAabb(
+  px: f32, py: f32, pz: f32,
+  ax: f32, ay: f32, az: f32,
+  bx: f32, by: f32, bz: f32,
+) -> f32 {
+  let dx = max(max(ax - px, 0.0), px - bx);
+  let dy = max(max(ay - py, 0.0), py - by);
+  let dz = max(max(az - pz, 0.0), pz - bz);
+  return dx * dx + dy * dy + dz * dz;
+}
+
+struct ClosestResult {
+  point: vec3<f32>,
+  distSq: f32,
+}
+
+// Ericson, Real-Time Collision Detection §5.1.5: closest point on
+// a triangle to an arbitrary point in space. Branches over the
+// Voronoi regions of the triangle (3 verts, 3 edges, interior).
+fn closestPointOnTriangle(p: vec3<f32>, a: vec3<f32>, b: vec3<f32>, c: vec3<f32>) -> ClosestResult {
+  let ab = b - a;
+  let ac = c - a;
+  let ap = p - a;
+  let d1 = dot(ab, ap);
+  let d2 = dot(ac, ap);
+  if (d1 <= 0.0 && d2 <= 0.0) {
+    let diff = p - a;
+    return ClosestResult(a, dot(diff, diff));
+  }
+  let bp = p - b;
+  let d3 = dot(ab, bp);
+  let d4 = dot(ac, bp);
+  if (d3 >= 0.0 && d4 <= d3) {
+    let diff = p - b;
+    return ClosestResult(b, dot(diff, diff));
+  }
+  let vc = d1 * d4 - d3 * d2;
+  if (vc <= 0.0 && d1 >= 0.0 && d3 <= 0.0) {
+    let v = d1 / (d1 - d3);
+    let q = a + v * ab;
+    let diff = p - q;
+    return ClosestResult(q, dot(diff, diff));
+  }
+  let cp = p - c;
+  let d5 = dot(ab, cp);
+  let d6 = dot(ac, cp);
+  if (d6 >= 0.0 && d5 <= d6) {
+    let diff = p - c;
+    return ClosestResult(c, dot(diff, diff));
+  }
+  let vb = d5 * d2 - d1 * d6;
+  if (vb <= 0.0 && d2 >= 0.0 && d6 <= 0.0) {
+    let w = d2 / (d2 - d6);
+    let q = a + w * ac;
+    let diff = p - q;
+    return ClosestResult(q, dot(diff, diff));
+  }
+  let va = d3 * d6 - d5 * d4;
+  if (va <= 0.0 && (d4 - d3) >= 0.0 && (d5 - d6) >= 0.0) {
+    let w = (d4 - d3) / ((d4 - d3) + (d5 - d6));
+    let q = b + w * (c - b);
+    let diff = p - q;
+    return ClosestResult(q, dot(diff, diff));
+  }
+  // Inside the face: barycentric (v, w).
+  let denom = 1.0 / (va + vb + vc);
+  let v = vb * denom;
+  let w = vc * denom;
+  let q = a + ab * v + ac * w;
+  let diff = p - q;
+  return ClosestResult(q, dot(diff, diff));
+}
+
+@compute @workgroup_size(64)
+fn cs_main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let pi = gid.x;
+  if (pi >= params.pointCount) {
+    return;
+  }
+  let posOff = pi * params.pointStrideF32 + params.positionOffsetF32;
+  let p = vec3<f32>(positions[posOff], positions[posOff + 1u], positions[posOff + 2u]);
+
+  // Best squared distance across all triangles. Stored squared so
+  // we can prune AABBs without taking sqrt every step.
+  var bestDistSq: f32 = 1.0e30;
+  var bestPoint: vec3<f32> = vec3<f32>(0.0);
+  var bestNormal: vec3<f32> = vec3<f32>(0.0, 1.0, 0.0);
+
+  // Stack-based BVH descent. Workgroup-uniform stack would let
+  // siblings cooperate; for v1 a per-thread stack in private memory
+  // is simpler and fast enough.
+  var stack: array<u32, STACK_SIZE>;
+  var sp: u32 = 0u;
+  stack[sp] = 0u;
+  sp = sp + 1u;
+
+  loop {
+    if (sp == 0u) { break; }
+    sp = sp - 1u;
+    let nodeIdx = stack[sp];
+    let node = bvhNodes[nodeIdx];
+
+    let aabbDistSq = distSqPointAabb(
+      p.x, p.y, p.z,
+      node.aabbMinX, node.aabbMinY, node.aabbMinZ,
+      node.aabbMaxX, node.aabbMaxY, node.aabbMaxZ,
+    );
+    if (aabbDistSq >= bestDistSq) {
+      continue;
+    }
+
+    let leafFlag = node.leafOrLeft & LEAF_FLAG;
+    if (leafFlag != 0u) {
+      let triStart = node.leafOrLeft & (~LEAF_FLAG);
+      let triCount = node.countOrRight;
+      var i: u32 = 0u;
+      loop {
+        if (i >= triCount) { break; }
+        let triOff = (triStart + i) * 12u;
+        let v0 = vec3<f32>(triangles[triOff],      triangles[triOff + 1u],  triangles[triOff + 2u]);
+        let v1 = vec3<f32>(triangles[triOff + 3u], triangles[triOff + 4u],  triangles[triOff + 5u]);
+        let v2 = vec3<f32>(triangles[triOff + 6u], triangles[triOff + 7u],  triangles[triOff + 8u]);
+        let n  = vec3<f32>(triangles[triOff + 9u], triangles[triOff + 10u], triangles[triOff + 11u]);
+        let res = closestPointOnTriangle(p, v0, v1, v2);
+        if (res.distSq < bestDistSq) {
+          bestDistSq = res.distSq;
+          bestPoint = res.point;
+          bestNormal = n;
+        }
+        i = i + 1u;
+      }
+    } else {
+      // Internal node: push both children. Sibling that's closer to
+      // p first (top of stack) so we hit the tighter bound earlier.
+      let leftIdx = node.leafOrLeft;
+      let rightIdx = node.countOrRight;
+      let lNode = bvhNodes[leftIdx];
+      let rNode = bvhNodes[rightIdx];
+      let lDist = distSqPointAabb(
+        p.x, p.y, p.z,
+        lNode.aabbMinX, lNode.aabbMinY, lNode.aabbMinZ,
+        lNode.aabbMaxX, lNode.aabbMaxY, lNode.aabbMaxZ,
+      );
+      let rDist = distSqPointAabb(
+        p.x, p.y, p.z,
+        rNode.aabbMinX, rNode.aabbMinY, rNode.aabbMinZ,
+        rNode.aabbMaxX, rNode.aabbMaxY, rNode.aabbMaxZ,
+      );
+      // Push the farther child first → closer popped first.
+      if (sp + 2u <= STACK_SIZE) {
+        if (lDist < rDist) {
+          stack[sp] = rightIdx; sp = sp + 1u;
+          stack[sp] = leftIdx;  sp = sp + 1u;
+        } else {
+          stack[sp] = leftIdx;  sp = sp + 1u;
+          stack[sp] = rightIdx; sp = sp + 1u;
+        }
+      }
+    }
+  }
+
+  // Signed distance: project (p - closestPoint) onto the closest
+  // triangle's normal. Positive ⇒ p is on the outward side.
+  let toPoint = p - bestPoint;
+  let dist = sqrt(bestDistSq);
+  let s = sign(dot(toPoint, bestNormal));
+  var signed: f32 = s * dist;
+
+  // Optional clip: keeps the histogram + ramp focused on near-surface
+  // points. Past ±maxRange the value pegs at the edge.
+  if (params.maxRange > 0.0) {
+    let mr = params.maxRange;
+    if (signed > mr) { signed = mr; }
+    if (signed < -mr) { signed = -mr; }
+  }
+
+  deviations[pi] = signed;
+}
+`;
+//# sourceMappingURL=deviation-shader.wgsl.js.map

package/dist/deviation/deviation-shader.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deviation-shader.wgsl.js","sourceRoot":"","sources":["../../src/deviation/deviation-shader.wgsl.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,CAAC,MAAM,qBAAqB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmN/C,CAAC"}

package/dist/deviation/triangle-bvh.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Per-triangle BVH for closest-point queries (BIM ↔ scan deviation).
+ *
+ * Distinct from `bvh.ts` which is a per-mesh BVH used for raycasting:
+ * for closest-point we want fine-grained pruning, so each leaf holds
+ * a contiguous range of triangles. The build also flattens the tree
+ * to a `Float32Array` ready for direct GPU upload — no second pass.
+ *
+ * Node layout (32 bytes = 8 floats per node, packed Float32 + bitcast u32):
+ *   [0..2] aabbMin       (vec3<f32>)
+ *   [3]    childA / triStart      (u32 bitcast: leaf flag = high bit)
+ *   [4..6] aabbMax       (vec3<f32>)
+ *   [7]    childB / triCount      (u32 bitcast)
+ *
+ * Triangle layout (48 bytes = 12 floats per triangle):
+ *   [0..2]   v0 (vec3)
+ *   [3..5]   v1 (vec3)
+ *   [6..8]   v2 (vec3)
+ *   [9..11]  normalised face normal (vec3) — sign convention: outward
+ *            from mesh interior assuming CCW winding (right-hand rule)
+ *
+ * Maximum supported triangles: ~2³¹ (one bit reserved for the leaf
+ * flag). Real BIMs top out around 10⁷ triangles before other bottle-
+ * necks kick in.
+ */
+import type { MeshData } from '@ifc-lite/geometry';
+export interface TriangleBVHResult {
+    /** Flat node buffer (Float32Array). Each node is 8 floats. */
+    nodes: Float32Array;
+    /** Flat triangle buffer (Float32Array). Each triangle is 12 floats. */
+    triangles: Float32Array;
+    /** Total number of triangles. */
+    triangleCount: number;
+    /** Total number of nodes (root at index 0). */
+    nodeCount: number;
+    /** Number of source meshes folded into this BVH. */
+    meshCount: number;
+    /** Aggregate bounds of all triangles. */
+    bounds: {
+        min: [number, number, number];
+        max: [number, number, number];
+    };
+}
+/**
+ * Build the per-triangle BVH.
+ *
+ * Splits leaves until each holds at most `maxTrisPerLeaf` triangles
+ * (default 16, balancing tree depth vs. per-leaf work). Median split
+ * along the longest AABB axis — fast O(n log n) build, no SAH for v1.
+ *
+ * For typical BIMs (1M triangles) the build runs in ~1–3 seconds on
+ * the main thread. Acceptable since it only re-runs when the mesh
+ * set changes (load / federation update).
+ */
+export declare function buildTriangleBVH(meshes: ReadonlyArray<MeshData>, options?: {
+    maxTrisPerLeaf?: number;
+}): TriangleBVHResult;
+//# sourceMappingURL=triangle-bvh.d.ts.map

package/dist/deviation/triangle-bvh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triangle-bvh.d.ts","sourceRoot":"","sources":["../../src/deviation/triangle-bvh.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD,MAAM,WAAW,iBAAiB;IAChC,8DAA8D;IAC9D,KAAK,EAAE,YAAY,CAAC;IACpB,uEAAuE;IACvE,SAAS,EAAE,YAAY,CAAC;IACxB,iCAAiC;IACjC,aAAa,EAAE,MAAM,CAAC;IACtB,+CAA+C;IAC/C,SAAS,EAAE,MAAM,CAAC;IAClB,oDAAoD;IACpD,SAAS,EAAE,MAAM,CAAC;IAClB,yCAAyC;IACzC,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,CAAC;CAC1E;AAKD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,aAAa,CAAC,QAAQ,CAAC,EAC/B,OAAO,GAAE;IAAE,cAAc,CAAC,EAAE,MAAM,CAAA;CAAO,GACxC,iBAAiB,CA+MnB"}