@ifc-lite/renderer 3.2.0 → 5.0.0

package/dist/pick-world-position.js

@@ -0,0 +1,21 @@
+/* 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/. */
+import { MathUtils } from './math.js';
+/** Reproject a pick pixel/depth pair through a reverse-Z view projection. */
+export function unprojectPickSample(viewProj, pickX, pickY, width, height, depth) {
+    if (!Number.isFinite(depth) || depth <= 0)
+        return null;
+    const ndcX = ((pickX + 0.5) / width) * 2 - 1;
+    const ndcY = 1 - ((pickY + 0.5) / height) * 2;
+    const inverse = MathUtils.invert({ m: viewProj });
+    return inverse ? MathUtils.transformPoint(inverse, { x: ndcX, y: ndcY, z: depth }) : null;
+}
+/** Restore the f64 camera translation after an RTE depth unprojection. */
+export function restoreRtePickWorld(relative, snapshot) {
+    if (!relative)
+        return null;
+    const camera = snapshot.getCameraWorld();
+    return { x: relative.x + camera[0], y: relative.y + camera[1], z: relative.z + camera[2] };
+}
+//# sourceMappingURL=pick-world-position.js.map

package/dist/pick-world-position.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pick-world-position.js","sourceRoot":"","sources":["../src/pick-world-position.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAGtC,6EAA6E;AAC7E,MAAM,UAAU,mBAAmB,CACjC,QAAsB,EACtB,KAAa,EACb,KAAa,EACb,KAAa,EACb,MAAc,EACd,KAAa;IAEb,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IACvD,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,GAAG,GAAG,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC7C,MAAM,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,KAAK,GAAG,GAAG,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IAC9C,MAAM,OAAO,GAAG,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC;IAClD,OAAO,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,cAAc,CAAC,OAAO,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AAC5F,CAAC;AAED,0EAA0E;AAC1E,MAAM,UAAU,mBAAmB,CACjC,QAAoD,EACpD,QAA+B;IAE/B,IAAI,CAAC,QAAQ;QAAE,OAAO,IAAI,CAAC;IAC3B,MAAM,MAAM,GAAG,QAAQ,CAAC,cAAc,EAAE,CAAC;IACzC,OAAO,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;AAC7F,CAAC"}

package/dist/picker-readbacks.d.ts

@@ -0,0 +1,6 @@
+/** Lifecycle handling for asynchronous GPU picker readbacks. */
+/** Only device teardown is an expected `AbortError`; real map faults propagate. */
+export declare function isReadbackAbort(err: unknown): boolean;
+/** Free aborted readbacks while preserving a visible diagnostic on a live device. */
+export declare function releaseReadbacks(...buffers: GPUBuffer[]): void;
+//# sourceMappingURL=picker-readbacks.d.ts.map

package/dist/picker-readbacks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"picker-readbacks.d.ts","sourceRoot":"","sources":["../src/picker-readbacks.ts"],"names":[],"mappings":"AAIA,gEAAgE;AAEhE,mFAAmF;AACnF,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAErD;AAED,qFAAqF;AACrF,wBAAgB,gBAAgB,CAAC,GAAG,OAAO,EAAE,SAAS,EAAE,GAAG,IAAI,CAQ9D"}

package/dist/picker-readbacks.js

@@ -0,0 +1,20 @@
+/* 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/. */
+/** Lifecycle handling for asynchronous GPU picker readbacks. */
+/** Only device teardown is an expected `AbortError`; real map faults propagate. */
+export function isReadbackAbort(err) {
+    return typeof err === 'object' && err !== null && err.name === 'AbortError';
+}
+/** Free aborted readbacks while preserving a visible diagnostic on a live device. */
+export function releaseReadbacks(...buffers) {
+    for (const buffer of buffers) {
+        try {
+            buffer.destroy();
+        }
+        catch (err) {
+            console.warn('[Picker] failed to release a readback buffer during teardown', err);
+        }
+    }
+}
+//# sourceMappingURL=picker-readbacks.js.map

