@speridlabs/visus 0.2.0 → 1.0.0

package/dist/main.es.js

@@ -1,14 +1,14 @@
-var ct = Object.defineProperty;
-var lt = (k, t, r) => t in k ? ct(k, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : k[t] = r;
-var f = (k, t, r) => lt(k, typeof t != "symbol" ? t + "" : t, r);
-import * as n from "three";
+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);
+import * as i from "three";
 class et {
   constructor() {
-    f(this, "min", new n.Vector3(1 / 0, 1 / 0, 1 / 0));
-    f(this, "max", new n.Vector3(-1 / 0, -1 / 0, -1 / 0));
-    f(this, "center", new n.Vector3());
+    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());
     /** Half extents (size/2) */
-    f(this, "halfExtents", new n.Vector3());
+    f(this, "halfExtents", new i.Vector3());
   }
   /**
    * Reset the bounding box to its initial state
@@ -49,7 +49,7 @@ class et {
    * @returns THREE.Box3 representation
    */
   toBox3() {
-    return new n.Box3().set(this.min, this.max);
+    return new i.Box3().set(this.min, this.max);
   }
   /**
    * Create a clone of this bounding box
@@ -60,7 +60,7 @@ class et {
     return t.min.copy(this.min), t.max.copy(this.max), t.center.copy(this.center), t.halfExtents.copy(this.halfExtents), t;
   }
 }
-class ht {
+class ut {
   // TODO: there is no sh spherical harmonics
   constructor(t = 0) {
     f(this, "numSplats", 0);
@@ -85,13 +85,13 @@ class ht {
    * @param color Color
    * @param opacity Opacity value
    */
