@speridlabs/visus 1.0.4 → 2.0.1

package/dist/main.es.js

@@ -1,14 +1,14 @@
-var lt = Object.defineProperty;
-var ht = (I, t, s) => t in I ? lt(I, t, { enumerable: !0, configurable: !0, writable: !0, value: s }) : I[t] = s;
-var c = (I, t, s) => ht(I, typeof t != "symbol" ? t + "" : t, s);
-import * as n from "three";
-class et {
+var pt = Object.defineProperty;
+var ft = (k, t, o) => t in k ? pt(k, t, { enumerable: !0, configurable: !0, writable: !0, value: o }) : k[t] = o;
+var h = (k, t, o) => ft(k, typeof t != "symbol" ? t + "" : t, o);
+import * as a from "three";
+class ct {
   constructor() {
-    c(this, "min", new n.Vector3(1 / 0, 1 / 0, 1 / 0));
-    c(this, "max", new n.Vector3(-1 / 0, -1 / 0, -1 / 0));
-    c(this, "center", new n.Vector3());
+    h(this, "min", new a.Vector3(1 / 0, 1 / 0, 1 / 0));
+    h(this, "max", new a.Vector3(-1 / 0, -1 / 0, -1 / 0));
+    h(this, "center", new a.Vector3());
     /** Half extents (size/2) */
-    c(this, "halfExtents", new n.Vector3());
+    h(this, "halfExtents", new a.Vector3());
   }
   /**
    * Reset the bounding box to its initial state
@@ -49,32 +49,31 @@ class et {
    * @returns THREE.Box3 representation
    */
   toBox3() {
-    return new n.Box3().set(this.min, this.max);
+    return new a.Box3().set(this.min, this.max);
   }
   /**
    * Create a clone of this bounding box
    * @returns New bounding box with the same values
    */
   clone() {
-    const t = new et();
+    const t = new ct();
     return t.min.copy(this.min), t.max.copy(this.max), t.center.copy(this.center), t.halfExtents.copy(this.halfExtents), t;
   }
 }
-class ut {
+class mt {
   // TODO: there is no sh spherical harmonics
   constructor(t = 0) {
-    c(this, "numSplats", 0);
-    c(this, "positions");
-    c(this, "rotations");
-    c(this, "scales");
-    c(this, "colors");
-    c(this, "opacities");
-    c(this, "centers");
-    c(this, "boundingBox", new et());
+    h(this, "numSplats", 0);
+    h(this, "positions");
+    h(this, "rotations");
+    h(this, "scales");
+    h(this, "colors");
+    h(this, "opacities");
+    h(this, "boundingBox", new ct());
     this.numSplats = t, this.allocateBuffers(t);
   }
   allocateBuffers(t) {
-    this.positions = new Float32Array(t * 3), this.rotations = new Float32Array(t * 4), this.scales = new Float32Array(t * 3), this.colors = new Float32Array(t * 3), this.opacities = new Float32Array(t), this.centers = new Float32Array(t * 3);
+    this.positions = new Float32Array(t * 3), this.rotations = new Float32Array(t * 4), this.scales = new Float32Array(t * 3), this.colors = new Float32Array(t * 3), this.opacities = new Float32Array(t);
   }
   /**
    * Set data for a specific splat
@@ -85,13 +84,13 @@ class ut {
    * @param color Color
    * @param opacity Opacity value
    */
-  setSplat(t, s, e, r, o, i) {
+  setSplat(t, o, e, s, r, n) {
     if (t >= this.numSplats)
       throw new Error(
         `Splat index out of bounds: ${t} >= ${this.numSplats}`
       );
-    const a = t * 3, d = t * 4, f = t * 3, v = t * 3;
-    this.positions[a] = s.x, this.positions[a + 1] = s.y, this.positions[a + 2] = s.z, this.rotations[d] = e.x, this.rotations[d + 1] = e.y, this.rotations[d + 2] = e.z, this.rotations[d + 3] = e.w, this.scales[f] = r.x, this.scales[f + 1] = r.y, this.scales[f + 2] = r.z, this.colors[v] = o.r, this.colors[v + 1] = o.g, this.colors[v + 2] = o.b, this.opacities[t] = i, this.centers[a] = s.x, this.centers[a + 1] = s.y, this.centers[a + 2] = s.z;
+    const i = t * 3, l = t * 4, x = t * 3, b = t * 3;
+    this.positions[i] = o.x, this.positions[i + 1] = o.y, this.positions[i + 2] = o.z, this.rotations[l] = e.x, this.rotations[l + 1] = e.y, this.rotations[l + 2] = e.z, this.rotations[l + 3] = e.w, this.scales[x] = s.x, this.scales[x + 1] = s.y, this.scales[x + 2] = s.z, this.colors[b] = r.r, this.colors[b + 1] = r.g, this.colors[b + 2] = r.b, this.opacities[t] = n;
   }
   /**
    * Get a splat's data
@@ -103,29 +102,29 @@ class ut {
       throw new Error(
         `Splat index out of bounds: ${t} >= ${this.numSplats}`
       );
-    const s = t * 3, e = t * 4, r = t * 3, o = t * 3;
+    const o = t * 3, e = t * 4, s = t * 3, r = t * 3;
     return {
-      position: new n.Vector3(
-        this.positions[s],
-        this.positions[s + 1],
-        this.positions[s + 2]
+      position: new a.Vector3(
+        this.positions[o],
+        this.positions[o + 1],
+        this.positions[o + 2]
       ),
-      rotation: new n.Quaternion(
+      rotation: new a.Quaternion(
         this.rotations[e],
         this.rotations[e + 1],
         this.rotations[e + 2],
         this.rotations[e + 3]
       ),
       // Convert log scale back to linear scale for external use
-      scale: new n.Vector3(
-        Math.exp(this.scales[r]),
-        Math.exp(this.scales[r + 1]),
-        Math.exp(this.scales[r + 2])
+      scale: new a.Vector3(
+        Math.exp(this.scales[s]),
+        Math.exp(this.scales[s + 1]),
+        Math.exp(this.scales[s + 2])
       ),
-      color: new n.Color(
-        this.colors[o],
-        this.colors[o + 1],
-        this.colors[o + 2]
+      color: new a.Color(
+        this.colors[r],
+        this.colors[r + 1],
+        this.colors[r + 2]
       ),
       opacity: this.opacities[t]
     };
@@ -136,9 +135,9 @@ class ut {
    */
   calculateBoundingBox() {
     this.boundingBox.reset();
-    const t = new n.Vector3();
-    for (let s = 0; s < this.numSplats; s++) {
-      const e = s * 3;
+    const t = new a.Vector3();
+    for (let o = 0; o < this.numSplats; o++) {
+      const e = o * 3;
       t.set(
         this.positions[e],
         this.positions[e + 1],
@@ -152,99 +151,100 @@ class ut {
    * This is for visualization/debugging purposes only, not for rendering
    */
   createDebugGeometry() {
-    const t = new n.BufferGeometry();
+    const t = new a.BufferGeometry();
     t.setAttribute(
       "position",
-      new n.BufferAttribute(this.positions, 3)
+      new a.BufferAttribute(this.positions, 3)
     );
-    const s = new Float32Array(this.numSplats * 3), e = new n.Quaternion(), r = new n.Euler();
-    for (let o = 0; o < this.numSplats; o++) {
-      const i = o * 4, a = o * 3;
+    const o = new Float32Array(this.numSplats * 3), e = new a.Quaternion(), s = new a.Euler();
+    for (let r = 0; r < this.numSplats; r++) {
+      const n = r * 4, i = r * 3;
       e.set(
-        this.rotations[i],
-        this.rotations[i + 1],
-        this.rotations[i + 2],
-        this.rotations[i + 3]
-      ), r.setFromQuaternion(e), s[a] = r.x, s[a + 1] = r.y, s[a + 2] = r.z;
+        this.rotations[n],
+        this.rotations[n + 1],
+        this.rotations[n + 2],
+        this.rotations[n + 3]
+      ), s.setFromQuaternion(e), o[i] = s.x, o[i + 1] = s.y, o[i + 2] = s.z;
     }
     return t.setAttribute(
       "rotation",
-      new n.BufferAttribute(s, 3)
+      new a.BufferAttribute(o, 3)
     ), t.setAttribute(
       "scale",
-      new n.BufferAttribute(this.scales, 3)
+      new a.BufferAttribute(this.scales, 3)
     ), t.setAttribute(
       "color",
-      new n.BufferAttribute(this.colors, 3)
+      new a.BufferAttribute(this.colors, 3)
     ), t.setAttribute(
       "opacity",
-      new n.BufferAttribute(this.opacities, 1)
+      new a.BufferAttribute(this.opacities, 1)
     ), t;
   }
 }
-class dt extends n.EventDispatcher {
+class xt extends a.EventDispatcher {
   constructor() {
     super();
-    c(this, "worker");
-    c(this, "centers", null);
-    c(this, "orderTexture", null);
+    h(this, "worker");
+    h(this, "centers", null);
+    h(this, "orderTexture", null);
     /** Bounding box data for optimization */
-    c(this, "chunks", null);
-    c(this, "lastCameraPosition", new n.Vector3());
-    c(this, "lastCameraDirection", new n.Vector3());
-    const s = this.createWorkerCode(), e = new Blob([s], { type: "application/javascript" });
+    h(this, "chunks", null);
+    h(this, "lastCameraPosition", new a.Vector3());
+    h(this, "lastCameraDirection", new a.Vector3());
+    const o = this.createWorkerCode(), e = new Blob([o], { type: "application/javascript" });
     this.worker = new Worker(URL.createObjectURL(e)), this.worker.onmessage = this.onWorkerMessage.bind(this);
   }
   /**
    * Handles messages received from the sorting worker.
    * @param event The message event from the worker.
    */
-  onWorkerMessage(s) {
+  onWorkerMessage(o) {
     if (!this.orderTexture || !this.orderTexture.image)
       return console.error("SplatSorter: Order texture not initialized!");
-    const { order: e, count: r } = s.data, o = this.orderTexture.image.data;
-    if (!(o instanceof Uint32Array))
+    const { order: e, count: s } = o.data, r = this.orderTexture.image.data;
+    if (!(r instanceof Uint32Array))
       return console.error(
         "SplatSorter: Order texture data is not a Uint32Array!"
       );
-    o.set(new Uint32Array(e)), this.orderTexture.needsUpdate = !0;
-    const i = o.buffer.slice(0), a = { order: i };
-    this.worker.postMessage(a, [i]), this.dispatchEvent({ type: "updated", count: r });
+    r.set(new Uint32Array(e)), this.orderTexture.needsUpdate = !0;
+    const n = r.buffer.slice(0), i = { order: n };
+    this.worker.postMessage(i, [n]), this.dispatchEvent({ type: "updated", count: s });
   }
   /**
    * Initializes the sorter with necessary data and textures.
    * @param orderTexture The THREE.DataTexture (R32UI) to store the sorted splat indices.
    * @param centers A Float32Array containing the center position (x, y, z) for each splat.
    * @param chunks Optional: A Float32Array containing bounding box chunk data [minX, minY, minZ, maxX, maxY, maxZ, ...] for optimization.
+   * @param transferOwnership Optional: If true, transfers ownership of centers buffer to worker (saves memory, main thread loses access). Default: false.
    */
-  init(s, e, r) {
-    if (!s || !(s.image.data instanceof Uint32Array))
+  init(o, e, s, r = !1) {
+    if (!o || !(o.image.data instanceof Uint32Array))
       throw new Error("SplatSorter: Invalid orderTexture provided. Must be DataTexture with Uint32Array data.");
     if (!e || e.length % 3 !== 0)
       throw new Error("SplatSorter: Invalid centers array provided. Length must be multiple of 3.");
-    if (s.image.data.length < e.length / 3)
+    if (o.image.data.length < e.length / 3)
       throw new Error("SplatSorter: orderTexture data buffer is smaller than the number of splats.");
-    const o = e.length / 3;
-    this.orderTexture = s, this.centers = e.slice();
+    const n = e.length / 3;
+    this.orderTexture = o, r ? this.centers = null : this.centers = e.slice();
     const i = this.orderTexture.image.data;
-    for (let g = 0; g < o; g++) i[g] = g;
+    for (let u = 0; u < n; u++) i[u] = u;
     this.orderTexture.needsUpdate = !0;
-    const a = i.buffer.slice(0), d = this.centers.buffer.slice(0), f = {
-      order: a,
-      centers: d
-    }, v = [
-      a,
-      d
+    const l = i.buffer.slice(0), x = r ? e.buffer : e.buffer.slice(0), b = {
+      order: l,
+      centers: x
+    }, C = [
+      l,
+      x
     ];
-    if (r) {
-      this.chunks = r.slice();
-      const g = this.chunks.buffer.slice(0);
-      f.chunks = g, v.push(g);
+    if (s) {
+      this.chunks = s.slice();
+      const u = this.chunks.buffer.slice(0);
+      b.chunks = u, C.push(u);
     }
-    this.worker.postMessage(f, v), queueMicrotask(() => {
+    this.worker.postMessage(b, C), queueMicrotask(() => {
       this.dispatchEvent({
         type: "updated",
-        count: o
+        count: n
       });
     });
   }
@@ -253,53 +253,53 @@ class dt extends n.EventDispatcher {
    * The sorter will only consider splats whose original indices are present in the mapping.
    * @param mapping A Uint32Array where each element is the *original* index of a splat to include, or null to reset mapping.
    */
-  setMapping(s) {
+  setMapping(o) {
     if (!this.centers)
       return console.warn(
         "SplatSorter: Cannot set mapping before initialization."
       );
     let e;
-    const r = [];
-    if (!s) {
-      const d = this.centers.buffer.slice(0);
+    const s = [];
+    if (!o) {
+      const l = this.centers.buffer.slice(0);
       return e = {
-        centers: d,
+        centers: l,
         mapping: null
-      }, r.push(d), this.worker.postMessage(e, r);
+      }, s.push(l), this.worker.postMessage(e, s);
     }
-    const o = new Float32Array(s.length * 3);
-    for (let d = 0; d < s.length; d++) {
-      const f = s[d];
-      if (f * 3 + 2 >= this.centers.length) {
+    const r = new Float32Array(o.length * 3);
+    for (let l = 0; l < o.length; l++) {
+      const x = o[l];
+      if (x * 3 + 2 >= this.centers.length) {
         console.warn(
-          `SplatSorter: Mapping index ${f} out of bounds.`
+          `SplatSorter: Mapping index ${x} out of bounds.`
         );
         continue;
       }
-      const v = f * 3, g = d * 3;
-      o[g + 0] = this.centers[v + 0], o[g + 1] = this.centers[v + 1], o[g + 2] = this.centers[v + 2];
+      const b = x * 3, C = l * 3;
+      r[C + 0] = this.centers[b + 0], r[C + 1] = this.centers[b + 1], r[C + 2] = this.centers[b + 2];
     }
-    const i = o.buffer.slice(0), a = s.buffer.slice(0);
+    const n = r.buffer.slice(0), i = o.buffer.slice(0);
     e = {
-      centers: i,
-      mapping: a
-    }, r.push(i, a), this.worker.postMessage(e, r);
+      centers: n,
+      mapping: i
+    }, s.push(n, i), this.worker.postMessage(e, s);
   }
   /**
    * Updates the camera parameters used for sorting.
    * @param position The camera's position in the sorter's local coordinate space.
    * @param direction The camera's forward direction in the sorter's local coordinate space.
    */
-  setCamera(s, e) {
-    const r = this.lastCameraPosition.distanceToSquared(s) > 1e-7, o = this.lastCameraDirection.dot(e) < 0.9999;
-    if (!r && !o)
+  setCamera(o, e) {
+    const s = this.lastCameraPosition.distanceToSquared(o) > 1e-7, r = this.lastCameraDirection.dot(e) < 0.9999;
+    if (!s && !r)
       return;
-    this.lastCameraPosition.copy(s), this.lastCameraDirection.copy(e);
-    const i = {
-      cameraPosition: { x: s.x, y: s.y, z: s.z },
+    this.lastCameraPosition.copy(o), this.lastCameraDirection.copy(e);
+    const n = {
+      cameraPosition: { x: o.x, y: o.y, z: o.z },
       cameraDirection: { x: e.x, y: e.y, z: e.z }
     };
-    this.worker.postMessage(i);
+    this.worker.postMessage(n);
   }
   /**
    * Terminates the Web Worker and cleans up resources.
@@ -313,165 +313,165 @@ class dt extends n.EventDispatcher {
    */
   createWorkerCode() {
     return `(${(function() {
-      let e = null, r = null, o = null, i = null, a = null, d = null, f = !1;
-      const v = { x: 0, y: 0, z: 0 }, g = { x: 0, y: 0, z: 0 }, p = { x: 0, y: 0, z: 0 }, h = { x: 0, y: 0, z: 0 };
-      let l = null, b = null;
-      const _ = 32, O = new Array(_).fill(0), q = new Array(_).fill(0), E = new Array(_).fill(0), R = (k, S, F) => {
-        for (; k <= S; ) {
-          const M = S + k >> 1, m = F(M);
-          if (m > 0) k = M + 1;
-          else if (m < 0) S = M - 1;
+      let e = null, s = null, r = null, n = null, i = null, l = null, x = !1;
+      const b = { x: 0, y: 0, z: 0 }, C = { x: 0, y: 0, z: 0 }, u = { x: 0, y: 0, z: 0 }, g = { x: 0, y: 0, z: 0 };
+      let v = null, S = null;
+      const I = 32, R = new Array(I).fill(0), Y = new Array(I).fill(0), W = new Array(I).fill(0), ot = (w, d, P) => {
+        for (; w <= d; ) {
+          const M = d + w >> 1, f = P(M);
+          if (f > 0) w = M + 1;
+          else if (f < 0) d = M - 1;
           else return M;
         }
-        return ~k;
-      }, W = () => {
-        if (!e || !r || !a || !d)
+        return ~w;
+      }, L = () => {
+        if (!e || !s || !i || !l)
           return;
-        if (r.length === 0) {
-          const y = {
+        if (s.length === 0) {
+          const c = {
             order: e.buffer,
             count: 0
           };
-          self.postMessage(y, [e.buffer]), e = null;
+          self.postMessage(c, [e.buffer]), e = null;
           return;
         }
-        const k = a.x, S = a.y, F = a.z, M = d.x, m = d.y, C = d.z, V = 1e-4, P = Math.abs(k - v.x) > V || Math.abs(S - v.y) > V || Math.abs(F - v.z) > V, x = Math.abs(M - g.x) > V || Math.abs(m - g.y) > V || Math.abs(C - g.z) > V;
-        if (!f && !P && !x)
+        const w = i.x, d = i.y, P = i.z, M = l.x, f = l.y, A = l.z, T = 1e-4, j = Math.abs(w - b.x) > T || Math.abs(d - b.y) > T || Math.abs(P - b.z) > T, J = Math.abs(M - C.x) > T || Math.abs(f - C.y) > T || Math.abs(A - C.z) > T;
+        if (!x && !j && !J)
           return;
-        f = !1, v.x = k, v.y = S, v.z = F, g.x = M, g.y = m, g.z = C;
-        let u = 1 / 0, z = -1 / 0;
-        for (let y = 0; y < 8; ++y) {
-          const B = y & 1 ? p.x : h.x, U = y & 2 ? p.y : h.y, w = y & 4 ? p.z : h.z, D = B * M + U * m + w * C;
-          u = Math.min(u, D), z = Math.max(z, D);
+        x = !1, b.x = w, b.y = d, b.z = P, C.x = M, C.y = f, C.z = A;
+        let $ = 1 / 0, D = -1 / 0;
+        for (let c = 0; c < 8; ++c) {
+          const y = c & 1 ? u.x : g.x, B = c & 2 ? u.y : g.y, m = c & 4 ? u.z : g.z, z = y * M + B * f + m * A;
+          $ = Math.min($, z), D = Math.max(D, z);
         }
-        const T = r.length / 3, L = z - u, A = (1 << Math.max(
+        const _ = s.length / 3, N = D - $, E = (1 << Math.max(
           10,
-          Math.min(20, Math.ceil(Math.log2(T / 4)))
+          Math.min(20, Math.ceil(Math.log2(_ / 4)))
         )) + 1;
-        if ((!l || l.length !== T) && (l = new Uint32Array(T)), !b || b.length !== A ? b = new Uint32Array(A) : b.fill(0), L < 1e-7) {
-          for (let y = 0; y < T; ++y) l[y] = 0;
-          b[0] = T;
-        } else if (o && o.length > 0) {
-          const y = o.length / 6;
-          O.fill(0);
-          for (let w = 0; w < y; ++w) {
-            const D = w * 6, X = o[D + 0], Z = o[D + 1], $ = o[D + 2], H = o[D + 3], Y = X * M + Z * m + $ * C - u, J = Y - H, G = Y + H, Q = Math.max(
+        if ((!v || v.length !== _) && (v = new Uint32Array(_)), !S || S.length !== E ? S = new Uint32Array(E) : S.fill(0), N < 1e-7) {
+          for (let c = 0; c < _; ++c) v[c] = 0;
+          S[0] = _;
+        } else if (r && r.length > 0) {
+          const c = r.length / 6;
+          R.fill(0);
+          for (let m = 0; m < c; ++m) {
+            const z = m * 6, U = r[z + 0], V = r[z + 1], O = r[z + 2], F = r[z + 3], q = U * M + V * f + O * A - $, X = q - F, Z = q + F, K = Math.max(
               0,
-              Math.floor(J * _ / L)
-            ), tt = Math.min(
-              _,
-              Math.ceil(G * _ / L)
+              Math.floor(X * I / N)
+            ), Q = Math.min(
+              I,
+              Math.ceil(Z * I / N)
             );
-            for (let N = Q; N < tt; ++N)
-              O[N]++;
+            for (let H = K; H < Q; ++H)
+              R[H]++;
           }
-          let B = 0;
-          for (let w = 0; w < _; ++w) B += O[w];
-          E[0] = 0, q[0] = 0;
-          for (let w = 1; w < _; ++w)
-            E[w - 1] = O[w - 1] / B * A >>> 0, q[w] = q[w - 1] + E[w - 1];
-          E[_ - 1] = O[_ - 1] / B * A >>> 0;
-          const U = L / _;
-          for (let w = 0; w < T; ++w) {
-            const D = w * 3, X = r[D + 0], Z = r[D + 1], $ = r[D + 2], H = X * M + Z * m + $ * C, J = (z - H) / U, G = Math.max(
+          let y = 0;
+          for (let m = 0; m < I; ++m) y += R[m];
+          W[0] = 0, Y[0] = 0;
+          for (let m = 1; m < I; ++m)
+            W[m - 1] = R[m - 1] / y * E >>> 0, Y[m] = Y[m - 1] + W[m - 1];
+          W[I - 1] = R[I - 1] / y * E >>> 0;
+          const B = N / I;
+          for (let m = 0; m < _; ++m) {
+            const z = m * 3, U = s[z + 0], V = s[z + 1], O = s[z + 2], F = U * M + V * f + O * A, X = (D - F) / B, Z = Math.max(
               0,
               Math.min(
-                _ - 1,
-                Math.floor(J)
+                I - 1,
+                Math.floor(X)
               )
-            ), Q = J - G, tt = q[G] + E[G] * Q >>> 0, N = Math.min(tt, A - 1);
-            l[w] = N, b[N]++;
+            ), K = X - Z, Q = Y[Z] + W[Z] * K >>> 0, H = Math.min(Q, E - 1);
+            v[m] = H, S[H]++;
           }
         } else {
-          const y = (A - 1) / L;
-          for (let B = 0; B < T; ++B) {
-            const U = B * 3, w = r[U + 0], D = r[U + 1], X = r[U + 2], Z = w * M + D * m + X * C, H = (z - Z) * y >>> 0, Y = Math.min(H, A - 1);
-            l[B] = Y, b[Y]++;
+          const c = (E - 1) / N;
+          for (let y = 0; y < _; ++y) {
+            const B = y * 3, m = s[B + 0], z = s[B + 1], U = s[B + 2], V = m * M + z * f + U * A, F = (D - V) * c >>> 0, q = Math.min(F, E - 1);
+            v[y] = q, S[q]++;
           }
         }
-        for (let y = 1; y < A; y++)
-          b[y] += b[y - 1];
-        for (let y = T - 1; y >= 0; y--) {
-          const B = l[y], U = --b[B];
-          e[U] = i ? i[y] : y;
+        for (let c = 1; c < E; c++)
+          S[c] += S[c - 1];
+        for (let c = _ - 1; c >= 0; c--) {
+          const y = v[c], B = --S[y];
+          e[B] = n ? n[c] : c;
         }
-        const at = k * M + S * m + F * C, rt = (y) => {
+        const st = w * M + d * f + P * A, tt = (c) => {
           if (!e) return -1 / 0;
-          const B = e[y], U = B;
-          if (!r || U * 3 + 2 >= r.length)
+          const y = e[c], B = y;
+          if (!s || B * 3 + 2 >= s.length)
             return -1 / 0;
-          const w = U * 3;
-          return r[w] * M + r[w + 1] * m + r[w + 2] * C - at;
+          const m = B * 3;
+          return s[m] * M + s[m + 1] * f + s[m + 2] * A - st;
         };
-        let st = T;
-        if (T > 0 && rt(T - 1) < 0) {
-          const y = R(
+        let et = _;
+        if (_ > 0 && tt(_ - 1) < 0) {
+          const c = ot(
             0,
-            T - 1,
-            rt
+            _ - 1,
+            tt
           );
-          st = y < 0 ? ~y : y;
+          et = c < 0 ? ~c : c;
         }
-        const ct = {
+        const p = {
           order: e.buffer,
-          count: st
+          count: et
         };
-        self.postMessage(ct, [e.buffer]), e = null;
+        self.postMessage(p, [e.buffer]), e = null;
       };
-      self.onmessage = (k) => {
-        const S = k.data;
-        S.order && (e = new Uint32Array(S.order));
-        let F = !1;
-        if (S.centers && (r = new Float32Array(S.centers), F = !0, f = !0), Object.prototype.hasOwnProperty.call(S, "mapping") && (i = S.mapping ? new Uint32Array(S.mapping) : null, f = !0), S.chunks) {
-          if (o = new Float32Array(S.chunks), o.length > 0 && o[3] > 0)
-            for (let M = 0; M < o.length / 6; ++M) {
-              const m = M * 6, C = o[m + 0], V = o[m + 1], P = o[m + 2], x = o[m + 3], u = o[m + 4], z = o[m + 5];
-              o[m + 0] = (C + x) * 0.5, o[m + 1] = (V + u) * 0.5, o[m + 2] = (P + z) * 0.5, o[m + 3] = Math.sqrt(
-                (x - C) ** 2 + (u - V) ** 2 + (z - P) ** 2
+      self.onmessage = (w) => {
+        const d = w.data;
+        d.order && (e = new Uint32Array(d.order));
+        let P = !1;
+        if (d.centers && (s = new Float32Array(d.centers), P = !0, x = !0), Object.prototype.hasOwnProperty.call(d, "mapping") && (n = d.mapping ? new Uint32Array(d.mapping) : null, x = !0), d.chunks) {
+          if (r = new Float32Array(d.chunks), r.length > 0 && r[3] > 0)
+            for (let M = 0; M < r.length / 6; ++M) {
+              const f = M * 6, A = r[f + 0], T = r[f + 1], j = r[f + 2], J = r[f + 3], $ = r[f + 4], D = r[f + 5];
+              r[f + 0] = (A + J) * 0.5, r[f + 1] = (T + $) * 0.5, r[f + 2] = (j + D) * 0.5, r[f + 3] = Math.sqrt(
+                (J - A) ** 2 + ($ - T) ** 2 + (D - j) ** 2
               ) * 0.5;
             }
-          f = !0;
+          x = !0;
         }
-        if (F && r && r.length > 0) {
-          p.x = h.x = r[0], p.y = h.y = r[1], p.z = h.z = r[2];
-          for (let M = 1; M < r.length / 3; M++) {
-            const m = M * 3;
-            p.x = Math.min(p.x, r[m + 0]), h.x = Math.max(h.x, r[m + 0]), p.y = Math.min(p.y, r[m + 1]), h.y = Math.max(h.y, r[m + 1]), p.z = Math.min(p.z, r[m + 2]), h.z = Math.max(h.z, r[m + 2]);
+        if (P && s && s.length > 0) {
+          u.x = g.x = s[0], u.y = g.y = s[1], u.z = g.z = s[2];
+          for (let M = 1; M < s.length / 3; M++) {
+            const f = M * 3;
+            u.x = Math.min(u.x, s[f + 0]), g.x = Math.max(g.x, s[f + 0]), u.y = Math.min(u.y, s[f + 1]), g.y = Math.max(g.y, s[f + 1]), u.z = Math.min(u.z, s[f + 2]), g.z = Math.max(g.z, s[f + 2]);
           }
-        } else F && r && r.length === 0 && (p.x = h.x = p.y = h.y = p.z = h.z = 0);
-        S.cameraPosition && (a = S.cameraPosition), S.cameraDirection && (d = S.cameraDirection), W();
+        } else P && s && s.length === 0 && (u.x = g.x = u.y = g.y = u.z = g.z = 0);
+        d.cameraPosition && (i = d.cameraPosition), d.cameraDirection && (l = d.cameraDirection), L();
       };
     }).toString()})();`;
   }
 }
-const pt = (I, t) => {
-  const s = ot(I), e = ot(t);
-  return s | e << 16;
+const yt = (k, t) => {
+  const o = ht(k), e = ht(t);
+  return o | e << 16;
 };
-function ot(I) {
-  const t = new Float32Array([I]), e = new Int32Array(t.buffer)[0];
-  let r = e >> 16 & 32768, o = e >> 12 & 2047;
-  const i = e >> 23 & 255;
-  return i < 103 ? r : i > 142 ? (r |= 31744, r |= (i === 255 ? 0 : 1) && e & 8388607, r) : i < 113 ? (o |= 2048, r |= (o >> 114 - i) + (o >> 113 - i & 1), r) : (r |= i - 112 << 10 | o >> 1, r += o & 1, r);
+function ht(k) {
+  const t = new Float32Array([k]), e = new Int32Array(t.buffer)[0];
+  let s = e >> 16 & 32768, r = e >> 12 & 2047;
+  const n = e >> 23 & 255;
+  return n < 103 ? s : n > 142 ? (s |= 31744, s |= (n === 255 ? 0 : 1) && e & 8388607, s) : n < 113 ? (r |= 2048, s |= (r >> 114 - n) + (r >> 113 - n & 1), s) : (s |= n - 112 << 10 | r >> 1, s += r & 1, s);
 }
-const ft = new ArrayBuffer(4), nt = new DataView(ft), mt = (I) => (nt.setUint32(0, I, !0), nt.getFloat32(0, !0));
-class xt {
+const gt = new ArrayBuffer(4), ut = new DataView(gt), vt = (k) => (ut.setUint32(0, k, !0), ut.getFloat32(0, !0));
+class wt {
   /**
    * Create a new TextureManager for a set of splats
    * @param splatData The splat data to manage textures for
    */
   constructor(t) {
-    c(this, "transformA");
+    h(this, "transformA");
     // position xyz and rotation quaternion y,z components
-    c(this, "transformB");
+    h(this, "transformB");
     // rotation quaternion x and scale xyz
-    c(this, "colorTexture");
+    h(this, "colorTexture");
     // color an opacity
-    c(this, "orderTexture");
-    c(this, "textureWidth");
-    c(this, "textureHeight");
-    const s = t.numSplats;
-    this.textureWidth = Math.ceil(Math.sqrt(s)), this.textureHeight = Math.ceil(s / this.textureWidth), this.transformA = this.createTransformATexture(t), this.transformB = this.createTransformBTexture(t), this.colorTexture = this.createColorTexture(t), this.orderTexture = this.createOrderTexture(s);
+    h(this, "orderTexture");
+    h(this, "textureWidth");
+    h(this, "textureHeight");
+    const o = t.numSplats;
+    this.textureWidth = Math.ceil(Math.sqrt(o)), this.textureHeight = Math.ceil(o / this.textureWidth), this.transformA = this.createTransformATexture(t), this.transformB = this.createTransformBTexture(t), this.colorTexture = this.createColorTexture(t), this.orderTexture = this.createOrderTexture(o);
   }
   /**
    * Create the transform A texture (positions and quaternion w component)
@@ -479,24 +479,24 @@ class xt {
    * @returns DataTexture containing position data
    */
   createTransformATexture(t) {
-    const s = t.numSplats, e = new Float32Array(
+    const o = t.numSplats, e = new Float32Array(
       this.textureWidth * this.textureHeight * 4
     );
-    for (let o = 0; o < s; o++) {
-      const i = o * 4, a = o * 3, d = o * 4;
-      e[i] = t.positions[a], e[i + 1] = t.positions[a + 1], e[i + 2] = t.positions[a + 2];
-      const f = t.rotations[d + 0], v = t.rotations[d + 1], g = pt(f, v);
-      e[i + 3] = mt(g);
+    for (let r = 0; r < o; r++) {
+      const n = r * 4, i = r * 3, l = r * 4;
+      e[n] = t.positions[i], e[n + 1] = t.positions[i + 1], e[n + 2] = t.positions[i + 2];
+      const x = t.rotations[l + 0], b = t.rotations[l + 1], C = yt(x, b);
+      e[n + 3] = vt(C);
     }
-    const r = new n.DataTexture(
+    const s = new a.DataTexture(
       e,
       this.textureWidth,
       this.textureHeight,
-      n.RGBAFormat,
-      n.FloatType
+      a.RGBAFormat,
+      a.FloatType
       // Store as Float32, shader will reinterpret bits
     );
-    return r.needsUpdate = !0, r.magFilter = n.NearestFilter, r.minFilter = n.NearestFilter, r;
+    return s.needsUpdate = !0, s.magFilter = a.NearestFilter, s.minFilter = a.NearestFilter, s;
   }
   /**
    * Create the transform B texture (scale and rotation xyz)
@@ -504,21 +504,21 @@ class xt {
    * @returns DataTexture containing scale and rotation data
    */
   createTransformBTexture(t) {
-    const s = t.numSplats, e = new Float32Array(
+    const o = t.numSplats, e = new Float32Array(
       this.textureWidth * this.textureHeight * 4
     );
-    for (let o = 0; o < s; o++) {
-      const i = o * 4, a = o * 3, d = o * 4;
-      e[i] = t.scales[a], e[i + 1] = t.scales[a + 1], e[i + 2] = t.scales[a + 2], e[i + 3] = t.rotations[d + 2];
+    for (let r = 0; r < o; r++) {
+      const n = r * 4, i = r * 3, l = r * 4;
+      e[n] = t.scales[i], e[n + 1] = t.scales[i + 1], e[n + 2] = t.scales[i + 2], e[n + 3] = t.rotations[l + 2];
     }
-    const r = new n.DataTexture(
+    const s = new a.DataTexture(
       e,
       this.textureWidth,
       this.textureHeight,
-      n.RGBAFormat,
-      n.FloatType
+      a.RGBAFormat,
+      a.FloatType
     );
-    return r.needsUpdate = !0, r.magFilter = n.NearestFilter, r.minFilter = n.NearestFilter, r;
+    return s.needsUpdate = !0, s.magFilter = a.NearestFilter, s.minFilter = a.NearestFilter, s;
   }
   /**
    * Create the color texture (RGB and opacity)
@@ -526,21 +526,21 @@ class xt {
    * @returns DataTexture containing color data
    */
   createColorTexture(t) {
-    const s = t.numSplats, e = new Float32Array(
+    const o = t.numSplats, e = new Float32Array(
       this.textureWidth * this.textureHeight * 4
     );
-    for (let o = 0; o < s; o++) {
-      const i = o * 4, a = o * 3;
-      e[i] = t.colors[a], e[i + 1] = t.colors[a + 1], e[i + 2] = t.colors[a + 2], e[i + 3] = t.opacities[o];
+    for (let r = 0; r < o; r++) {
+      const n = r * 4, i = r * 3;
+      e[n] = t.colors[i], e[n + 1] = t.colors[i + 1], e[n + 2] = t.colors[i + 2], e[n + 3] = t.opacities[r];
     }
-    const r = new n.DataTexture(
+    const s = new a.DataTexture(
       e,
       this.textureWidth,
       this.textureHeight,
-      n.RGBAFormat,
-      n.FloatType
+      a.RGBAFormat,
+      a.FloatType
     );
-    return r.needsUpdate = !0, r;
+    return s.needsUpdate = !0, s;
   }
   /**
    * Create the order texture for sorting
@@ -548,15 +548,15 @@ class xt {
    * @returns DataTexture for storing order indices
    */
   createOrderTexture(t) {
-    const s = new Uint32Array(this.textureWidth * this.textureHeight);
-    for (let r = 0; r < t; r++)
-      s[r] = r;
-    const e = new n.DataTexture(
-      s,
+    const o = new Uint32Array(this.textureWidth * this.textureHeight);
+    for (let s = 0; s < t; s++)
+      o[s] = s;
+    const e = new a.DataTexture(
+      o,
       this.textureWidth,
       this.textureHeight,
-      n.RedIntegerFormat,
-      n.UnsignedIntType
+      a.RedIntegerFormat,
+      a.UnsignedIntType
     );
     return e.needsUpdate = !0, e;
   }
@@ -564,7 +564,7 @@ class xt {
     this.transformA.dispose(), this.transformB.dispose(), this.colorTexture.dispose(), this.orderTexture.dispose();
   }
 }
-const yt = (
+const bt = (
   /* glsl */
   `
 precision highp float;
@@ -822,7 +822,7 @@ void main(void) {
     vUv = clippedCornerOffset;
 }
 `
-), gt = (
+), Mt = (
   /* glsl */
   `
 precision highp float;
@@ -856,56 +856,56 @@ void main(void) {
 }
 `
 );
-class vt extends n.ShaderMaterial {
+class Ct extends a.ShaderMaterial {
   constructor(t = {}) {
-    const s = {
+    const o = {
       // Textures (values set via methods)
       transformA: { value: null },
       transformB: { value: null },
       splatColor: { value: null },
       splatOrder: { value: null },
       // Other uniforms
-      viewport: { value: new n.Vector2(1, 1) },
+      viewport: { value: new a.Vector2(1, 1) },
       // Will be updated
       numSplats: { value: 0 }
       // Max splats to render (updated by sorter)
     };
     super({
-      vertexShader: yt,
-      fragmentShader: gt,
-      uniforms: s,
+      vertexShader: bt,
+      fragmentShader: Mt,
+      uniforms: o,
       transparent: !0,
-      blending: n.CustomBlending,
+      blending: a.CustomBlending,
       // Premultiplied alpha blending:
       // color = src_color * src_alpha + dst_color * (1 - src_alpha)
       // alpha = src_alpha * 1 + dst_alpha * (1 - src_alpha)
-      blendSrc: n.OneFactor,
+      blendSrc: a.OneFactor,
       // Using ONE because shader outputs premultiplied color (color * alpha)
-      blendDst: n.OneMinusSrcAlphaFactor,
-      blendSrcAlpha: n.OneFactor,
+      blendDst: a.OneMinusSrcAlphaFactor,
+      blendSrcAlpha: a.OneFactor,
       // source alpha comes from shader
-      blendDstAlpha: n.OneMinusSrcAlphaFactor,
-      blendEquation: n.AddEquation,
-      blendEquationAlpha: n.AddEquation,
+      blendDstAlpha: a.OneMinusSrcAlphaFactor,
+      blendEquation: a.AddEquation,
+      blendEquationAlpha: a.AddEquation,
       depthTest: !0,
       depthWrite: !1,
       // Disable depth write for transparency
-      side: n.DoubleSide,
+      side: a.DoubleSide,
       // Render both sides (or CULLFACE_NONE equivalent)
       // Optional settings from constructor
       alphaTest: t.alphaTest !== void 0 ? t.alphaTest : 0,
       // Typically 0 for blending
       toneMapped: t.toneMapped !== void 0 ? t.toneMapped : !1
       // prettier-ignore
-    }), t.alphaHash && (this.alphaHash = !0, this.depthWrite = !0, this.blending = n.NoBlending);
+    }), t.alphaHash && (this.alphaHash = !0, this.depthWrite = !0, this.blending = a.NoBlending);
   }
   /**
    * Update the viewport size
    * @param width Viewport width
    * @param height Viewport height
    */
-  updateViewport(t, s) {
-    this.uniforms.viewport.value.set(t, s);
+  updateViewport(t, o) {
+    this.uniforms.viewport.value.set(t, o);
   }
   /**
    * Set transform texture A (positions)
@@ -943,47 +943,48 @@ class vt extends n.ShaderMaterial {
     this.uniforms.numSplats.value = t;
   }
 }
-const j = class j extends n.Mesh {
+const rt = class rt extends a.Mesh {
   // Match shader constant
   /**
    * Create a new SplatMesh for rendering Gaussian splats
    * @param splatData The splat data to render
    * @param options Rendering options
    */
-  constructor(s, e = {}) {
-    const r = new vt(e), o = j.createInstancedGeometry(s.numSplats, j.INSTANCE_SIZE);
-    super(o, r);
-    c(this, "sorter");
-    c(this, "splatData");
-    c(this, "options");
-    c(this, "textureManager");
-    c(this, "material");
-    c(this, "geometry");
-    c(this, "lastCameraPositionLocal", new n.Vector3());
-    c(this, "lastCameraDirectionLocal", new n.Vector3());
-    c(this, "invModelMatrix", new n.Matrix4());
+  constructor(o, e = {}) {
+    const s = new Ct(e), r = rt.createInstancedGeometry(o.numSplats, rt.INSTANCE_SIZE);
+    super(r, s);
+    h(this, "sorter");
+    h(this, "splatData");
+    h(this, "options");
+    h(this, "textureManager");
+    h(this, "material");
+    h(this, "geometry");
+    h(this, "lastCameraPositionLocal", new a.Vector3());
+    h(this, "lastCameraDirectionLocal", new a.Vector3());
+    h(this, "invModelMatrix", new a.Matrix4());
     // Cached inverse matrix
-    c(this, "_vpW", -1);
-    c(this, "_vpH", -1);
-    c(this, "_size", new n.Vector2());
-    c(this, "_camPosW", new n.Vector3());
-    c(this, "_camDirW", new n.Vector3());
-    c(this, "_camPosL", new n.Vector3());
-    c(this, "_camDirL", new n.Vector3());
-    c(this, "onSorterUpdated", (s) => {
-      const e = s.count;
-      this.geometry.instanceCount = Math.ceil(e / j.INSTANCE_SIZE), this.material.setNumSplats(e);
+    h(this, "_vpW", -1);
+    h(this, "_vpH", -1);
+    h(this, "_size", new a.Vector2());
+    h(this, "_camPosW", new a.Vector3());
+    h(this, "_camDirW", new a.Vector3());
+    h(this, "_camPosL", new a.Vector3());
+    h(this, "_camDirL", new a.Vector3());
+    h(this, "onSorterUpdated", (o) => {
+      const e = o.count;
+      this.geometry.instanceCount = Math.ceil(e / rt.INSTANCE_SIZE), this.material.setNumSplats(e);
     });
-    this.geometry = o, this.material = r, this.splatData = s, this.frustumCulled = !1, this.options = {
+    this.geometry = r, this.material = s, this.splatData = o, this.frustumCulled = !1, this.options = {
       autoSort: !0,
       ...e
-    }, this.textureManager = new xt(s), this.sorter = new dt();
-    let i = this.createChunks() || void 0;
-    i === null && console.warn("Visus: Could not create sorter chunks, bounding box might be invalid."), i = void 0, this.sorter.addEventListener("updated", this.onSorterUpdated), this.sorter.init(
+    }, this.textureManager = new wt(o), this.sorter = new xt();
+    let n = this.createChunks() || void 0;
+    n === null && console.warn("Visus: Could not create sorter chunks, bounding box might be invalid."), n = void 0, this.sorter.addEventListener("updated", this.onSorterUpdated), this.sorter.init(
       this.textureManager.orderTexture,
-      this.splatData.centers,
-      i ?? void 0
-    ), this.material.setTransformA(this.textureManager.transformA), this.material.setTransformB(this.textureManager.transformB), this.material.setColorTexture(this.textureManager.colorTexture), this.material.setOrderTexture(this.textureManager.orderTexture), this.material.setNumSplats(0), this.geometry.boundingBox = s.boundingBox.toBox3(), this.geometry.boundingSphere = new n.Sphere(), this.geometry.boundingBox.getBoundingSphere(this.geometry.boundingSphere);
+      this.splatData.positions,
+      n ?? void 0,
+      !this.options.keepSplatData
+    ), this.material.setTransformA(this.textureManager.transformA), this.material.setTransformB(this.textureManager.transformB), this.material.setColorTexture(this.textureManager.colorTexture), this.material.setOrderTexture(this.textureManager.orderTexture), this.material.setNumSplats(0), this.geometry.boundingBox = o.boundingBox.toBox3(), this.geometry.boundingSphere = new a.Sphere(), this.geometry.boundingBox.getBoundingSphere(this.geometry.boundingSphere), this.options.keepSplatData || (this.splatData = null);
   }
   /**
    * Creates the instanced geometry for rendering splats.
@@ -991,8 +992,8 @@ const j = class j extends n.Mesh {
    * @param instanceSize Number of splats per instance.
    * @returns InstancedBufferGeometry
    */
-  static createInstancedGeometry(s, e) {
-    const r = Math.ceil(s / e), o = new n.BufferGeometry(), i = new Float32Array([
+  static createInstancedGeometry(o, e) {
+    const s = Math.ceil(o / e), r = new a.BufferGeometry(), n = new Float32Array([
       // x, y, splat_index_in_instance
       -1,
       -1,
@@ -1006,38 +1007,40 @@ const j = class j extends n.Mesh {
       -1,
       1,
       0
-    ]), a = new Uint16Array([0, 1, 2, 0, 2, 3]), d = new Float32Array(4 * 3 * e);
-    for (let p = 0; p < e; p++) {
-      const h = p * 4 * 3;
-      for (let l = 0; l < 4; l++)
-        d[h + l * 3 + 0] = i[l * 3 + 0], d[h + l * 3 + 1] = i[l * 3 + 1], d[h + l * 3 + 2] = p;
+    ]), i = new Uint16Array([0, 1, 2, 0, 2, 3]), l = new Float32Array(4 * 3 * e);
+    for (let u = 0; u < e; u++) {
+      const g = u * 4 * 3;
+      for (let v = 0; v < 4; v++)
+        l[g + v * 3 + 0] = n[v * 3 + 0], l[g + v * 3 + 1] = n[v * 3 + 1], l[g + v * 3 + 2] = u;
     }
-    const f = new Uint32Array(6 * e);
-    for (let p = 0; p < e; p++) {
-      const h = p * 6, l = p * 4;
-      f[h + 0] = a[0] + l, f[h + 1] = a[1] + l, f[h + 2] = a[2] + l, f[h + 3] = a[3] + l, f[h + 4] = a[4] + l, f[h + 5] = a[5] + l;
+    const x = new Uint32Array(6 * e);
+    for (let u = 0; u < e; u++) {
+      const g = u * 6, v = u * 4;
+      x[g + 0] = i[0] + v, x[g + 1] = i[1] + v, x[g + 2] = i[2] + v, x[g + 3] = i[3] + v, x[g + 4] = i[4] + v, x[g + 5] = i[5] + v;
     }
-    o.setAttribute("position", new n.BufferAttribute(d, 3)), o.setIndex(new n.BufferAttribute(f, 1));
-    const v = new n.InstancedBufferGeometry();
-    v.index = o.index, v.setAttribute("position", o.getAttribute("position"));
-    const g = new Uint32Array(r);
-    for (let p = 0; p < r; p++)
-      g[p] = p * e;
-    return v.setAttribute("splatInstanceIndex", new n.InstancedBufferAttribute(g, 1, !1)), v.instanceCount = 0, v;
+    r.setAttribute("position", new a.BufferAttribute(l, 3)), r.setIndex(new a.BufferAttribute(x, 1));
+    const b = new a.InstancedBufferGeometry();
+    b.index = r.index, b.setAttribute("position", r.getAttribute("position"));
+    const C = new Uint32Array(s);
+    for (let u = 0; u < s; u++)
+      C[u] = u * e;
+    return b.setAttribute("splatInstanceIndex", new a.InstancedBufferAttribute(C, 1, !1)), b.instanceCount = 0, b;
   }
   /**
    * Create chunks data (bounding box min/max) for the sorter.
    * @returns Float32Array containing chunk data [minX, minY, minZ, maxX, maxY, maxZ] or null.
    */
   createChunks() {
-    const s = this.splatData.boundingBox;
-    return s.min.x === 1 / 0 || s.max.x === -1 / 0 ? null : new Float32Array([
-      s.min.x,
-      s.min.y,
-      s.min.z,
-      s.max.x,
-      s.max.y,
-      s.max.z
+    if (!this.splatData)
+      return null;
+    const o = this.splatData.boundingBox;
+    return o.min.x === 1 / 0 || o.max.x === -1 / 0 ? null : new Float32Array([
+      o.min.x,
+      o.min.y,
+      o.min.z,
+      o.max.x,
+      o.max.y,
+      o.max.z
     ]);
   }
   /**
@@ -1045,17 +1048,17 @@ const j = class j extends n.Mesh {
    * @param width Viewport width
    * @param height Viewport height
    */
-  updateViewport(s, e) {
-    s === this._vpW && e === this._vpH || (this._vpW = s, this._vpH = e, this.material.updateViewport(s, e));
+  updateViewport(o, e) {
+    o === this._vpW && e === this._vpH || (this._vpW = o, this._vpH = e, this.material.updateViewport(o, e));
   }
   /**
    * Sorts splats based on camera position and direction.
    * @param camera The camera to sort against.
    */
-  sort(s) {
-    s.getWorldPosition(this._camPosW), s.getWorldDirection(this._camDirW), this.invModelMatrix.copy(this.matrixWorld).invert(), this._camPosL.copy(this._camPosW).applyMatrix4(this.invModelMatrix), this._camDirL.copy(this._camDirW).transformDirection(this.invModelMatrix);
-    const e = this.lastCameraPositionLocal.distanceToSquared(this._camPosL) > 1e-6, r = this.lastCameraDirectionLocal.dot(this._camDirL) < 0.999;
-    this.options.autoSort && (e || r) && (this.lastCameraPositionLocal.copy(this._camPosL), this.lastCameraDirectionLocal.copy(this._camDirL), this.sorter.setCamera(this._camPosL, this._camDirL));
+  sort(o) {
+    o.getWorldPosition(this._camPosW), o.getWorldDirection(this._camDirW), this.invModelMatrix.copy(this.matrixWorld).invert(), this._camPosL.copy(this._camPosW).applyMatrix4(this.invModelMatrix), this._camDirL.copy(this._camDirW).transformDirection(this.invModelMatrix);
+    const e = this.lastCameraPositionLocal.distanceToSquared(this._camPosL) > 1e-6, s = this.lastCameraDirectionLocal.dot(this._camDirL) < 0.999;
+    this.options.autoSort && (e || s) && (this.lastCameraPositionLocal.copy(this._camPosL), this.lastCameraDirectionLocal.copy(this._camDirL), this.sorter.setCamera(this._camPosL, this._camDirL));
   }
   /**
    * THREE.js hook called before rendering the object.
@@ -1066,8 +1069,8 @@ const j = class j extends n.Mesh {
    */
   // prettier-ignore
   // @ts-expect-error scene is not used
-  onBeforeRender(s, e, r) {
-    this.sort(r), s.getSize(this._size), this.updateViewport(this._size.x, this._size.y);
+  onBeforeRender(o, e, s) {
+    this.sort(s), o.getSize(this._size), this.updateViewport(this._size.x, this._size.y);
   }
   /**
    * Dispose of resources
@@ -1077,9 +1080,41 @@ const j = class j extends n.Mesh {
   }
 };
 /** Number of splats combined into a single instanced draw call. */
-c(j, "INSTANCE_SIZE", 128);
-let it = j;
-class bt extends n.Loader {
+h(rt, "INSTANCE_SIZE", 128);
+let dt = rt;
+class At extends a.Loader {
+  constructor(o) {
+    super(o);
+    h(this, "requestId", 0);
+    h(this, "worker");
+    h(this, "pendingCallbacks", /* @__PURE__ */ new Map());
+    const e = this.createWorkerCode(), s = new Blob([e], { type: "application/javascript" });
+    this.worker = new Worker(URL.createObjectURL(s)), this.worker.onmessage = this.onWorkerMessage.bind(this);
+  }
+  /**
+   * Handles messages received from the parsing worker
+   * @param event The message event from the worker
+   */
+  onWorkerMessage(o) {
+    const { requestId: e, error: s, result: r } = o.data, n = this.pendingCallbacks.get(e);
+    if (!n) return console.warn(`PlyLoader: Received response for unknown request ${e}`);
+    if (this.pendingCallbacks.delete(e), s) return n.reject(new Error(s));
+    if (!r) return n.reject(new Error("Worker returned no result"));
+    try {
+      const i = new mt(0);
+      i.numSplats = r.numSplats, i.positions = new Float32Array(r.positions), i.rotations = new Float32Array(r.rotations), i.scales = new Float32Array(r.scales), i.colors = new Float32Array(r.colors), i.opacities = new Float32Array(r.opacities), i.boundingBox.min.set(
+        r.boundingBox.minX,
+        r.boundingBox.minY,
+        r.boundingBox.minZ
+      ), i.boundingBox.max.set(
+        r.boundingBox.maxX,
+        r.boundingBox.maxY,
+        r.boundingBox.maxZ
+      ), n.resolve(i);
+    } catch (i) {
+      n.reject(i);
+    }
+  }
   /**
    * Load a PLY file with Gaussian Splat data
    * @param url URL of the PLY file
@@ -1087,21 +1122,18 @@ class bt extends n.Loader {
    * @param onProgress Optional progress callback
    * @param onError Optional error callback
    */
-  load(t, s, e, r) {
-    const o = new n.FileLoader(this.manager);
-    o.setResponseType("arraybuffer"), o.setRequestHeader(this.requestHeader), o.setPath(this.path), o.setWithCredentials(this.withCredentials), o.load(
-      t,
+  load(o, e, s, r) {
+    const n = new a.FileLoader(this.manager);
+    n.setResponseType("arraybuffer"), n.setRequestHeader(this.requestHeader), n.setPath(this.path), n.setWithCredentials(this.withCredentials), n.load(
+      o,
       (i) => {
-        try {
-          if (s) {
-            const a = this.parse(i);
-            s(a);
-          }
-        } catch (a) {
-          r ? r(a) : console.error(a), this.manager.itemError(t);
-        }
+        this.parseAsync(i).then((l) => {
+          e && e(l);
+        }).catch((l) => {
+          r ? r(l) : console.error(l), this.manager.itemError(o);
+        });
       },
-      e,
+      s,
       r
     );
   }
@@ -1111,197 +1143,255 @@ class bt extends n.Loader {
    * @param onProgress Optional progress callback
    * @returns A Promise that resolves with the parsed SplatData
    */
-  loadAsync(t, s) {
-    return new Promise((e, r) => {
-      const o = new n.FileLoader(this.manager);
-      o.setResponseType("arraybuffer"), o.setRequestHeader(this.requestHeader), o.setPath(this.path), o.setWithCredentials(this.withCredentials), o.load(
-        t,
+  loadAsync(o, e) {
+    return new Promise((s, r) => {
+      const n = new a.FileLoader(this.manager);
+      n.setResponseType("arraybuffer"), n.setRequestHeader(this.requestHeader), n.setPath(this.path), n.setWithCredentials(this.withCredentials), n.load(
+        o,
         (i) => {
-          try {
-            const a = this.parse(i);
-            e(a);
-          } catch (a) {
-            r(a), this.manager.itemError(t);
-          }
+          this.parseAsync(i).then(s).catch((l) => {
+            r(l), this.manager.itemError(o);
+          });
         },
-        s,
+        e,
         (i) => {
-          r(i), this.manager.itemError(t);
+          r(i), this.manager.itemError(o);
         }
       );
     });
   }
   /**
-   * Parse PLY buffer data into SplatData
+   * Parse PLY buffer data asynchronously using Web Worker
    * @param buffer ArrayBuffer containing PLY data
-   * @returns Parsed SplatData
+   * @returns Promise that resolves with parsed SplatData
    */
-  parse(t) {
-    const s = new TextDecoder(), e = new Uint8Array(t), r = [112, 108, 121, 10], o = `
+  parseAsync(o) {
+    return new Promise((e, s) => {
+      const r = this.requestId++;
+      this.pendingCallbacks.set(r, { resolve: e, reject: s });
+      const n = {
+        requestId: r,
+        buffer: o
+      };
+      this.worker.postMessage(n, [o]);
+    });
+  }
+  /**
+   * Terminate the Web Worker and clean up resources
+   */
+  dispose() {
+    this.worker && this.worker.terminate(), this.pendingCallbacks.clear();
+  }
+  /**
+   * Creates the self-contained code for the parsing Web Worker
+   * @returns A string containing the JavaScript code for the worker
+   */
+  createWorkerCode() {
+    return `(${(function() {
+      self.onmessage = (s) => {
+        const { requestId: r, buffer: n } = s.data;
+        try {
+          const i = e(n), l = {
+            requestId: r,
+            result: i
+          };
+          self.postMessage(l, [
+            i.positions,
+            i.rotations,
+            i.scales,
+            i.colors,
+            i.opacities
+          ]);
+        } catch (i) {
+          const l = {
+            requestId: r,
+            error: i instanceof Error ? i.message : String(i)
+          };
+          self.postMessage(l);
+        }
+      };
+      function e(s) {
+        const r = new TextDecoder(), n = new Uint8Array(s), i = [112, 108, 121, 10], l = `
 end_header
 `;
-    for (let x = 0; x < r.length; x++)
-      if (e[x] !== r[x])
-        throw new Error("Invalid PLY file: Missing magic bytes");
-    let i = 0;
-    for (let x = 0; x < e.length - o.length; x++) {
-      let u = !0;
-      for (let z = 0; z < o.length; z++)
-        if (e[x + z] !== o.charCodeAt(z)) {
-          u = !1;
-          break;
-        }
-      if (u) {
-        i = x + o.length;
-        break;
-      }
-    }
-    if (i === 0)
-      throw new Error("Invalid PLY file: Could not find end of header");
-    const d = s.decode(e.subarray(0, i)).split(`
-`), f = [];
-    let v = null;
-    for (let x = 1; x < d.length; x++) {
-      const u = d[x].trim();
-      if (u === "" || u === "end_header") continue;
-      const z = u.split(" ");
-      switch (z[0]) {
-        case "format":
-          v = z[1];
-          break;
-        case "element":
-          f.push({
-            name: z[1],
-            count: parseInt(z[2], 10),
-            properties: []
-          });
-          break;
-        case "property":
-          if (f.length === 0)
+        for (let p = 0; p < i.length; p++)
+          if (n[p] !== i[p])
             throw new Error(
-              "Invalid PLY file: Property without element"
+              "Invalid PLY file: Missing magic bytes"
             );
-          f[f.length - 1].properties.push({
-            type: z[1],
-            name: z[2],
-            storage: null
-          });
-          break;
-      }
-    }
-    if (v !== "binary_little_endian")
-      throw new Error(`Unsupported PLY format: ${v}`);
-    const g = f.find((x) => x.name === "vertex");
-    if (!g)
-      throw new Error("Invalid PLY file: No vertex element found");
-    const p = new ut(g.count), h = new DataView(t);
-    let l = i;
-    const b = (x) => g.properties.findIndex((u) => u.name === x), _ = b("x"), O = b("y"), q = b("z"), E = [
-      b("rot_0"),
-      b("rot_1"),
-      b("rot_2"),
-      b("rot_3")
-    ], R = [
-      b("scale_0"),
-      b("scale_1"),
-      b("scale_2")
-    ], W = [
-      b("f_dc_0"),
-      b("f_dc_1"),
-      b("f_dc_2")
-    ], k = b("opacity");
-    if ([
-      _,
-      O,
-      q,
-      ...E,
-      ...R,
-      ...W,
-      k
-    ].some((x) => x === -1))
-      throw new Error("Invalid PLY file: Missing required properties");
-    const F = 0.28209479177387814, M = (x) => {
-      if (x > 0) return 1 / (1 + Math.exp(-x));
-      const u = Math.exp(x);
-      return u / (1 + u);
-    }, m = new n.Vector3(), C = new n.Quaternion(), V = new n.Vector3(), P = new n.Color();
-    for (let x = 0; x < g.count; x++) {
-      const u = [];
-      for (let T = 0; T < g.properties.length; T++) {
-        const K = g.properties[T].type;
-        let A;
-        switch (K) {
-          case "char":
-            A = h.getInt8(l), l += 1;
-            break;
-          case "uchar":
-            A = h.getUint8(l), l += 1;
-            break;
-          case "short":
-            A = h.getInt16(l, !0), l += 2;
-            break;
-          case "ushort":
-            A = h.getUint16(l, !0), l += 2;
-            break;
-          case "int":
-            A = h.getInt32(l, !0), l += 4;
-            break;
-          case "uint":
-            A = h.getUint32(l, !0), l += 4;
-            break;
-          case "float":
-            A = h.getFloat32(l, !0), l += 4;
-            break;
-          case "double":
-            A = h.getFloat64(l, !0), l += 8;
+        let x = 0;
+        for (let p = 0; p < n.length - l.length; p++) {
+          let c = !0;
+          for (let y = 0; y < l.length; y++)
+            if (n[p + y] !== l.charCodeAt(y)) {
+              c = !1;
+              break;
+            }
+          if (c) {
+            x = p + l.length;
             break;
-          default:
-            throw new Error(`Unsupported property type: ${K}`);
+          }
         }
-        u.push(A);
+        if (x === 0)
+          throw new Error(
+            "Invalid PLY file: Could not find end of header"
+          );
+        const C = r.decode(
+          n.subarray(0, x)
+        ).split(`
+`), u = [];
+        let g = null;
+        for (let p = 1; p < C.length; p++) {
+          const c = C[p].trim();
+          if (c === "" || c === "end_header") continue;
+          const y = c.split(" ");
+          switch (y[0]) {
+            case "format":
+              g = y[1];
+              break;
+            case "element":
+              u.push({
+                name: y[1],
+                count: parseInt(y[2], 10),
+                properties: []
+              });
+              break;
+            case "property":
+              if (u.length === 0)
+                throw new Error(
+                  "Invalid PLY file: Property without element"
+                );
+              u[u.length - 1].properties.push({
+                type: y[1],
+                name: y[2]
+              });
+              break;
+          }
+        }
+        if (g !== "binary_little_endian")
+          throw new Error(`Unsupported PLY format: ${g}`);
+        const v = u.find((p) => p.name === "vertex");
+        if (!v)
+          throw new Error(
+            "Invalid PLY file: No vertex element found"
+          );
+        const S = v.count, I = new Float32Array(S * 3), R = new Float32Array(S * 4), Y = new Float32Array(S * 3), W = new Float32Array(S * 3), ot = new Float32Array(S), L = new DataView(s);
+        let w = x;
+        const d = (p) => v.properties.findIndex(
+          (c) => c.name === p
+        ), P = d("x"), M = d("y"), f = d("z"), A = [
+          d("rot_0"),
+          d("rot_1"),
+          d("rot_2"),
+          d("rot_3")
+        ], T = [
+          d("scale_0"),
+          d("scale_1"),
+          d("scale_2")
+        ], j = [
+          d("f_dc_0"),
+          d("f_dc_1"),
+          d("f_dc_2")
+        ], J = d("opacity");
+        if ([
+          P,
+          M,
+          f,
+          ...A,
+          ...T,
+          ...j,
+          J
+        ].some((p) => p === -1))
+          throw new Error(
+            "Invalid PLY file: Missing required properties"
+          );
+        const D = 0.28209479177387814, _ = (p) => {
+          if (p > 0) return 1 / (1 + Math.exp(-p));
+          const c = Math.exp(p);
+          return c / (1 + c);
+        };
+        let N = 1 / 0, nt = 1 / 0, E = 1 / 0, st = -1 / 0, tt = -1 / 0, et = -1 / 0;
+        for (let p = 0; p < S; p++) {
+          const c = [];
+          for (let at = 0; at < v.properties.length; at++) {
+            const lt = v.properties[at].type;
+            let G;
+            switch (lt) {
+              case "char":
+                G = L.getInt8(w), w += 1;
+                break;
+              case "uchar":
+                G = L.getUint8(w), w += 1;
+                break;
+              case "short":
+                G = L.getInt16(w, !0), w += 2;
+                break;
+              case "ushort":
+                G = L.getUint16(w, !0), w += 2;
+                break;
+              case "int":
+                G = L.getInt32(w, !0), w += 4;
+                break;
+              case "uint":
+                G = L.getUint32(w, !0), w += 4;
+                break;
+              case "float":
+                G = L.getFloat32(w, !0), w += 4;
+                break;
+              case "double":
+                G = L.getFloat64(w, !0), w += 8;
+                break;
+              default:
+                throw new Error(
+                  `Unsupported property type: ${lt}`
+                );
+            }
+            c.push(G);
+          }
+          const y = c[P], B = c[M], m = c[f], z = p * 3;
+          I[z] = y, I[z + 1] = B, I[z + 2] = m, N = Math.min(N, y), nt = Math.min(nt, B), E = Math.min(E, m), st = Math.max(st, y), tt = Math.max(tt, B), et = Math.max(et, m);
+          let U = c[A[1]], V = c[A[2]], O = c[A[3]], F = c[A[0]];
+          const q = Math.sqrt(
+            U * U + V * V + O * O + F * F
+          );
+          q > 0 && (U /= q, V /= q, O /= q, F /= q), F < 0 && (U = -U, V = -V, O = -O, F = -F);
+          const X = p * 4;
+          R[X] = U, R[X + 1] = V, R[X + 2] = O, R[X + 3] = F;
+          const Z = p * 3;
+          Y[Z] = c[T[0]], Y[Z + 1] = c[T[1]], Y[Z + 2] = c[T[2]];
+          let K = 0.5 + c[j[0]] * D, Q = 0.5 + c[j[1]] * D, H = 0.5 + c[j[2]] * D;
+          K = Math.max(0, Math.min(1, K)), Q = Math.max(0, Math.min(1, Q)), H = Math.max(0, Math.min(1, H));
+          const it = p * 3;
+          W[it] = K, W[it + 1] = Q, W[it + 2] = H, ot[p] = _(c[J]);
+        }
+        return {
+          numSplats: S,
+          positions: I.buffer,
+          rotations: R.buffer,
+          scales: Y.buffer,
+          colors: W.buffer,
+          opacities: ot.buffer,
+          boundingBox: {
+            minX: N,
+            minY: nt,
+            minZ: E,
+            maxX: st,
+            maxY: tt,
+            maxZ: et
+          }
+        };
       }
-      m.set(
-        u[_],
-        u[O],
-        u[q]
-      ), C.set(
-        u[E[1]],
-        // PLY stores rot 1,2,3,0 (x,y,z,w)
-        u[E[2]],
-        u[E[3]],
-        u[E[0]]
-      ).normalize(), C.w < 0 && (C.x = -C.x, C.y = -C.y, C.z = -C.z, C.w = -C.w), V.set(
-        u[R[0]],
-        // Read directly assuming it's log scale
-        u[R[1]],
-        u[R[2]]
-      ), P.set(
-        0.5 + u[W[0]] * F,
-        0.5 + u[W[1]] * F,
-        0.5 + u[W[2]] * F
-      ), P.r = Math.max(0, Math.min(1, P.r)), P.g = Math.max(0, Math.min(1, P.g)), P.b = Math.max(0, Math.min(1, P.b));
-      const z = M(u[k]);
-      p.setSplat(
-        x,
-        m,
-        C,
-        V,
-        // Pass log scale directly
-        P,
-        z
-      );
-    }
-    return p.calculateBoundingBox(), p;
+    }).toString()})();`;
   }
 }
-const Mt = "0.3.0";
+const zt = "0.3.0";
 export {
-  et as BoundingBox,
-  bt as PlyLoader,
-  ut as SplatData,
-  vt as SplatMaterial,
-  it as SplatMesh,
-  dt as SplatSorter,
-  xt as TextureManager,
-  Mt as VERSION
+  ct as BoundingBox,
+  At as PlyLoader,
+  mt as SplatData,
+  Ct as SplatMaterial,
+  dt as SplatMesh,
+  xt as SplatSorter,
+  wt as TextureManager,
+  zt as VERSION
 };