@speridlabs/visus 1.0.2 → 1.0.3

package/dist/main.es.js

@@ -1,14 +1,14 @@
-var le = Object.defineProperty;
-var ue = (z, e, t) => e in z ? le(z, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : z[e] = t;
-var p = (z, e, t) => ue(z, typeof e != "symbol" ? e + "" : e, t);
-import * as i from "three";
-class te {
+var lt = Object.defineProperty;
+var ht = (A, t, s) => t in A ? lt(A, t, { enumerable: !0, configurable: !0, writable: !0, value: s }) : A[t] = s;
+var c = (A, t, s) => ht(A, typeof t != "symbol" ? t + "" : t, s);
+import * as n from "three";
+class et {
   constructor() {
-    p(this, "min", new i.Vector3(1 / 0, 1 / 0, 1 / 0));
-    p(this, "max", new i.Vector3(-1 / 0, -1 / 0, -1 / 0));
-    p(this, "center", new i.Vector3());
+    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());
     /** Half extents (size/2) */
-    p(this, "halfExtents", new i.Vector3());
+    c(this, "halfExtents", new n.Vector3());
   }
   /**
    * Reset the bounding box to its initial state
@@ -20,15 +20,15 @@ class te {
    * Expand the bounding box to include the given point
    * @param point Point to include in the bounding box
    */
-  expandByPoint(e) {
-    this.min.x = Math.min(this.min.x, e.x), this.min.y = Math.min(this.min.y, e.y), this.min.z = Math.min(this.min.z, e.z), this.max.x = Math.max(this.max.x, e.x), this.max.y = Math.max(this.max.y, e.y), this.max.z = Math.max(this.max.z, e.z), this.updateDerived();
+  expandByPoint(t) {
+    this.min.x = Math.min(this.min.x, t.x), this.min.y = Math.min(this.min.y, t.y), this.min.z = Math.min(this.min.z, t.z), this.max.x = Math.max(this.max.x, t.x), this.max.y = Math.max(this.max.y, t.y), this.max.z = Math.max(this.max.z, t.z), this.updateDerived();
   }
   /**
    * Expand this bounding box to include another bounding box
    * @param box Bounding box to include
    */
-  expandByBox(e) {
-    this.min.x = Math.min(this.min.x, e.min.x), this.min.y = Math.min(this.min.y, e.min.y), this.min.z = Math.min(this.min.z, e.min.z), this.max.x = Math.max(this.max.x, e.max.x), this.max.y = Math.max(this.max.y, e.max.y), this.max.z = Math.max(this.max.z, e.max.z), this.updateDerived();
+  expandByBox(t) {
+    this.min.x = Math.min(this.min.x, t.min.x), this.min.y = Math.min(this.min.y, t.min.y), this.min.z = Math.min(this.min.z, t.min.z), this.max.x = Math.max(this.max.x, t.max.x), this.max.y = Math.max(this.max.y, t.max.y), this.max.z = Math.max(this.max.z, t.max.z), this.updateDerived();
   }
   /**
    * Update the center and half extents based on min/max
@@ -41,40 +41,40 @@ class te {
    * @param point Point to check
    * @returns True if the point is inside the box
    */
-  containsPoint(e) {
-    return e.x >= this.min.x && e.x <= this.max.x && e.y >= this.min.y && e.y <= this.max.y && e.z >= this.min.z && e.z <= this.max.z;
+  containsPoint(t) {
+    return t.x >= this.min.x && t.x <= this.max.x && t.y >= this.min.y && t.y <= this.max.y && t.z >= this.min.z && t.z <= this.max.z;
   }
   /**
    * Create a Three.js Box3 from this bounding box
    * @returns THREE.Box3 representation
    */
   toBox3() {
-    return new i.Box3().set(this.min, this.max);
+    return new n.Box3().set(this.min, this.max);
   }
   /**
    * Create a clone of this bounding box
    * @returns New bounding box with the same values
    */
   clone() {
-    const e = new te();
-    return e.min.copy(this.min), e.max.copy(this.max), e.center.copy(this.center), e.halfExtents.copy(this.halfExtents), e;
+    const t = new et();
+    return t.min.copy(this.min), t.max.copy(this.max), t.center.copy(this.center), t.halfExtents.copy(this.halfExtents), t;
   }
 }
-class de {
+class ut {
   // TODO: there is no sh spherical harmonics
-  constructor(e = 0) {
-    p(this, "numSplats", 0);
-    p(this, "positions");
-    p(this, "rotations");
-    p(this, "scales");
-    p(this, "colors");
-    p(this, "opacities");
-    p(this, "centers");
-    p(this, "boundingBox", new te());
-    this.numSplats = e, this.allocateBuffers(e);
+  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());
+    this.numSplats = t, this.allocateBuffers(t);
   }
-  allocateBuffers(e) {
-    this.positions = new Float32Array(e * 3), this.rotations = new Float32Array(e * 4), this.scales = new Float32Array(e * 3), this.colors = new Float32Array(e * 3), this.opacities = new Float32Array(e), this.centers = new Float32Array(e * 3);
+  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);
   }
   /**
    * Set data for a specific splat
@@ -85,49 +85,49 @@ class de {
    * @param color Color
    * @param opacity Opacity value
    */
-  setSplat(e, t, o, r, n, s) {
-    if (e >= this.numSplats)
+  setSplat(t, s, e, r, o, i) {
+    if (t >= this.numSplats)
       throw new Error(
-        `Splat index out of bounds: ${e} >= ${this.numSplats}`
+        `Splat index out of bounds: ${t} >= ${this.numSplats}`
       );
-    const a = e * 3, c = e * 4, f = e * 3, m = e * 3;
-    this.positions[a] = t.x, this.positions[a + 1] = t.y, this.positions[a + 2] = t.z, this.rotations[c] = o.x, this.rotations[c + 1] = o.y, this.rotations[c + 2] = o.z, this.rotations[c + 3] = o.w, this.scales[f] = r.x, this.scales[f + 1] = r.y, this.scales[f + 2] = r.z, this.colors[m] = n.r, this.colors[m + 1] = n.g, this.colors[m + 2] = n.b, this.opacities[e] = s, this.centers[a] = t.x, this.centers[a + 1] = t.y, this.centers[a + 2] = t.z;
+    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;
   }
   /**
    * Get a splat's data
    * @param index Splat index
    * @returns Object containing splat data (linear scale)
    */
-  getSplat(e) {
-    if (e >= this.numSplats)
+  getSplat(t) {
+    if (t >= this.numSplats)
       throw new Error(
-        `Splat index out of bounds: ${e} >= ${this.numSplats}`
+        `Splat index out of bounds: ${t} >= ${this.numSplats}`
       );
-    const t = e * 3, o = e * 4, r = e * 3, n = e * 3;
+    const s = t * 3, e = t * 4, r = t * 3, o = t * 3;
     return {
-      position: new i.Vector3(
-        this.positions[t],
-        this.positions[t + 1],
-        this.positions[t + 2]
+      position: new n.Vector3(
+        this.positions[s],
+        this.positions[s + 1],
+        this.positions[s + 2]
       ),
-      rotation: new i.Quaternion(
-        this.rotations[o],
-        this.rotations[o + 1],
-        this.rotations[o + 2],
-        this.rotations[o + 3]
+      rotation: new n.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 i.Vector3(
+      scale: new n.Vector3(
         Math.exp(this.scales[r]),
         Math.exp(this.scales[r + 1]),
         Math.exp(this.scales[r + 2])
       ),
-      color: new i.Color(
-        this.colors[n],
-        this.colors[n + 1],
-        this.colors[n + 2]
+      color: new n.Color(
+        this.colors[o],
+        this.colors[o + 1],
+        this.colors[o + 2]
       ),
-      opacity: this.opacities[e]
+      opacity: this.opacities[t]
     };
   }
   /**
@@ -136,14 +136,14 @@ class de {
    */
   calculateBoundingBox() {
     this.boundingBox.reset();
-    const e = new i.Vector3();
-    for (let t = 0; t < this.numSplats; t++) {
-      const o = t * 3;
-      e.set(
-        this.positions[o],
-        this.positions[o + 1],
-        this.positions[o + 2]
-      ), this.boundingBox.expandByPoint(e);
+    const t = new n.Vector3();
+    for (let s = 0; s < this.numSplats; s++) {
+      const e = s * 3;
+      t.set(
+        this.positions[e],
+        this.positions[e + 1],
+        this.positions[e + 2]
+      ), this.boundingBox.expandByPoint(t);
     }
     return this.boundingBox;
   }
@@ -152,64 +152,64 @@ class de {
    * This is for visualization/debugging purposes only, not for rendering
    */
   createDebugGeometry() {
-    const e = new i.BufferGeometry();
-    e.setAttribute(
+    const t = new n.BufferGeometry();
+    t.setAttribute(
       "position",
-      new i.BufferAttribute(this.positions, 3)
+      new n.BufferAttribute(this.positions, 3)
     );
-    const t = new Float32Array(this.numSplats * 3), o = new i.Quaternion(), r = new i.Euler();
-    for (let n = 0; n < this.numSplats; n++) {
-      const s = n * 4, a = n * 3;
-      o.set(
-        this.rotations[s],
-        this.rotations[s + 1],
-        this.rotations[s + 2],
-        this.rotations[s + 3]
-      ), r.setFromQuaternion(o), t[a] = r.x, t[a + 1] = r.y, t[a + 2] = r.z;
+    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;
+      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;
     }
-    return e.setAttribute(
+    return t.setAttribute(
       "rotation",
-      new i.BufferAttribute(t, 3)
-    ), e.setAttribute(
+      new n.BufferAttribute(s, 3)
+    ), t.setAttribute(
       "scale",
-      new i.BufferAttribute(this.scales, 3)
-    ), e.setAttribute(
+      new n.BufferAttribute(this.scales, 3)
+    ), t.setAttribute(
       "color",
-      new i.BufferAttribute(this.colors, 3)
-    ), e.setAttribute(
+      new n.BufferAttribute(this.colors, 3)
+    ), t.setAttribute(
       "opacity",
-      new i.BufferAttribute(this.opacities, 1)
-    ), e;
+      new n.BufferAttribute(this.opacities, 1)
+    ), t;
   }
 }
-class he extends i.EventDispatcher {
+class dt extends n.EventDispatcher {
   constructor() {
     super();
-    p(this, "worker");
-    p(this, "centers", null);
-    p(this, "orderTexture", null);
+    c(this, "worker");
+    c(this, "centers", null);
+    c(this, "orderTexture", null);
     /** Bounding box data for optimization */
-    p(this, "chunks", null);
-    p(this, "lastCameraPosition", new i.Vector3());
-    p(this, "lastCameraDirection", new i.Vector3());
-    const t = this.createWorkerCode(), o = new Blob([t], { type: "application/javascript" });
-    this.worker = new Worker(URL.createObjectURL(o)), this.worker.onmessage = this.onWorkerMessage.bind(this);
+    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" });
+    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(t) {
+  onWorkerMessage(s) {
     if (!this.orderTexture || !this.orderTexture.image)
       return console.error("SplatSorter: Order texture not initialized!");
-    const { order: o, count: r } = t.data, n = this.orderTexture.image.data;
-    if (!(n instanceof Uint32Array))
+    const { order: e, count: r } = s.data, o = this.orderTexture.image.data;
+    if (!(o instanceof Uint32Array))
       return console.error(
         "SplatSorter: Order texture data is not a Uint32Array!"
       );
-    n.set(new Uint32Array(o)), this.orderTexture.needsUpdate = !0;
-    const s = n.buffer.slice(0), a = { order: s };
-    this.worker.postMessage(a, [s]), this.dispatchEvent({ type: "updated", count: r });
+    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 });
   }
   /**
    * Initializes the sorter with necessary data and textures.
@@ -217,84 +217,89 @@ class he extends i.EventDispatcher {
    * @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.
    */
-  init(t, o, r) {
-    if (!t || !(t.image.data instanceof Uint32Array))
+  init(s, e, r) {
+    if (!s || !(s.image.data instanceof Uint32Array))
       throw new Error("SplatSorter: Invalid orderTexture provided. Must be DataTexture with Uint32Array data.");
-    if (!o || o.length % 3 !== 0)
+    if (!e || e.length % 3 !== 0)
       throw new Error("SplatSorter: Invalid centers array provided. Length must be multiple of 3.");
-    if (t.image.data.length < o.length / 3)
+    if (s.image.data.length < e.length / 3)
       throw new Error("SplatSorter: orderTexture data buffer is smaller than the number of splats.");
-    const n = o.length / 3;
-    this.orderTexture = t, this.centers = o.slice();
-    const s = this.orderTexture.image.data;
-    for (let x = 0; x < n; x++) s[x] = x;
+    const o = e.length / 3;
+    this.orderTexture = s, this.centers = e.slice();
+    const i = this.orderTexture.image.data;
+    for (let g = 0; g < o; g++) i[g] = g;
     this.orderTexture.needsUpdate = !0;
-    const a = s.buffer.slice(0), c = this.centers.buffer.slice(0), f = {
+    const a = i.buffer.slice(0), d = this.centers.buffer.slice(0), f = {
       order: a,
-      centers: c
-    }, m = [
+      centers: d
+    }, v = [
       a,
-      c
+      d
     ];
     if (r) {
       this.chunks = r.slice();
-      const x = this.chunks.buffer.slice(0);
-      f.chunks = x, m.push(x);
+      const g = this.chunks.buffer.slice(0);
+      f.chunks = g, v.push(g);
     }
-    this.worker.postMessage(f, m);
+    this.worker.postMessage(f, v), queueMicrotask(() => {
+      this.dispatchEvent({
+        type: "updated",
+        count: o
+      });
+    });
   }
   /**
    * Applies an optional mapping to filter or reorder splats before sorting.
    * 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(t) {
+  setMapping(s) {
     if (!this.centers)
       return console.warn(
         "SplatSorter: Cannot set mapping before initialization."
       );
-    let o;
+    let e;
     const r = [];
-    if (!t) {
-      const c = this.centers.buffer.slice(0);
-      return o = {
-        centers: c,
+    if (!s) {
+      const d = this.centers.buffer.slice(0);
+      return e = {
+        centers: d,
         mapping: null
-      }, r.push(c), this.worker.postMessage(o, r);
+      }, r.push(d), this.worker.postMessage(e, r);
     }
-    const n = new Float32Array(t.length * 3);
-    for (let c = 0; c < t.length; c++) {
-      const f = t[c];
+    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) {
         console.warn(
           `SplatSorter: Mapping index ${f} out of bounds.`
         );
         continue;
       }
-      const m = f * 3, x = c * 3;
-      n[x + 0] = this.centers[m + 0], n[x + 1] = this.centers[m + 1], n[x + 2] = this.centers[m + 2];
+      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 s = n.buffer.slice(0), a = t.buffer.slice(0);
-    o = {
-      centers: s,
+    const i = o.buffer.slice(0), a = s.buffer.slice(0);
+    e = {
+      centers: i,
       mapping: a
-    }, r.push(s, a), this.worker.postMessage(o, r);
+    }, r.push(i, a), this.worker.postMessage(e, r);
   }
   /**
    * 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(t, o) {
-    const r = this.lastCameraPosition.distanceToSquared(t) > 1e-7, n = this.lastCameraDirection.dot(o) < 0.9999;
-    if (!r && !n)
+  setCamera(s, e) {
+    const r = this.lastCameraPosition.distanceToSquared(s) > 1e-7, o = this.lastCameraDirection.dot(e) < 0.9999;
+    if (!r && !o)
       return;
-    this.lastCameraPosition.copy(t), this.lastCameraDirection.copy(o);
-    const s = {
-      cameraPosition: { x: t.x, y: t.y, z: t.z },
-      cameraDirection: { x: o.x, y: o.y, z: o.z }
+    this.lastCameraPosition.copy(s), this.lastCameraDirection.copy(e);
+    const i = {
+      cameraPosition: { x: s.x, y: s.y, z: s.z },
+      cameraDirection: { x: e.x, y: e.y, z: e.z }
     };
-    this.worker.postMessage(s);
+    this.worker.postMessage(i);
   }
   /**
    * Terminates the Web Worker and cleans up resources.
@@ -308,232 +313,232 @@ class he extends i.EventDispatcher {
    */
   createWorkerCode() {
     return `(${(function() {
-      let o = null, r = null, n = null, s = null, a = null, c = null, f = !1;
-      const m = { x: 0, y: 0, z: 0 }, x = { x: 0, y: 0, z: 0 }, v = { x: 0, y: 0, z: 0 }, d = { x: 0, y: 0, z: 0 };
-      let S = null, u = null;
-      const M = 32, O = new Array(M).fill(0), H = new Array(M).fill(0), R = new Array(M).fill(0), P = (B, A, F) => {
-        for (; B <= A; ) {
-          const C = A + B >> 1, y = F(C);
-          if (y > 0) B = C + 1;
-          else if (y < 0) A = C - 1;
-          else return C;
+      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 T = 32, O = new Array(T).fill(0), q = new Array(T).fill(0), E = new Array(T).fill(0), R = (k, C, F) => {
+        for (; k <= C; ) {
+          const M = C + k >> 1, m = F(M);
+          if (m > 0) k = M + 1;
+          else if (m < 0) C = M - 1;
+          else return M;
         }
-        return ~B;
+        return ~k;
       }, W = () => {
-        if (!o || !r || !a || !c)
+        if (!e || !r || !a || !d)
           return;
         if (r.length === 0) {
-          const g = {
-            order: o.buffer,
+          const y = {
+            order: e.buffer,
             count: 0
           };
-          self.postMessage(g, [o.buffer]), o = null;
+          self.postMessage(y, [e.buffer]), e = null;
           return;
         }
-        const B = a.x, A = a.y, F = a.z, C = c.x, y = c.y, _ = c.z, I = 1e-4, V = Math.abs(B - m.x) > I || Math.abs(A - m.y) > I || Math.abs(F - m.z) > I, E = Math.abs(C - x.x) > I || Math.abs(y - x.y) > I || Math.abs(_ - x.z) > I;
-        if (!f && !V && !E)
+        const k = a.x, C = a.y, F = a.z, M = d.x, m = d.y, B = d.z, V = 1e-4, P = Math.abs(k - v.x) > V || Math.abs(C - v.y) > V || Math.abs(F - v.z) > V, x = Math.abs(M - g.x) > V || Math.abs(m - g.y) > V || Math.abs(B - g.z) > V;
+        if (!f && !P && !x)
           return;
-        f = !1, m.x = B, m.y = A, m.z = F, x.x = C, x.y = y, x.z = _;
-        let l = 1 / 0, h = -1 / 0;
-        for (let g = 0; g < 8; ++g) {
-          const T = g & 1 ? v.x : d.x, k = g & 2 ? v.y : d.y, b = g & 4 ? v.z : d.z, D = T * C + k * y + b * _;
-          l = Math.min(l, D), h = Math.max(h, D);
+        f = !1, v.x = k, v.y = C, v.z = F, g.x = M, g.y = m, g.z = B;
+        let u = 1 / 0, S = -1 / 0;
+        for (let y = 0; y < 8; ++y) {
+          const _ = y & 1 ? p.x : h.x, U = y & 2 ? p.y : h.y, w = y & 4 ? p.z : h.z, D = _ * M + U * m + w * B;
+          u = Math.min(u, D), S = Math.max(S, D);
         }
-        const w = r.length / 3, q = h - l, L = (1 << Math.max(
+        const I = r.length / 3, L = S - u, z = (1 << Math.max(
           10,
-          Math.min(20, Math.ceil(Math.log2(w / 4)))
+          Math.min(20, Math.ceil(Math.log2(I / 4)))
         )) + 1;
-        if ((!S || S.length !== w) && (S = new Uint32Array(w)), !u || u.length !== L ? u = new Uint32Array(L) : u.fill(0), q < 1e-7) {
-          for (let g = 0; g < w; ++g) S[g] = 0;
-          u[0] = w;
-        } else if (n && n.length > 0) {
-          const g = n.length / 6;
+        if ((!l || l.length !== I) && (l = new Uint32Array(I)), !b || b.length !== z ? b = new Uint32Array(z) : b.fill(0), L < 1e-7) {
+          for (let y = 0; y < I; ++y) l[y] = 0;
+          b[0] = I;
+        } else if (o && o.length > 0) {
+          const y = o.length / 6;
           O.fill(0);
-          for (let b = 0; b < g; ++b) {
-            const D = b * 6, Z = n[D + 0], X = n[D + 1], J = n[D + 2], Y = n[D + 3], G = Z * C + X * y + J * _ - l, K = G - Y, $ = G + Y, Q = Math.max(
+          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 + $ * B - u, J = Y - H, G = Y + H, Q = Math.max(
               0,
-              Math.floor(K * M / q)
-            ), ee = Math.min(
-              M,
-              Math.ceil($ * M / q)
+              Math.floor(J * T / L)
+            ), tt = Math.min(
+              T,
+              Math.ceil(G * T / L)
             );
-            for (let j = Q; j < ee; ++j)
-              O[j]++;
+            for (let N = Q; N < tt; ++N)
+              O[N]++;
           }
-          let T = 0;
-          for (let b = 0; b < M; ++b) T += O[b];
-          R[0] = 0, H[0] = 0;
-          for (let b = 1; b < M; ++b)
-            R[b - 1] = O[b - 1] / T * L >>> 0, H[b] = H[b - 1] + R[b - 1];
-          R[M - 1] = O[M - 1] / T * L >>> 0;
-          const k = q / M;
-          for (let b = 0; b < w; ++b) {
-            const D = b * 3, Z = r[D + 0], X = r[D + 1], J = r[D + 2], Y = Z * C + X * y + J * _, K = (h - Y) / k, $ = Math.max(
+          let _ = 0;
+          for (let w = 0; w < T; ++w) _ += O[w];
+          E[0] = 0, q[0] = 0;
+          for (let w = 1; w < T; ++w)
+            E[w - 1] = O[w - 1] / _ * z >>> 0, q[w] = q[w - 1] + E[w - 1];
+          E[T - 1] = O[T - 1] / _ * z >>> 0;
+          const U = L / T;
+          for (let w = 0; w < I; ++w) {
+            const D = w * 3, X = r[D + 0], Z = r[D + 1], $ = r[D + 2], H = X * M + Z * m + $ * B, J = (S - H) / U, G = Math.max(
               0,
               Math.min(
-                M - 1,
-                Math.floor(K)
+                T - 1,
+                Math.floor(J)
               )
-            ), Q = K - $, ee = H[$] + R[$] * Q >>> 0, j = Math.min(ee, L - 1);
-            S[b] = j, u[j]++;
+            ), Q = J - G, tt = q[G] + E[G] * Q >>> 0, N = Math.min(tt, z - 1);
+            l[w] = N, b[N]++;
           }
         } else {
-          const g = (L - 1) / q;
-          for (let T = 0; T < w; ++T) {
-            const k = T * 3, b = r[k + 0], D = r[k + 1], Z = r[k + 2], X = b * C + D * y + Z * _, Y = (h - X) * g >>> 0, G = Math.min(Y, L - 1);
-            S[T] = G, u[G]++;
+          const y = (z - 1) / L;
+          for (let _ = 0; _ < I; ++_) {
+            const U = _ * 3, w = r[U + 0], D = r[U + 1], X = r[U + 2], Z = w * M + D * m + X * B, H = (S - Z) * y >>> 0, Y = Math.min(H, z - 1);
+            l[_] = Y, b[Y]++;
           }
         }
-        for (let g = 1; g < L; g++)
-          u[g] += u[g - 1];
-        for (let g = w - 1; g >= 0; g--) {
-          const T = S[g], k = --u[T];
-          o[k] = s ? s[g] : g;
+        for (let y = 1; y < z; y++)
+          b[y] += b[y - 1];
+        for (let y = I - 1; y >= 0; y--) {
+          const _ = l[y], U = --b[_];
+          e[U] = i ? i[y] : y;
         }
-        const U = B * C + A * y + F * _, re = (g) => {
-          if (!o) return -1 / 0;
-          const T = o[g], k = T;
-          if (!r || k * 3 + 2 >= r.length)
+        const at = k * M + C * m + F * B, rt = (y) => {
+          if (!e) return -1 / 0;
+          const _ = e[y], U = _;
+          if (!r || U * 3 + 2 >= r.length)
             return -1 / 0;
-          const b = k * 3;
-          return r[b] * C + r[b + 1] * y + r[b + 2] * _ - U;
+          const w = U * 3;
+          return r[w] * M + r[w + 1] * m + r[w + 2] * B - at;
         };
-        let oe = w;
-        if (w > 0 && re(w - 1) < 0) {
-          const g = P(
+        let st = I;
+        if (I > 0 && rt(I - 1) < 0) {
+          const y = R(
             0,
-            w - 1,
-            re
+            I - 1,
+            rt
           );
-          oe = g < 0 ? ~g : g;
+          st = y < 0 ? ~y : y;
         }
-        const ce = {
-          order: o.buffer,
-          count: oe
+        const ct = {
+          order: e.buffer,
+          count: st
         };
-        self.postMessage(ce, [o.buffer]), o = null;
+        self.postMessage(ct, [e.buffer]), e = null;
       };
-      self.onmessage = (B) => {
-        const A = B.data;
-        A.order && (o = new Uint32Array(A.order));
+      self.onmessage = (k) => {
+        const C = k.data;
+        C.order && (e = new Uint32Array(C.order));
         let F = !1;
-        if (A.centers && (r = new Float32Array(A.centers), F = !0, f = !0), Object.prototype.hasOwnProperty.call(A, "mapping") && (s = A.mapping ? new Uint32Array(A.mapping) : null, f = !0), A.chunks) {
-          if (n = new Float32Array(A.chunks), n.length > 0 && n[3] > 0)
-            for (let C = 0; C < n.length / 6; ++C) {
-              const y = C * 6, _ = n[y + 0], I = n[y + 1], V = n[y + 2], E = n[y + 3], l = n[y + 4], h = n[y + 5];
-              n[y + 0] = (_ + E) * 0.5, n[y + 1] = (I + l) * 0.5, n[y + 2] = (V + h) * 0.5, n[y + 3] = Math.sqrt(
-                (E - _) ** 2 + (l - I) ** 2 + (h - V) ** 2
+        if (C.centers && (r = new Float32Array(C.centers), F = !0, f = !0), Object.prototype.hasOwnProperty.call(C, "mapping") && (i = C.mapping ? new Uint32Array(C.mapping) : null, f = !0), C.chunks) {
+          if (o = new Float32Array(C.chunks), o.length > 0 && o[3] > 0)
+            for (let M = 0; M < o.length / 6; ++M) {
+              const m = M * 6, B = o[m + 0], V = o[m + 1], P = o[m + 2], x = o[m + 3], u = o[m + 4], S = o[m + 5];
+              o[m + 0] = (B + x) * 0.5, o[m + 1] = (V + u) * 0.5, o[m + 2] = (P + S) * 0.5, o[m + 3] = Math.sqrt(
+                (x - B) ** 2 + (u - V) ** 2 + (S - P) ** 2
               ) * 0.5;
             }
           f = !0;
         }
         if (F && r && r.length > 0) {
-          v.x = d.x = r[0], v.y = d.y = r[1], v.z = d.z = r[2];
-          for (let C = 1; C < r.length / 3; C++) {
-            const y = C * 3;
-            v.x = Math.min(v.x, r[y + 0]), d.x = Math.max(d.x, r[y + 0]), v.y = Math.min(v.y, r[y + 1]), d.y = Math.max(d.y, r[y + 1]), v.z = Math.min(v.z, r[y + 2]), d.z = Math.max(d.z, r[y + 2]);
+          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]);
           }
-        } else F && r && r.length === 0 && (v.x = d.x = v.y = d.y = v.z = d.z = 0);
-        A.cameraPosition && (a = A.cameraPosition), A.cameraDirection && (c = A.cameraDirection), W();
+        } else F && r && r.length === 0 && (p.x = h.x = p.y = h.y = p.z = h.z = 0);
+        C.cameraPosition && (a = C.cameraPosition), C.cameraDirection && (d = C.cameraDirection), W();
       };
     }).toString()})();`;
   }
 }
-const fe = (z, e) => {
-  const t = ne(z), o = ne(e);
-  return t | o << 16;
+const pt = (A, t) => {
+  const s = ot(A), e = ot(t);
+  return s | e << 16;
 };
-function ne(z) {
-  const e = new Float32Array([z]), o = new Int32Array(e.buffer)[0];
-  let r = o >> 16 & 32768, n = o >> 12 & 2047;
-  const s = o >> 23 & 255;
-  return s < 103 ? r : s > 142 ? (r |= 31744, r |= (s === 255 ? 0 : 1) && o & 8388607, r) : s < 113 ? (n |= 2048, r |= (n >> 114 - s) + (n >> 113 - s & 1), r) : (r |= s - 112 << 10 | n >> 1, r += n & 1, r);
+function ot(A) {
+  const t = new Float32Array([A]), 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);
 }
-const pe = new ArrayBuffer(4), se = new DataView(pe), me = (z) => (se.setUint32(0, z, !0), se.getFloat32(0, !0));
-class xe {
+const ft = new ArrayBuffer(4), nt = new DataView(ft), mt = (A) => (nt.setUint32(0, A, !0), nt.getFloat32(0, !0));
+class xt {
   /**
    * Create a new TextureManager for a set of splats
    * @param splatData The splat data to manage textures for
    */
-  constructor(e) {
-    p(this, "transformA");
+  constructor(t) {
+    c(this, "transformA");
     // position xyz and rotation quaternion y,z components
-    p(this, "transformB");
+    c(this, "transformB");
     // rotation quaternion x and scale xyz
-    p(this, "colorTexture");
+    c(this, "colorTexture");
     // color an opacity
-    p(this, "orderTexture");
-    p(this, "textureWidth");
-    p(this, "textureHeight");
-    const t = e.numSplats;
-    this.textureWidth = Math.ceil(Math.sqrt(t)), this.textureHeight = Math.ceil(t / this.textureWidth), this.transformA = this.createTransformATexture(e), this.transformB = this.createTransformBTexture(e), this.colorTexture = this.createColorTexture(e), this.orderTexture = this.createOrderTexture(t);
+    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);
   }
   /**
    * Create the transform A texture (positions and quaternion w component)
    * @param splatData The splat data
    * @returns DataTexture containing position data
    */
-  createTransformATexture(e) {
-    const t = e.numSplats, o = new Float32Array(
+  createTransformATexture(t) {
+    const s = t.numSplats, e = new Float32Array(
       this.textureWidth * this.textureHeight * 4
     );
-    for (let n = 0; n < t; n++) {
-      const s = n * 4, a = n * 3, c = n * 4;
-      o[s] = e.positions[a], o[s + 1] = e.positions[a + 1], o[s + 2] = e.positions[a + 2];
-      const f = e.rotations[c + 0], m = e.rotations[c + 1], x = fe(f, m);
-      o[s + 3] = me(x);
+    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);
     }
-    const r = new i.DataTexture(
-      o,
+    const r = new n.DataTexture(
+      e,
       this.textureWidth,
       this.textureHeight,
-      i.RGBAFormat,
-      i.FloatType
+      n.RGBAFormat,
+      n.FloatType
       // Store as Float32, shader will reinterpret bits
     );
-    return r.needsUpdate = !0, r.magFilter = i.NearestFilter, r.minFilter = i.NearestFilter, r;
+    return r.needsUpdate = !0, r.magFilter = n.NearestFilter, r.minFilter = n.NearestFilter, r;
   }
   /**
    * Create the transform B texture (scale and rotation xyz)
    * @param splatData The splat data
    * @returns DataTexture containing scale and rotation data
    */
-  createTransformBTexture(e) {
-    const t = e.numSplats, o = new Float32Array(
+  createTransformBTexture(t) {
+    const s = t.numSplats, e = new Float32Array(
       this.textureWidth * this.textureHeight * 4
     );
-    for (let n = 0; n < t; n++) {
-      const s = n * 4, a = n * 3, c = n * 4;
-      o[s] = e.scales[a], o[s + 1] = e.scales[a + 1], o[s + 2] = e.scales[a + 2], o[s + 3] = e.rotations[c + 2];
+    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];
     }
-    const r = new i.DataTexture(
-      o,
+    const r = new n.DataTexture(
+      e,
       this.textureWidth,
       this.textureHeight,
-      i.RGBAFormat,
-      i.FloatType
+      n.RGBAFormat,
+      n.FloatType
     );
-    return r.needsUpdate = !0, r.magFilter = i.NearestFilter, r.minFilter = i.NearestFilter, r;
+    return r.needsUpdate = !0, r.magFilter = n.NearestFilter, r.minFilter = n.NearestFilter, r;
   }
   /**
    * Create the color texture (RGB and opacity)
    * @param splatData The splat data
    * @returns DataTexture containing color data
    */
-  createColorTexture(e) {
-    const t = e.numSplats, o = new Float32Array(
+  createColorTexture(t) {
+    const s = t.numSplats, e = new Float32Array(
       this.textureWidth * this.textureHeight * 4
     );
-    for (let n = 0; n < t; n++) {
-      const s = n * 4, a = n * 3;
-      o[s] = e.colors[a], o[s + 1] = e.colors[a + 1], o[s + 2] = e.colors[a + 2], o[s + 3] = e.opacities[n];
+    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];
     }
-    const r = new i.DataTexture(
-      o,
+    const r = new n.DataTexture(
+      e,
       this.textureWidth,
       this.textureHeight,
-      i.RGBAFormat,
-      i.FloatType
+      n.RGBAFormat,
+      n.FloatType
     );
     return r.needsUpdate = !0, r;
   }
@@ -542,24 +547,24 @@ class xe {
    * @param numSplats Number of splats
    * @returns DataTexture for storing order indices
    */
-  createOrderTexture(e) {
-    const t = new Uint32Array(this.textureWidth * this.textureHeight);
-    for (let r = 0; r < e; r++)
-      t[r] = r;
-    const o = new i.DataTexture(
-      t,
+  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,
       this.textureWidth,
       this.textureHeight,
-      i.RedIntegerFormat,
-      i.UnsignedIntType
+      n.RedIntegerFormat,
+      n.UnsignedIntType
     );
-    return o.needsUpdate = !0, o;
+    return e.needsUpdate = !0, e;
   }
   dispose() {
     this.transformA.dispose(), this.transformB.dispose(), this.colorTexture.dispose(), this.orderTexture.dispose();
   }
 }
-const ge = (
+const yt = (
   /* glsl */
   `
 precision highp float;
@@ -817,7 +822,7 @@ void main(void) {
     vUv = clippedCornerOffset;
 }
 `
-), ye = (
+), gt = (
   /* glsl */
   `
 precision highp float;
@@ -851,146 +856,134 @@ void main(void) {
 }
 `
 );
-class we extends i.ShaderMaterial {
-  constructor(e = {}) {
-    const t = {
+class vt extends n.ShaderMaterial {
+  constructor(t = {}) {
+    const s = {
       // Textures (values set via methods)
       transformA: { value: null },
       transformB: { value: null },
       splatColor: { value: null },
       splatOrder: { value: null },
       // Other uniforms
-      viewport: { value: new i.Vector2(1, 1) },
+      viewport: { value: new n.Vector2(1, 1) },
       // Will be updated
       numSplats: { value: 0 }
       // Max splats to render (updated by sorter)
     };
     super({
-      vertexShader: ge,
-      fragmentShader: ye,
-      uniforms: t,
+      vertexShader: yt,
+      fragmentShader: gt,
+      uniforms: s,
       transparent: !0,
-      blending: i.CustomBlending,
+      blending: n.CustomBlending,
       // Premultiplied alpha blending:
       // color = src_color * src_alpha + dst_color * (1 - src_alpha)
       // alpha = src_alpha * 1 + dst_alpha * (1 - src_alpha)
-      blendSrc: i.OneFactor,
+      blendSrc: n.OneFactor,
       // Using ONE because shader outputs premultiplied color (color * alpha)
-      blendDst: i.OneMinusSrcAlphaFactor,
-      blendSrcAlpha: i.OneFactor,
+      blendDst: n.OneMinusSrcAlphaFactor,
+      blendSrcAlpha: n.OneFactor,
       // source alpha comes from shader
-      blendDstAlpha: i.OneMinusSrcAlphaFactor,
-      blendEquation: i.AddEquation,
-      blendEquationAlpha: i.AddEquation,
+      blendDstAlpha: n.OneMinusSrcAlphaFactor,
+      blendEquation: n.AddEquation,
+      blendEquationAlpha: n.AddEquation,
       depthTest: !0,
       depthWrite: !1,
       // Disable depth write for transparency
-      side: i.DoubleSide,
+      side: n.DoubleSide,
       // Render both sides (or CULLFACE_NONE equivalent)
       // Optional settings from constructor
-      alphaTest: e.alphaTest !== void 0 ? e.alphaTest : 0,
+      alphaTest: t.alphaTest !== void 0 ? t.alphaTest : 0,
       // Typically 0 for blending
-      toneMapped: e.toneMapped !== void 0 ? e.toneMapped : !1
+      toneMapped: t.toneMapped !== void 0 ? t.toneMapped : !1
       // prettier-ignore
-    }), e.alphaHash && (this.alphaHash = !0, this.depthWrite = !0, this.blending = i.NoBlending);
+    }), t.alphaHash && (this.alphaHash = !0, this.depthWrite = !0, this.blending = n.NoBlending);
   }
   /**
    * Update the viewport size
    * @param width Viewport width
    * @param height Viewport height
    */
-  updateViewport(e, t) {
-    this.uniforms.viewport.value.set(e, t);
+  updateViewport(t, s) {
+    this.uniforms.viewport.value.set(t, s);
   }
   /**
    * Set transform texture A (positions)
    * @param texture Texture containing positions
    */
-  setTransformA(e) {
-    this.uniforms.transformA.value = e;
+  setTransformA(t) {
+    this.uniforms.transformA.value = t;
   }
   /**
    * Set transform texture B (rotation, scale)
    * @param texture Texture containing rotation and scale data
    */
-  setTransformB(e) {
-    this.uniforms.transformB.value = e;
+  setTransformB(t) {
+    this.uniforms.transformB.value = t;
   }
   /**
    * Set color texture
    * @param texture Texture containing colors
    */
-  setColorTexture(e) {
-    this.uniforms.splatColor.value = e;
+  setColorTexture(t) {
+    this.uniforms.splatColor.value = t;
   }
   /**
    * Set order texture
    * @param texture Texture containing sort order
    */
-  setOrderTexture(e) {
-    this.uniforms.splatOrder.value = e;
+  setOrderTexture(t) {
+    this.uniforms.splatOrder.value = t;
   }
   /**
    * Set number of splats to render
    * @param count Number of splats
    */
-  setNumSplats(e) {
-    this.uniforms.numSplats.value = e;
+  setNumSplats(t) {
+    this.uniforms.numSplats.value = t;
   }
 }
-const N = class N extends i.Mesh {
+const j = class j extends n.Mesh {
   // Match shader constant
   /**
    * Create a new SplatMesh for rendering Gaussian splats
    * @param splatData The splat data to render
    * @param options Rendering options
    */
-  constructor(t, o = {}) {
-    const r = (typeof window < "u" && window.__VISUS_SPLAT_DEBUG__) === !0;
-    r && console.debug(
-      "[1/8] MESH SplatMesh: creating mesh with",
-      t.numSplats,
-      "splats"
-    );
-    const n = new we(o), s = N.createInstancedGeometry(t.numSplats, N.INSTANCE_SIZE);
-    r && console.debug(
-      "[2/8] MESH SplatMesh: created instanced geometry with",
-      Math.ceil(t.numSplats / N.INSTANCE_SIZE),
-      "instances"
-    );
-    super(s, n);
-    p(this, "sorter");
-    p(this, "splatData");
-    p(this, "options");
-    p(this, "textureManager");
-    p(this, "material");
-    p(this, "geometry");
-    p(this, "lastCameraPositionLocal", new i.Vector3());
-    p(this, "lastCameraDirectionLocal", new i.Vector3());
-    p(this, "invModelMatrix", new i.Matrix4());
-    this.geometry = s, this.material = n, this.splatData = t, this.frustumCulled = !1, this.options = { autoSort: !0, ...o }, r && console.debug("[3/8] MESH SplatMesh: initializing texture manager"), this.textureManager = new xe(t), this.sorter = new he(), r && console.debug("[4/8] MESH SplatMesh: creating chunks for sorter");
-    let a = this.createChunks() || void 0;
-    a === null && console.warn("Visus: Could not create sorter chunks, bounding box might be invalid."), a = void 0, r && console.debug(
-      "[5/8] MESH SplatMesh: initializing sorter with",
-      a ? "chunks" : "no chunks"
-    ), this.sorter.init(
+  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());
+    // 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);
+    });
+    this.geometry = o, this.material = r, this.splatData = s, 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.orderTexture,
       this.splatData.centers,
-      a ?? void 0
-    ), this.sorter.addEventListener(
-      "updated",
-      (c) => {
-        const f = c.count;
-        r && console.debug(
-          "[6/8] MESH SplatMesh: sorter updated, rendering",
-          f,
-          "splats"
-        ), this.geometry.instanceCount = Math.ceil(f / N.INSTANCE_SIZE), this.material.setNumSplats(f);
-      }
-    ), r && console.debug("[7/8] MESH SplatMesh: setting up material textures"), 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 = t.boundingBox.toBox3(), this.geometry.boundingSphere = new i.Sphere(), this.geometry.boundingBox.getBoundingSphere(this.geometry.boundingSphere), r && console.debug(
-      "[8/8] MESH SplatMesh: mesh initialization complete, bounding box:",
-      t.boundingBox
-    );
+      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);
   }
   /**
    * Creates the instanced geometry for rendering splats.
@@ -998,16 +991,8 @@ const N = class N extends i.Mesh {
    * @param instanceSize Number of splats per instance.
    * @returns InstancedBufferGeometry
    */
-  static createInstancedGeometry(t, o) {
-    const r = (typeof window < "u" && window.__VISUS_SPLAT_DEBUG__) === !0, n = Math.ceil(t / o);
-    r && console.debug(
-      "MESH createInstancedGeometry: creating geometry for",
-      t,
-      "splats,",
-      n,
-      "instances"
-    );
-    const s = new i.BufferGeometry(), a = new Float32Array([
+  static createInstancedGeometry(s, e) {
+    const r = Math.ceil(s / e), o = new n.BufferGeometry(), i = new Float32Array([
       // x, y, splat_index_in_instance
       -1,
       -1,
@@ -1021,79 +1006,56 @@ const N = class N extends i.Mesh {
       -1,
       1,
       0
-    ]), c = new Uint16Array([0, 1, 2, 0, 2, 3]), f = new Float32Array(4 * 3 * o);
-    for (let d = 0; d < o; d++) {
-      const S = d * 4 * 3;
-      for (let u = 0; u < 4; u++)
-        f[S + u * 3 + 0] = a[u * 3 + 0], f[S + u * 3 + 1] = a[u * 3 + 1], f[S + u * 3 + 2] = d;
+    ]), 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;
     }
-    const m = new Uint32Array(6 * o);
-    for (let d = 0; d < o; d++) {
-      const S = d * 6, u = d * 4;
-      m[S + 0] = c[0] + u, m[S + 1] = c[1] + u, m[S + 2] = c[2] + u, m[S + 3] = c[3] + u, m[S + 4] = c[4] + u, m[S + 5] = c[5] + 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;
     }
-    s.setAttribute("position", new i.BufferAttribute(f, 3)), s.setIndex(new i.BufferAttribute(m, 1));
-    const x = new i.InstancedBufferGeometry();
-    x.index = s.index, x.setAttribute("position", s.getAttribute("position"));
-    const v = new Uint32Array(n);
-    for (let d = 0; d < n; d++)
-      v[d] = d * o;
-    return x.setAttribute("splatInstanceIndex", new i.InstancedBufferAttribute(v, 1, !1)), x.instanceCount = 0, r && console.debug(
-      "MESH createInstancedGeometry: geometry created with",
-      x.attributes.position.count,
-      "vertices"
-    ), x;
+    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;
   }
   /**
    * 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 t = (typeof window < "u" && window.__VISUS_SPLAT_DEBUG__) === !0, o = this.splatData.boundingBox;
-    if (o.min.x === 1 / 0 || o.max.x === -1 / 0)
-      return t && console.debug(
-        "MESH createChunks: invalid bounding box, cannot create chunks"
-      ), null;
-    const r = new Float32Array([
-      o.min.x,
-      o.min.y,
-      o.min.z,
-      o.max.x,
-      o.max.y,
-      o.max.z
+    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
     ]);
-    return t && console.debug(
-      "MESH createChunks: created chunks with bounding box",
-      o
-    ), r;
   }
   /**
    * Update the viewport size
    * @param width Viewport width
    * @param height Viewport height
    */
-  updateViewport(t, o) {
-    (typeof window < "u" && window.__VISUS_SPLAT_DEBUG__) === !0 && console.debug(
-      "MESH updateViewport: updating viewport to",
-      t,
-      "x",
-      o
-    ), this.material.updateViewport(t, o);
+  updateViewport(s, e) {
+    s === this._vpW && e === this._vpH || (this._vpW = s, this._vpH = e, this.material.updateViewport(s, e));
   }
   /**
    * Sorts splats based on camera position and direction.
    * @param camera The camera to sort against.
    */
-  sort(t) {
-    const o = (typeof window < "u" && window.__VISUS_SPLAT_DEBUG__) === !0, r = new i.Vector3(), n = new i.Vector3();
-    t.getWorldPosition(r), t.getWorldDirection(n), this.invModelMatrix.copy(this.matrixWorld).invert();
-    const s = r.applyMatrix4(this.invModelMatrix), a = n.transformDirection(this.invModelMatrix), c = this.lastCameraPositionLocal.distanceToSquared(s) > 1e-6, f = this.lastCameraDirectionLocal.dot(a) < 0.999;
-    this.options.autoSort && (c || f) && (o && console.debug(
-      "MESH sort: camera changed, triggering sort. Position changed:",
-      c,
-      "Direction changed:",
-      f
-    ), this.lastCameraPositionLocal.copy(s), this.lastCameraDirectionLocal.copy(a), this.sorter.setCamera(s, a));
+  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));
   }
   /**
    * THREE.js hook called before rendering the object.
@@ -1104,30 +1066,20 @@ const N = class N extends i.Mesh {
    */
   // prettier-ignore
   // @ts-expect-error scene is not used
-  onBeforeRender(t, o, r) {
-    this.sort(r);
-    const n = t.getSize(new i.Vector2());
-    let { width: s, height: a } = n;
-    const c = t.xr;
-    if (c.enabled && c.isPresenting) {
-      const f = c.getCamera().cameras[0].view;
-      f && (s = f.width, a = f.height);
-    }
-    this.updateViewport(s, a);
+  onBeforeRender(s, e, r) {
+    this.sort(r), s.getSize(this._size), this.updateViewport(this._size.x, this._size.y);
   }
   /**
    * Dispose of resources
    */
   dispose() {
-    const t = (typeof window < "u" && window.__VISUS_SPLAT_DEBUG__) === !0;
-    t && console.debug("MESH dispose: cleaning up mesh resources"), this.sorter.dispose(), this.geometry.dispose(), this.material.dispose(), this.textureManager.dispose(), t && console.debug("MESH dispose: mesh resources cleaned up");
+    this.sorter.removeEventListener("updated", this.onSorterUpdated), this.sorter.dispose(), this.geometry.dispose(), this.material.dispose(), this.textureManager.dispose();
   }
 };
-// Cached inverse matrix
 /** Number of splats combined into a single instanced draw call. */
-p(N, "INSTANCE_SIZE", 128);
-let ie = N;
-class be extends i.Loader {
+c(j, "INSTANCE_SIZE", 128);
+let it = j;
+class bt extends n.Loader {
   /**
    * Load a PLY file with Gaussian Splat data
    * @param url URL of the PLY file
@@ -1135,22 +1087,21 @@ class be extends i.Loader {
    * @param onProgress Optional progress callback
    * @param onError Optional error callback
    */
-  load(e, t, o, r) {
-    (typeof window < "u" && window.__VISUS_SPLAT_DEBUG__) === !0 && console.debug("[1/12] LOADER PlyLoader: loading", e);
-    const s = new i.FileLoader(this.manager);
-    s.setResponseType("arraybuffer"), s.setRequestHeader(this.requestHeader), s.setPath(this.path), s.setWithCredentials(this.withCredentials), s.load(
-      e,
-      (a) => {
+  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,
+      (i) => {
         try {
-          if (t) {
-            const c = this.parse(a);
-            t(c);
+          if (s) {
+            const a = this.parse(i);
+            s(a);
           }
-        } catch (c) {
-          r ? r(c) : console.error(c), this.manager.itemError(e);
+        } catch (a) {
+          r ? r(a) : console.error(a), this.manager.itemError(t);
         }
       },
-      o,
+      e,
       r
     );
   }
@@ -1160,22 +1111,22 @@ class be extends i.Loader {
    * @param onProgress Optional progress callback
    * @returns A Promise that resolves with the parsed SplatData
    */
-  loadAsync(e, t) {
-    return new Promise((o, r) => {
-      const n = new i.FileLoader(this.manager);
-      n.setResponseType("arraybuffer"), n.setRequestHeader(this.requestHeader), n.setPath(this.path), n.setWithCredentials(this.withCredentials), n.load(
-        e,
-        (s) => {
+  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,
+        (i) => {
           try {
-            const a = this.parse(s);
-            o(a);
+            const a = this.parse(i);
+            e(a);
           } catch (a) {
-            r(a), this.manager.itemError(e);
+            r(a), this.manager.itemError(t);
           }
         },
-        t,
-        (s) => {
-          r(s), this.manager.itemError(e);
+        s,
+        (i) => {
+          r(i), this.manager.itemError(t);
         }
       );
     });
@@ -1185,264 +1136,172 @@ class be extends i.Loader {
    * @param buffer ArrayBuffer containing PLY data
    * @returns Parsed SplatData
    */
-  parse(e) {
-    const t = (typeof window < "u" && window.__VISUS_SPLAT_DEBUG__) === !0;
-    t && console.debug(
-      "[2/12] LOADER PlyLoader: starting parse, buffer size:",
-      e.byteLength
-    );
-    const o = new TextDecoder(), r = new Uint8Array(e), n = [112, 108, 121, 10], s = `
+  parse(t) {
+    const s = new TextDecoder(), e = new Uint8Array(t), r = [112, 108, 121, 10], o = `
 end_header
 `;
-    for (let l = 0; l < n.length; l++)
-      if (r[l] !== n[l])
+    for (let x = 0; x < r.length; x++)
+      if (e[x] !== r[x])
         throw new Error("Invalid PLY file: Missing magic bytes");
-    t && console.debug("[3/12] LOADER PlyLoader: PLY magic bytes verified");
-    let a = 0;
-    for (let l = 0; l < r.length - s.length; l++) {
-      let h = !0;
-      for (let w = 0; w < s.length; w++)
-        if (r[l + w] !== s.charCodeAt(w)) {
-          h = !1;
+    let i = 0;
+    for (let x = 0; x < e.length - o.length; x++) {
+      let u = !0;
+      for (let S = 0; S < o.length; S++)
+        if (e[x + S] !== o.charCodeAt(S)) {
+          u = !1;
           break;
         }
-      if (h) {
-        a = l + s.length;
+      if (u) {
+        i = x + o.length;
         break;
       }
     }
-    if (a === 0)
+    if (i === 0)
       throw new Error("Invalid PLY file: Could not find end of header");
-    t && console.debug(
-      "[4/12] LOADER PlyLoader: header length:",
-      a
-    );
-    const c = o.decode(r.subarray(0, a));
-    t && console.debug("[5/12] LOADER PlyLoader: header text:", c);
-    const f = c.split(`
-`), m = [];
-    let x = null;
-    for (let l = 1; l < f.length; l++) {
-      const h = f[l].trim();
-      if (h === "" || h === "end_header") continue;
-      const w = h.split(" ");
-      switch (w[0]) {
+    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 S = u.split(" ");
+      switch (S[0]) {
         case "format":
-          x = w[1], t && console.debug(
-            "[6/12] LOADER PlyLoader: format detected:",
-            x
-          );
+          v = S[1];
           break;
         case "element":
-          m.push({
-            name: w[1],
-            count: parseInt(w[2], 10),
+          f.push({
+            name: S[1],
+            count: parseInt(S[2], 10),
             properties: []
-          }), t && console.debug(
-            "[6/12] LOADER PlyLoader: element found:",
-            w[1],
-            "count:",
-            w[2]
-          );
+          });
           break;
         case "property":
-          if (m.length === 0)
+          if (f.length === 0)
             throw new Error(
               "Invalid PLY file: Property without element"
             );
-          m[m.length - 1].properties.push({
-            type: w[1],
-            name: w[2],
+          f[f.length - 1].properties.push({
+            type: S[1],
+            name: S[2],
             storage: null
-          }), t && console.debug(
-            "[6/12] LOADER PlyLoader: property found:",
-            w[2],
-            "type:",
-            w[1]
-          );
+          });
           break;
       }
     }
-    if (x !== "binary_little_endian")
-      throw new Error(`Unsupported PLY format: ${x}`);
-    const v = m.find((l) => l.name === "vertex");
-    if (!v)
+    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");
-    t && console.debug(
-      "[7/12] LOADER PlyLoader: vertex element properties:",
-      v.properties.map((l) => l.name)
-    );
-    const d = new de(v.count);
-    t && console.debug(
-      "[8/12] LOADER PlyLoader: created SplatData for",
-      v.count,
-      "splats"
-    );
-    const S = new DataView(e);
-    let u = a;
-    const M = (l) => v.properties.findIndex((h) => h.name === l), O = M("x"), H = M("y"), R = M("z"), P = [
-      M("rot_0"),
-      M("rot_1"),
-      M("rot_2"),
-      M("rot_3")
+    const p = new ut(g.count), h = new DataView(t);
+    let l = i;
+    const b = (x) => g.properties.findIndex((u) => u.name === x), T = 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 = [
-      M("scale_0"),
-      M("scale_1"),
-      M("scale_2")
-    ], B = [
-      M("f_dc_0"),
-      M("f_dc_1"),
-      M("f_dc_2")
-    ], A = M("opacity");
-    if (t && console.debug("[9/12] LOADER PlyLoader: property indices:", {
-      position: [O, H, R],
-      rotation: P,
-      scale: W,
-      color: B,
-      opacity: A
-    }), [
+      b("f_dc_0"),
+      b("f_dc_1"),
+      b("f_dc_2")
+    ], k = b("opacity");
+    if ([
+      T,
       O,
-      H,
-      R,
-      ...P,
+      q,
+      ...E,
+      ...R,
       ...W,
-      ...B,
-      A
-    ].some((l) => l === -1))
+      k
+    ].some((x) => x === -1))
       throw new Error("Invalid PLY file: Missing required properties");
-    const C = 0.28209479177387814, y = (l) => {
-      if (l > 0) return 1 / (1 + Math.exp(-l));
-      const h = Math.exp(l);
-      return h / (1 + h);
-    };
-    t && console.debug(
-      "[10/12] LOADER PlyLoader: starting binary data parsing, offset:",
-      u
-    );
-    const _ = new i.Vector3(), I = new i.Quaternion(), V = new i.Vector3(), E = new i.Color();
-    for (let l = 0; l < v.count; l++) {
-      t && l % 1e4 === 0 && console.debug(
-        `[10/12] LOADER PlyLoader: processing splat ${l}/${v.count} (${(l / v.count * 100).toFixed(1)}%)`
-      );
-      const h = [];
-      for (let q = 0; q < v.properties.length; q++) {
-        const L = v.properties[q].type;
-        let U;
-        switch (L) {
+    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(), B = new n.Quaternion(), V = new n.Vector3(), P = new n.Color();
+    for (let x = 0; x < g.count; x++) {
+      const u = [];
+      for (let I = 0; I < g.properties.length; I++) {
+        const K = g.properties[I].type;
+        let z;
+        switch (K) {
           case "char":
-            U = S.getInt8(u), u += 1;
+            z = h.getInt8(l), l += 1;
             break;
           case "uchar":
-            U = S.getUint8(u), u += 1;
+            z = h.getUint8(l), l += 1;
             break;
           case "short":
-            U = S.getInt16(u, !0), u += 2;
+            z = h.getInt16(l, !0), l += 2;
             break;
           case "ushort":
-            U = S.getUint16(u, !0), u += 2;
+            z = h.getUint16(l, !0), l += 2;
             break;
           case "int":
-            U = S.getInt32(u, !0), u += 4;
+            z = h.getInt32(l, !0), l += 4;
             break;
           case "uint":
-            U = S.getUint32(u, !0), u += 4;
+            z = h.getUint32(l, !0), l += 4;
             break;
           case "float":
-            U = S.getFloat32(u, !0), u += 4;
+            z = h.getFloat32(l, !0), l += 4;
             break;
           case "double":
-            U = S.getFloat64(u, !0), u += 8;
+            z = h.getFloat64(l, !0), l += 8;
             break;
           default:
-            throw new Error(`Unsupported property type: ${L}`);
+            throw new Error(`Unsupported property type: ${K}`);
         }
-        h.push(U);
+        u.push(z);
       }
-      _.set(
-        h[O],
-        h[H],
-        h[R]
-      ), I.set(
-        h[P[1]],
+      m.set(
+        u[T],
+        u[O],
+        u[q]
+      ), B.set(
+        u[E[1]],
         // PLY stores rot 1,2,3,0 (x,y,z,w)
-        h[P[2]],
-        h[P[3]],
-        h[P[0]]
-      ).normalize(), t && l < 5 && console.debug(
-        `[10/12] LOADER PlyLoader: splat ${l} rotation:`,
-        {
-          original: [
-            h[P[0]],
-            h[P[1]],
-            h[P[2]],
-            h[P[3]]
-          ],
-          processed: [
-            I.x,
-            I.y,
-            I.z,
-            I.w
-          ]
-        }
-      ), V.set(
-        h[W[0]],
+        u[E[2]],
+        u[E[3]],
+        u[E[0]]
+      ).normalize(), V.set(
+        u[R[0]],
         // Read directly assuming it's log scale
-        h[W[1]],
-        h[W[2]]
-      ), E.set(
-        0.5 + h[B[0]] * C,
-        0.5 + h[B[1]] * C,
-        0.5 + h[B[2]] * C
-      ), E.r = Math.max(0, Math.min(1, E.r)), E.g = Math.max(0, Math.min(1, E.g)), E.b = Math.max(0, Math.min(1, E.b));
-      const w = y(h[A]);
-      t && l < 3 && console.debug(`[10/12] LOADER PlyLoader: splat ${l} data:`, {
-        position: [_.x, _.y, _.z],
-        rotation: [
-          I.x,
-          I.y,
-          I.z,
-          I.w
-        ],
-        scale: [V.x, V.y, V.z],
-        color: [E.r, E.g, E.b],
-        opacity: w
-      }), d.setSplat(
-        l,
-        _,
-        I,
+        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 S = M(u[k]);
+      p.setSplat(
+        x,
+        m,
+        B,
         V,
         // Pass log scale directly
-        E,
-        w
+        P,
+        S
       );
     }
-    return t && console.debug(
-      "[11/12] LOADER PlyLoader: finished parsing all splats, calculating bounding box"
-    ), d.calculateBoundingBox(), t && console.debug(
-      "[12/12] LOADER PlyLoader: parsing complete, bounding box:",
-      {
-        min: [
-          d.boundingBox.min.x,
-          d.boundingBox.min.y,
-          d.boundingBox.min.z
-        ],
-        max: [
-          d.boundingBox.max.x,
-          d.boundingBox.max.y,
-          d.boundingBox.max.z
-        ]
-      }
-    ), d;
+    return p.calculateBoundingBox(), p;
   }
 }
-const Se = "0.3.0";
+const Mt = "0.3.0";
 export {
-  te as BoundingBox,
-  be as PlyLoader,
-  de as SplatData,
-  we as SplatMaterial,
-  ie as SplatMesh,
-  he as SplatSorter,
-  xe as TextureManager,
-  Se as VERSION
+  et as BoundingBox,
+  bt as PlyLoader,
+  ut as SplatData,
+  vt as SplatMaterial,
+  it as SplatMesh,
+  dt as SplatSorter,
+  xt as TextureManager,
+  Mt as VERSION
 };