@speridlabs/visus 1.0.0 → 1.0.2

package/dist/main.es.js

@@ -1,14 +1,14 @@
-var lt = Object.defineProperty;
-var ht = (A, t, n) => t in A ? lt(A, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : A[t] = n;
-var f = (A, t, n) => ht(A, typeof t != "symbol" ? t + "" : t, n);
+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 et {
+class te {
   constructor() {
-    f(this, "min", new i.Vector3(1 / 0, 1 / 0, 1 / 0));
-    f(this, "max", new i.Vector3(-1 / 0, -1 / 0, -1 / 0));
-    f(this, "center", new i.Vector3());
+    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());
     /** Half extents (size/2) */
-    f(this, "halfExtents", new i.Vector3());
+    p(this, "halfExtents", new i.Vector3());
   }
   /**
    * Reset the bounding box to its initial state
@@ -20,15 +20,15 @@ class et {
    * Expand the bounding box to include the given point
    * @param point Point to include in the bounding box
    */
-  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();
+  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();
   }
   /**
    * Expand this bounding box to include another bounding box
    * @param box Bounding box to include
    */
-  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();
+  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();
   }
   /**
    * Update the center and half extents based on min/max
@@ -41,8 +41,8 @@ class et {
    * @param point Point to check
    * @returns True if the point is inside the box
    */
-  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;
+  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;
   }
   /**
    * Create a Three.js Box3 from this bounding box
@@ -56,25 +56,25 @@ class et {
    * @returns New bounding box with the same values
    */
   clone() {
-    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;
+    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;
   }
 }
-class ut {
+class de {
   // TODO: there is no sh spherical harmonics
-  constructor(t = 0) {
-    f(this, "numSplats", 0);
-    f(this, "positions");
-    f(this, "rotations");
-    f(this, "scales");
-    f(this, "colors");
-    f(this, "opacities");
-    f(this, "centers");
-    f(this, "boundingBox", new et());
-    this.numSplats = t, this.allocateBuffers(t);
+  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);
   }
-  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);
+  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);
   }
   /**
    * Set data for a specific splat
@@ -85,36 +85,36 @@ class ut {
    * @param color Color
    * @param opacity Opacity value
    */