package/dist/picker-readbacks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"picker-readbacks.js","sourceRoot":"","sources":["../src/picker-readbacks.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D,gEAAgE;AAEhE,mFAAmF;AACnF,MAAM,UAAU,eAAe,CAAC,GAAY;IAC1C,OAAO,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,IAAI,IAAK,GAA0B,CAAC,IAAI,KAAK,YAAY,CAAC;AACtG,CAAC;AAED,qFAAqF;AACrF,MAAM,UAAU,gBAAgB,CAAC,GAAG,OAAoB;IACtD,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,IAAI,CAAC;YACH,MAAM,CAAC,OAAO,EAAE,CAAC;QACnB,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,OAAO,CAAC,IAAI,CAAC,8DAA8D,EAAE,GAAG,CAAC,CAAC;QACpF,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/picker-rte-uniforms.d.ts

@@ -0,0 +1,6 @@
+import { type RelativeToEyeSnapshot } from './relative-to-eye.js';
+import type { Mesh, PickClipState } from './types.js';
+export declare function writePickUniforms(device: GPUDevice, buffer: GPUBuffer, scratch: Float32Array, clipFlags: Uint32Array, viewProj: Float32Array, clip?: PickClipState | null): void;
+export declare function writeFlatPickUniform(device: GPUDevice, buffer: GPUBuffer, scratch: Float32Array, clipFlags: Uint32Array, mesh: Mesh, snapshot: RelativeToEyeSnapshot, clip: PickClipState | null | undefined, slot: number): void;
+export declare function writeInstancedPickUniforms(device: GPUDevice, buffer: GPUBuffer, scratch: Float32Array, clipFlags: Uint32Array, snapshot: RelativeToEyeSnapshot, clip?: PickClipState | null): void;
+//# sourceMappingURL=picker-rte-uniforms.d.ts.map

package/dist/picker-rte-uniforms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"picker-rte-uniforms.d.ts","sourceRoot":"","sources":["../src/picker-rte-uniforms.ts"],"names":[],"mappings":"AAOA,OAAO,EAAiB,KAAK,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAEjF,OAAO,KAAK,EAAE,IAAI,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEtD,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,YAAY,EACrB,SAAS,EAAE,WAAW,EACtB,QAAQ,EAAE,YAAY,EACtB,IAAI,CAAC,EAAE,aAAa,GAAG,IAAI,GAC1B,IAAI,CAMN;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,YAAY,EACrB,SAAS,EAAE,WAAW,EACtB,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,qBAAqB,EAC/B,IAAI,EAAE,aAAa,GAAG,IAAI,GAAG,SAAS,EACtC,IAAI,EAAE,MAAM,GACX,IAAI,CAUN;AAED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,YAAY,EACrB,SAAS,EAAE,WAAW,EACtB,QAAQ,EAAE,qBAAqB,EAC/B,IAAI,CAAC,EAAE,aAAa,GAAG,IAAI,GAC1B,IAAI,CAQN"}

package/dist/picker-rte-uniforms.js

@@ -0,0 +1,41 @@
+/* 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/. */
+/** Dynamic uniform writers for production RTE object picking. */
+import { packPickClip, packPickUniforms } from './pick-uniforms.js';
+import { packRteOrigin } from './relative-to-eye.js';
+import { packRteClipBox, rtePlaneDistance } from './rte-clip-space.js';
+export function writePickUniforms(device, buffer, scratch, clipFlags, viewProj, clip) {
+    scratch.fill(0);
+    scratch.set(viewProj, 0);
+    scratch[16] = 1;
+    scratch[21] = 1;
+    scratch[26] = 1;
+    scratch[31] = 1;
+    packPickClip(clip, scratch, clipFlags, 32);
+    device.queue.writeBuffer(buffer, 0, scratch);
+}
+export function writeFlatPickUniform(device, buffer, scratch, clipFlags, mesh, snapshot, clip, slot) {
+    scratch.fill(0);
+    scratch.set(snapshot.getViewProjection().m, 0);
+    scratch.set(mesh.transform.m, 16);
+    packPickClip(clip, scratch, clipFlags, 32);
+    const camera = snapshot.getCameraWorld();
+    packRteClipBox(clip?.clipBox, camera, scratch, 32);
+    if (clip?.sectionPlane)
+        scratch[43] = rtePlaneDistance(clip.sectionPlane.distance, clip.sectionPlane.normal, camera);
+    snapshot.packDrawableOrigin(mesh.rteOrigin ?? [mesh.transform.m[12], mesh.transform.m[13], mesh.transform.m[14]], scratch, 48);
+    device.queue.writeBuffer(buffer, slot * 256, scratch);
+}
+export function writeInstancedPickUniforms(device, buffer, scratch, clipFlags, snapshot, clip) {
+    packPickUniforms(snapshot.getViewProjection().m, clip, scratch, clipFlags);
+    const camera = snapshot.getCameraWorld();
+    packRteClipBox(clip?.clipBox, camera, scratch, 16);
+    if (clip?.sectionPlane)
+        scratch[27] = rtePlaneDistance(clip.sectionPlane.distance, clip.sectionPlane.normal, camera);
+    packRteOrigin(camera, scratch, 32);
+    scratch[35] = 0;
+    scratch[39] = 0;
+    device.queue.writeBuffer(buffer, 0, scratch);
+}
+//# sourceMappingURL=picker-rte-uniforms.js.map

package/dist/picker-rte-uniforms.js.map

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

package/dist/picker.d.ts

@@ -5,6 +5,7 @@ import { WebGPUDevice } from './device.js';
 import type { Mesh, PickResult, PickClipState } from './types.js';
 import type { InstancedTemplateGPU } from './scene.js';
 import { type PointPickNode } from './point-picker.js';