-  setSplat(t, r, e, o, s, i) {
+  setSplat(t, n, e, r, s, o) {
     if (t >= this.numSplats)
       throw new Error(
         `Splat index out of bounds: ${t} >= ${this.numSplats}`
       );
     const a = t * 3, c = t * 4, h = t * 3, v = t * 3;
-    this.positions[a] = r.x, this.positions[a + 1] = r.y, this.positions[a + 2] = r.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] = o.x, this.scales[h + 1] = o.y, this.scales[h + 2] = o.z, this.colors[v] = s.r, this.colors[v + 1] = s.g, this.colors[v + 2] = s.b, this.opacities[t] = i, this.centers[a] = r.x, this.centers[a + 1] = r.y, this.centers[a + 2] = r.z;
+    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;
   }
   /**
    * Get a splat's data
@@ -103,26 +103,26 @@ class ht {
       throw new Error(
         `Splat index out of bounds: ${t} >= ${this.numSplats}`
       );
-    const r = t * 3, e = t * 4, o = t * 3, s = t * 3;
+    const n = t * 3, e = t * 4, r = t * 3, s = t * 3;
     return {
-      position: new n.Vector3(
-        this.positions[r],
-        this.positions[r + 1],
-        this.positions[r + 2]
+      position: new i.Vector3(
+        this.positions[n],
+        this.positions[n + 1],
+        this.positions[n + 2]
       ),
-      rotation: new n.Quaternion(
+      rotation: new i.Quaternion(
         this.rotations[e],
         this.rotations[e + 1],
         this.rotations[e + 2],
         this.rotations[e + 3]
       ),
       // Convert log scale back to linear scale for external use
-      scale: new n.Vector3(
-        Math.exp(this.scales[o]),
-        Math.exp(this.scales[o + 1]),
-        Math.exp(this.scales[o + 2])
+      scale: new i.Vector3(
+        Math.exp(this.scales[r]),
+        Math.exp(this.scales[r + 1]),
+        Math.exp(this.scales[r + 2])
       ),
-      color: new n.Color(
+      color: new i.Color(
         this.colors[s],
         this.colors[s + 1],
         this.colors[s + 2]
@@ -136,9 +136,9 @@ class ht {
    */
   calculateBoundingBox() {
     this.boundingBox.reset();
-    const t = new n.Vector3();
-    for (let r = 0; r < this.numSplats; r++) {
-      const e = r * 3;
+    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],
@@ -152,37 +152,37 @@ class ht {
    * This is for visualization/debugging purposes only, not for rendering
    */
   createDebugGeometry() {
-    const t = new n.BufferGeometry();
+    const t = new i.BufferGeometry();
     t.setAttribute(
       "position",
-      new n.BufferAttribute(this.positions, 3)
+      new i.BufferAttribute(this.positions, 3)
     );
-    const r = new Float32Array(this.numSplats * 3), e = new n.Quaternion(), o = new n.Euler();
+    const n = new Float32Array(this.numSplats * 3), e = new i.Quaternion(), r = new i.Euler();
     for (let s = 0; s < this.numSplats; s++) {
-      const i = s * 4, a = s * 3;
+      const o = s * 4, a = s * 3;
       e.set(
-        this.rotations[i],
-        this.rotations[i + 1],
-        this.rotations[i + 2],
-        this.rotations[i + 3]
-      ), o.setFromQuaternion(e), r[a] = o.x, r[a + 1] = o.y, r[a + 2] = o.z;
+        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;
     }
     return t.setAttribute(
       "rotation",
-      new n.BufferAttribute(r, 3)
+      new i.BufferAttribute(n, 3)
     ), t.setAttribute(
       "scale",
-      new n.BufferAttribute(this.scales, 3)
+      new i.BufferAttribute(this.scales, 3)
     ), t.setAttribute(
       "color",
-      new n.BufferAttribute(this.colors, 3)
+      new i.BufferAttribute(this.colors, 3)
     ), t.setAttribute(
       "opacity",
-      new n.BufferAttribute(this.opacities, 1)
+      new i.BufferAttribute(this.opacities, 1)
     ), t;
   }
 }
-class ut extends n.EventDispatcher {
+class dt extends i.EventDispatcher {
   constructor() {
     super();
     f(this, "worker");
@@ -190,26 +190,26 @@ class ut extends n.EventDispatcher {
     f(this, "orderTexture", null);
     /** Bounding box data for optimization */
     f(this, "chunks", null);
-    f(this, "lastCameraPosition", new n.Vector3());
-    f(this, "lastCameraDirection", new n.Vector3());
-    const r = this.createWorkerCode(), e = new Blob([r], { type: "application/javascript" });
+    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);
   }
   /**
    * Handles messages received from the sorting worker.
    * @param event The message event from the worker.
    */
-  onWorkerMessage(r) {
+  onWorkerMessage(n) {
     if (!this.orderTexture || !this.orderTexture.image)
       return console.error("SplatSorter: Order texture not initialized!");
-    const { order: e, count: o } = r.data, s = this.orderTexture.image.data;
+    const { order: e, count: r } = n.data, s = this.orderTexture.image.data;
     if (!(s instanceof Uint32Array))
       return console.error(
         "SplatSorter: Order texture data is not a Uint32Array!"
       );
     s.set(new Uint32Array(e)), this.orderTexture.needsUpdate = !0;
-    const i = s.buffer.slice(0), a = { order: i };
-    this.worker.postMessage(a, [i]), this.dispatchEvent({ type: "updated", count: o });
+    const o = s.buffer.slice(0), a = { order: o };
+    this.worker.postMessage(a, [o]), this.dispatchEvent({ type: "updated", count: r });
   }
   /**
    * Initializes the sorter with necessary data and textures.
@@ -217,29 +217,29 @@ class ut extends n.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(r, e, o) {
-    if (!r || !(r.image.data instanceof Uint32Array))
+  init(n, e, r) {
+    if (!n || !(n.image.data instanceof Uint32Array))
       throw new Error("SplatSorter: Invalid orderTexture provided. Must be DataTexture with Uint32Array data.");
     if (!e || e.length % 3 !== 0)
       throw new Error("SplatSorter: Invalid centers array provided. Length must be multiple of 3.");
-    if (r.image.data.length < e.length / 3)
+    if (n.image.data.length < e.length / 3)
       throw new Error("SplatSorter: orderTexture data buffer is smaller than the number of splats.");
     const s = e.length / 3;
-    this.orderTexture = r, this.centers = e.slice();
-    const i = this.orderTexture.image.data;
-    for (let g = 0; g < s; g++) i[g] = g;
+    this.orderTexture = n, this.centers = e.slice();
+    const o = this.orderTexture.image.data;
+    for (let y = 0; y < s; y++) o[y] = y;
     this.orderTexture.needsUpdate = !0;
-    const a = i.buffer.slice(0), c = this.centers.buffer.slice(0), h = {
+    const a = o.buffer.slice(0), c = this.centers.buffer.slice(0), h = {
       order: a,
       centers: c
     }, v = [
       a,
       c
     ];
-    if (o) {
-      this.chunks = o.slice();
-      const g = this.chunks.buffer.slice(0);
-      h.chunks = g, v.push(g);
+    if (r) {
+      this.chunks = r.slice();
+      const y = this.chunks.buffer.slice(0);
+      h.chunks = y, v.push(y);
     }
     this.worker.postMessage(h, v);
   }
@@ -248,53 +248,53 @@ class ut extends n.EventDispatcher {
    * The sorter will only consider splats whose original indices are present in the mapping.
    * @param mapping A Uint32Array where each element is the *original* index of a splat to include, or null to reset mapping.
    */
-  setMapping(r) {
+  setMapping(n) {
     if (!this.centers)
       return console.warn(
         "SplatSorter: Cannot set mapping before initialization."
       );
     let e;
-    const o = [];
-    if (!r) {
+    const r = [];
+    if (!n) {
       const c = this.centers.buffer.slice(0);
       return e = {
         centers: c,
         mapping: null
-      }, o.push(c), this.worker.postMessage(e, o);
+      }, r.push(c), this.worker.postMessage(e, r);
     }
-    const s = new Float32Array(r.length * 3);
-    for (let c = 0; c < r.length; c++) {
-      const h = r[c];
+    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) {
         console.warn(
           `SplatSorter: Mapping index ${h} out of bounds.`
         );
         continue;
       }
-      const v = h * 3, g = c * 3;
-      s[g + 0] = this.centers[v + 0], s[g + 1] = this.centers[v + 1], s[g + 2] = this.centers[v + 2];
+      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 i = s.buffer.slice(0), a = r.buffer.slice(0);
+    const o = s.buffer.slice(0), a = n.buffer.slice(0);
     e = {
-      centers: i,
+      centers: o,
       mapping: a
-    }, o.push(i, a), this.worker.postMessage(e, o);
+    }, r.push(o, 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(r, e) {
-    const o = this.lastCameraPosition.distanceToSquared(r) > 1e-7, s = this.lastCameraDirection.dot(e) < 0.9999;
-    if (!o && !s)
+  setCamera(n, e) {
+    const r = this.lastCameraPosition.distanceToSquared(n) > 1e-7, s = this.lastCameraDirection.dot(e) < 0.9999;
+    if (!r && !s)
       return;
-    this.lastCameraPosition.copy(r), this.lastCameraDirection.copy(e);
-    const i = {
-      cameraPosition: { x: r.x, y: r.y, z: r.z },
+    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.worker.postMessage(i);
+    this.worker.postMessage(o);
   }
   /**
    * Terminates the Web Worker and cleans up resources.
@@ -308,148 +308,149 @@ class ut extends n.EventDispatcher {
    */
   createWorkerCode() {
     return `(${(function() {
-      let e = null, o = null, s = null, i = null, a = null, c = null, h = !1;
-      const v = { x: 0, y: 0, z: 0 }, g = { x: 0, y: 0, z: 0 }, p = { x: 0, y: 0, z: 0 }, u = { x: 0, y: 0, z: 0 };
+      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 A = 32, O = new Array(A).fill(0), q = new Array(A).fill(0), R = new Array(A).fill(0), E = (F, z, _) => {
-        for (; F <= z; ) {
-          const M = z + F >> 1, m = _(M);
+      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) z = M - 1;
+          else if (m < 0) S = M - 1;
           else return M;
         }
         return ~F;
       }, W = () => {
-        if (!e || !o || !a || !c)
+        if (!e || !r || !a || !c)
           return;
-        if (o.length === 0) {
-          const y = {
+        if (r.length === 0) {
+          const g = {
             order: e.buffer,
             count: 0
           };
-          self.postMessage(y, [e.buffer]), e = null;
+          self.postMessage(g, [e.buffer]), e = null;
           return;
         }
-        const F = a.x, z = a.y, _ = a.z, M = c.x, m = c.y, B = c.z, P = 1e-4, V = Math.abs(F - v.x) > P || Math.abs(z - v.y) > P || Math.abs(_ - v.z) > P, x = Math.abs(M - g.x) > P || Math.abs(m - g.y) > P || Math.abs(B - g.z) > P;
+        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)
           return;
-        h = !1, v.x = F, v.y = z, v.z = _, g.x = M, g.y = m, g.z = B;
-        let d = 1 / 0, C = -1 / 0;
-        for (let y = 0; y < 8; ++y) {
-          const T = y & 1 ? p.x : u.x, U = y & 2 ? p.y : u.y, w = y & 4 ? p.z : u.z, D = T * M + U * m + w * B;
-          d = Math.min(d, D), C = Math.max(C, D);
+        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;
+        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 I = o.length / 3, L = C - d, S = (1 << Math.max(
+        const T = r.length / 3, L = z - d, I = (1 << Math.max(
           10,
-          Math.min(20, Math.ceil(Math.log2(I / 4)))
+          Math.min(20, Math.ceil(Math.log2(T / 4)))
         )) + 1;
-        if ((!l || l.length !== I) && (l = new Uint32Array(I)), !b || b.length !== S ? b = new Uint32Array(S) : b.fill(0), L < 1e-7) {
-          for (let y = 0; y < I; ++y) l[y] = 0;
-          b[0] = I;
+        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 y = s.length / 6;
+          const g = s.length / 6;
           O.fill(0);
-          for (let w = 0; w < y; ++w) {
-            const D = w * 6, G = s[D + 0], Z = s[D + 1], J = s[D + 2], N = s[D + 3], H = G * M + Z * m + J * B - d, K = H - N, $ = H + N, X = Math.max(
+          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(
               0,
-              Math.floor(K * A / L)
+              Math.floor(J * B / L)
             ), tt = Math.min(
-              A,
-              Math.ceil($ * A / L)
+              B,
+              Math.ceil(X * B / L)
             );
-            for (let j = X; j < tt; ++j)
-              O[j]++;
+            for (let N = Q; N < tt; ++N)
+              O[N]++;
           }
-          let T = 0;
-          for (let w = 0; w < A; ++w) T += O[w];
-          R[0] = 0, q[0] = 0;
-          for (let w = 1; w < A; ++w)
-            R[w - 1] = O[w - 1] / T * S >>> 0, q[w] = q[w - 1] + R[w - 1];
-          R[A - 1] = O[A - 1] / T * S >>> 0;
-          const U = L / A;
-          for (let w = 0; w < I; ++w) {
-            const D = w * 3, G = o[D + 0], Z = o[D + 1], J = o[D + 2], N = G * M + Z * m + J * B, K = (C - N) / U, $ = Math.max(
+          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(
               0,
               Math.min(
-                A - 1,
-                Math.floor(K)
+                B - 1,
+                Math.floor(J)
               )
-            ), X = K - $, tt = q[$] + R[$] * X >>> 0, j = Math.min(tt, S - 1);
-            l[w] = j, b[j]++;
+            ), Q = J - X, tt = q[X] + E[X] * Q >>> 0, N = Math.min(tt, I - 1);
+            l[w] = N, b[N]++;
           }
         } else {
-          const y = (S - 1) / L;
-          for (let T = 0; T < I; ++T) {
-            const U = T * 3, w = o[U + 0], D = o[U + 1], G = o[U + 2], Z = w * M + D * m + G * B, N = (C - Z) * y >>> 0, H = Math.min(N, S - 1);
-            l[T] = H, b[H]++;
+          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]++;
           }
         }
-        for (let y = 1; y < S; y++)
-          b[y] += b[y - 1];
-        for (let y = I - 1; y >= 0; y--) {
-          const T = l[y], U = --b[T];
-          e[U] = i ? i[y] : y;
+        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;
         }
-        const it = F * M + z * m + _ * B, rt = (y) => {
+        const at = F * M + S * m + D * C, rt = (g) => {
           if (!e) return -1 / 0;
-          const T = e[y], U = T;
-          if (!o || U * 3 + 2 >= o.length)
+          const k = e[g], U = k;
+          if (!r || U * 3 + 2 >= r.length)
             return -1 / 0;
           const w = U * 3;
-          return o[w] * M + o[w + 1] * m + o[w + 2] * B - it;
+          return r[w] * M + r[w + 1] * m + r[w + 2] * C - at;
         };
-        let st = I;
-        if (I > 0 && rt(I - 1) < 0) {
-          const y = E(
+        let st = T;
+        if (T > 0 && rt(T - 1) < 0) {
+          const g = R(
             0,
-            I - 1,
+            T - 1,
             rt
           );
-          st = y < 0 ? ~y : y;
+          st = g < 0 ? ~g : g;
         }
-        const at = {
+        const ct = {
           order: e.buffer,
           count: st
         };
-        self.postMessage(at, [e.buffer]), e = null;
+        self.postMessage(ct, [e.buffer]), e = null;
       };
       self.onmessage = (F) => {
-        const z = F.data;
-        z.order && (e = new Uint32Array(z.order));
-        let _ = !1;
-        if (z.centers && (o = new Float32Array(z.centers), _ = !0, h = !0), Object.prototype.hasOwnProperty.call(z, "mapping") && (i = z.mapping ? new Uint32Array(z.mapping) : null, h = !0), z.chunks) {
-          if (s = new Float32Array(z.chunks), s.length > 0 && s[3] > 0)
+        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, B = s[m + 0], P = s[m + 1], V = s[m + 2], x = s[m + 3], d = s[m + 4], C = s[m + 5];
-              s[m + 0] = (B + x) * 0.5, s[m + 1] = (P + d) * 0.5, s[m + 2] = (V + C) * 0.5, s[m + 3] = Math.sqrt(
-                (x - B) ** 2 + (d - P) ** 2 + (C - V) ** 2
+              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
               ) * 0.5;
             }
           h = !0;
         }
-        if (_ && o && o.length > 0) {
-          p.x = u.x = o[0], p.y = u.y = o[1], p.z = u.z = o[2];
-          for (let M = 1; M < o.length / 3; M++) {
+        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, o[m + 0]), u.x = Math.max(u.x, o[m + 0]), p.y = Math.min(p.y, o[m + 1]), u.y = Math.max(u.y, o[m + 1]), p.z = Math.min(p.z, o[m + 2]), u.z = Math.max(u.z, o[m + 2]);
+            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]);
           }
-        } else _ && o && o.length === 0 && (p.x = u.x = p.y = u.y = p.z = u.z = 0);
-        z.cameraPosition && (a = z.cameraPosition), z.cameraDirection && (c = z.cameraDirection), W();
+        } 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();
       };
     }).toString()})();`;
   }
 }
-const dt = (k, t) => {
-  const r = Math.max(
-    0,
-    Math.min(65535, Math.round((k + 1) / 2 * 65535))
-  ), e = Math.max(
-    0,
-    Math.min(65535, Math.round((t + 1) / 2 * 65535))
-  );
-  return r << 16 | e;
-}, ft = new ArrayBuffer(4), ot = new DataView(ft), pt = (k) => (ot.setUint32(0, k, !0), ot.getFloat32(0, !0));
-class mt {
+const ft = (A, t) => {
+  const n = nt(A), e = nt(t);
+  return n | e << 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);
+}
+const pt = new ArrayBuffer(4), ot = new DataView(pt), mt = (A) => (ot.setUint32(0, A, !0), ot.getFloat32(0, !0));
+class xt {
   /**
    * Create a new TextureManager for a set of splats
    * @param splatData The splat data to manage textures for
@@ -464,8 +465,8 @@ class mt {
     f(this, "orderTexture");
     f(this, "textureWidth");
     f(this, "textureHeight");
-    const r = t.numSplats;
-    this.textureWidth = Math.ceil(Math.sqrt(r)), this.textureHeight = Math.ceil(r / this.textureWidth), this.transformA = this.createTransformATexture(t), this.transformB = this.createTransformBTexture(t), this.colorTexture = this.createColorTexture(t), this.orderTexture = this.createOrderTexture(r);
+    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);
   }
   /**
    * Create the transform A texture (positions and quaternion w component)
@@ -473,24 +474,24 @@ class mt {
    * @returns DataTexture containing position data
    */
   createTransformATexture(t) {
-    const r = t.numSplats, e = new Float32Array(
+    const n = t.numSplats, e = new Float32Array(
       this.textureWidth * this.textureHeight * 4
     );
-    for (let s = 0; s < r; s++) {
-      const i = s * 4, a = s * 3, c = s * 4;
-      e[i] = t.positions[a], e[i + 1] = t.positions[a + 1], e[i + 2] = t.positions[a + 2];
-      const h = t.rotations[c + 1], v = t.rotations[c + 2], g = dt(h, v);
-      e[i + 3] = pt(g);
+    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);
     }
-    const o = new n.DataTexture(
+    const r = new i.DataTexture(
       e,
       this.textureWidth,
       this.textureHeight,
-      n.RGBAFormat,
-      n.FloatType
+      i.RGBAFormat,
+      i.FloatType
       // Store as Float32, shader will reinterpret bits
     );
-    return o.needsUpdate = !0, o.magFilter = n.NearestFilter, o.minFilter = n.NearestFilter, o;
+    return r.needsUpdate = !0, r.magFilter = i.NearestFilter, r.minFilter = i.NearestFilter, r;
   }
   /**
    * Create the transform B texture (scale and rotation xyz)
@@ -498,21 +499,21 @@ class mt {
    * @returns DataTexture containing scale and rotation data
    */
   createTransformBTexture(t) {
-    const r = t.numSplats, e = new Float32Array(
+    const n = t.numSplats, e = new Float32Array(
       this.textureWidth * this.textureHeight * 4
     );
-    for (let s = 0; s < r; s++) {
-      const i = s * 4, a = s * 3, c = s * 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[c];
+    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];
     }
-    const o = new n.DataTexture(
+    const r = new i.DataTexture(
       e,
       this.textureWidth,
       this.textureHeight,
-      n.RGBAFormat,
-      n.FloatType
+      i.RGBAFormat,
+      i.FloatType
     );
-    return o.needsUpdate = !0, o.magFilter = n.NearestFilter, o.minFilter = n.NearestFilter, o;
+    return r.needsUpdate = !0, r.magFilter = i.NearestFilter, r.minFilter = i.NearestFilter, r;
   }
   /**
    * Create the color texture (RGB and opacity)
@@ -520,21 +521,21 @@ class mt {
    * @returns DataTexture containing color data
    */
   createColorTexture(t) {
-    const r = t.numSplats, e = new Float32Array(
+    const n = t.numSplats, e = new Float32Array(
       this.textureWidth * this.textureHeight * 4
     );
-    for (let s = 0; s < r; s++) {
-      const i = s * 4, a = s * 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[s];
+    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];
     }
-    const o = new n.DataTexture(
+    const r = new i.DataTexture(
       e,
       this.textureWidth,
       this.textureHeight,
-      n.RGBAFormat,
-      n.FloatType
+      i.RGBAFormat,
+      i.FloatType
     );
-    return o.needsUpdate = !0, o;
+    return r.needsUpdate = !0, r;
   }
   /**
    * Create the order texture for sorting
@@ -542,15 +543,15 @@ class mt {
    * @returns DataTexture for storing order indices
    */
   createOrderTexture(t) {
-    const r = new Uint32Array(this.textureWidth * this.textureHeight);
-    for (let o = 0; o < t; o++)
-      r[o] = o;
-    const e = new n.DataTexture(
-      r,
+    const n = new Uint32Array(this.textureWidth * this.textureHeight);
+    for (let r = 0; r < t; r++)
+      n[r] = r;
+    const e = new i.DataTexture(
+      n,
       this.textureWidth,
       this.textureHeight,
-      n.RedIntegerFormat,
-      n.UnsignedIntType
+      i.RedIntegerFormat,
+      i.UnsignedIntType
     );
     return e.needsUpdate = !0, e;
   }
@@ -558,7 +559,7 @@ class mt {
     this.transformA.dispose(), this.transformB.dispose(), this.colorTexture.dispose(), this.orderTexture.dispose();
   }
 }
-const xt = (
+const gt = (
   /* glsl */
   `
 precision highp float;
@@ -596,61 +597,53 @@ varying vec2 vUv; // For gaussian calculation in fragment shader
 
 // --- Helper Functions ---
 
-// Unpack two 16-bit floats (halfs) from a single 32-bit float (packed as uint bits)
-vec2 unpackHalf2x16FromFloat(float packedFloat) {
-    uint packedUInt = floatBitsToUint(packedFloat);
-    uint y_bits = packedUInt >> 16;
-    uint z_bits = packedUInt & uint(0xFFFF);
-
-    // NOTE: This assumes packing used "packNormalizedFloatToUint16Pair"
-    // which maps [-1, 1] to [0, 65535]. Adjust if packing method changes.
-    float y = (float(y_bits) / 65535.0) * 2.0 - 1.0;
-    float z = (float(z_bits) / 65535.0) * 2.0 - 1.0;
-    return vec2(y, z);
-}
+// Use GLSL built-in unpackHalf2x16 for proper half-float unpacking
 
-// Reconstruct quaternion from packed components (x, yz_packed)
-vec4 unpackRotation(float yz_packed, float x) {
-    vec2 yz = unpackHalf2x16FromFloat(yz_packed);
-    float y = yz.x;
-    float z = yz.y;
+// Reconstruct quaternion from packed components (xy_packed, z)
+// Returns (w,x,y,z) format for quatToMat3 compatibility  
+vec4 unpackRotation(float xy_packed, float z) {
+    vec2 xy = unpackHalf2x16(floatBitsToUint(xy_packed));
+    float x = xy.x;
+    float y = xy.y;
     float w_squared = 1.0 - x*x - y*y - z*z;
-    float w = (w_squared < 0.0) ? 0.0 : sqrt(w_squared); // Calculate w
-    return vec4(x, y, z, w);
+    float w = (w_squared < 0.0) ? 0.0 : sqrt(w_squared);
+    return vec4(w, x, y, z); // Return (w,x,y,z) 
 }
 
 // Convert quaternion to 3x3 rotation matrix
-mat3 quatToMat3(vec4 q) {
-    float x = q.x, y = q.y, z = q.z, w = q.w;
-    float x2 = x + x, y2 = y + y, z2 = z + z;
-    float xx = x * x2, xy = x * y2, xz = x * z2;
-    float yy = y * y2, yz = y * z2, zz = z * z2;
-    float wx = w * x2, wy = w * y2, wz = w * z2;
+mat3 quatToMat3(vec4 R) {
+    vec4 R2 = R + R;
+    float X = R2.x * R.w;
+    vec4 Y  = R2.y * R;
+    vec4 Z  = R2.z * R;
+    float W = R2.w * R.w;
 
     return mat3(
-        1.0 - (yy + zz), xy + wz, xz - wy,
-        xy - wz, 1.0 - (xx + zz), yz + wx,
-        xz + wy, yz - wx, 1.0 - (xx + yy)
+        1.0 - Z.z - W,
+              Y.z + X,
+              Y.w - Z.x,
+              Y.z - X,
+        1.0 - Y.y - W,
+              Z.w + Y.x,
+              Y.w + Z.x,
+              Z.w - Y.x,
+        1.0 - Y.y - Z.z
     );
 }
 
-// Calculate model-space covariance components R * S^2 * transpose(R)
+// Calculate model-space covariance components
 void getModelCovariance(vec3 scale, vec4 rotation, out vec3 covA, out vec3 covB) {
-    mat3 R = quatToMat3(rotation);
-
-    // Define M = R * S (where S is the diagonal scale matrix)
-    // Note R is column-major, so R[0] is the first column, etc.
-    // We want M's rows to be R's rows scaled by the corresponding scale factor.
-    mat3 M = mat3(
-        R[0][0] * scale.x, R[0][1] * scale.y, R[0][2] * scale.z, // Row 0 = (R_row0 * S)
-        R[1][0] * scale.x, R[1][1] * scale.y, R[1][2] * scale.z, // Row 1 = (R_row1 * S)
-        R[2][0] * scale.x, R[2][1] * scale.y, R[2][2] * scale.z  // Row 2 = (R_row2 * S)
-    );
+    mat3 rot = quatToMat3(rotation);
+    
+    // M = S * R (scale COLUMNS, then transpose)
+    mat3 M = transpose(mat3(
+        scale.x * rot[0],  // scale.x * column 0
+        scale.y * rot[1],  // scale.y * column 1
+        scale.z * rot[2]   // scale.z * column 2
+    ));
 
-    // Now compute Vrk = M * transpose(M)
-    // Vrk[i][j] = dot(M[i], M[j]) where M[i] is the i-th row vector of M.
-    covA = vec3(dot(M[0], M[0]), dot(M[0], M[1]), dot(M[0], M[2])); // Vrk[0][0], Vrk[0][1], Vrk[0][2]
-    covB = vec3(dot(M[1], M[1]), dot(M[1], M[2]), dot(M[2], M[2])); // Vrk[1][1], Vrk[1][2], Vrk[2][2]
+    covA = vec3(dot(M[0], M[0]), dot(M[0], M[1]), dot(M[0], M[2]));
+    covB = vec3(dot(M[1], M[1]), dot(M[1], M[2]), dot(M[2], M[2]));
 }
 
 // --- Main Function ---
@@ -679,7 +672,7 @@ void main(void) {
 
     vec3 splatPosition = texTransformA.xyz;
     vec3 splatLogScale = texTransformB.xyz; // Assume stored as log scale
-    vec4 splatRotation = unpackRotation(texTransformA.w, texTransformB.w); // Unpack rot yz, x
+    vec4 splatRotation = unpackRotation(texTransformA.w, texTransformB.w); // Unpack rot xy, z
     vec3 splatColor = texColor.rgb;
     float splatOpacity = texColor.a;
 
@@ -805,7 +798,6 @@ void main(void) {
     // Apply clip to the corner offset *before* calculating screen space offset
     vec2 clippedCornerOffset = cornerOffset * clip;
     vec2 screenOffsetPixels = clippedCornerOffset.x * v1_scaled + clippedCornerOffset.y * v2_scaled;
-    //vec2 screenOffsetPixels = vec2(clippedCornerOffset.x, clippedCornerOffset.y);
 
     // Convert pixel offset to clip space offset
     vec2 clipOffset = screenOffsetPixels * (centerClip.w / viewport);
@@ -846,56 +838,56 @@ void main(void) {
 }
 `
 );
-class gt extends n.ShaderMaterial {
+class vt extends i.ShaderMaterial {
   constructor(t = {}) {
-    const r = {
+    const n = {
       // Textures (values set via methods)
       transformA: { value: null },
       transformB: { value: null },
       splatColor: { value: null },
       splatOrder: { value: null },
       // Other uniforms
-      viewport: { value: new n.Vector2(1, 1) },
+      viewport: { value: new i.Vector2(1, 1) },
       // Will be updated
       numSplats: { value: 0 }
       // Max splats to render (updated by sorter)
     };
     super({
-      vertexShader: xt,
+      vertexShader: gt,
       fragmentShader: yt,
-      uniforms: r,
+      uniforms: n,
       transparent: !0,
-      blending: n.CustomBlending,
+      blending: i.CustomBlending,
       // Premultiplied alpha blending:
       // color = src_color * src_alpha + dst_color * (1 - src_alpha)
       // alpha = src_alpha * 1 + dst_alpha * (1 - src_alpha)
-      blendSrc: n.OneFactor,
+      blendSrc: i.OneFactor,
       // Using ONE because shader outputs premultiplied color (color * alpha)
-      blendDst: n.OneMinusSrcAlphaFactor,
-      blendSrcAlpha: n.OneFactor,
+      blendDst: i.OneMinusSrcAlphaFactor,
+      blendSrcAlpha: i.OneFactor,
       // source alpha comes from shader
-      blendDstAlpha: n.OneMinusSrcAlphaFactor,
-      blendEquation: n.AddEquation,
-      blendEquationAlpha: n.AddEquation,
+      blendDstAlpha: i.OneMinusSrcAlphaFactor,
+      blendEquation: i.AddEquation,
+      blendEquationAlpha: i.AddEquation,
       depthTest: !0,
       depthWrite: !1,
       // Disable depth write for transparency
-      side: n.DoubleSide,
+      side: i.DoubleSide,
       // Render both sides (or CULLFACE_NONE equivalent)
       // Optional settings from constructor
       alphaTest: t.alphaTest !== void 0 ? t.alphaTest : 0,
       // Typically 0 for blending
       toneMapped: t.toneMapped !== void 0 ? t.toneMapped : !1
       // prettier-ignore
-    }), t.alphaHash && (this.alphaHash = !0, this.depthWrite = !0, this.blending = n.NoBlending);
+    }), t.alphaHash && (this.alphaHash = !0, this.depthWrite = !0, this.blending = i.NoBlending);
   }
   /**
    * Update the viewport size
    * @param width Viewport width
    * @param height Viewport height
    */
-  updateViewport(t, r) {
-    this.uniforms.viewport.value.set(t, r);
+  updateViewport(t, n) {
+    this.uniforms.viewport.value.set(t, n);
   }
   /**
    * Set transform texture A (positions)
@@ -933,38 +925,38 @@ class gt extends n.ShaderMaterial {
     this.uniforms.numSplats.value = t;
   }
 }
-const Y = class Y extends n.Mesh {
+const j = class j 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(r, e = {}) {
-    const o = new gt(e), s = Y.createInstancedGeometry(r.numSplats, Y.INSTANCE_SIZE);
-    super(s, o);
+  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 n.Vector3());
-    f(this, "lastCameraDirectionLocal", new n.Vector3());
-    f(this, "invModelMatrix", new n.Matrix4());
-    this.geometry = s, this.material = o, this.splatData = r, this.frustumCulled = !1, this.options = { autoSort: !0, ...e }, this.textureManager = new mt(r), this.sorter = new ut();
-    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.init(
+    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(
       this.textureManager.orderTexture,
       this.splatData.centers,
-      i ?? void 0
+      o ?? void 0
     ), this.sorter.addEventListener(
       "updated",
       (a) => {
         const c = a.count;
-        this.geometry.instanceCount = Math.ceil(c / Y.INSTANCE_SIZE), this.material.setNumSplats(c);
+        this.geometry.instanceCount = Math.ceil(c / j.INSTANCE_SIZE), this.material.setNumSplats(c);
       }
-    ), 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 = r.boundingBox.toBox3(), this.geometry.boundingSphere = new n.Sphere(), this.geometry.boundingBox.getBoundingSphere(this.geometry.boundingSphere);
+    ), 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);
   }
   /**
    * Creates the instanced geometry for rendering splats.
@@ -972,8 +964,8 @@ const Y = class Y extends n.Mesh {
    * @param instanceSize Number of splats per instance.
    * @returns InstancedBufferGeometry
    */
-  static createInstancedGeometry(r, e) {
-    const o = Math.ceil(r / e), s = new n.BufferGeometry(), i = new Float32Array([
+  static createInstancedGeometry(n, e) {
+    const r = Math.ceil(n / e), s = new i.BufferGeometry(), o = new Float32Array([
       // x, y, splat_index_in_instance
       -1,
       -1,
@@ -991,34 +983,34 @@ const Y = class Y extends n.Mesh {
     for (let p = 0; p < e; p++) {
       const u = p * 4 * 3;
       for (let l = 0; l < 4; l++)
-        c[u + l * 3 + 0] = i[l * 3 + 0], c[u + l * 3 + 1] = i[l * 3 + 1], c[u + l * 3 + 2] = p;
+        c[u + l * 3 + 0] = o[l * 3 + 0], c[u + l * 3 + 1] = o[l * 3 + 1], c[u + l * 3 + 2] = p;
     }
     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;
     }
-    s.setAttribute("position", new n.BufferAttribute(c, 3)), s.setIndex(new n.BufferAttribute(h, 1));
-    const v = new n.InstancedBufferGeometry();
+    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 g = new Uint32Array(o);
-    for (let p = 0; p < o; p++)
-      g[p] = p * e;
-    return v.setAttribute("splatInstanceIndex", new n.InstancedBufferAttribute(g, 1, !1)), v.instanceCount = 0, v;
+    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;
   }
   /**
    * 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 r = this.splatData.boundingBox;
-    return r.min.x === 1 / 0 || r.max.x === -1 / 0 ? null : new Float32Array([
-      r.min.x,
-      r.min.y,
-      r.min.z,
-      r.max.x,
-      r.max.y,
-      r.max.z
+    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
     ]);
   }
   /**
@@ -1026,18 +1018,18 @@ const Y = class Y extends n.Mesh {
    * @param width Viewport width
    * @param height Viewport height
    */
-  updateViewport(r, e) {
-    this.material.updateViewport(r, e);
+  updateViewport(n, e) {
+    this.material.updateViewport(n, e);
   }
   /**
    * Sorts splats based on camera position and direction.
    * @param camera The camera to sort against.
    */
-  sort(r) {
-    const e = new n.Vector3(), o = new n.Vector3();
-    r.getWorldPosition(e), r.getWorldDirection(o), this.invModelMatrix.copy(this.matrixWorld).invert();
-    const s = e.applyMatrix4(this.invModelMatrix), i = o.transformDirection(this.invModelMatrix), a = this.lastCameraPositionLocal.distanceToSquared(s) > 1e-6, c = this.lastCameraDirectionLocal.dot(i) < 0.999;
-    this.options.autoSort && (a || c) && (this.lastCameraPositionLocal.copy(s), this.lastCameraDirectionLocal.copy(i), this.sorter.setCamera(s, i));
+  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));
   }
   /**
    * THREE.js hook called before rendering the object.
@@ -1048,16 +1040,16 @@ const Y = class Y extends n.Mesh {
    */
   // prettier-ignore
   // @ts-expect-error scene is not used
-  onBeforeRender(r, e, o) {
-    this.sort(o);
-    const s = r.getSize(new n.Vector2());
-    let { width: i, height: a } = s;
-    const c = r.xr;
+  onBeforeRender(n, e, r) {
+    this.sort(r);
+    const s = n.getSize(new i.Vector2());
+    let { width: o, height: a } = s;
+    const c = n.xr;
     if (c.enabled && c.isPresenting) {
       const h = c.getCamera().cameras[0].view;
-      h && (i = h.width, a = h.height);
+      h && (o = h.width, a = h.height);
     }
-    this.updateViewport(i, a);
+    this.updateViewport(o, a);
   }
   /**
    * Dispose of resources
@@ -1068,9 +1060,9 @@ const Y = class Y extends n.Mesh {
 };
 // Cached inverse matrix
 /** Number of splats combined into a single instanced draw call. */
-f(Y, "INSTANCE_SIZE", 128);
-let nt = Y;
-class wt extends n.Loader {
+f(j, "INSTANCE_SIZE", 128);
+let it = j;
+class bt extends i.Loader {
   /**
    * Load a PLY file with Gaussian Splat data
    * @param url URL of the PLY file
@@ -1078,22 +1070,22 @@ class wt extends n.Loader {
    * @param onProgress Optional progress callback
    * @param onError Optional error callback
    */
-  load(t, r, e, o) {
-    const s = new n.FileLoader(this.manager);
+  load(t, n, 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,
-      (i) => {
+      (o) => {
         try {
-          if (r) {
-            const a = this.parse(i);
-            r(a);
+          if (n) {
+            const a = this.parse(o);
+            n(a);
           }
         } catch (a) {
-          o ? o(a) : console.error(a), this.manager.itemError(t);
+          r ? r(a) : console.error(a), this.manager.itemError(t);
         }
       },
       e,
-      o
+      r
     );
   }
   /**
@@ -1102,22 +1094,22 @@ class wt extends n.Loader {
    * @param onProgress Optional progress callback
    * @returns A Promise that resolves with the parsed SplatData
    */
-  loadAsync(t, r) {
-    return new Promise((e, o) => {
-      const s = new n.FileLoader(this.manager);
+  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,
-        (i) => {
+        (o) => {
           try {
-            const a = this.parse(i);
+            const a = this.parse(o);
             e(a);
           } catch (a) {
-            o(a), this.manager.itemError(t);
+            r(a), this.manager.itemError(t);
           }
         },
-        r,
-        (i) => {
-          o(i), this.manager.itemError(t);
+        n,
+        (o) => {
+          r(o), this.manager.itemError(t);
         }
       );
     });
@@ -1128,44 +1120,44 @@ class wt extends n.Loader {
    * @returns Parsed SplatData
    */
   parse(t) {
-    const r = new TextDecoder(), e = new Uint8Array(t), o = [112, 108, 121, 10], s = `
+    const n = new TextDecoder(), e = new Uint8Array(t), r = [112, 108, 121, 10], s = `
 end_header
 `;
-    for (let x = 0; x < o.length; x++)
-      if (e[x] !== o[x])
+    for (let x = 0; x < r.length; x++)
+      if (e[x] !== r[x])
         throw new Error("Invalid PLY file: Missing magic bytes");
-    let i = 0;
+    let o = 0;
     for (let x = 0; x < e.length - s.length; x++) {
       let d = !0;
-      for (let C = 0; C < s.length; C++)
-        if (e[x + C] !== s.charCodeAt(C)) {
+      for (let z = 0; z < s.length; z++)
+        if (e[x + z] !== s.charCodeAt(z)) {
           d = !1;
           break;
         }
       if (d) {
-        i = x + s.length;
+        o = x + s.length;
         break;
       }
     }
-    if (i === 0)
+    if (o === 0)
       throw new Error("Invalid PLY file: Could not find end of header");
-    const c = r.decode(
-      e.slice(0, i)
+    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 C = d.split(" ");
-      switch (C[0]) {
+      const z = d.split(" ");
+      switch (z[0]) {
         case "format":
-          v = C[1];
+          v = z[1];
           break;
         case "element":
           h.push({
-            name: C[1],
-            count: parseInt(C[2], 10),
+            name: z[1],
+            count: parseInt(z[2], 10),
             properties: []
           });
           break;
@@ -1175,8 +1167,8 @@ end_header
               "Invalid PLY file: Property without element"
             );
           h[h.length - 1].properties.push({
-            type: C[1],
-            name: C[2],
+            type: z[1],
+            name: z[2],
             storage: null
           });
           break;
@@ -1184,17 +1176,17 @@ end_header
     }
     if (v !== "binary_little_endian")
       throw new Error(`Unsupported PLY format: ${v}`);
-    const g = h.find((x) => x.name === "vertex");
-    if (!g)
+    const y = h.find((x) => x.name === "vertex");
+    if (!y)
       throw new Error("Invalid PLY file: No vertex element found");
-    const p = new ht(g.count), u = new DataView(t);
-    let l = i;
-    const b = (x) => g.properties.findIndex((d) => d.name === x), A = b("x"), O = b("y"), q = b("z"), R = [
+    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")
-    ], E = [
+    ], R = [
       b("scale_0"),
       b("scale_1"),
       b("scale_2")
@@ -1204,98 +1196,97 @@ end_header
       b("f_dc_2")
     ], F = b("opacity");
     if ([
-      A,
+      B,
       O,
       q,
-      ...R,
       ...E,
+      ...R,
       ...W,
       F
     ].some((x) => x === -1))
       throw new Error("Invalid PLY file: Missing required properties");
-    const _ = 0.28209479177387814, M = (x) => {
+    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 n.Vector3(), B = new n.Quaternion(), P = new n.Vector3(), V = new n.Color();
-    for (let x = 0; x < g.count; x++) {
+    }, 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 I = 0; I < g.properties.length; I++) {
-        const Q = g.properties[I].type;
-        let S;
-        switch (Q) {
+      for (let T = 0; T < y.properties.length; T++) {
+        const K = y.properties[T].type;
+        let I;
+        switch (K) {
           case "char":
-            S = u.getInt8(l), l += 1;
+            I = u.getInt8(l), l += 1;
             break;
           case "uchar":
-            S = u.getUint8(l), l += 1;
+            I = u.getUint8(l), l += 1;
             break;
           case "short":
-            S = u.getInt16(l, !0), l += 2;
+            I = u.getInt16(l, !0), l += 2;
             break;
           case "ushort":
-            S = u.getUint16(l, !0), l += 2;
+            I = u.getUint16(l, !0), l += 2;
             break;
           case "int":
-            S = u.getInt32(l, !0), l += 4;
+            I = u.getInt32(l, !0), l += 4;
             break;
           case "uint":
-            S = u.getUint32(l, !0), l += 4;
+            I = u.getUint32(l, !0), l += 4;
             break;
           case "float":
-            S = u.getFloat32(l, !0), l += 4;
+            I = u.getFloat32(l, !0), l += 4;
             break;
           case "double":
-            S = u.getFloat64(l, !0), l += 8;
+            I = u.getFloat64(l, !0), l += 8;
             break;
           default:
-            throw new Error(`Unsupported property type: ${Q}`);
+            throw new Error(`Unsupported property type: ${K}`);
         }
-        d.push(S);
+        d.push(I);
       }
       m.set(
-        d[A],
+        d[B],
         d[O],
         d[q]
-      ), B.set(
-        // TODO: dangerous see if true
-        d[R[1]],
-        // PLY stores rot  1,2,3,0 (x,y,z,w)
-        d[R[2]],
-        d[R[3]],
-        d[R[0]]
-      ).normalize(), P.set(
-        d[E[0]],
-        // Read directly assuming it's log scale
+      ), C.set(
         d[E[1]],
-        d[E[2]]
+        // 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]]
       ), V.set(
-        0.5 + d[W[0]] * _,
-        0.5 + d[W[1]] * _,
-        0.5 + d[W[2]] * _
+        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 C = M(d[F]);
+      const z = M(d[F]);
       p.setSplat(
         x,
         m,
-        B,
-        P,
+        C,
+        _,
         // Pass log scale directly
         V,
-        C
+        z
       );
     }
     return p.calculateBoundingBox(), p;
   }
 }
-const bt = "0.2.0";
+const Mt = "0.3.0";
 export {
   et as BoundingBox,
-  wt as PlyLoader,
-  ht as SplatData,
-  gt as SplatMaterial,
-  nt as SplatMesh,
-  ut as SplatSorter,
-  mt as TextureManager,
-  bt as VERSION
+  bt as PlyLoader,
+  ut as SplatData,
+  vt as SplatMaterial,
+  it as SplatMesh,
+  dt as SplatSorter,
+  xt as TextureManager,
+  Mt as VERSION
 };