-  setSplat(t, n, e, r, s, o) {
-    if (t >= this.numSplats)
+  setSplat(e, t, o, r, n, s) {
+    if (e >= this.numSplats)
       throw new Error(
-        `Splat index out of bounds: ${t} >= ${this.numSplats}`
+        `Splat index out of bounds: ${e} >= ${this.numSplats}`
       );
-    const a = t * 3, c = t * 4, h = t * 3, v = t * 3;
-    this.positions[a] = n.x, this.positions[a + 1] = n.y, this.positions[a + 2] = n.z, this.rotations[c] = e.x, this.rotations[c + 1] = e.y, this.rotations[c + 2] = e.z, this.rotations[c + 3] = e.w, this.scales[h] = r.x, this.scales[h + 1] = r.y, this.scales[h + 2] = r.z, this.colors[v] = s.r, this.colors[v + 1] = s.g, this.colors[v + 2] = s.b, this.opacities[t] = o, this.centers[a] = n.x, this.centers[a + 1] = n.y, this.centers[a + 2] = n.z;
+    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;
   }
   /**
    * Get a splat's data
    * @param index Splat index
    * @returns Object containing splat data (linear scale)
    */
-  getSplat(t) {
-    if (t >= this.numSplats)
+  getSplat(e) {
+    if (e >= this.numSplats)
       throw new Error(
-        `Splat index out of bounds: ${t} >= ${this.numSplats}`
+        `Splat index out of bounds: ${e} >= ${this.numSplats}`
       );
-    const n = t * 3, e = t * 4, r = t * 3, s = t * 3;
+    const t = e * 3, o = e * 4, r = e * 3, n = e * 3;
     return {
       position: new i.Vector3(
-        this.positions[n],
-        this.positions[n + 1],
-        this.positions[n + 2]
+        this.positions[t],
+        this.positions[t + 1],
+        this.positions[t + 2]
       ),
       rotation: new i.Quaternion(
-        this.rotations[e],
-        this.rotations[e + 1],
-        this.rotations[e + 2],
-        this.rotations[e + 3]
+        this.rotations[o],
+        this.rotations[o + 1],
+        this.rotations[o + 2],
+        this.rotations[o + 3]
       ),
       // Convert log scale back to linear scale for external use
       scale: new i.Vector3(
@@ -123,11 +123,11 @@ class ut {
         Math.exp(this.scales[r + 2])
       ),
       color: new i.Color(
-        this.colors[s],
-        this.colors[s + 1],
-        this.colors[s + 2]
+        this.colors[n],
+        this.colors[n + 1],
+        this.colors[n + 2]
       ),
-      opacity: this.opacities[t]
+      opacity: this.opacities[e]
     };
   }
   /**
@@ -136,14 +136,14 @@ class ut {
    */
   calculateBoundingBox() {
     this.boundingBox.reset();
-    const t = new i.Vector3();
-    for (let n = 0; n < this.numSplats; n++) {
-      const e = n * 3;
-      t.set(
-        this.positions[e],
-        this.positions[e + 1],
-        this.positions[e + 2]
-      ), this.boundingBox.expandByPoint(t);
+    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);
     }
     return this.boundingBox;
   }
@@ -152,64 +152,64 @@ class ut {
    * This is for visualization/debugging purposes only, not for rendering
    */
   createDebugGeometry() {
-    const t = new i.BufferGeometry();
-    t.setAttribute(
+    const e = new i.BufferGeometry();
+    e.setAttribute(
       "position",
       new i.BufferAttribute(this.positions, 3)
     );
-    const n = new Float32Array(this.numSplats * 3), e = new i.Quaternion(), r = new i.Euler();
-    for (let s = 0; s < this.numSplats; s++) {
-      const o = s * 4, a = s * 3;
-      e.set(
-        this.rotations[o],
-        this.rotations[o + 1],
-        this.rotations[o + 2],
-        this.rotations[o + 3]
-      ), r.setFromQuaternion(e), n[a] = r.x, n[a + 1] = r.y, n[a + 2] = r.z;
+    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;
     }
-    return t.setAttribute(
+    return e.setAttribute(
       "rotation",
-      new i.BufferAttribute(n, 3)
-    ), t.setAttribute(
+      new i.BufferAttribute(t, 3)
+    ), e.setAttribute(
       "scale",
       new i.BufferAttribute(this.scales, 3)
-    ), t.setAttribute(
+    ), e.setAttribute(
       "color",
       new i.BufferAttribute(this.colors, 3)
-    ), t.setAttribute(
+    ), e.setAttribute(
       "opacity",
       new i.BufferAttribute(this.opacities, 1)
-    ), t;
+    ), e;
   }
 }
-class dt extends i.EventDispatcher {
+class he extends i.EventDispatcher {
   constructor() {
     super();
-    f(this, "worker");
-    f(this, "centers", null);
-    f(this, "orderTexture", null);
+    p(this, "worker");
+    p(this, "centers", null);
+    p(this, "orderTexture", null);
     /** Bounding box data for optimization */
-    f(this, "chunks", null);
-    f(this, "lastCameraPosition", new i.Vector3());
-    f(this, "lastCameraDirection", new i.Vector3());
-    const n = this.createWorkerCode(), e = new Blob([n], { type: "application/javascript" });
-    this.worker = new Worker(URL.createObjectURL(e)), this.worker.onmessage = this.onWorkerMessage.bind(this);
+    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);
   }
   /**
    * Handles messages received from the sorting worker.
    * @param event The message event from the worker.
    */
-  onWorkerMessage(n) {
+  onWorkerMessage(t) {
     if (!this.orderTexture || !this.orderTexture.image)
       return console.error("SplatSorter: Order texture not initialized!");
-    const { order: e, count: r } = n.data, s = this.orderTexture.image.data;
-    if (!(s instanceof Uint32Array))
+    const { order: o, count: r } = t.data, n = this.orderTexture.image.data;
+    if (!(n instanceof Uint32Array))
       return console.error(
         "SplatSorter: Order texture data is not a Uint32Array!"
       );
-    s.set(new Uint32Array(e)), this.orderTexture.needsUpdate = !0;
-    const o = s.buffer.slice(0), a = { order: o };
-    this.worker.postMessage(a, [o]), this.dispatchEvent({ type: "updated", count: r });
+    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 });
   }
   /**
    * Initializes the sorter with necessary data and textures.
@@ -217,84 +217,84 @@ class dt 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(n, e, r) {
-    if (!n || !(n.image.data instanceof Uint32Array))
+  init(t, o, r) {
+    if (!t || !(t.image.data instanceof Uint32Array))
       throw new Error("SplatSorter: Invalid orderTexture provided. Must be DataTexture with Uint32Array data.");
-    if (!e || e.length % 3 !== 0)
+    if (!o || o.length % 3 !== 0)
       throw new Error("SplatSorter: Invalid centers array provided. Length must be multiple of 3.");
-    if (n.image.data.length < e.length / 3)
+    if (t.image.data.length < o.length / 3)
       throw new Error("SplatSorter: orderTexture data buffer is smaller than the number of splats.");
-    const s = e.length / 3;
-    this.orderTexture = n, this.centers = e.slice();
-    const o = this.orderTexture.image.data;
-    for (let y = 0; y < s; y++) o[y] = y;
+    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;
     this.orderTexture.needsUpdate = !0;
-    const a = o.buffer.slice(0), c = this.centers.buffer.slice(0), h = {
+    const a = s.buffer.slice(0), c = this.centers.buffer.slice(0), f = {
       order: a,
       centers: c
-    }, v = [
+    }, m = [
       a,
       c
     ];
     if (r) {
       this.chunks = r.slice();
-      const y = this.chunks.buffer.slice(0);
-      h.chunks = y, v.push(y);
+      const x = this.chunks.buffer.slice(0);
+      f.chunks = x, m.push(x);
     }
-    this.worker.postMessage(h, v);
+    this.worker.postMessage(f, m);
   }
   /**
    * 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(n) {
+  setMapping(t) {
     if (!this.centers)
       return console.warn(
         "SplatSorter: Cannot set mapping before initialization."
       );
-    let e;
+    let o;
     const r = [];
-    if (!n) {
+    if (!t) {
       const c = this.centers.buffer.slice(0);
-      return e = {
+      return o = {
         centers: c,
         mapping: null
-      }, r.push(c), this.worker.postMessage(e, r);
+      }, r.push(c), this.worker.postMessage(o, r);
     }
-    const s = new Float32Array(n.length * 3);
-    for (let c = 0; c < n.length; c++) {
-      const h = n[c];
-      if (h * 3 + 2 >= this.centers.length) {
+    const n = new Float32Array(t.length * 3);
+    for (let c = 0; c < t.length; c++) {
+      const f = t[c];
+      if (f * 3 + 2 >= this.centers.length) {
         console.warn(
-          `SplatSorter: Mapping index ${h} out of bounds.`
+          `SplatSorter: Mapping index ${f} out of bounds.`
         );
         continue;
       }
-      const v = h * 3, y = c * 3;
-      s[y + 0] = this.centers[v + 0], s[y + 1] = this.centers[v + 1], s[y + 2] = this.centers[v + 2];
+      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 o = s.buffer.slice(0), a = n.buffer.slice(0);
-    e = {
-      centers: o,
+    const s = n.buffer.slice(0), a = t.buffer.slice(0);
+    o = {
+      centers: s,
       mapping: a
-    }, r.push(o, a), this.worker.postMessage(e, r);
+    }, r.push(s, a), this.worker.postMessage(o, 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(n, e) {
-    const r = this.lastCameraPosition.distanceToSquared(n) > 1e-7, s = this.lastCameraDirection.dot(e) < 0.9999;
-    if (!r && !s)
+  setCamera(t, o) {
+    const r = this.lastCameraPosition.distanceToSquared(t) > 1e-7, n = this.lastCameraDirection.dot(o) < 0.9999;
+    if (!r && !n)
       return;
-    this.lastCameraPosition.copy(n), this.lastCameraDirection.copy(e);
-    const o = {
-      cameraPosition: { x: n.x, y: n.y, z: n.z },
-      cameraDirection: { x: e.x, y: e.y, z: e.z }
+    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.worker.postMessage(o);
+    this.worker.postMessage(s);
   }
   /**
    * Terminates the Web Worker and cleans up resources.
@@ -308,183 +308,183 @@ class dt extends i.EventDispatcher {
    */
   createWorkerCode() {
     return `(${(function() {
-      let e = null, r = null, s = null, o = null, a = null, c = null, h = !1;
-      const v = { x: 0, y: 0, z: 0 }, y = { x: 0, y: 0, z: 0 }, p = { x: 0, y: 0, z: 0 }, u = { x: 0, y: 0, z: 0 };
-      let l = null, b = null;
-      const B = 32, O = new Array(B).fill(0), q = new Array(B).fill(0), E = new Array(B).fill(0), R = (F, S, D) => {
-        for (; F <= S; ) {
-          const M = S + F >> 1, m = D(M);
-          if (m > 0) F = M + 1;
-          else if (m < 0) S = M - 1;
-          else return M;
+      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;
         }
-        return ~F;
+        return ~B;
       }, W = () => {
-        if (!e || !r || !a || !c)
+        if (!o || !r || !a || !c)
           return;
         if (r.length === 0) {
           const g = {
-            order: e.buffer,
+            order: o.buffer,
             count: 0
           };
-          self.postMessage(g, [e.buffer]), e = null;
+          self.postMessage(g, [o.buffer]), o = null;
           return;
         }
-        const F = a.x, S = a.y, D = a.z, M = c.x, m = c.y, C = c.z, _ = 1e-4, V = Math.abs(F - v.x) > _ || Math.abs(S - v.y) > _ || Math.abs(D - v.z) > _, x = Math.abs(M - y.x) > _ || Math.abs(m - y.y) > _ || Math.abs(C - y.z) > _;
-        if (!h && !V && !x)
+        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)
           return;
-        h = !1, v.x = F, v.y = S, v.z = D, y.x = M, y.y = m, y.z = C;
-        let d = 1 / 0, z = -1 / 0;
+        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 k = g & 1 ? p.x : u.x, U = g & 2 ? p.y : u.y, w = g & 4 ? p.z : u.z, P = k * M + U * m + w * C;
-          d = Math.min(d, P), z = Math.max(z, P);
+          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);
         }
-        const T = r.length / 3, L = z - d, I = (1 << Math.max(
+        const w = r.length / 3, q = h - l, L = (1 << Math.max(
           10,
-          Math.min(20, Math.ceil(Math.log2(T / 4)))
+          Math.min(20, Math.ceil(Math.log2(w / 4)))
         )) + 1;
-        if ((!l || l.length !== T) && (l = new Uint32Array(T)), !b || b.length !== I ? b = new Uint32Array(I) : b.fill(0), L < 1e-7) {
-          for (let g = 0; g < T; ++g) l[g] = 0;
-          b[0] = T;
-        } else if (s && s.length > 0) {
-          const g = s.length / 6;
+        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;
           O.fill(0);
-          for (let w = 0; w < g; ++w) {
-            const P = w * 6, Z = s[P + 0], G = s[P + 1], $ = s[P + 2], H = s[P + 3], Y = Z * M + G * m + $ * C - d, J = Y - H, X = Y + H, Q = Math.max(
+          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(
               0,
-              Math.floor(J * B / L)
-            ), tt = Math.min(
-              B,
-              Math.ceil(X * B / L)
+              Math.floor(K * M / q)
+            ), ee = Math.min(
+              M,
+              Math.ceil($ * M / q)
             );
-            for (let N = Q; N < tt; ++N)
-              O[N]++;
+            for (let j = Q; j < ee; ++j)
+              O[j]++;
           }
-          let k = 0;
-          for (let w = 0; w < B; ++w) k += O[w];
-          E[0] = 0, q[0] = 0;
-          for (let w = 1; w < B; ++w)
-            E[w - 1] = O[w - 1] / k * I >>> 0, q[w] = q[w - 1] + E[w - 1];
-          E[B - 1] = O[B - 1] / k * I >>> 0;
-          const U = L / B;
-          for (let w = 0; w < T; ++w) {
-            const P = w * 3, Z = r[P + 0], G = r[P + 1], $ = r[P + 2], H = Z * M + G * m + $ * C, J = (z - H) / U, X = Math.max(
+          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(
               0,
               Math.min(
-                B - 1,
-                Math.floor(J)
+                M - 1,
+                Math.floor(K)
               )
-            ), Q = J - X, tt = q[X] + E[X] * Q >>> 0, N = Math.min(tt, I - 1);
-            l[w] = N, b[N]++;
+            ), Q = K - $, ee = H[$] + R[$] * Q >>> 0, j = Math.min(ee, L - 1);
+            S[b] = j, u[j]++;
           }
         } else {
-          const g = (I - 1) / L;
-          for (let k = 0; k < T; ++k) {
-            const U = k * 3, w = r[U + 0], P = r[U + 1], Z = r[U + 2], G = w * M + P * m + Z * C, H = (z - G) * g >>> 0, Y = Math.min(H, I - 1);
-            l[k] = Y, b[Y]++;
+          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]++;
           }
         }
-        for (let g = 1; g < I; g++)
-          b[g] += b[g - 1];
-        for (let g = T - 1; g >= 0; g--) {
-          const k = l[g], U = --b[k];
-          e[U] = o ? o[g] : g;
+        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;
         }
-        const at = F * M + S * m + D * C, rt = (g) => {
-          if (!e) return -1 / 0;
-          const k = e[g], U = k;
-          if (!r || U * 3 + 2 >= r.length)
+        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)
             return -1 / 0;
-          const w = U * 3;
-          return r[w] * M + r[w + 1] * m + r[w + 2] * C - at;
+          const b = k * 3;
+          return r[b] * C + r[b + 1] * y + r[b + 2] * _ - U;
         };
-        let st = T;
-        if (T > 0 && rt(T - 1) < 0) {
-          const g = R(
+        let oe = w;
+        if (w > 0 && re(w - 1) < 0) {
+          const g = P(
             0,
-            T - 1,
-            rt
+            w - 1,
+            re
           );
-          st = g < 0 ? ~g : g;
+          oe = g < 0 ? ~g : g;
         }
-        const ct = {
-          order: e.buffer,
-          count: st
+        const ce = {
+          order: o.buffer,
+          count: oe
         };
-        self.postMessage(ct, [e.buffer]), e = null;
+        self.postMessage(ce, [o.buffer]), o = null;
       };
-      self.onmessage = (F) => {
-        const S = F.data;
-        S.order && (e = new Uint32Array(S.order));
-        let D = !1;
-        if (S.centers && (r = new Float32Array(S.centers), D = !0, h = !0), Object.prototype.hasOwnProperty.call(S, "mapping") && (o = S.mapping ? new Uint32Array(S.mapping) : null, h = !0), S.chunks) {
-          if (s = new Float32Array(S.chunks), s.length > 0 && s[3] > 0)
-            for (let M = 0; M < s.length / 6; ++M) {
-              const m = M * 6, C = s[m + 0], _ = s[m + 1], V = s[m + 2], x = s[m + 3], d = s[m + 4], z = s[m + 5];
-              s[m + 0] = (C + x) * 0.5, s[m + 1] = (_ + d) * 0.5, s[m + 2] = (V + z) * 0.5, s[m + 3] = Math.sqrt(
-                (x - C) ** 2 + (d - _) ** 2 + (z - V) ** 2
+      self.onmessage = (B) => {
+        const A = B.data;
+        A.order && (o = new Uint32Array(A.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
               ) * 0.5;
             }
-          h = !0;
+          f = !0;
         }
-        if (D && r && r.length > 0) {
-          p.x = u.x = r[0], p.y = u.y = r[1], p.z = u.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]), u.x = Math.max(u.x, r[m + 0]), p.y = Math.min(p.y, r[m + 1]), u.y = Math.max(u.y, r[m + 1]), p.z = Math.min(p.z, r[m + 2]), u.z = Math.max(u.z, r[m + 2]);
+        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]);
           }
-        } else D && r && r.length === 0 && (p.x = u.x = p.y = u.y = p.z = u.z = 0);
-        S.cameraPosition && (a = S.cameraPosition), S.cameraDirection && (c = S.cameraDirection), W();
+        } 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();
       };
     }).toString()})();`;
   }
 }
-const ft = (A, t) => {
-  const n = nt(A), e = nt(t);
-  return n | e << 16;
+const fe = (z, e) => {
+  const t = ne(z), o = ne(e);
+  return t | o << 16;
 };
-function nt(A) {
-  const t = new Float32Array([A]), e = new Int32Array(t.buffer)[0];
-  let r = e >> 16 & 32768, s = e >> 12 & 2047;
-  const o = e >> 23 & 255;
-  return o < 103 ? r : o > 142 ? (r |= 31744, r |= (o === 255 ? 0 : 1) && e & 8388607, r) : o < 113 ? (s |= 2048, r |= (s >> 114 - o) + (s >> 113 - o & 1), r) : (r |= o - 112 << 10 | s >> 1, r += s & 1, r);
+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);
 }
-const pt = new ArrayBuffer(4), ot = new DataView(pt), mt = (A) => (ot.setUint32(0, A, !0), ot.getFloat32(0, !0));
-class xt {
+const pe = new ArrayBuffer(4), se = new DataView(pe), me = (z) => (se.setUint32(0, z, !0), se.getFloat32(0, !0));
+class xe {
   /**
    * Create a new TextureManager for a set of splats
    * @param splatData The splat data to manage textures for
    */
-  constructor(t) {
-    f(this, "transformA");
+  constructor(e) {
+    p(this, "transformA");
     // position xyz and rotation quaternion y,z components
-    f(this, "transformB");
+    p(this, "transformB");
     // rotation quaternion x and scale xyz
-    f(this, "colorTexture");
+    p(this, "colorTexture");
     // color an opacity
-    f(this, "orderTexture");
-    f(this, "textureWidth");
-    f(this, "textureHeight");
-    const n = t.numSplats;
-    this.textureWidth = Math.ceil(Math.sqrt(n)), this.textureHeight = Math.ceil(n / this.textureWidth), this.transformA = this.createTransformATexture(t), this.transformB = this.createTransformBTexture(t), this.colorTexture = this.createColorTexture(t), this.orderTexture = this.createOrderTexture(n);
+    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);
   }
   /**
    * Create the transform A texture (positions and quaternion w component)
    * @param splatData The splat data
    * @returns DataTexture containing position data
    */
-  createTransformATexture(t) {
-    const n = t.numSplats, e = new Float32Array(
+  createTransformATexture(e) {
+    const t = e.numSplats, o = new Float32Array(
       this.textureWidth * this.textureHeight * 4
     );
-    for (let s = 0; s < n; s++) {
-      const o = s * 4, a = s * 3, c = s * 4;
-      e[o] = t.positions[a], e[o + 1] = t.positions[a + 1], e[o + 2] = t.positions[a + 2];
-      const h = t.rotations[c + 0], v = t.rotations[c + 1], y = ft(h, v);
-      e[o + 3] = mt(y);
+    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);
     }
     const r = new i.DataTexture(
-      e,
+      o,
       this.textureWidth,
       this.textureHeight,
       i.RGBAFormat,
@@ -498,16 +498,16 @@ class xt {
    * @param splatData The splat data
    * @returns DataTexture containing scale and rotation data
    */
-  createTransformBTexture(t) {
-    const n = t.numSplats, e = new Float32Array(
+  createTransformBTexture(e) {
+    const t = e.numSplats, o = new Float32Array(
       this.textureWidth * this.textureHeight * 4
     );
-    for (let s = 0; s < n; s++) {
-      const o = s * 4, a = s * 3, c = s * 4;
-      e[o] = t.scales[a], e[o + 1] = t.scales[a + 1], e[o + 2] = t.scales[a + 2], e[o + 3] = t.rotations[c + 2];
+    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];
     }
     const r = new i.DataTexture(
-      e,
+      o,
       this.textureWidth,
       this.textureHeight,
       i.RGBAFormat,
@@ -520,16 +520,16 @@ class xt {
    * @param splatData The splat data
    * @returns DataTexture containing color data
    */
-  createColorTexture(t) {
-    const n = t.numSplats, e = new Float32Array(
+  createColorTexture(e) {
+    const t = e.numSplats, o = new Float32Array(
       this.textureWidth * this.textureHeight * 4
     );
-    for (let s = 0; s < n; s++) {
-      const o = s * 4, a = s * 3;
-      e[o] = t.colors[a], e[o + 1] = t.colors[a + 1], e[o + 2] = t.colors[a + 2], e[o + 3] = t.opacities[s];
+    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];
     }
     const r = new i.DataTexture(
-      e,
+      o,
       this.textureWidth,
       this.textureHeight,
       i.RGBAFormat,
@@ -542,24 +542,24 @@ class xt {
    * @param numSplats Number of splats
    * @returns DataTexture for storing order indices
    */
-  createOrderTexture(t) {
-    const n = new Uint32Array(this.textureWidth * this.textureHeight);
-    for (let r = 0; r < t; r++)
-      n[r] = r;
-    const e = new i.DataTexture(
-      n,
+  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,
       this.textureWidth,
       this.textureHeight,
       i.RedIntegerFormat,
       i.UnsignedIntType
     );
-    return e.needsUpdate = !0, e;
+    return o.needsUpdate = !0, o;
   }
   dispose() {
     this.transformA.dispose(), this.transformB.dispose(), this.colorTexture.dispose(), this.orderTexture.dispose();
   }
 }
-const gt = (
+const ge = (
   /* glsl */
   `
 precision highp float;
@@ -765,6 +765,10 @@ void main(void) {
     float l1 = sqrt(lambda1) * scaleFactor; // scaleX
     float l2 = sqrt(lambda2) * scaleFactor; // scaleY
 
+    float vmin = min(512.0, min(viewport.x, viewport.y));
+    l1 = min(l1, 2.0 * vmin);
+    l2 = min(l2, 2.0 * vmin);
+
     // Early out tiny splats
     if (l1 < 2.0 && l2 < 2.0) { // Check if smaller than ~2 pixel
          gl_Position = vec4(2.0, 2.0, 2.0, 1.0);
@@ -775,14 +779,15 @@ void main(void) {
     vec2 v1_scaled = l1 * v1_eigen;
     vec2 v2_scaled = l2 * v2_eigen;
 
-    // --- FRUSTUM CHECK  ---
+    // --- FRUSTUM CHECK (laxo, estilo PlayCanvas) ---
 
-    vec2 clipRadius = vec2(max(l1, l2)) * (centerClip.w / viewport);
+    vec2 c = centerClip.ww / viewport;  // pixel to clip
+    float r = max(l1, l2);              // radius in pixels
 
-    // Check if the bounding circle's edge is outside the [-w, w] range in clip space for x or y
-    if (any(greaterThan(abs(centerClip.xy) + clipRadius, vec2(abs(centerClip.w))))) {
-         gl_Position = vec4(2.0, 2.0, 2.0, 1.0); // Off-screen
-         return;
+    // Remove if the center - radius is already out of -w..w
+    if (any(greaterThan(abs(centerClip.xy) - vec2(r) * c, centerClip.ww))) {
+        gl_Position = vec4(2.0, 2.0, 2.0, 1.0);
+        return;
     }
 
     // --- END FRUSTUM CHECK ---
@@ -812,7 +817,7 @@ void main(void) {
     vUv = clippedCornerOffset;
 }
 `
-), yt = (
+), ye = (
   /* glsl */
   `
 precision highp float;
@@ -820,6 +825,14 @@ precision highp float;
 varying vec4 vColor; // Color and opacity passed from vertex shader
 varying vec2 vUv;    // Quad UV coordinates (-1 to 1) passed from vertex shader
 
+// Fast approximate e^x based on https://nic.schraudolph.org/pubs/Schraudolph99.pdf
+const float EXP_A = 12102203.0;     // ≈ 2^23 / ln(2)
+const int EXP_BC_RMS = 1064866808;  // (127 << 23) - 60801 * 8
+float fastExp(float x) {
+    int i = int(EXP_A * x) + EXP_BC_RMS;
+    return intBitsToFloat(i);
+}
+
 void main(void) {
 
     float distSq = dot(vUv, vUv); // Calculate squared distance from center (in the quad's coordinate system)
@@ -829,7 +842,7 @@ void main(void) {
     // The factor 4.0 corresponds to the original implementation's scaling.
     // factor = 1 / (2 * sigma^2), where sigma controls the spread.
     // Using 4.0 implies sigma^2 = 1/8.
-    float alpha = exp(-distSq * 4.0) * vColor.a;
+    float alpha = fastExp(-distSq * 4.0) * vColor.a;
 
     if (alpha < 1.0 / 255.0) discard; // Discard fragments with very low alpha
 
@@ -838,9 +851,9 @@ void main(void) {
 }
 `
 );
-class vt extends i.ShaderMaterial {
-  constructor(t = {}) {
-    const n = {
+class we extends i.ShaderMaterial {
+  constructor(e = {}) {
+    const t = {
       // Textures (values set via methods)
       transformA: { value: null },
       transformB: { value: null },
@@ -853,9 +866,9 @@ class vt extends i.ShaderMaterial {
       // Max splats to render (updated by sorter)
     };
     super({
-      vertexShader: gt,
-      fragmentShader: yt,
-      uniforms: n,
+      vertexShader: ge,
+      fragmentShader: ye,
+      uniforms: t,
       transparent: !0,
       blending: i.CustomBlending,
       // Premultiplied alpha blending:
@@ -875,88 +888,109 @@ class vt extends i.ShaderMaterial {
       side: i.DoubleSide,
       // Render both sides (or CULLFACE_NONE equivalent)
       // Optional settings from constructor
-      alphaTest: t.alphaTest !== void 0 ? t.alphaTest : 0,
+      alphaTest: e.alphaTest !== void 0 ? e.alphaTest : 0,
       // Typically 0 for blending
-      toneMapped: t.toneMapped !== void 0 ? t.toneMapped : !1
+      toneMapped: e.toneMapped !== void 0 ? e.toneMapped : !1
       // prettier-ignore
-    }), t.alphaHash && (this.alphaHash = !0, this.depthWrite = !0, this.blending = i.NoBlending);
+    }), e.alphaHash && (this.alphaHash = !0, this.depthWrite = !0, this.blending = i.NoBlending);
   }
   /**
    * Update the viewport size
    * @param width Viewport width
    * @param height Viewport height
    */
-  updateViewport(t, n) {
-    this.uniforms.viewport.value.set(t, n);
+  updateViewport(e, t) {
+    this.uniforms.viewport.value.set(e, t);
   }
   /**
    * Set transform texture A (positions)
    * @param texture Texture containing positions
    */
-  setTransformA(t) {
-    this.uniforms.transformA.value = t;
+  setTransformA(e) {
+    this.uniforms.transformA.value = e;
   }
   /**
    * Set transform texture B (rotation, scale)
    * @param texture Texture containing rotation and scale data
    */
-  setTransformB(t) {
-    this.uniforms.transformB.value = t;
+  setTransformB(e) {
+    this.uniforms.transformB.value = e;
   }
   /**
    * Set color texture
    * @param texture Texture containing colors
    */
-  setColorTexture(t) {
-    this.uniforms.splatColor.value = t;
+  setColorTexture(e) {
+    this.uniforms.splatColor.value = e;
   }
   /**
    * Set order texture
    * @param texture Texture containing sort order
    */
-  setOrderTexture(t) {
-    this.uniforms.splatOrder.value = t;
+  setOrderTexture(e) {
+    this.uniforms.splatOrder.value = e;
   }
   /**
    * Set number of splats to render
    * @param count Number of splats
    */
-  setNumSplats(t) {
-    this.uniforms.numSplats.value = t;
+  setNumSplats(e) {
+    this.uniforms.numSplats.value = e;
   }
 }
-const j = class j extends i.Mesh {
+const N = class N extends i.Mesh {
   // Match shader constant
   /**
    * Create a new SplatMesh for rendering Gaussian splats
    * @param splatData The splat data to render
    * @param options Rendering options
    */
-  constructor(n, e = {}) {
-    const r = new vt(e), s = j.createInstancedGeometry(n.numSplats, j.INSTANCE_SIZE);
-    super(s, r);
-    f(this, "sorter");
-    f(this, "splatData");
-    f(this, "options");
-    f(this, "textureManager");
-    f(this, "material");
-    f(this, "geometry");
-    f(this, "lastCameraPositionLocal", new i.Vector3());
-    f(this, "lastCameraDirectionLocal", new i.Vector3());
-    f(this, "invModelMatrix", new i.Matrix4());
-    this.geometry = s, this.material = r, this.splatData = n, this.frustumCulled = !1, this.options = { autoSort: !0, ...e }, this.textureManager = new xt(n), this.sorter = new dt();
-    let o = this.createChunks() || void 0;
-    o === null && console.warn("Visus: Could not create sorter chunks, bounding box might be invalid."), o = void 0, this.sorter.init(
+  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(
       this.textureManager.orderTexture,
       this.splatData.centers,
-      o ?? void 0
+      a ?? void 0
     ), this.sorter.addEventListener(
       "updated",
-      (a) => {
-        const c = a.count;
-        this.geometry.instanceCount = Math.ceil(c / j.INSTANCE_SIZE), this.material.setNumSplats(c);
+      (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);
       }
-    ), 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 = n.boundingBox.toBox3(), this.geometry.boundingSphere = new i.Sphere(), this.geometry.boundingBox.getBoundingSphere(this.geometry.boundingSphere);
+    ), 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
+    );
   }
   /**
    * Creates the instanced geometry for rendering splats.
@@ -964,8 +998,16 @@ const j = class j extends i.Mesh {
    * @param instanceSize Number of splats per instance.
    * @returns InstancedBufferGeometry
    */
-  static createInstancedGeometry(n, e) {
-    const r = Math.ceil(n / e), s = new i.BufferGeometry(), o = new Float32Array([
+  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([
       // x, y, splat_index_in_instance
       -1,
       -1,
@@ -979,57 +1021,79 @@ const j = class j extends i.Mesh {
       -1,
       1,
       0
-    ]), a = new Uint16Array([0, 1, 2, 0, 2, 3]), c = new Float32Array(4 * 3 * e);
-    for (let p = 0; p < e; p++) {
-      const u = p * 4 * 3;
-      for (let l = 0; l < 4; l++)
-        c[u + l * 3 + 0] = o[l * 3 + 0], c[u + l * 3 + 1] = o[l * 3 + 1], c[u + l * 3 + 2] = p;
+    ]), 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;
     }
-    const h = new Uint32Array(6 * e);
-    for (let p = 0; p < e; p++) {
-      const u = p * 6, l = p * 4;
-      h[u + 0] = a[0] + l, h[u + 1] = a[1] + l, h[u + 2] = a[2] + l, h[u + 3] = a[3] + l, h[u + 4] = a[4] + l, h[u + 5] = a[5] + l;
+    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;
     }
-    s.setAttribute("position", new i.BufferAttribute(c, 3)), s.setIndex(new i.BufferAttribute(h, 1));
-    const v = new i.InstancedBufferGeometry();
-    v.index = s.index, v.setAttribute("position", s.getAttribute("position"));
-    const y = new Uint32Array(r);
-    for (let p = 0; p < r; p++)
-      y[p] = p * e;
-    return v.setAttribute("splatInstanceIndex", new i.InstancedBufferAttribute(y, 1, !1)), v.instanceCount = 0, v;
+    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;
   }
   /**
    * 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 n = this.splatData.boundingBox;
-    return n.min.x === 1 / 0 || n.max.x === -1 / 0 ? null : new Float32Array([
-      n.min.x,
-      n.min.y,
-      n.min.z,
-      n.max.x,
-      n.max.y,
-      n.max.z
+    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
     ]);
+    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(n, e) {
-    this.material.updateViewport(n, e);
+  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);
   }
   /**
    * Sorts splats based on camera position and direction.
    * @param camera The camera to sort against.
    */
-  sort(n) {
-    const e = new i.Vector3(), r = new i.Vector3();
-    n.getWorldPosition(e), n.getWorldDirection(r), this.invModelMatrix.copy(this.matrixWorld).invert();
-    const s = e.applyMatrix4(this.invModelMatrix), o = r.transformDirection(this.invModelMatrix), a = this.lastCameraPositionLocal.distanceToSquared(s) > 1e-6, c = this.lastCameraDirectionLocal.dot(o) < 0.999;
-    this.options.autoSort && (a || c) && (this.lastCameraPositionLocal.copy(s), this.lastCameraDirectionLocal.copy(o), this.sorter.setCamera(s, o));
+  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));
   }
   /**
    * THREE.js hook called before rendering the object.
@@ -1040,29 +1104,30 @@ const j = class j extends i.Mesh {
    */
   // prettier-ignore
   // @ts-expect-error scene is not used
-  onBeforeRender(n, e, r) {
+  onBeforeRender(t, o, r) {
     this.sort(r);
-    const s = n.getSize(new i.Vector2());
-    let { width: o, height: a } = s;
-    const c = n.xr;
+    const n = t.getSize(new i.Vector2());
+    let { width: s, height: a } = n;
+    const c = t.xr;
     if (c.enabled && c.isPresenting) {
-      const h = c.getCamera().cameras[0].view;
-      h && (o = h.width, a = h.height);
+      const f = c.getCamera().cameras[0].view;
+      f && (s = f.width, a = f.height);
     }
-    this.updateViewport(o, a);
+    this.updateViewport(s, a);
   }
   /**
    * Dispose of resources
    */
   dispose() {
-    this.sorter.dispose(), this.geometry.dispose(), this.material.dispose(), this.textureManager.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");
   }
 };
 // Cached inverse matrix
 /** Number of splats combined into a single instanced draw call. */
-f(j, "INSTANCE_SIZE", 128);
-let it = j;
-class bt extends i.Loader {
+p(N, "INSTANCE_SIZE", 128);
+let ie = N;
+class be extends i.Loader {
   /**
    * Load a PLY file with Gaussian Splat data
    * @param url URL of the PLY file
@@ -1070,21 +1135,22 @@ class bt extends i.Loader {
    * @param onProgress Optional progress callback
    * @param onError Optional error callback
    */
-  load(t, n, e, r) {
+  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(
-      t,
-      (o) => {
+      e,
+      (a) => {
         try {
-          if (n) {
-            const a = this.parse(o);
-            n(a);
+          if (t) {
+            const c = this.parse(a);
+            t(c);
           }
-        } catch (a) {
-          r ? r(a) : console.error(a), this.manager.itemError(t);
+        } catch (c) {
+          r ? r(c) : console.error(c), this.manager.itemError(e);
         }
       },
-      e,
+      o,
       r
     );
   }
@@ -1094,22 +1160,22 @@ class bt extends i.Loader {
    * @param onProgress Optional progress callback
    * @returns A Promise that resolves with the parsed SplatData
    */
-  loadAsync(t, n) {
-    return new Promise((e, r) => {
-      const s = new i.FileLoader(this.manager);
-      s.setResponseType("arraybuffer"), s.setRequestHeader(this.requestHeader), s.setPath(this.path), s.setWithCredentials(this.withCredentials), s.load(
-        t,
-        (o) => {
+  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) => {
           try {
-            const a = this.parse(o);
-            e(a);
+            const a = this.parse(s);
+            o(a);
           } catch (a) {
-            r(a), this.manager.itemError(t);
+            r(a), this.manager.itemError(e);
           }
         },
-        n,
-        (o) => {
-          r(o), this.manager.itemError(t);
+        t,
+        (s) => {
+          r(s), this.manager.itemError(e);
         }
       );
     });
@@ -1119,174 +1185,264 @@ class bt extends i.Loader {
    * @param buffer ArrayBuffer containing PLY data
    * @returns Parsed SplatData
    */
-  parse(t) {
-    const n = new TextDecoder(), e = new Uint8Array(t), r = [112, 108, 121, 10], s = `
+  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 = `
 end_header
 `;
-    for (let x = 0; x < r.length; x++)
-      if (e[x] !== r[x])
+    for (let l = 0; l < n.length; l++)
+      if (r[l] !== n[l])
         throw new Error("Invalid PLY file: Missing magic bytes");
-    let o = 0;
-    for (let x = 0; x < e.length - s.length; x++) {
-      let d = !0;
-      for (let z = 0; z < s.length; z++)
-        if (e[x + z] !== s.charCodeAt(z)) {
-          d = !1;
+    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;
           break;
         }
-      if (d) {
-        o = x + s.length;
+      if (h) {
+        a = l + s.length;
         break;
       }
     }
-    if (o === 0)
+    if (a === 0)
       throw new Error("Invalid PLY file: Could not find end of header");
-    const c = n.decode(
-      e.slice(0, o)
-    ).split(`
-`), h = [];
-    let v = null;
-    for (let x = 1; x < c.length; x++) {
-      const d = c[x].trim();
-      if (d === "" || d === "end_header") continue;
-      const z = d.split(" ");
-      switch (z[0]) {
+    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]) {
         case "format":
-          v = z[1];
+          x = w[1], t && console.debug(
+            "[6/12] LOADER PlyLoader: format detected:",
+            x
+          );
           break;
         case "element":
-          h.push({
-            name: z[1],
-            count: parseInt(z[2], 10),
+          m.push({
+            name: w[1],
+            count: parseInt(w[2], 10),
             properties: []
-          });
+          }), t && console.debug(
+            "[6/12] LOADER PlyLoader: element found:",
+            w[1],
+            "count:",
+            w[2]
+          );
           break;
         case "property":
-          if (h.length === 0)
+          if (m.length === 0)
             throw new Error(
               "Invalid PLY file: Property without element"
             );
-          h[h.length - 1].properties.push({
-            type: z[1],
-            name: z[2],
+          m[m.length - 1].properties.push({
+            type: w[1],
+            name: w[2],
             storage: null
-          });
+          }), t && console.debug(
+            "[6/12] LOADER PlyLoader: property found:",
+            w[2],
+            "type:",
+            w[1]
+          );
           break;
       }
     }
-    if (v !== "binary_little_endian")
-      throw new Error(`Unsupported PLY format: ${v}`);
-    const y = h.find((x) => x.name === "vertex");
-    if (!y)
+    if (x !== "binary_little_endian")
+      throw new Error(`Unsupported PLY format: ${x}`);
+    const v = m.find((l) => l.name === "vertex");
+    if (!v)
       throw new Error("Invalid PLY file: No vertex element found");
-    const p = new ut(y.count), u = new DataView(t);
-    let l = o;
-    const b = (x) => y.properties.findIndex((d) => d.name === x), B = 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")
+    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")
     ], W = [
-      b("f_dc_0"),
-      b("f_dc_1"),
-      b("f_dc_2")
-    ], F = b("opacity");
-    if ([
-      B,
+      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
+    }), [
       O,
-      q,
-      ...E,
-      ...R,
+      H,
+      R,
+      ...P,
       ...W,
-      F
-    ].some((x) => x === -1))
+      ...B,
+      A
+    ].some((l) => l === -1))
       throw new Error("Invalid PLY file: Missing required properties");
-    const D = 0.28209479177387814, M = (x) => {
-      if (x > 0) return 1 / (1 + Math.exp(-x));
-      const d = Math.exp(x);
-      return d / (1 + d);
-    }, m = new i.Vector3(), C = new i.Quaternion(), _ = new i.Vector3(), V = new i.Color();
-    for (let x = 0; x < y.count; x++) {
-      const d = [];
-      for (let T = 0; T < y.properties.length; T++) {
-        const K = y.properties[T].type;
-        let I;
-        switch (K) {
+    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) {
           case "char":
-            I = u.getInt8(l), l += 1;
+            U = S.getInt8(u), u += 1;
             break;
           case "uchar":
-            I = u.getUint8(l), l += 1;
+            U = S.getUint8(u), u += 1;
             break;
           case "short":
-            I = u.getInt16(l, !0), l += 2;
+            U = S.getInt16(u, !0), u += 2;
             break;
           case "ushort":
-            I = u.getUint16(l, !0), l += 2;
+            U = S.getUint16(u, !0), u += 2;
             break;
           case "int":
-            I = u.getInt32(l, !0), l += 4;
+            U = S.getInt32(u, !0), u += 4;
             break;
           case "uint":
-            I = u.getUint32(l, !0), l += 4;
+            U = S.getUint32(u, !0), u += 4;
             break;
           case "float":
-            I = u.getFloat32(l, !0), l += 4;
+            U = S.getFloat32(u, !0), u += 4;
             break;
           case "double":
-            I = u.getFloat64(l, !0), l += 8;
+            U = S.getFloat64(u, !0), u += 8;
             break;
           default:
-            throw new Error(`Unsupported property type: ${K}`);
+            throw new Error(`Unsupported property type: ${L}`);
         }
-        d.push(I);
+        h.push(U);
       }
-      m.set(
-        d[B],
-        d[O],
-        d[q]
-      ), C.set(
-        d[E[1]],
+      _.set(
+        h[O],
+        h[H],
+        h[R]
+      ), I.set(
+        h[P[1]],
         // PLY stores rot 1,2,3,0 (x,y,z,w)
-        d[E[2]],
-        d[E[3]],
-        d[E[0]]
-      ).normalize(), C.w < 0 && (C.x = -C.x, C.y = -C.y, C.z = -C.z, C.w = -C.w), _.set(
-        d[R[0]],
-        // Read directly assuming it's log scale
-        d[R[1]],
-        d[R[2]]
+        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(
-        0.5 + d[W[0]] * D,
-        0.5 + d[W[1]] * D,
-        0.5 + d[W[2]] * D
-      ), V.r = Math.max(0, Math.min(1, V.r)), V.g = Math.max(0, Math.min(1, V.g)), V.b = Math.max(0, Math.min(1, V.b));
-      const z = M(d[F]);
-      p.setSplat(
-        x,
-        m,
-        C,
+        h[W[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,
         _,
-        // Pass log scale directly
+        I,
         V,
-        z
+        // Pass log scale directly
+        E,
+        w
       );
     }
-    return p.calculateBoundingBox(), p;
+    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;
   }
 }
-const Mt = "0.3.0";
+const Se = "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
+  te as BoundingBox,
+  be as PlyLoader,
+  de as SplatData,
+  we as SplatMaterial,
+  ie as SplatMesh,
+  he as SplatSorter,
+  xe as TextureManager,
+  Se as VERSION
 };