+import type { RelativeToEyeSnapshot } from './relative-to-eye.js';
 /** Point-pick sizing parameters forwarded to the GPU pipeline. */
 export interface PointPickSizing {
     sizeMode: 0 | 1 | 2;
@@ -19,6 +20,7 @@ export declare class Picker {
     private pipeline;
     private instancedPickPipeline;
     private instancedPickBindGroup;
+    private instancedUniformBuffer;
     private depthTexture;
     private colorTexture;
     private uniformBuffer;
@@ -30,6 +32,8 @@ export declare class Picker {
     private pointPicker;
     private readonly uniformScratch;
     private readonly clipFlags;
+    private readonly instancedUniformScratch;
+    private readonly instancedClipFlags;
     constructor(device: WebGPUDevice, width?: number, height?: number);
     /**
      * Pick object at screen coordinates.
@@ -48,13 +52,8 @@ export declare class Picker {
      * null if the device dies *during* the readback, which no entry guard can
      * pre-empt (see {@link isReadbackAbort}).
      */
-    pick(x: number, y: number, width: number, height: number, meshes: Mesh[], viewProj: Float32Array, pointNodes?: ReadonlyArray<PointPickNode>, pointSizing?: PointPickSizing, instancedTemplates?: readonly InstancedTemplateGPU[], clip?: PickClipState | null): Promise<PickResult | null>;
+    pick(x: number, y: number, width: number, height: number, meshes: Mesh[], viewProj: Float32Array, pointNodes?: ReadonlyArray<PointPickNode>, pointSizing?: PointPickSizing, instancedTemplates?: readonly InstancedTemplateGPU[], clip?: PickClipState | null, pointRteSnapshot?: RelativeToEyeSnapshot): Promise<PickResult | null>;
     updateUniforms(viewProj: Float32Array, clip?: PickClipState | null): void;
-    /**
-     * Pack viewProj + the last render's section plane / crop box into the shared
-     * pick uniform and upload it. Layout + flag bits live in {@link packPickUniforms}.
-     */
-    private writePickUniforms;
     /**
      * Rectangle pick: render the pick pass once, then read back every
      * texel inside `[x0, y0]..[x1, y1]` and dedupe the hit set. Returns
@@ -68,7 +67,7 @@ export declare class Picker {
      * Returns an empty set once `destroy()` has run — or if the device dies
      * mid-readback — for the same reasons {@link Picker.pick} returns null.
      */
-    pickRect(x0: number, y0: number, x1: number, y1: number, width: number, height: number, meshes: Mesh[], viewProj: Float32Array, pointNodes?: ReadonlyArray<PointPickNode>, pointSizing?: PointPickSizing, instancedTemplates?: readonly InstancedTemplateGPU[], clip?: PickClipState | null): Promise<Set<number>>;
+    pickRect(x0: number, y0: number, x1: number, y1: number, width: number, height: number, meshes: Mesh[], viewProj: Float32Array, pointNodes?: ReadonlyArray<PointPickNode>, pointSizing?: PointPickSizing, instancedTemplates?: readonly InstancedTemplateGPU[], clip?: PickClipState | null, pointRteSnapshot?: RelativeToEyeSnapshot): Promise<Set<number>>;
     /**
      * Render the picker pass into `colorTexture` + `depthTexture` and
      * return the still-open command encoder so the caller can append a

package/dist/picker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"picker.d.ts","sourceRoot":"","sources":["../src/picker.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAElE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACvD,OAAO,EAAiC,KAAK,aAAa,EAAE,MAAM,mBAAmB,CAAC;AA8EtF,kEAAkE;AAClE,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,6EAA6E;IAC7E,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,qBAAa,MAAM;IACjB,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,QAAQ,CAAoB;IACpC,OAAO,CAAC,qBAAqB,CAAkC;IAC/D,OAAO,CAAC,sBAAsB,CAA6B;IAC3D,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,aAAa,CAAY;IACjC,OAAO,CAAC,eAAe,CAAY;IACnC,OAAO,CAAC,SAAS,CAAe;IAChC,OAAO,CAAC,SAAS,CAAkB;IACnC,uFAAuF;IACvF,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,WAAW,CAA4B;IAI/C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAwB;IACvD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAuD;gBAErE,MAAM,EAAE,YAAY,EAAE,KAAK,GAAE,MAAU,EAAE,MAAM,GAAE,MAAU;IAiQvE;;;;;;;;;;;;;;;;OAgBG;IACG,IAAI,CACR,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,IAAI,EAAE,EACd,QAAQ,EAAE,YAAY,EACtB,UAAU,CAAC,EAAE,aAAa,CAAC,aAAa,CAAC,EACzC,WAAW,CAAC,EAAE,eAAe,EAC7B,kBAAkB,CAAC,EAAE,SAAS,oBAAoB,EAAE,EACpD,IAAI,CAAC,EAAE,aAAa,GAAG,IAAI,GAC1B,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IAyF7B,cAAc,CAAC,QAAQ,EAAE,YAAY,EAAE,IAAI,CAAC,EAAE,aAAa,GAAG,IAAI,GAAG,IAAI;IAIzE;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAKzB;;;;;;;;;;;;OAYG;IACG,QAAQ,CACZ,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,IAAI,EAAE,EACd,QAAQ,EAAE,YAAY,EACtB,UAAU,CAAC,EAAE,aAAa,CAAC,aAAa,CAAC,EACzC,WAAW,CAAC,EAAE,eAAe,EAC7B,kBAAkB,CAAC,EAAE,SAAS,oBAAoB,EAAE,EACpD,IAAI,CAAC,EAAE,aAAa,GAAG,IAAI,GAC1B,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAsEvB;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAmGtB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IA6B7B;;;;OAIG;IACH,OAAO,IAAI,IAAI;CAUhB"}
+{"version":3,"file":"picker.d.ts","sourceRoot":"","sources":["../src/picker.ts"],"names":[],"mappings":"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"}

package/dist/picker.js

@@ -3,81 +3,18 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 import { resolvePickSample, resolvePickedExpressId } from './pick-resolve.js';
 import { PointPicker, decodePickSample } from './point-picker.js';
-import { packPickUniforms } from './pick-uniforms.js';
-import { MathUtils } from './math.js';
-/**
- * Reproject a pick coordinate (px, depth in [0, 1]) into world space
- * using the inverse view-projection matrix.
- *
- * Reverse-Z: depth=1 is the near plane, depth=0 is far. A depth of
- * exactly 0 means the click missed every drawn primitive (depth was
- * never written, so the clear value sticks), and we return null.
- *
- * Pixel coords use the WebGPU/screen convention (origin top-left, y
- * increases downward); NDC y is inverted to match the camera's
- * projection matrix.
- */
-function unprojectPickSample(viewProj, pickX, pickY, width, height, depth) {
-    if (!Number.isFinite(depth) || depth <= 0)
-        return null;
-    const ndcX = ((pickX + 0.5) / width) * 2 - 1;
-    const ndcY = 1 - ((pickY + 0.5) / height) * 2;
-    const inv = MathUtils.invert({ m: viewProj });
-    if (!inv)
-        return null;
-    return MathUtils.transformPoint(inv, { x: ndcX, y: ndcY, z: depth });
-}
-/**
- * Whether a rejected `mapAsync` readback means "the GPU resource went away"
- * rather than "we asked for something illegal".
- *
- * WebGPU only rejects a map with `AbortError` when the thing being mapped
- * stops existing: the buffer is destroyed or unmapped before the map settles,
- * or the device/instance behind it is destroyed or lost. The pick path never
- * touches its readback buffers before the map settles, so for us that reduces
- * to "the device is gone" — Chromium words it
- * `AbortError: … A valid external Instance reference no longer exists.` (#1901).
- *
- * The entry guards in `pick()` / `pickRect()` (and `Renderer.pickPathAlive()`)
- * stop a pick that STARTS on a dead device, but they cannot close the window
- * between `queue.submit()` and the map settling: a pick that was perfectly
- * legal when it started is still aborted if the canvas unmounts, the model
- * reloads (`Renderer.destroy()` ends in `device.destroy()`), or the driver
- * resets while the readback is in flight. Nothing on that path can handle the
- * rejection — the DOM listeners that reach it are `async` functions nobody
- * awaits — so it escapes as an unhandled rejection.
- *
- * Real faults are NOT covered here: a validation failure (already-mapped
- * buffer, bad usage flags, out-of-range range) rejects with `OperationError`,
- * which still propagates.
- */
-function isReadbackAbort(err) {
-    return typeof err === 'object' && err !== null && err.name === 'AbortError';
-}
-/**
- * Free readback buffers on the aborted path. The device may already be gone,
- * in which case `destroy()` is a no-op — or throws on some backends, which
- * must not turn a handled teardown back into an escaping error.
- */
-function releaseReadbacks(...buffers) {
-    for (const buffer of buffers) {
-        try {
-            buffer.destroy();
-        }
-        catch (err) {
-            // Non-fatal: the device is already gone and the buffer died with it.
-            // Surfaced rather than swallowed, per the no-silent-catch house rule —
-            // this firing on a LIVE device would mean a real teardown bug.
-            console.warn('[Picker] failed to release a readback buffer during teardown', err);
-        }
-    }
-}
+import { restoreRtePickWorld, unprojectPickSample } from './pick-world-position.js';
+import { writeFlatPickUniform, writeInstancedPickUniforms, writePickUniforms, } from './picker-rte-uniforms.js';
+import { isReadbackAbort, releaseReadbacks } from './picker-readbacks.js';
+import { relativeToEyeWgsl } from './shaders/relative-to-eye.wgsl.js';
+import { uploadInstancedRteDeltas } from './instanced-rte.js';
 export class Picker {
     device;
     webgpuDevice;
     pipeline;
     instancedPickPipeline = null; // GPU-instancing: pick pass for instanced occurrences; null if the backend rejected it
     instancedPickBindGroup = null;
+    instancedUniformBuffer;
     depthTexture;
     colorTexture;
     uniformBuffer;
@@ -87,11 +24,13 @@ export class Picker {
     /** Set by `destroy()`; makes it idempotent and turns `pick`/`pickRect` into no-ops. */
     destroyed = false;
     pointPicker = null;
-    // Reused scratch for the 32-float (128-byte) uniform block: viewProj +
-    // clipBoxMin/Max + sectionPlane + clipFlags. `clipFlags` is a u32 view aliasing
-    // floats 28-31 (byte 112): bit 0 = sectionEnabled, bit 1 = flipped, bit 2 = clipBox.
-    uniformScratch = new Float32Array(32);
-    clipFlags = new Uint32Array(this.uniformScratch.buffer, 112, 4);
+    // Flat meshes each bind a dynamic 256-byte slot: RTE view projection +
+    // model linear transform + clip state + split drawable origin. A single
+    // uniform rewritten in a loop would make every draw observe the last mesh.
+    uniformScratch = new Float32Array(64);
+    clipFlags = new Uint32Array(this.uniformScratch.buffer, 44 * 4, 4);
+    instancedUniformScratch = new Float32Array(40);
+    instancedClipFlags = new Uint32Array(this.instancedUniformScratch.buffer, 112, 4);
     constructor(device, width = 1, height = 1) {
         this.webgpuDevice = device;
         this.device = device.getDevice();
@@ -109,12 +48,15 @@ export class Picker {
             // point for hover tooltips / measurements.
             usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
         });
-        // Uniform buffer: viewProj (16 floats) + clipBoxMin (vec4) + clipBoxMax (vec4)
-        // + sectionPlane (vec4) + clipFlags (vec4<u32>) = 32 floats = 128 bytes. The
-        // picker mirrors the main render's section plane + crop box so clipped-away
-        // geometry is unpickable, not just invisible.
+        // One dynamically-offset uniform slot per flat mesh. The buffer carries
+        // `maxMeshes` slots so the command encoder can bind the immutable payload
+        // for each draw after all queue writes have completed.
         this.uniformBuffer = this.device.createBuffer({
-            size: 128,
+            size: this.maxMeshes * 256,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        });
+        this.instancedUniformBuffer = this.device.createBuffer({
+            size: 160,
             usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
         });
         // Create storage buffer for expressIds (one u32 per mesh, +1 encoding)
@@ -126,12 +68,16 @@ export class Picker {
         // Create picker shader that uses storage buffer for per-object expressId
         const shaderModule = this.device.createShaderModule({
             code: `
+        ${relativeToEyeWgsl}
         struct Uniforms {
-          viewProj: mat4x4<f32>,
+          viewProj: mat4x4<f32>, // translation-free RTE projection
+          model: mat4x4<f32>,    // linear transform; translation lives in originHigh/Low
           clipBoxMin: vec4<f32>,   // xyz = min corner (world), w = pad
           clipBoxMax: vec4<f32>,   // xyz = max corner (world), w = pad
           sectionPlane: vec4<f32>, // xyz = plane normal, w = plane distance
           clipFlags: vec4<u32>,    // x: bit0 sectionEnabled, bit1 flipped, bit2 clipBox
+          originHigh: vec4<f32>,
+          originLow: vec4<f32>,
         }
         @binding(0) @group(0) var<uniform> uniforms: Uniforms;
         @binding(1) @group(0) var<storage, read> expressIds: array<u32>;
@@ -150,9 +96,10 @@ export class Picker {
         @vertex
         fn vs_main(input: VertexInput, @builtin(instance_index) instanceIndex: u32) -> VertexOutput {
           var output: VertexOutput;
-          // Identity transform - positions are already in world space
-          output.position = uniforms.viewProj * vec4<f32>(input.position, 1.0);
-          output.worldPos = input.position;
+          let linear = (uniforms.model * vec4<f32>(input.position, 0.0)).xyz;
+          let relative = rteWorldPosition(linear, RteDrawableUniform(uniforms.originHigh, uniforms.originLow)).xyz;
+          output.position = uniforms.viewProj * vec4<f32>(relative, 1.0);
+          output.worldPos = relative;
           // Look up expressId from storage buffer using instance index
           output.objectId = expressIds[instanceIndex];
           return output;
@@ -181,7 +128,12 @@ export class Picker {
       `,
         });
         this.pipeline = this.device.createRenderPipeline({
-            layout: 'auto',
+            layout: this.device.createPipelineLayout({ bindGroupLayouts: [this.device.createBindGroupLayout({
+                        entries: [
+                            { binding: 0, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: true, minBindingSize: 224 } },
+                            { binding: 1, visibility: GPUShaderStage.VERTEX, buffer: { type: 'read-only-storage' } },
+                        ],
+                    })] }),
             vertex: {
                 module: shaderModule,
                 entryPoint: 'vs_main',
@@ -213,14 +165,13 @@ export class Picker {
                 depthCompare: 'greater', // Reverse-Z: greater instead of less
             },
         });
-        // Create bind group using the pipeline's auto-generated layout
-        // IMPORTANT: Must use getBindGroupLayout() when pipeline uses layout: 'auto'
+        // Dynamic uniform offset selects the mesh-specific RTE origin/transform.
         this.bindGroup = this.device.createBindGroup({
             layout: this.pipeline.getBindGroupLayout(0),
             entries: [
                 {
                     binding: 0,
-                    resource: { buffer: this.uniformBuffer },
+                    resource: { buffer: this.uniformBuffer, size: 224 },
                 },
                 {
                     binding: 1,
@@ -236,12 +187,15 @@ export class Picker {
         // storage buffer — the id rides the instance buffer per occurrence.
         const instancedPickModule = this.device.createShaderModule({
             code: `
+        ${relativeToEyeWgsl}
         struct Uniforms {
           viewProj: mat4x4<f32>,
           clipBoxMin: vec4<f32>,   // xyz = min corner (world), w = pad
           clipBoxMax: vec4<f32>,   // xyz = max corner (world), w = pad
           sectionPlane: vec4<f32>, // xyz = plane normal, w = plane distance
           clipFlags: vec4<u32>,    // x: bit0 sectionEnabled, bit1 flipped, bit2 clipBox
+          cameraHigh: vec4<f32>,
+          cameraLow: vec4<f32>,
         }
         @binding(0) @group(0) var<uniform> uniforms: Uniforms;
         struct VertexInput { @location(0) position: vec3<f32> }
@@ -252,6 +206,8 @@ export class Picker {
           @location(6) m3: vec4<f32>,
           @location(7) instEntityId: u32,
           @location(8) instFlags: u32,
+          @location(9) anchorHigh: vec4<f32>,
+          @location(10) anchorLow: vec4<f32>,
         }
         struct VertexOutput {
           @builtin(position) position: vec4<f32>,
@@ -263,9 +219,10 @@ export class Picker {
         fn vs_main(input: VertexInput, inst: InstanceInput) -> VertexOutput {
           var output: VertexOutput;
           let m = mat4x4<f32>(inst.m0, inst.m1, inst.m2, inst.m3);
-          let world = m * vec4<f32>(input.position, 1.0);
-          output.position = uniforms.viewProj * world;
-          output.worldPos = world.xyz;
+          let linear = (m * vec4<f32>(input.position, 0.0)).xyz;
+          let relative = rteWorldPosition(linear, RteDrawableUniform(inst.anchorHigh, inst.anchorLow)).xyz;
+          output.position = uniforms.viewProj * vec4<f32>(relative, 1.0);
+          output.worldPos = relative;
           // bit 30 = instanced marker; express id in the low 30 bits.
           output.objectId = 0x40000000u | (inst.instEntityId & 0x3FFFFFFFu);
           output.instFlags = inst.instFlags;
@@ -311,9 +268,10 @@ export class Picker {
                     buffers: [
                         // slot 0: template vertex (28B pos+norm+entityId) — only position read.
                         { arrayStride: 28, attributes: [{ shaderLocation: 0, offset: 0, format: 'float32x3' }] },
-                        // slot 1: per-instance (88B) — mat4 + entityId + flags (colour ignored here).
+                        // slot 1: V2 per-instance record — mat4 + id/colour/flags +
+                        // CPU-packed drawable-minus-camera lanes.
                         {
-                            arrayStride: 88,
+                            arrayStride: 120,
                             stepMode: 'instance',
                             attributes: [
                                 { shaderLocation: 3, offset: 0, format: 'float32x4' },
@@ -322,6 +280,8 @@ export class Picker {
                                 { shaderLocation: 6, offset: 48, format: 'float32x4' },
                                 { shaderLocation: 7, offset: 64, format: 'uint32' },
                                 { shaderLocation: 8, offset: 84, format: 'uint32' },
+                                { shaderLocation: 9, offset: 88, format: 'float32x4' },
+                                { shaderLocation: 10, offset: 104, format: 'float32x4' },
                             ],
                         },
                     ],
@@ -332,7 +292,7 @@ export class Picker {
             });
             this.instancedPickBindGroup = this.device.createBindGroup({
                 layout: this.instancedPickPipeline.getBindGroupLayout(0),
-                entries: [{ binding: 0, resource: { buffer: this.uniformBuffer } }],
+                entries: [{ binding: 0, resource: { buffer: this.instancedUniformBuffer } }],
             });
         }
         catch (err) {
@@ -358,10 +318,10 @@ export class Picker {
      * null if the device dies *during* the readback, which no entry guard can
      * pre-empt (see {@link isReadbackAbort}).
      */
-    async pick(x, y, width, height, meshes, viewProj, pointNodes, pointSizing, instancedTemplates, clip) {
+    async pick(x, y, width, height, meshes, viewProj, pointNodes, pointSizing, instancedTemplates, clip, pointRteSnapshot) {
         if (this.destroyed)
             return null;
-        const encoder = this.renderPickPass(width, height, meshes, viewProj, pointNodes, pointSizing, instancedTemplates, clip);
+        const encoder = this.renderPickPass(width, height, meshes, viewProj, pointNodes, pointSizing, instancedTemplates, clip, pointRteSnapshot);
         // Clamp the texel origin to the texture bounds. Math.floor(x/y) can
         // be -1 or equal to width/height on border clicks (and on
         // pointer-captured drags that leave the canvas), and either makes
@@ -426,21 +386,19 @@ export class Picker {
         // [0, 1] (1 = near, 0 = far) — same NDC convention as the camera
         // raycaster, so MathUtils.transformPoint with the inverse viewProj
         // gives the world hit position directly.
-        const worldXYZ = unprojectPickSample(viewProj, sampleX, sampleY, width, height, depth);
+        // Flat meshes, points and instanced occurrences all rasterise in the
+        // captured RTE frame. Decode depth with that same immutable projection.
+        const rteDecoded = decoded.kind === 'mesh' || decoded.kind === 'point' || decoded.kind === 'instanced';
+        const projectedWorld = unprojectPickSample(rteDecoded && pointRteSnapshot ? pointRteSnapshot.getViewProjection().m : viewProj, sampleX, sampleY, width, height, depth);
+        const worldXYZ = rteDecoded && pointRteSnapshot
+            ? restoreRtePickWorld(projectedWorld, pointRteSnapshot)
+            : projectedWorld;
         // Which entity (and which representation item) the sample landed on is a
         // pure lookup — see resolvePickSample.
         return resolvePickSample(decoded, meshes, pointNodes, worldXYZ);
     }
     updateUniforms(viewProj, clip) {
-        this.writePickUniforms(viewProj, clip);
-    }
-    /**
-     * Pack viewProj + the last render's section plane / crop box into the shared
-     * pick uniform and upload it. Layout + flag bits live in {@link packPickUniforms}.
-     */
-    writePickUniforms(viewProj, clip) {
-        packPickUniforms(viewProj, clip, this.uniformScratch, this.clipFlags);
-        this.device.queue.writeBuffer(this.uniformBuffer, 0, this.uniformScratch);
+        writePickUniforms(this.device, this.uniformBuffer, this.uniformScratch, this.clipFlags, viewProj, clip);
     }
     /**
      * Rectangle pick: render the pick pass once, then read back every
@@ -455,7 +413,7 @@ export class Picker {
      * Returns an empty set once `destroy()` has run — or if the device dies
      * mid-readback — for the same reasons {@link Picker.pick} returns null.
      */
-    async pickRect(x0, y0, x1, y1, width, height, meshes, viewProj, pointNodes, pointSizing, instancedTemplates, clip) {
+    async pickRect(x0, y0, x1, y1, width, height, meshes, viewProj, pointNodes, pointSizing, instancedTemplates, clip, pointRteSnapshot) {
         if (this.destroyed)
             return new Set();
         // Normalise + clip rect to texture bounds.
@@ -467,7 +425,7 @@ export class Picker {
         const rectH = hy - ly + 1;
         if (rectW <= 0 || rectH <= 0)
             return new Set();
-        const encoder = this.renderPickPass(width, height, meshes, viewProj, pointNodes, pointSizing, instancedTemplates, clip);
+        const encoder = this.renderPickPass(width, height, meshes, viewProj, pointNodes, pointSizing, instancedTemplates, clip, pointRteSnapshot);
         // copyTextureToBuffer requires bytesPerRow to be a multiple of 256.
         // r32uint = 4 bytes per texel. Round up to nearest 256.
         const rawRowBytes = rectW * 4;
@@ -530,7 +488,7 @@ export class Picker {
      * `copyTextureToBuffer` for either a single texel (`pick`) or a
      * whole rect (`pickRect`) before submitting.
      */
-    renderPickPass(width, height, meshes, viewProj, pointNodes, pointSizing, instancedTemplates, clip) {
+    renderPickPass(width, height, meshes, viewProj, pointNodes, pointSizing, instancedTemplates, clip, pointRteSnapshot) {
         if (this.colorTexture.width !== width || this.colorTexture.height !== height) {
             this.colorTexture.destroy();
             this.depthTexture.destroy();
@@ -569,7 +527,6 @@ export class Picker {
         if (meshes.length > this.maxMeshes) {
             this.resizeExpressIdBuffer(meshes.length);
         }
-        this.writePickUniforms(viewProj, clip);
         const meshIndexArray = new Uint32Array(meshes.length);
         for (let i = 0; i < meshes.length; i++) {
             if (meshes[i])
@@ -577,11 +534,20 @@ export class Picker {
         }
         this.device.queue.writeBuffer(this.expressIdBuffer, 0, meshIndexArray);
         pass.setPipeline(this.pipeline);
-        pass.setBindGroup(0, this.bindGroup);
         for (let i = 0; i < meshes.length; i++) {
             const mesh = meshes[i];
             if (!mesh)
                 continue;
+            if (pointRteSnapshot) {
+                writeFlatPickUniform(this.device, this.uniformBuffer, this.uniformScratch, this.clipFlags, mesh, pointRteSnapshot, clip, i);
+            }
+            else {
+                // Compatibility for direct Picker callers that predate RTE snapshots.
+                // Renderer/PickingManager always supplies one so production draws use
+                // the per-mesh immutable RTE slots above.
+                writePickUniforms(this.device, this.uniformBuffer, this.uniformScratch, this.clipFlags, viewProj, clip);
+            }
+            pass.setBindGroup(0, this.bindGroup, [i * 256]);
             pass.setVertexBuffer(0, mesh.vertexBuffer);
             pass.setIndexBuffer(mesh.indexBuffer, 'uint32');
             pass.drawIndexed(mesh.indexCount, 1, 0, 0, i);
@@ -589,7 +555,9 @@ export class Picker {
         // GPU-instanced occurrences — drawn into the SAME r32uint + depth target so
         // occlusion is shared with flat meshes/points. The shader writes
         // (bit30 | express id) per occurrence; the decoder returns the entity.
-        if (instancedTemplates && instancedTemplates.length > 0 && this.instancedPickPipeline && this.instancedPickBindGroup) {
+        if (instancedTemplates && instancedTemplates.length > 0 && this.instancedPickPipeline && this.instancedPickBindGroup && pointRteSnapshot) {
+            uploadInstancedRteDeltas(this.device, instancedTemplates, pointRteSnapshot.getCameraWorld());
+            writeInstancedPickUniforms(this.device, this.instancedUniformBuffer, this.instancedUniformScratch, this.instancedClipFlags, pointRteSnapshot, clip);
             pass.setPipeline(this.instancedPickPipeline);
             pass.setBindGroup(0, this.instancedPickBindGroup);
             for (const it of instancedTemplates) {
@@ -604,14 +572,13 @@ export class Picker {
                 this.pointPicker = new PointPicker(this.webgpuDevice);
             }
             const sz = pointSizing ?? { sizeMode: 0, worldRadius: 0.02, pointSizePx: 4 };
-            // Point clouds are section-clipped on render, so the point picker must clip
-            // on the same plane (the crop box does not clip points, on render or here).
+            // Point clouds share both RTE section and crop discards with their colour pass.
             this.pointPicker.drawIntoPass(pass, pointNodes, viewProj, { width, height }, {
                 sizeMode: sz.sizeMode,
                 worldRadius: sz.worldRadius,
                 pointSizePx: sz.pointSizePx,
                 clickTolerancePx: sz.clickTolerancePx ?? 2,
-            }, clip?.sectionPlane ?? null);
+            }, clip?.sectionPlane ?? null, pointRteSnapshot, clip?.clipBox ?? null);
         }
         pass.end();
         return encoder;
@@ -622,6 +589,7 @@ export class Picker {
     resizeExpressIdBuffer(newSize) {
         // Destroy old buffer
         this.expressIdBuffer.destroy();
+        this.uniformBuffer.destroy();
         // Increase maxMeshes with 50% headroom for future growth
         this.maxMeshes = Math.ceil(newSize * 1.5);
         // Create new buffer
@@ -629,13 +597,17 @@ export class Picker {
             size: this.maxMeshes * 4, // 4 bytes per u32
             usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
         });
+        this.uniformBuffer = this.device.createBuffer({
+            size: this.maxMeshes * 256,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        });
         // Recreate bind group with new buffer
         this.bindGroup = this.device.createBindGroup({
             layout: this.pipeline.getBindGroupLayout(0),
             entries: [
                 {
                     binding: 0,
-                    resource: { buffer: this.uniformBuffer },
+                    resource: { buffer: this.uniformBuffer, size: 224 },
                 },
                 {
                     binding: 1,
@@ -656,6 +628,7 @@ export class Picker {
         this.colorTexture.destroy();
         this.depthTexture.destroy();
         this.uniformBuffer.destroy();
+        this.instancedUniformBuffer.destroy();
         this.expressIdBuffer.destroy();
         this.pointPicker?.destroy();
         this.pointPicker = null;