@equinor/videx-3d 1.1.1 → 2.0.0

package/dist/sdk.js

@@ -1,9 +1,9 @@
 import { wrap as Y } from "comlink";
 import R from "p-limit";
-import { d as K } from "./chunk-iY0wQ9Z6.js";
-import { x as xt, D as bt, P as vt, b as Mt, a as Ct, c as Et, T as Bt, y as At, z as zt, A as Ft, B as It, p as St, E as Lt, F as Vt, G as Tt, H as Pt, I as Dt, J as Gt, K as qt, L as jt, M as kt, e as Nt, N as Ot, o as Qt, O as Ut, Q as Wt, R as Ht, i as Zt, S as $t, U as Jt, V as Kt, X as Xt, g as Yt, Y as Rt, Z as te, _ as ee, $ as se, h as ie, m as ne, a0 as re, a1 as ae, a2 as oe, n as le, a3 as he, f as ce, a4 as fe, a5 as ue, a6 as de, a7 as ge, a8 as me, a9 as pe, aa as ye, ab as _e, ac as we, ad as xe, ae as be, af as ve, ag as Me, s as Ce, ah as Ee, ai as Be, aj as Ae, u as ze, ak as Fe } from "./chunk-iY0wQ9Z6.js";
-import { C as Se, T as Le, c as Ve, b as Te, a as Pe, d as De, e as Ge, g as qe, f as je, t as ke, h as Ne, w as Oe } from "./chunk-CnY6Tmof.js";
-import { D as Ue, c as We, a as He, b as Ze, d as $e, m as Je, t as Ke, e as Xe, f as Ye } from "./chunk-BlPg4RjP.js";
+import { d as K } from "./chunk-61X6qE5N.js";
+import { y as xt, D as bt, P as vt, b as Mt, a as Ct, c as Et, T as Bt, z as At, A as zt, B as Ft, E as St, q as It, F as Lt, G as Vt, i as Tt, H as Pt, j as qt, I as Dt, J as Gt, K as jt, L as kt, M as Nt, N as Ot, O as Qt, Q as Ut, e as Wt, R as Ht, S as Zt, p as $t, U as Jt, V as Kt, X as Xt, h as Yt, Y as Rt, Z as te, _ as ee, $ as se, g as ie, a0 as ne, a1 as re, a2 as ae, a3 as oe, m as le, a4 as he, a5 as ce, a6 as fe, a7 as ue, n as de, a8 as ge, f as me, a9 as pe, aa as ye, ab as _e, ac as we, ad as xe, ae as be, af as ve, ag as Me, ah as Ce, ai as Ee, aj as Be, ak as Ae, al as ze, s as Fe, am as Se, an as Ie, ao as Le, ap as Ve, u as Te, aq as Pe } from "./chunk-61X6qE5N.js";
+import { C as De, T as Ge, c as je, b as ke, g as Ne, e as Oe, t as Qe, w as Ue } from "./chunk-ChG5d4HC.js";
+import { D as He, c as Ze, a as $e, b as Je, d as Ke, m as Xe, t as Ye, e as Re, f as ts } from "./chunk-M-Pcc_Yg.js";
 import { Vector2 as N, Shape as tt, Path as et } from "three";
 const st = 10, it = 25;
 class lt {
@@ -308,12 +308,12 @@ class $ extends W {
 function ct(u, t, e = 1, s = 1, i = (r) => r) {
   console.time("triangulate");
   const r = [], n = [], a = [], c = [], h = u.length / t;
-  let o, l, d, g, b, y, _, v, C, A, x, z, M, E, B, G, f, O, V, T, P, m, w, Q, X = 0, U = 0, J = 0, I = new Array(t).fill(null), q = new Array(t).fill(null);
+  let o, l, d, g, b, y, _, v, C, A, x, z, M, E, B, D, f, O, V, T, P, m, w, Q, X = 0, U = 0, J = 0, S = new Array(t).fill(null), G = new Array(t).fill(null);
   const p = new Array(t - 1).fill(null);
-  function j(F, L, D) {
-    return r.push({ x: F * e, y: D, z: L * s, edge: null }), a.push(F / (t - 1), 1 - L / (h - 1)), X++;
+  function j(F, L, q) {
+    return r.push({ x: F * e, y: q, z: L * s, edge: null }), a.push(F / (t - 1), 1 - L / (h - 1)), X++;
   }
-  function S(F, L, D) {
+  function I(F, L, q) {
     V = {
       index: U++,
       tail: F,
@@ -324,24 +324,24 @@ function ct(u, t, e = 1, s = 1, i = (r) => r) {
     }, T = {
       index: U++,
       tail: L,
-      head: D,
+      head: q,
       twin: null,
       prev: null,
       next: null
     }, P = {
       index: U++,
-      tail: D,
+      tail: q,
       head: F,
       twin: null,
       prev: null,
       next: null
-    }, V.next = T, T.next = P, P.next = V, V.prev = P, T.prev = V, P.prev = T, r[F].edge || (r[F].edge = V), r[L].edge || (r[L].edge = T), r[D].edge || (r[D].edge = P), n.push(V, T, P), c.push(F, L, D);
+    }, V.next = T, T.next = P, P.next = V, V.prev = P, T.prev = V, P.prev = T, r[F].edge || (r[F].edge = V), r[L].edge || (r[L].edge = T), r[q].edge || (r[q].edge = P), n.push(V, T, P), c.push(F, L, q);
   }
-  for (G = 1; G < h - 1; G++) {
+  for (D = 1; D < h - 1; D++) {
     Q = !1;
-    const F = I;
-    for (I = q, q = F.fill(null), m = null, O = G - 1, J += t, B = 1; B < t - 1; B++)
-      f = B - 1, A = J + B, C = A - 1, v = A - t, _ = v - 1, x = i(u[_]), z = i(u[v]), M = i(u[C]), E = i(u[A]), x !== null && z !== null && M !== null && E !== null ? w = 1 : x !== null && z !== null && M !== null ? w = 2 : x !== null && z !== null && E !== null ? w = 3 : x !== null && M !== null && E !== null ? w = 4 : z !== null && M !== null && E !== null ? w = 5 : w = 0, d = null, g = null, w !== 0 ? (Q ? (o = I[f], d = q[f]) : (w !== 5 && (I[f] === null ? (o = j(f, O, x), I[f] = o) : o = I[f]), w !== 3 && (d = j(f, G, M)), q[f] = d), w !== 4 && (I[B] === null ? (l = j(B, O, z), I[B] = l) : l = I[B]), w !== 2 && (g = j(B, G, E)), w === 1 ? (b = Math.abs(r[o].y - r[g].y), y = Math.abs(r[l].y - r[d].y), b < y ? (S(o, d, g), m !== null && (n[n.length - 3].twin = m, m.twin = n[n.length - 3]), S(g, l, o), p[f] !== null && (n[n.length - 2].twin = p[f], p[f].twin = n[n.length - 2]), n[n.length - 4].twin = n[n.length - 1], n[n.length - 1].twin = n[n.length - 4], p[f] = n[n.length - 5], m = n[n.length - 3]) : (S(o, d, l), p[f] !== null && (n[n.length - 1].twin = p[f], p[f].twin = n[n.length - 1]), m !== null && (n[n.length - 3].twin = m, m.twin = n[n.length - 3]), S(l, d, g), n[n.length - 5].twin = n[n.length - 3], n[n.length - 3].twin = n[n.length - 5], p[f] = n[n.length - 2], m = n[n.length - 1])) : w === 2 ? (S(o, d, l), p[f] !== null && (n[n.length - 1].twin = p[f], p[f].twin = n[n.length - 1]), m !== null && (n[n.length - 3].twin = m, m.twin = n[n.length - 3]), p[f] = null, m = null) : w === 5 ? (S(l, d, g), p[f] = n[n.length - 2], m = n[n.length - 1]) : w === 3 ? (S(l, o, g), p[f] !== null && (n[n.length - 3].twin = p[f], p[f].twin = n[n.length - 3]), p[f] = null, m = n[n.length - 1]) : (S(o, d, g), m !== null && (n[n.length - 3].twin = m, m.twin = n[n.length - 3]), p[f] = n[n.length - 2], m = null)) : (p[f] = null, m = null), q[B] = g, Q = !!w;
+    const F = S;
+    for (S = G, G = F.fill(null), m = null, O = D - 1, J += t, B = 1; B < t - 1; B++)
+      f = B - 1, A = J + B, C = A - 1, v = A - t, _ = v - 1, x = i(u[_]), z = i(u[v]), M = i(u[C]), E = i(u[A]), x !== null && z !== null && M !== null && E !== null ? w = 1 : x !== null && z !== null && M !== null ? w = 2 : x !== null && z !== null && E !== null ? w = 3 : x !== null && M !== null && E !== null ? w = 4 : z !== null && M !== null && E !== null ? w = 5 : w = 0, d = null, g = null, w !== 0 ? (Q ? (o = S[f], d = G[f]) : (w !== 5 && (S[f] === null ? (o = j(f, O, x), S[f] = o) : o = S[f]), w !== 3 && (d = j(f, D, M)), G[f] = d), w !== 4 && (S[B] === null ? (l = j(B, O, z), S[B] = l) : l = S[B]), w !== 2 && (g = j(B, D, E)), w === 1 ? (b = Math.abs(r[o].y - r[g].y), y = Math.abs(r[l].y - r[d].y), b < y ? (I(o, d, g), m !== null && (n[n.length - 3].twin = m, m.twin = n[n.length - 3]), I(g, l, o), p[f] !== null && (n[n.length - 2].twin = p[f], p[f].twin = n[n.length - 2]), n[n.length - 4].twin = n[n.length - 1], n[n.length - 1].twin = n[n.length - 4], p[f] = n[n.length - 5], m = n[n.length - 3]) : (I(o, d, l), p[f] !== null && (n[n.length - 1].twin = p[f], p[f].twin = n[n.length - 1]), m !== null && (n[n.length - 3].twin = m, m.twin = n[n.length - 3]), I(l, d, g), n[n.length - 5].twin = n[n.length - 3], n[n.length - 3].twin = n[n.length - 5], p[f] = n[n.length - 2], m = n[n.length - 1])) : w === 2 ? (I(o, d, l), p[f] !== null && (n[n.length - 1].twin = p[f], p[f].twin = n[n.length - 1]), m !== null && (n[n.length - 3].twin = m, m.twin = n[n.length - 3]), p[f] = null, m = null) : w === 5 ? (I(l, d, g), p[f] = n[n.length - 2], m = n[n.length - 1]) : w === 3 ? (I(l, o, g), p[f] !== null && (n[n.length - 3].twin = p[f], p[f].twin = n[n.length - 3]), p[f] = null, m = n[n.length - 1]) : (I(o, d, g), m !== null && (n[n.length - 3].twin = m, m.twin = n[n.length - 3]), p[f] = n[n.length - 2], m = null)) : (p[f] = null, m = null), G[B] = g, Q = !!w;
   }
   return console.timeEnd("triangulate"), console.log(c.length / 3), { vertices: r, indices: c, uvs: a, edges: n };
 }
@@ -681,10 +681,10 @@ function yt(u) {
   return t;
 }
 export {
-  Se as CRS,
+  De as CRS,
   xt as CameraManager,
   lt as DataLoader,
-  Ue as Delatin,
+  He as Delatin,
   bt as DepthReadMaterial,
   ht as GeneratorRegistry,
   vt as PI,
@@ -696,90 +696,92 @@ export {
   H as PlanarPointGeometry,
   $ as PlanarPolygonGeometry,
   Bt as TAU,
-  Le as TubeMaterial,
+  Ge as TubeMaterial,
   k as Typed2DArray,
   At as WellboreManager,
   zt as addVec2,
   Ft as addVec3,
-  It as angleVec3,
-  St as calculateFrenetFrames,
-  We as calculateHashValue,
-  Ve as calculateWellSegments,
+  St as angleVec3,
+  It as calculateFrenetFrames,
+  Ze as calculateHashValue,
+  je as calculateWellSegments,
   K as clamp,
-  Lt as copyVec3,
-  Te as createConfig,
-  Pe as createElevationTexture,
-  He as createFenceGeometry,
-  De as createNormalTexture,
-  Ze as createTubeGeometries,
-  $e as createTubeGeometry,
-  Vt as crossVec3,
-  Tt as degreesToRadians,
-  Pt as directionVec2,
-  Dt as directionVec3,
-  Gt as distanceVec2,
-  qt as distanceVec3,
-  jt as dotVec2,
-  kt as dotVec3,
-  Nt as edgeOfRectangle,
-  Ge as elevationMapNormalsToRGBA,
-  Ot as feetToMeters,
-  Qt as getCurvePositions,
-  Ut as getFormationMarkers,
+  Lt as computeSurfaceNormalsRG,
+  Vt as copyVec3,
+  ke as createConfig,
+  Tt as createElevationTexture,
+  $e as createFenceGeometry,
+  Pt as createNormalTexture,
+  qt as createPackedNormalTexture,
+  Je as createTubeGeometries,
+  Ke as createTubeGeometry,
+  Dt as crossVec3,
+  Gt as degreesToRadians,
+  jt as directionVec2,
+  kt as directionVec3,
+  Nt as distanceVec2,
+  Ot as distanceVec3,
+  Qt as dotVec2,
+  Ut as dotVec3,
+  Wt as edgeOfRectangle,
+  Ht as elevationMapNormalsToRGBA,
+  Zt as feetToMeters,
+  $t as getCurvePositions,
+  Jt as getFormationMarkers,
   pt as getObjectByCustomProperty,
-  Wt as getProjectedTrajectory,
-  qe as getProjectionDefFromUtmZone,
-  Ht as getSplineCurve,
-  Zt as getTrajectory,
-  $t as getTypedArrayFromBuffer,
-  Jt as getTypedArrayType,
-  je as getUtmZoneFromLatLng,
-  Kt as getVec2,
-  Xt as getVec3,
-  Yt as getWellboreFormations,
+  Kt as getProjectedTrajectory,
+  Ne as getProjectionDefFromUtmZone,
+  Xt as getSplineCurve,
+  Yt as getTrajectory,
+  Rt as getTypedArrayFromBuffer,
+  te as getTypedArrayType,
+  Oe as getUtmZoneFromLatLng,
+  ee as getVec2,
+  se as getVec3,
+  ie as getWellboreFormations,
   ft as idToHexColor,
-  Rt as inverseLerp,
-  te as lengthVec2,
-  ee as lengthVec3,
-  se as lerp,
-  ie as mergeFormationIntervals,
-  Je as mergeGeometries,
-  ne as mixVec2,
-  re as mixVec3,
+  ne as inverseLerp,
+  re as lengthVec2,
+  ae as lengthVec3,
+  oe as lerp,
+  le as mergeFormationIntervals,
+  Xe as mergeGeometries,
+  he as mixVec2,
+  ce as mixVec3,
   mt as multiply,
   gt as negate,
-  ae as negateVec2,
-  oe as negateVec3,
-  le as normalizeVec2,
-  he as normalizeVec3,
-  ce as normalizedDeviceToScreen,
-  fe as packAttribute,
-  ue as packBufferGeometries,
-  de as packBufferGeometry,
-  ge as packBufferGeometryLike,
+  fe as negateVec2,
+  ue as negateVec3,
+  de as normalizeVec2,
+  ge as normalizeVec3,
+  me as normalizedDeviceToScreen,
+  pe as packAttribute,
+  ye as packBufferGeometries,
+  _e as packBufferGeometry,
+  we as packBufferGeometryLike,
   dt as parseIrapbin,
   ut as randomColor,
-  me as readDepth,
-  pe as remap,
-  ye as rotateVec3,
-  _e as scaleVec2,
-  we as scaleVec3,
-  xe as screenToNormalizedDevice,
-  be as setVec2,
-  ve as setVec3,
-  Me as simplifyCurve2D,
-  Ce as subVec2,
-  Ee as subVec3,
-  Ke as titleCase,
-  Xe as toBufferGeometry,
+  xe as readDepth,
+  be as remap,
+  ve as rotateVec3,
+  Me as scaleVec2,
+  Ce as scaleVec3,
+  Ee as screenToNormalizedDevice,
+  Be as setVec2,
+  Ae as setVec3,
+  ze as simplifyCurve2D,
+  Fe as subVec2,
+  Se as subVec3,
+  Ye as titleCase,
+  Re as toBufferGeometry,
   yt as toFloat32Array,
-  Be as toRGB,
-  ke as toSegments,
-  Ne as triangleNormal,
+  Ie as toRGB,
+  Qe as toSegments,
+  Le as triangleNormal,
   ct as triangulateGrid,
-  Ye as triangulateGridDelaunay,
-  Ae as unpackBufferGeometries,
-  ze as unpackBufferGeometry,
-  Fe as uvMaterial,
-  Oe as wgs84Def
+  ts as triangulateGridDelaunay,
+  Ve as unpackBufferGeometries,
+  Te as unpackBufferGeometry,
+  Pe as uvMaterial,
+  Ue as wgs84Def
 };

package/dist/shaderLib/oit.glsl

@@ -0,0 +1,106 @@
+// Order-independent transparency (OIT) shared shader chunk.
+//
+// Provides the uniforms and the per-pass output logic used by the OITRenderPass
+// hybrid pipeline (exact depth-peeled front layer + weighted-blended OIT tail).
+//
+// Usage (library ShaderMaterials, GLSL1 / gl_FragColor):
+//   #include <this file>           // brings uniforms + oitProcess()
+//   ...
+//   gl_FragColor = ...;            // compute final straight (non-premultiplied) color
+//   #ifdef USE_OIT
+//     gl_FragColor = oitProcess(gl_FragColor);
+//   #endif
+//
+// The fragment shader must have `vViewPosition` (view-space position) available.
+//
+// Pass selection is driven by defines set on the per-pass variant materials:
+//   USE_OIT            enables the whole block
+//   OIT_DEPTH_PASS     min-depth pre-pass (writes linear view-space depth)
+//   OIT_FRONT_PASS     exact front layer (alpha-over, discards tail fragments)
+//   (none of the above, USE_OIT only) => single-buffer weighted-blended OIT tail
+//
+// The WBOIT tail uses a single RGBA16F accumulation target with optical-depth
+// weighting: each fragment contributes weight b = -ln(1 - alpha), so
+//   accum.rgb = sum(rgb * b),  accum.a = sum(b).
+// The composite recovers the weighted-average colour as accum.rgb / accum.a and the
+// coverage as 1 - exp(-accum.a) = 1 - prod(1 - alpha) -- identical to a separate
+// (ZERO, ONE_MINUS_SRC_COLOR) reveal pass, but without the extra rasterisation.
+//
+// The `oitSkipFront` uniform (1) disables front peeling so the tail pass keeps the
+// front fragments too (debug: everything resolved through WBOIT).
+
+#ifdef USE_OIT
+
+uniform float oitDepthFar;          // normalisation factor for view-space depth
+uniform vec2 oitScreenSize;         // render target size in pixels
+uniform sampler2D oitMinDepthTexture; // per-pixel min linear depth (front layer)
+uniform int oitSkipFront;           // 1 = disable front peeling (debug: all WBOIT)
+uniform float oitOcclusionThreshold; // occlusion-stamp pass: min alpha to write depth
+
+// Process the straight (non-premultiplied) fragment color for the active pass.
+vec4 oitProcess(vec4 color) {
+  #ifdef OIT_OCCLUSION_PASS
+  // Occlusion depth stamp: write depth only where this surface is opaque enough
+  // (its own alpha clears the threshold). Colour writes are disabled on the
+  // variant, so the returned colour is ignored; discarding skips the depth write.
+  // Lets sufficiently-opaque transparent surfaces occlude annotation labels even
+  // though they don't write depth in the regular OIT passes.
+  if(color.a < oitOcclusionThreshold)
+    discard;
+  return color;
+  #endif
+
+  // View-space linear depth, normalised. Independent of the (logarithmic) depth
+  // buffer encoding, so the partition is correct at any camera scale.
+  float linZ = abs(vViewPosition.z) / oitDepthFar;
+
+  #ifdef OIT_DEPTH_PASS
+
+  // Written into an R32F target with MinEquation blending => per-pixel minimum.
+  return vec4(linZ, 0.0, 0.0, 1.0);
+
+  #else
+
+  // Gradient-relative tolerance: only the surface that produced the per-pixel
+  // minimum qualifies as "front". A fixed epsilon would form a depth slab and let
+  // distinct surfaces grazing within it bleed into each other.
+  vec2 uv = gl_FragCoord.xy / oitScreenSize;
+  float minZ = texture2D(oitMinDepthTexture, uv).r;
+  // Depth-relative tolerance. The min-depth pre-pass and this pass rasterise the
+  // SAME geometry with the SAME vertex transform, so the genuine front fragment's
+  // linZ matches the stored minZ to near bit-exactness; a tiny epsilon suffices.
+  // Avoid fwidth(linZ) here: at self-overlap silhouettes the 2x2 derivative quads
+  // straddle the depth discontinuity between layers, so fwidth spikes and inflates
+  // the tolerance, misclassifying back-layer fragments as front (visible edges).
+  float tol = minZ * 1e-3 + 1e-6;
+  bool isFront = (linZ - minZ) <= tol;
+
+  #ifdef OIT_FRONT_PASS
+
+  // Exact front layer: keep only the nearest fragment, blended alpha-over.
+  if(!isFront)
+    discard;
+  return color;
+
+  #else
+
+  // Tail pass: exclude the front fragment (handled exactly by the front pass),
+  // unless front peeling is disabled (debug: every fragment goes through WBOIT).
+  if(isFront && oitSkipFront == 0)
+    discard;
+
+  float alpha = color.a;
+
+  // Optical-depth weight b = -ln(1 - alpha). Additive (ONE, ONE) blending then gives
+  // accum.rgb = sum(rgb * b), accum.a = sum(b). The composite reconstructs both the
+  // weighted-average colour (accum.rgb / accum.a) and the coverage
+  // (1 - exp(-accum.a) = 1 - prod(1 - alpha)) from this single buffer, so no separate
+  // reveal pass is needed. alpha is clamped below 1 to keep b finite.
+  float b = -log(1.0 - clamp(alpha, 0.0, 0.9999));
+  return vec4(color.rgb * b, b);
+
+  #endif // OIT_FRONT_PASS
+  #endif // OIT_DEPTH_PASS
+}
+
+#endif // USE_OIT

package/dist/types/components/Annotations/AutoUpdate.d.ts

@@ -1,3 +1,3 @@
 export declare const AutoUpdate: ({ maxVisible }: {
     maxVisible: number;
-}) => null;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Annotations/index.d.ts

@@ -1,8 +1,8 @@
 import { Vec3 } from '../../sdk';
 import { AnnotationProps } from './types';
+export * from '../../rendering/passes/AnnotationsPass';
 export * from './Annotations';
-export * from './annotations-renderer';
 export * from './annotations-state';
 export * from './AnnotationsLayer';
 export * from './types';
-export declare const getAnnotationPosition: (annotation: AnnotationProps) => Vec3;
+export declare const getAnnotationPosition: (annotation: AnnotationProps, target?: Vec3) => Vec3;

package/dist/types/components/Annotations/types.d.ts

@@ -55,7 +55,7 @@ export type AnnotationInstanceState = {
     kill?: boolean;
     cooldown?: number;
     opacity?: number;
-    labelWidht: number;
+    labelWidth: number;
     labelHeight: number;
     labelX?: number;
     labelY?: number;
@@ -68,6 +68,8 @@ export type AnnotationInstanceState = {
     _zIndex?: string;
     _transform?: string;
     _needsUpdate?: boolean;
+    _connPrevX?: number;
+    _connPrevY?: number;
 };
 export type AnnotationInstance = {
     id: string;

package/dist/types/components/Annotations/update-annotations.d.ts

@@ -1,6 +1,16 @@
 import { Clock, PerspectiveCamera } from 'three';
 import { Vec2 } from '../../sdk';
 import { AnnotationInstance } from './types';
+/**
+ * Activity flags updated by preprocessInstances each frame. Used by
+ * AnnotationsPass to skip the expensive post-process/overlay work when the
+ * scene is settled (camera static and no animations in progress).
+ */
+export declare const annotationsActivity: {
+    animating: boolean;
+    positionChanged: boolean;
+    deltaTime: number;
+};
 /**
  * PRE-PROCESS INSTANCES
  */

package/dist/types/components/EventEmitter/picking-helper.d.ts

@@ -19,10 +19,26 @@ export declare class PickingHelper {
     private _radius;
     private _pbo;
     private _buffer;
+    private _prevClearColor;
     private _material;
+    /**
+     * Dedicated camera used for the picking render so the shared scene camera is
+     * never mutated. `setViewOffset` rebuilds a camera's projection (it remaps the
+     * frustum to the tiny patch under the cursor), and that mutation would clobber
+     * any external modification of the real camera's projection — e.g. the
+     * sub-pixel jitter a TAA pass bakes in. Each pick this camera is `copy()`d from
+     * the real camera (which faithfully mirrors `matrixWorld`,
+     * `matrixWorldInverse`, the projection and all intrinsics) and the view offset
+     * is applied here instead. `matrixWorldAutoUpdate` is disabled so the renderer
+     * uses the copied world matrix verbatim rather than recomputing it.
+     */
+    private _camera;
     private _listeners;
     private _emitters;
-    private _currentObjectMap;
+    private _mapStarts;
+    private _mapObjectIds;
+    private _objectMapLength;
+    private _objectMapCount;
     constructor(options?: {});
     private traverseObject;
     updateListeners: () => void;
@@ -30,6 +46,12 @@ export declare class PickingHelper {
     getListener: (id: number) => Listener | undefined;
     removeListener: (id: number) => void;
     render(pointer: Vector2, renderer: WebGLRenderer, scene: Scene, camera: PerspectiveCamera): Promise<PickResult>;
+    /**
+     * Locate the emitter owning a flat id via binary search. Emitter ranges are
+     * contiguous and sorted by start, so the owner is the rightmost entry whose
+     * start is `<= flatId`.
+     */
+    private findEmitterIndex;
     private pick;
     dispose(): void;
 }

package/dist/types/components/Surfaces/Surface.d.ts

@@ -28,6 +28,13 @@ export type SurfaceProps = CommonComponentProps & PointerEvents & {
     wireframe?: boolean;
     normalMap?: Texture;
     normalScale?: Vec2;
+    /**
+     * Precompute the surface normals into a compact texture instead of deriving
+     * them per-fragment from the elevation map. This skips the normal recompute
+     * the shader otherwise repeats across the order-independent transparency
+     * passes, at the cost of a little extra texture memory. Defaults to `false`.
+     */
+    precomputeNormals?: boolean;
     debug?: boolean;
 };
 /**
@@ -43,4 +50,4 @@ export type SurfaceProps = CommonComponentProps & PointerEvents & {
  *
  * @group Components
  */
-export declare const Surface: ({ meta, color, colorRamp, rampMin, rampMax, reverseRamp, useColorRamp, showContours, contoursInterval, contoursColorMode, contoursColorModeFactor, contoursThickness, contoursColor, opacity, priority, maxError, doubleSide, wireframe, normalMap, normalScale, name, userData, receiveShadow, castShadow, layers, position, renderOrder, visible, debug, onPointerClick, onPointerEnter, onPointerLeave, onPointerMove, }: SurfaceProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const Surface: ({ meta, color, colorRamp, rampMin, rampMax, reverseRamp, useColorRamp, showContours, contoursInterval, contoursColorMode, contoursColorModeFactor, contoursThickness, contoursColor, opacity, priority, maxError, doubleSide, wireframe, normalMap, normalScale, precomputeNormals, name, userData, receiveShadow, castShadow, layers, position, renderOrder, visible, debug, onPointerClick, onPointerEnter, onPointerLeave, onPointerMove, }: SurfaceProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/Surfaces/SurfaceMaterial.d.ts

@@ -20,6 +20,7 @@ export type SurfaceMaterialParameters = ShaderMaterialParameters & MeshLambertMa
     contoursColor?: string | number | Color;
     elevationTexture?: Texture;
     normalTexture?: Texture;
+    usePrecomputedNormals?: boolean;
     debug?: boolean;
 };
 /**
@@ -48,6 +49,8 @@ export declare class SurfaceMaterial extends ShaderMaterial {
     set showContours(value: any);
     get debug(): any;
     set debug(value: any);
+    get usePrecomputedNormals(): any;
+    set usePrecomputedNormals(value: any);
     dispose(): void;
     onBeforeCompile(): void;
 }

package/dist/types/components/Surfaces/surface-defs.d.ts

@@ -4,4 +4,5 @@ export declare const surfaceTextures = "surfaceTextures";
 export type SurfaceGeometryResponse = PackedBufferGeometry;
 export type SurfaceTexturesResponse = {
     elevationImageBuffer: Float32Array;
+    normalImageBuffer?: Uint8Array;
 };

package/dist/types/generators/surface-generator.d.ts

@@ -1,4 +1,4 @@
 import { SurfaceTexturesResponse } from '../main';
 import { PackedBufferGeometry, ReadonlyStore } from '../sdk';
-export declare function generateSurfaceTexturesData(this: ReadonlyStore, id: string): Promise<SurfaceTexturesResponse | null>;
+export declare function generateSurfaceTexturesData(this: ReadonlyStore, id: string, computeNormals?: boolean): Promise<SurfaceTexturesResponse | null>;
 export declare function generateSurfaceGeometry(this: ReadonlyStore, id: string, maxError?: number): Promise<PackedBufferGeometry | null>;

package/dist/types/layers/layers.d.ts

@@ -1,5 +1,9 @@
 import { Layers } from 'three';
 export declare const LAYERS: {
+    OIT_EXCLUDED: number;
+    FORCE_OPAQUE: number;
+    OVERLAY: number;
+    EMISSIVE: number;
     NOT_EMITTER: number;
     EMITTER: number;
 };

package/dist/types/rendering/OitMaterial.d.ts

@@ -0,0 +1,59 @@
+import { Side } from 'three';
+/**
+ * Props for {@link OitMaterial}.
+ * @expand
+ */
+export type OitMaterialProps = {
+    /**
+     * Force a specific `side` on the OIT variants (e.g. `DoubleSide`). Defaults to
+     * the material's own side.
+     */
+    side?: Side;
+    /**
+     * Names of custom uniform-container properties on the material to share by
+     * reference with the per-pass variants. Only needed for non-`ShaderMaterial`
+     * materials that read a custom uniforms object in `onBeforeCompile`.
+     */
+    shareUniforms?: string[];
+    /**
+     * Names of value properties (e.g. `color`, `metalness`) to keep live on the
+     * per-pass variants of a cloned built-in material. See
+     * {@link OitMaterialOptions.syncProperties}. Ignored for `ShaderMaterial`s
+     * (already live via shared uniforms).
+     */
+    syncProperties?: string[];
+    /**
+     * - `inject` (default): patch the material's shaders at compile time (stock or
+     *   inline materials whose shader does not already include `oit.glsl`).
+     * - `attach`: the material's shader already `#include`s `oit.glsl` and calls
+     *   `oitProcess` (library materials); only wire up the variant machinery.
+     */
+    mode?: 'inject' | 'attach';
+};
+/**
+ * A declarative helper that makes the material of its parent `mesh` participate in
+ * the {@link OITRenderPass} pipeline, so transparent inline materials are resolved
+ * order-independently instead of being treated as opaque occluders.
+ *
+ * Drop it in as a sibling of the material, inside the `mesh`:
+ *
+ * ```tsx
+ * <mesh geometry={geometry}>
+ *   <shaderMaterial
+ *     uniforms={uniforms}
+ *     vertexShader={vertexShader}
+ *     fragmentShader={fragmentShader}
+ *     transparent
+ *   />
+ *   <OitMaterial side={DoubleSide} />
+ * </mesh>
+ * ```
+ *
+ * It renders an invisible, empty `object3D` purely to locate the parent mesh; the
+ * wiring is idempotent and a no-op outside the OIT pipeline.
+ *
+ * @group Rendering
+ * @see {@link makeOitCompatible}
+ * @see {@link attachOitVariants}
+ */
+export declare function OitMaterial({ side, shareUniforms, syncProperties, mode, }: OitMaterialProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/rendering/Pass.d.ts

@@ -0,0 +1,7 @@
+import { WebGLRenderer, WebGLRenderTarget } from 'three';
+export declare abstract class Pass {
+    writeToScreen: boolean;
+    setSize?(width: number, height: number, pixelRatio: number): void;
+    dispose?(): void;
+    abstract render(renderer: WebGLRenderer, buffer: WebGLRenderTarget): void;
+}

package/dist/types/rendering/RenderingPipeline.d.ts

@@ -0,0 +1,37 @@
+import { Pass } from './Pass';
+/**
+ * Props for the {@link RenderingPipeline} component.
+ * @expand
+ */
+export type RenderingPipelineProps = {
+    /** Ordered list of passes to execute every frame. */
+    passes: Pass[];
+    /** Multisample count for the main render target. Defaults to 0. */
+    samples?: number;
+    /** Render target supersampling factor. Defaults to 1. */
+    supersample?: number;
+    /** Frame priority (passed to `useFrame`). Defaults to 1. */
+    priority?: number;
+};
+/**
+ * Generic render pipeline component that runs an ordered list of {@link Pass} objects
+ * against a shared `WebGLRenderTarget` (color + depth texture). Use it to compose
+ * custom rendering pipelines — e.g. a {@link OITRenderPass} based pipeline for
+ * order-independent transparency.
+ *
+ * @example
+ * ```tsx
+ * const passes = useMemo(
+ *   () => [new OITRenderPass(scene, camera), new OutputPass()],
+ *   [scene, camera],
+ * );
+ * return <RenderingPipeline passes={passes} />;
+ * ```
+ *
+ * @group Components
+ * @category Rendering
+ * @see {@link Pass}
+ * @see {@link OITRenderPass}
+ * @see {@link OutputPass}
+ */
+export declare const RenderingPipeline: ({ passes, samples, supersample, priority, }: RenderingPipelineProps) => null;

package/dist/types/rendering/fullscreen-renderer.d.ts

@@ -4,6 +4,7 @@ export declare class FullscreenRenderer {
     mesh: Mesh;
     copyMaterial: RawShaderMaterial;
     constructor();
+    dispose(): void;
     renderMaterial(renderer: WebGLRenderer, buffer: WebGLRenderTarget | null, material: Material): void;
     renderTexture(renderer: WebGLRenderer, buffer: WebGLRenderTarget | null, texture: Texture, opacity?: number): void;
 }