@speridlabs/visus 1.0.1 → 1.0.3

package/dist/main.es.js

@@ -0,0 +1,1307 @@
+var lt = Object.defineProperty;
+var ht = (A, t, s) => t in A ? lt(A, t, { enumerable: !0, configurable: !0, writable: !0, value: s }) : A[t] = s;
+var c = (A, t, s) => ht(A, typeof t != "symbol" ? t + "" : t, s);
+import * as n from "three";
+class et {
+  constructor() {
+    c(this, "min", new n.Vector3(1 / 0, 1 / 0, 1 / 0));
+    c(this, "max", new n.Vector3(-1 / 0, -1 / 0, -1 / 0));
+    c(this, "center", new n.Vector3());
+    /** Half extents (size/2) */
+    c(this, "halfExtents", new n.Vector3());
+  }
+  /**
+   * Reset the bounding box to its initial state
+   */
+  reset() {
+    this.min.set(1 / 0, 1 / 0, 1 / 0), this.max.set(-1 / 0, -1 / 0, -1 / 0), this.center.set(0, 0, 0), this.halfExtents.set(0, 0, 0);
+  }
+  /**
+   * 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();
+  }
+  /**
+   * 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();
+  }
+  /**
+   * Update the center and half extents based on min/max
+   */
+  updateDerived() {
+    this.center.addVectors(this.min, this.max).multiplyScalar(0.5), this.halfExtents.subVectors(this.max, this.min).multiplyScalar(0.5);
+  }
+  /**
+   * Check if this box contains a point
+   * @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;
+  }
+  /**
+   * Create a Three.js Box3 from this bounding box
+   * @returns THREE.Box3 representation
+   */
+  toBox3() {
+    return new n.Box3().set(this.min, this.max);
+  }
+  /**
+   * Create a clone of this bounding box
+   * @returns New bounding box with the same values
+   */
+  clone() {
+    const t = new et();
+    return t.min.copy(this.min), t.max.copy(this.max), t.center.copy(this.center), t.halfExtents.copy(this.halfExtents), t;
+  }
+}
+class ut {
+  // TODO: there is no sh spherical harmonics
+  constructor(t = 0) {
+    c(this, "numSplats", 0);
+    c(this, "positions");
+    c(this, "rotations");
+    c(this, "scales");
+    c(this, "colors");
+    c(this, "opacities");
+    c(this, "centers");
+    c(this, "boundingBox", new et());
+    this.numSplats = t, this.allocateBuffers(t);
+  }
+  allocateBuffers(t) {
+    this.positions = new Float32Array(t * 3), this.rotations = new Float32Array(t * 4), this.scales = new Float32Array(t * 3), this.colors = new Float32Array(t * 3), this.opacities = new Float32Array(t), this.centers = new Float32Array(t * 3);
+  }
+  /**
+   * Set data for a specific splat
+   * @param index Splat index
+   * @param position Position vector
+   * @param rotation Quaternion
+   * @param scale Scale vector (expects LOG SCALE)
+   * @param color Color
+   * @param opacity Opacity value
+   */
+  setSplat(t, s, e, r, o, i) {
+    if (t >= this.numSplats)
+      throw new Error(
+        `Splat index out of bounds: ${t} >= ${this.numSplats}`
+      );
+    const a = t * 3, d = t * 4, f = t * 3, v = t * 3;
+    this.positions[a] = s.x, this.positions[a + 1] = s.y, this.positions[a + 2] = s.z, this.rotations[d] = e.x, this.rotations[d + 1] = e.y, this.rotations[d + 2] = e.z, this.rotations[d + 3] = e.w, this.scales[f] = r.x, this.scales[f + 1] = r.y, this.scales[f + 2] = r.z, this.colors[v] = o.r, this.colors[v + 1] = o.g, this.colors[v + 2] = o.b, this.opacities[t] = i, this.centers[a] = s.x, this.centers[a + 1] = s.y, this.centers[a + 2] = s.z;
+  }
+  /**
+   * Get a splat's data
+   * @param index Splat index
+   * @returns Object containing splat data (linear scale)
+   */
+  getSplat(t) {
+    if (t >= this.numSplats)
+      throw new Error(
+        `Splat index out of bounds: ${t} >= ${this.numSplats}`
+      );
+    const s = t * 3, e = t * 4, r = t * 3, o = t * 3;
+    return {
+      position: new n.Vector3(
+        this.positions[s],
+        this.positions[s + 1],
+        this.positions[s + 2]
+      ),
+      rotation: new n.Quaternion(
+        this.rotations[e],
+        this.rotations[e + 1],
+        this.rotations[e + 2],
+        this.rotations[e + 3]
+      ),
+      // Convert log scale back to linear scale for external use
+      scale: new n.Vector3(
+        Math.exp(this.scales[r]),
+        Math.exp(this.scales[r + 1]),
+        Math.exp(this.scales[r + 2])
+      ),
+      color: new n.Color(
+        this.colors[o],
+        this.colors[o + 1],
+        this.colors[o + 2]
+      ),
+      opacity: this.opacities[t]
+    };
+  }
+  /**
+   * Calculate the bounding box for all splats
+   * NOTE: Currently it only uses positions, not the actual splat bounds
+   */
+  calculateBoundingBox() {
+    this.boundingBox.reset();
+    const t = new n.Vector3();
+    for (let s = 0; s < this.numSplats; s++) {
+      const e = s * 3;
+      t.set(
+        this.positions[e],
+        this.positions[e + 1],
+        this.positions[e + 2]
+      ), this.boundingBox.expandByPoint(t);
+    }
+    return this.boundingBox;
+  }
+  /**
+   * Create a Three.js BufferGeometry from this splat data
+   * This is for visualization/debugging purposes only, not for rendering
+   */
+  createDebugGeometry() {
+    const t = new n.BufferGeometry();
+    t.setAttribute(
+      "position",
+      new n.BufferAttribute(this.positions, 3)
+    );
+    const s = new Float32Array(this.numSplats * 3), e = new n.Quaternion(), r = new n.Euler();
+    for (let o = 0; o < this.numSplats; o++) {
+      const i = o * 4, a = o * 3;
+      e.set(
+        this.rotations[i],
+        this.rotations[i + 1],
+        this.rotations[i + 2],
+        this.rotations[i + 3]
+      ), r.setFromQuaternion(e), s[a] = r.x, s[a + 1] = r.y, s[a + 2] = r.z;
+    }
+    return t.setAttribute(
+      "rotation",
+      new n.BufferAttribute(s, 3)
+    ), t.setAttribute(
+      "scale",
+      new n.BufferAttribute(this.scales, 3)
+    ), t.setAttribute(
+      "color",
+      new n.BufferAttribute(this.colors, 3)
+    ), t.setAttribute(
+      "opacity",
+      new n.BufferAttribute(this.opacities, 1)
+    ), t;
+  }
+}
+class dt extends n.EventDispatcher {
+  constructor() {
+    super();
+    c(this, "worker");
+    c(this, "centers", null);
+    c(this, "orderTexture", null);
+    /** Bounding box data for optimization */
+    c(this, "chunks", null);
+    c(this, "lastCameraPosition", new n.Vector3());
+    c(this, "lastCameraDirection", new n.Vector3());
+    const s = this.createWorkerCode(), e = new Blob([s], { type: "application/javascript" });
+    this.worker = new Worker(URL.createObjectURL(e)), this.worker.onmessage = this.onWorkerMessage.bind(this);
+  }
+  /**
+   * Handles messages received from the sorting worker.
+   * @param event The message event from the worker.
+   */
+  onWorkerMessage(s) {
+    if (!this.orderTexture || !this.orderTexture.image)
+      return console.error("SplatSorter: Order texture not initialized!");
+    const { order: e, count: r } = s.data, o = this.orderTexture.image.data;
+    if (!(o instanceof Uint32Array))
+      return console.error(
+        "SplatSorter: Order texture data is not a Uint32Array!"
+      );
+    o.set(new Uint32Array(e)), this.orderTexture.needsUpdate = !0;
+    const i = o.buffer.slice(0), a = { order: i };
+    this.worker.postMessage(a, [i]), this.dispatchEvent({ type: "updated", count: r });
+  }
+  /**
+   * Initializes the sorter with necessary data and textures.
+   * @param orderTexture The THREE.DataTexture (R32UI) to store the sorted splat indices.
+   * @param centers A Float32Array containing the center position (x, y, z) for each splat.
+   * @param chunks Optional: A Float32Array containing bounding box chunk data [minX, minY, minZ, maxX, maxY, maxZ, ...] for optimization.
+   */
+  init(s, e, r) {
+    if (!s || !(s.image.data instanceof Uint32Array))
+      throw new Error("SplatSorter: Invalid orderTexture provided. Must be DataTexture with Uint32Array data.");
+    if (!e || e.length % 3 !== 0)
+      throw new Error("SplatSorter: Invalid centers array provided. Length must be multiple of 3.");
+    if (s.image.data.length < e.length / 3)
+      throw new Error("SplatSorter: orderTexture data buffer is smaller than the number of splats.");
+    const o = e.length / 3;
+    this.orderTexture = s, this.centers = e.slice();
+    const i = this.orderTexture.image.data;
+    for (let g = 0; g < o; g++) i[g] = g;
+    this.orderTexture.needsUpdate = !0;
+    const a = i.buffer.slice(0), d = this.centers.buffer.slice(0), f = {
+      order: a,
+      centers: d
+    }, v = [
+      a,
+      d
+    ];
+    if (r) {
+      this.chunks = r.slice();
+      const g = this.chunks.buffer.slice(0);
+      f.chunks = g, v.push(g);
+    }
+    this.worker.postMessage(f, v), queueMicrotask(() => {
+      this.dispatchEvent({
+        type: "updated",
+        count: o
+      });
+    });
+  }
+  /**
+   * Applies an optional mapping to filter or reorder splats before sorting.
+   * The sorter will only consider splats whose original indices are present in the mapping.
+   * @param mapping A Uint32Array where each element is the *original* index of a splat to include, or null to reset mapping.
+   */
+  setMapping(s) {
+    if (!this.centers)
+      return console.warn(
+        "SplatSorter: Cannot set mapping before initialization."
+      );
+    let e;
+    const r = [];
+    if (!s) {
+      const d = this.centers.buffer.slice(0);
+      return e = {
+        centers: d,
+        mapping: null
+      }, r.push(d), this.worker.postMessage(e, r);
+    }
+    const o = new Float32Array(s.length * 3);
+    for (let d = 0; d < s.length; d++) {
+      const f = s[d];
+      if (f * 3 + 2 >= this.centers.length) {
+        console.warn(
+          `SplatSorter: Mapping index ${f} out of bounds.`
+        );
+        continue;
+      }
+      const v = f * 3, g = d * 3;
+      o[g + 0] = this.centers[v + 0], o[g + 1] = this.centers[v + 1], o[g + 2] = this.centers[v + 2];
+    }
+    const i = o.buffer.slice(0), a = s.buffer.slice(0);
+    e = {
+      centers: i,
+      mapping: a
+    }, r.push(i, a), this.worker.postMessage(e, r);
+  }
+  /**
+   * Updates the camera parameters used for sorting.
+   * @param position The camera's position in the sorter's local coordinate space.
+   * @param direction The camera's forward direction in the sorter's local coordinate space.
+   */
+  setCamera(s, e) {
+    const r = this.lastCameraPosition.distanceToSquared(s) > 1e-7, o = this.lastCameraDirection.dot(e) < 0.9999;
+    if (!r && !o)
+      return;
+    this.lastCameraPosition.copy(s), this.lastCameraDirection.copy(e);
+    const i = {
+      cameraPosition: { x: s.x, y: s.y, z: s.z },
+      cameraDirection: { x: e.x, y: e.y, z: e.z }
+    };
+    this.worker.postMessage(i);
+  }
+  /**
+   * Terminates the Web Worker and cleans up resources.
+   */
+  dispose() {
+    this.worker && this.worker.terminate(), this.orderTexture = null, this.centers = null, this.chunks = null;
+  }
+  /**
+   * Creates the self-contained code for the sorting Web Worker.
+   * @returns A string containing the JavaScript code for the worker.
+   */
+  createWorkerCode() {
+    return `(${(function() {
+      let e = null, r = null, o = null, i = null, a = null, d = null, f = !1;
+      const v = { x: 0, y: 0, z: 0 }, g = { x: 0, y: 0, z: 0 }, p = { x: 0, y: 0, z: 0 }, h = { x: 0, y: 0, z: 0 };
+      let l = null, b = null;
+      const T = 32, O = new Array(T).fill(0), q = new Array(T).fill(0), E = new Array(T).fill(0), R = (k, C, F) => {
+        for (; k <= C; ) {
+          const M = C + k >> 1, m = F(M);
+          if (m > 0) k = M + 1;
+          else if (m < 0) C = M - 1;
+          else return M;
+        }
+        return ~k;
+      }, W = () => {
+        if (!e || !r || !a || !d)
+          return;
+        if (r.length === 0) {
+          const y = {
+            order: e.buffer,
+            count: 0
+          };
+          self.postMessage(y, [e.buffer]), e = null;
+          return;
+        }
+        const k = a.x, C = a.y, F = a.z, M = d.x, m = d.y, B = d.z, V = 1e-4, P = Math.abs(k - v.x) > V || Math.abs(C - v.y) > V || Math.abs(F - v.z) > V, x = Math.abs(M - g.x) > V || Math.abs(m - g.y) > V || Math.abs(B - g.z) > V;
+        if (!f && !P && !x)
+          return;
+        f = !1, v.x = k, v.y = C, v.z = F, g.x = M, g.y = m, g.z = B;
+        let u = 1 / 0, S = -1 / 0;
+        for (let y = 0; y < 8; ++y) {
+          const _ = y & 1 ? p.x : h.x, U = y & 2 ? p.y : h.y, w = y & 4 ? p.z : h.z, D = _ * M + U * m + w * B;
+          u = Math.min(u, D), S = Math.max(S, D);
+        }
+        const I = r.length / 3, L = S - u, z = (1 << Math.max(
+          10,
+          Math.min(20, Math.ceil(Math.log2(I / 4)))
+        )) + 1;
+        if ((!l || l.length !== I) && (l = new Uint32Array(I)), !b || b.length !== z ? b = new Uint32Array(z) : b.fill(0), L < 1e-7) {
+          for (let y = 0; y < I; ++y) l[y] = 0;
+          b[0] = I;
+        } else if (o && o.length > 0) {
+          const y = o.length / 6;
+          O.fill(0);
+          for (let w = 0; w < y; ++w) {
+            const D = w * 6, X = o[D + 0], Z = o[D + 1], $ = o[D + 2], H = o[D + 3], Y = X * M + Z * m + $ * B - u, J = Y - H, G = Y + H, Q = Math.max(
+              0,
+              Math.floor(J * T / L)
+            ), tt = Math.min(
+              T,
+              Math.ceil(G * T / L)
+            );
+            for (let N = Q; N < tt; ++N)
+              O[N]++;
+          }
+          let _ = 0;
+          for (let w = 0; w < T; ++w) _ += O[w];
+          E[0] = 0, q[0] = 0;
+          for (let w = 1; w < T; ++w)
+            E[w - 1] = O[w - 1] / _ * z >>> 0, q[w] = q[w - 1] + E[w - 1];
+          E[T - 1] = O[T - 1] / _ * z >>> 0;
+          const U = L / T;
+          for (let w = 0; w < I; ++w) {
+            const D = w * 3, X = r[D + 0], Z = r[D + 1], $ = r[D + 2], H = X * M + Z * m + $ * B, J = (S - H) / U, G = Math.max(
+              0,
+              Math.min(
+                T - 1,
+                Math.floor(J)
+              )
+            ), Q = J - G, tt = q[G] + E[G] * Q >>> 0, N = Math.min(tt, z - 1);
+            l[w] = N, b[N]++;
+          }
+        } else {
+          const y = (z - 1) / L;
+          for (let _ = 0; _ < I; ++_) {
+            const U = _ * 3, w = r[U + 0], D = r[U + 1], X = r[U + 2], Z = w * M + D * m + X * B, H = (S - Z) * y >>> 0, Y = Math.min(H, z - 1);
+            l[_] = Y, b[Y]++;
+          }
+        }
+        for (let y = 1; y < z; y++)
+          b[y] += b[y - 1];
+        for (let y = I - 1; y >= 0; y--) {
+          const _ = l[y], U = --b[_];
+          e[U] = i ? i[y] : y;
+        }
+        const at = k * M + C * m + F * B, rt = (y) => {
+          if (!e) return -1 / 0;
+          const _ = e[y], U = _;
+          if (!r || U * 3 + 2 >= r.length)
+            return -1 / 0;
+          const w = U * 3;
+          return r[w] * M + r[w + 1] * m + r[w + 2] * B - at;
+        };
+        let st = I;
+        if (I > 0 && rt(I - 1) < 0) {
+          const y = R(
+            0,
+            I - 1,
+            rt
+          );
+          st = y < 0 ? ~y : y;
+        }
+        const ct = {
+          order: e.buffer,
+          count: st
+        };
+        self.postMessage(ct, [e.buffer]), e = null;
+      };
+      self.onmessage = (k) => {
+        const C = k.data;
+        C.order && (e = new Uint32Array(C.order));
+        let F = !1;
+        if (C.centers && (r = new Float32Array(C.centers), F = !0, f = !0), Object.prototype.hasOwnProperty.call(C, "mapping") && (i = C.mapping ? new Uint32Array(C.mapping) : null, f = !0), C.chunks) {
+          if (o = new Float32Array(C.chunks), o.length > 0 && o[3] > 0)
+            for (let M = 0; M < o.length / 6; ++M) {
+              const m = M * 6, B = o[m + 0], V = o[m + 1], P = o[m + 2], x = o[m + 3], u = o[m + 4], S = o[m + 5];
+              o[m + 0] = (B + x) * 0.5, o[m + 1] = (V + u) * 0.5, o[m + 2] = (P + S) * 0.5, o[m + 3] = Math.sqrt(
+                (x - B) ** 2 + (u - V) ** 2 + (S - P) ** 2
+              ) * 0.5;
+            }
+          f = !0;
+        }
+        if (F && r && r.length > 0) {
+          p.x = h.x = r[0], p.y = h.y = r[1], p.z = h.z = r[2];
+          for (let M = 1; M < r.length / 3; M++) {
+            const m = M * 3;
+            p.x = Math.min(p.x, r[m + 0]), h.x = Math.max(h.x, r[m + 0]), p.y = Math.min(p.y, r[m + 1]), h.y = Math.max(h.y, r[m + 1]), p.z = Math.min(p.z, r[m + 2]), h.z = Math.max(h.z, r[m + 2]);
+          }
+        } else F && r && r.length === 0 && (p.x = h.x = p.y = h.y = p.z = h.z = 0);
+        C.cameraPosition && (a = C.cameraPosition), C.cameraDirection && (d = C.cameraDirection), W();
+      };
+    }).toString()})();`;
+  }
+}
+const pt = (A, t) => {
+  const s = ot(A), e = ot(t);
+  return s | e << 16;
+};
+function ot(A) {
+  const t = new Float32Array([A]), e = new Int32Array(t.buffer)[0];
+  let r = e >> 16 & 32768, o = e >> 12 & 2047;
+  const i = e >> 23 & 255;
+  return i < 103 ? r : i > 142 ? (r |= 31744, r |= (i === 255 ? 0 : 1) && e & 8388607, r) : i < 113 ? (o |= 2048, r |= (o >> 114 - i) + (o >> 113 - i & 1), r) : (r |= i - 112 << 10 | o >> 1, r += o & 1, r);
+}
+const ft = new ArrayBuffer(4), nt = new DataView(ft), mt = (A) => (nt.setUint32(0, A, !0), nt.getFloat32(0, !0));
+class xt {
+  /**
+   * Create a new TextureManager for a set of splats
+   * @param splatData The splat data to manage textures for
+   */
+  constructor(t) {
+    c(this, "transformA");
+    // position xyz and rotation quaternion y,z components
+    c(this, "transformB");
+    // rotation quaternion x and scale xyz
+    c(this, "colorTexture");
+    // color an opacity
+    c(this, "orderTexture");
+    c(this, "textureWidth");
+    c(this, "textureHeight");
+    const s = t.numSplats;
+    this.textureWidth = Math.ceil(Math.sqrt(s)), this.textureHeight = Math.ceil(s / this.textureWidth), this.transformA = this.createTransformATexture(t), this.transformB = this.createTransformBTexture(t), this.colorTexture = this.createColorTexture(t), this.orderTexture = this.createOrderTexture(s);
+  }
+  /**
+   * Create the transform A texture (positions and quaternion w component)
+   * @param splatData The splat data
+   * @returns DataTexture containing position data
+   */
+  createTransformATexture(t) {
+    const s = t.numSplats, e = new Float32Array(
+      this.textureWidth * this.textureHeight * 4
+    );
+    for (let o = 0; o < s; o++) {
+      const i = o * 4, a = o * 3, d = o * 4;
+      e[i] = t.positions[a], e[i + 1] = t.positions[a + 1], e[i + 2] = t.positions[a + 2];
+      const f = t.rotations[d + 0], v = t.rotations[d + 1], g = pt(f, v);
+      e[i + 3] = mt(g);
+    }
+    const r = new n.DataTexture(
+      e,
+      this.textureWidth,
+      this.textureHeight,
+      n.RGBAFormat,
+      n.FloatType
+      // Store as Float32, shader will reinterpret bits
+    );
+    return r.needsUpdate = !0, r.magFilter = n.NearestFilter, r.minFilter = n.NearestFilter, r;
+  }
+  /**
+   * Create the transform B texture (scale and rotation xyz)
+   * @param splatData The splat data
+   * @returns DataTexture containing scale and rotation data
+   */
+  createTransformBTexture(t) {
+    const s = t.numSplats, e = new Float32Array(
+      this.textureWidth * this.textureHeight * 4
+    );
+    for (let o = 0; o < s; o++) {
+      const i = o * 4, a = o * 3, d = o * 4;
+      e[i] = t.scales[a], e[i + 1] = t.scales[a + 1], e[i + 2] = t.scales[a + 2], e[i + 3] = t.rotations[d + 2];
+    }
+    const r = new n.DataTexture(
+      e,
+      this.textureWidth,
+      this.textureHeight,
+      n.RGBAFormat,
+      n.FloatType
+    );
+    return r.needsUpdate = !0, r.magFilter = n.NearestFilter, r.minFilter = n.NearestFilter, r;
+  }
+  /**
+   * Create the color texture (RGB and opacity)
+   * @param splatData The splat data
+   * @returns DataTexture containing color data
+   */
+  createColorTexture(t) {
+    const s = t.numSplats, e = new Float32Array(
+      this.textureWidth * this.textureHeight * 4
+    );
+    for (let o = 0; o < s; o++) {
+      const i = o * 4, a = o * 3;
+      e[i] = t.colors[a], e[i + 1] = t.colors[a + 1], e[i + 2] = t.colors[a + 2], e[i + 3] = t.opacities[o];
+    }
+    const r = new n.DataTexture(
+      e,
+      this.textureWidth,
+      this.textureHeight,
+      n.RGBAFormat,
+      n.FloatType
+    );
+    return r.needsUpdate = !0, r;
+  }
+  /**
+   * Create the order texture for sorting
+   * @param numSplats Number of splats
+   * @returns DataTexture for storing order indices
+   */
+  createOrderTexture(t) {
+    const s = new Uint32Array(this.textureWidth * this.textureHeight);
+    for (let r = 0; r < t; r++)
+      s[r] = r;
+    const e = new n.DataTexture(
+      s,
+      this.textureWidth,
+      this.textureHeight,
+      n.RedIntegerFormat,
+      n.UnsignedIntType
+    );
+    return e.needsUpdate = !0, e;
+  }
+  dispose() {
+    this.transformA.dispose(), this.transformB.dispose(), this.colorTexture.dispose(), this.orderTexture.dispose();
+  }
+}
+const yt = (
+  /* glsl */
+  `
+precision highp float;
+precision highp int;
+precision highp usampler2D;
+precision highp sampler2D;
+
+// --- Uniforms (Provided by Three.js) ---
+// uniform mat4 modelViewMatrix; // Don't redeclare
+// uniform mat4 projectionMatrix; // Don't redeclare
+uniform vec2 viewport;          // Viewport dimensions (width, height)
+uniform uint numSplats;         // Total number of splats potentially renderable by sorter
+
+// Textures
+uniform highp sampler2D transformA;   // vec4: pos.xyz, packed_rot.yz
+uniform highp sampler2D transformB;   // vec4: log_scale.xyz, rot.x
+uniform highp sampler2D splatColor;   // vec4: color.rgb, opacity
+uniform highp usampler2D splatOrder;  // uint: original splat index
+
+// --- Attributes ---
+// Instancing attribute: base index for this block of splats
+attribute uint splatInstanceIndex;
+
+// Per-vertex attribute of the quad (Built-in, don't redeclare 'position')
+// attribute vec3 position; // Use the built-in 'position'
+// position.xy: corner coords (-1..1)
+// position.z: index within the instance block (0..INSTANCE_BUFFER_SIZE-1)
+
+// --- Varyings ---
+varying vec4 vColor;
+varying vec2 vUv; // For gaussian calculation in fragment shader
+
+// --- Constants ---
+#define INSTANCE_BUFFER_SIZE 128.0 // Must match the size in SplatMesh
+
+// --- Helper Functions ---
+
+// Use GLSL built-in unpackHalf2x16 for proper half-float unpacking
+
+// 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);
+    return vec4(w, x, y, z); // Return (w,x,y,z) 
+}
+
+// Convert quaternion to 3x3 rotation matrix
+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 - 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
+void getModelCovariance(vec3 scale, vec4 rotation, out vec3 covA, out vec3 covB) {
+    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
+    ));
+
+    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 ---
+void main(void) {
+    // Calculate the final splat index for this vertex
+    uint instanceOffset = uint(position.z); // Read index within instance from Z
+    uint orderedSplatIndex = splatInstanceIndex + instanceOffset;
+
+    // Discard if this splat index is beyond the sorted count
+    if (orderedSplatIndex >= numSplats) {
+        gl_Position = vec4(2.0, 2.0, 2.0, 1.0); // Off-screen
+        return;
+    }
+
+    // --- Source Data Lookup ---
+    uint texWidth = uint(textureSize(splatOrder, 0).x);
+    ivec2 orderUV = ivec2(orderedSplatIndex % texWidth, orderedSplatIndex / texWidth);
+    uint originalSplatIndex = texelFetch(splatOrder, orderUV, 0).r;
+
+    ivec2 dataUV = ivec2(originalSplatIndex % texWidth, originalSplatIndex / texWidth);
+
+    // Fetch data from textures
+    vec4 texTransformA = texelFetch(transformA, dataUV, 0);
+    vec4 texTransformB = texelFetch(transformB, dataUV, 0);
+    vec4 texColor = texelFetch(splatColor, dataUV, 0);
+
+    vec3 splatPosition = texTransformA.xyz;
+    vec3 splatLogScale = texTransformB.xyz; // Assume stored as log scale
+    vec4 splatRotation = unpackRotation(texTransformA.w, texTransformB.w); // Unpack rot xy, z
+    vec3 splatColor = texColor.rgb;
+    float splatOpacity = texColor.a;
+
+    vec3 splatScale = exp(splatLogScale); // Convert log scale to actual scale
+
+    // --- Center Projection ---
+
+    // Compute normalized view-space center
+    vec4 centerClipRaw = modelViewMatrix * vec4(splatPosition, 1.0);
+    vec3 centerView  = centerClipRaw.xyz / centerClipRaw.w;
+
+    // Early out if splat is behind the camera
+    if (centerView.z > -0.2) { // Use small epsilon
+        gl_Position = vec4(2.0, 2.0, 2.0, 1.0);
+        return;
+    }
+
+    // Project to clip space
+    vec4 centerClip = projectionMatrix * centerClipRaw;
+
+    // --- Covariance Calculation & Projection ---
+
+    // Calculating model space covariance (Vrk)
+    vec3 covA, covB;
+    getModelCovariance(splatScale, splatRotation, covA, covB);
+    mat3 Vrk = mat3(
+        covA.x, covA.y, covA.z,
+        covA.y, covB.x, covB.y, // covB.x is Vrk[1][1]
+        covA.z, covB.y, covB.z  // covB.y is Vrk[1][2], covB.z is Vrk[2][2]
+    );
+
+    // Calculate Jacobian J (screen space change wrt view space change)
+    //    Requres focal lenghts and view-space center depth (tz)
+    float focalX = viewport.x * projectionMatrix[0][0];
+    float focalY = viewport.y * projectionMatrix[1][1];
+    float tz = centerView.z;
+    float tz2 = tz * tz;
+
+    // Jacobian J = [fx/tz,  0,    -fx*tx/tz^2]
+    //              [0,     fy/tz, -fy*ty/tz^2]
+    mat3 J = mat3(
+        focalX / tz,     0.0,  -focalX * centerView.x / tz2,
+        0.0,     focalY / tz,  -focalY * centerView.y / tz2,
+        0.0,             0.0,                0.0
+    );
+
+    // Calculate W 
+    mat3 W = transpose(mat3(modelViewMatrix));
+    // Calculate T = W * J
+    mat3 T = W * J;
+    // Calculate Projected 2D Covariance: SigmaProj = transpose(T) * Vrk * T
+    mat3 SigmaProj = transpose(T) * Vrk * T;
+
+    // Extract 2D components and add bias
+    float cov2D_11 = SigmaProj[0][0] + 0.3;
+    float cov2D_12 = SigmaProj[0][1];
+    float cov2D_22 = SigmaProj[1][1] + 0.3;
+
+    // --- Calculate 2D Screen Space Rotation & Scale ---
+
+    float det = cov2D_11 * cov2D_22 - cov2D_12 * cov2D_12;
+    // Ensure determinant is non-negative before sqrt
+    if (det <= 0.0) {
+      gl_Position = vec4(2.0, 2.0, 2.0, 1.0); // Discard degenerated
+      return;
+    }
+
+    float trace = cov2D_11 + cov2D_22;
+    float traceOver2 = 0.5 * trace;
+    float discriminantSqrt = sqrt(max(traceOver2 * traceOver2 - det, 0.0)); // Avoid sqrt(negative)
+
+    float lambda1 = traceOver2 + discriminantSqrt; // Larger eigenvalue
+    float lambda2 = max(0.1, traceOver2 - discriminantSqrt); // Smaller eigenvalue, clamped
+
+    // Compute eigenvectors 
+
+    vec2 v1_eigen, v2_eigen;
+    
+    // Handle diagonal case
+    if(abs(cov2D_12) < 1e-16) {
+        v1_eigen = vec2(1.0, 0.0);
+    } else {
+        v1_eigen = normalize(vec2(cov2D_12, lambda1 - cov2D_11)); // diagonal choice
+    }
+
+    v2_eigen = vec2(-v1_eigen.y, v1_eigen.x); // Perpendicular eigenvector
+
+    // Calculate SCALED vectors (l1, l2, incorparate factor)
+    float scaleFactor = 2.0 * sqrt(2.0); // ~2.8284
+    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);
+         return;
+    }
+
+    // Scaled eigenvectors for offset calculation
+    vec2 v1_scaled = l1 * v1_eigen;
+    vec2 v2_scaled = l2 * v2_eigen;
+
+    // --- FRUSTUM CHECK (laxo, estilo PlayCanvas) ---
+
+    vec2 c = centerClip.ww / viewport;  // pixel to clip
+    float r = max(l1, l2);              // radius in pixels
+
+    // 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 ---
+
+    // --- Final Vertex Position ---
+
+    vec2 cornerOffset = position.xy; // (-1,-1) to (1,1)
+
+    // Clip the quad so only high-alpha core is visible
+    float alpha = max(splatOpacity, 1e-6);     // avoid log(0)
+    float clip  = min(1.0, sqrt(-log(1.0 / 255.0 / alpha)) / 2.0);
+
+    // 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;
+
+    // Convert pixel offset to clip space offset
+    vec2 clipOffset = screenOffsetPixels * (centerClip.w / viewport);
+
+
+    // Apply offset to center clip position
+    gl_Position = centerClip + vec4(clipOffset, 0.0, 0.0);
+
+    // --- Pass data to Fragment Shader ---
+
+    vColor = vec4(splatColor, splatOpacity);
+    vUv = clippedCornerOffset;
+}
+`
+), gt = (
+  /* glsl */
+  `
+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)
+    if (distSq > 1.0) discard; // Discard fragments outside the circle inscribed in the quad
+
+    // Calculate Gaussian function: alpha = opacity * exp(-distSq * factor)
+    // 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 = fastExp(-distSq * 4.0) * vColor.a;
+
+    if (alpha < 1.0 / 255.0) discard; // Discard fragments with very low alpha
+
+    // Premultiply color by alpha (required for correct blending)
+    gl_FragColor = vec4(vColor.rgb * alpha, alpha);
+}
+`
+);
+class vt extends n.ShaderMaterial {
+  constructor(t = {}) {
+    const s = {
+      // Textures (values set via methods)
+      transformA: { value: null },
+      transformB: { value: null },
+      splatColor: { value: null },
+      splatOrder: { value: null },
+      // Other uniforms
+      viewport: { value: new n.Vector2(1, 1) },
+      // Will be updated
+      numSplats: { value: 0 }
+      // Max splats to render (updated by sorter)
+    };
+    super({
+      vertexShader: yt,
+      fragmentShader: gt,
+      uniforms: s,
+      transparent: !0,
+      blending: n.CustomBlending,
+      // Premultiplied alpha blending:
+      // color = src_color * src_alpha + dst_color * (1 - src_alpha)
+      // alpha = src_alpha * 1 + dst_alpha * (1 - src_alpha)
+      blendSrc: n.OneFactor,
+      // Using ONE because shader outputs premultiplied color (color * alpha)
+      blendDst: n.OneMinusSrcAlphaFactor,
+      blendSrcAlpha: n.OneFactor,
+      // source alpha comes from shader
+      blendDstAlpha: n.OneMinusSrcAlphaFactor,
+      blendEquation: n.AddEquation,
+      blendEquationAlpha: n.AddEquation,
+      depthTest: !0,
+      depthWrite: !1,
+      // Disable depth write for transparency
+      side: n.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);
+  }
+  /**
+   * Update the viewport size
+   * @param width Viewport width
+   * @param height Viewport height
+   */
+  updateViewport(t, s) {
+    this.uniforms.viewport.value.set(t, s);
+  }
+  /**
+   * Set transform texture A (positions)
+   * @param texture Texture containing positions
+   */
+  setTransformA(t) {
+    this.uniforms.transformA.value = t;
+  }
+  /**
+   * Set transform texture B (rotation, scale)
+   * @param texture Texture containing rotation and scale data
+   */
+  setTransformB(t) {
+    this.uniforms.transformB.value = t;
+  }
+  /**
+   * Set color texture
+   * @param texture Texture containing colors
+   */
+  setColorTexture(t) {
+    this.uniforms.splatColor.value = t;
+  }
+  /**
+   * Set order texture
+   * @param texture Texture containing sort order
+   */
+  setOrderTexture(t) {
+    this.uniforms.splatOrder.value = t;
+  }
+  /**
+   * Set number of splats to render
+   * @param count Number of splats
+   */
+  setNumSplats(t) {
+    this.uniforms.numSplats.value = t;
+  }
+}
+const j = class j extends n.Mesh {
+  // Match shader constant
+  /**
+   * Create a new SplatMesh for rendering Gaussian splats
+   * @param splatData The splat data to render
+   * @param options Rendering options
+   */
+  constructor(s, e = {}) {
+    const r = new vt(e), o = j.createInstancedGeometry(s.numSplats, j.INSTANCE_SIZE);
+    super(o, r);
+    c(this, "sorter");
+    c(this, "splatData");
+    c(this, "options");
+    c(this, "textureManager");
+    c(this, "material");
+    c(this, "geometry");
+    c(this, "lastCameraPositionLocal", new n.Vector3());
+    c(this, "lastCameraDirectionLocal", new n.Vector3());
+    c(this, "invModelMatrix", new n.Matrix4());
+    // Cached inverse matrix
+    c(this, "_vpW", -1);
+    c(this, "_vpH", -1);
+    c(this, "_size", new n.Vector2());
+    c(this, "_camPosW", new n.Vector3());
+    c(this, "_camDirW", new n.Vector3());
+    c(this, "_camPosL", new n.Vector3());
+    c(this, "_camDirL", new n.Vector3());
+    c(this, "onSorterUpdated", (s) => {
+      const e = s.count;
+      this.geometry.instanceCount = Math.ceil(e / j.INSTANCE_SIZE), this.material.setNumSplats(e);
+    });
+    this.geometry = o, this.material = r, this.splatData = s, this.frustumCulled = !1, this.options = {
+      autoSort: !0,
+      ...e
+    }, this.textureManager = new xt(s), this.sorter = new dt();
+    let i = this.createChunks() || void 0;
+    i === null && console.warn("Visus: Could not create sorter chunks, bounding box might be invalid."), i = void 0, this.sorter.addEventListener("updated", this.onSorterUpdated), this.sorter.init(
+      this.textureManager.orderTexture,
+      this.splatData.centers,
+      i ?? void 0
+    ), this.material.setTransformA(this.textureManager.transformA), this.material.setTransformB(this.textureManager.transformB), this.material.setColorTexture(this.textureManager.colorTexture), this.material.setOrderTexture(this.textureManager.orderTexture), this.material.setNumSplats(0), this.geometry.boundingBox = s.boundingBox.toBox3(), this.geometry.boundingSphere = new n.Sphere(), this.geometry.boundingBox.getBoundingSphere(this.geometry.boundingSphere);
+  }
+  /**
+   * Creates the instanced geometry for rendering splats.
+   * @param totalSplats Total number of splats in the data.
+   * @param instanceSize Number of splats per instance.
+   * @returns InstancedBufferGeometry
+   */
+  static createInstancedGeometry(s, e) {
+    const r = Math.ceil(s / e), o = new n.BufferGeometry(), i = new Float32Array([
+      // x, y, splat_index_in_instance
+      -1,
+      -1,
+      0,
+      1,
+      -1,
+      0,
+      1,
+      1,
+      0,
+      -1,
+      1,
+      0
+    ]), a = new Uint16Array([0, 1, 2, 0, 2, 3]), d = new Float32Array(4 * 3 * e);
+    for (let p = 0; p < e; p++) {
+      const h = p * 4 * 3;
+      for (let l = 0; l < 4; l++)
+        d[h + l * 3 + 0] = i[l * 3 + 0], d[h + l * 3 + 1] = i[l * 3 + 1], d[h + l * 3 + 2] = p;
+    }
+    const f = new Uint32Array(6 * e);
+    for (let p = 0; p < e; p++) {
+      const h = p * 6, l = p * 4;
+      f[h + 0] = a[0] + l, f[h + 1] = a[1] + l, f[h + 2] = a[2] + l, f[h + 3] = a[3] + l, f[h + 4] = a[4] + l, f[h + 5] = a[5] + l;
+    }
+    o.setAttribute("position", new n.BufferAttribute(d, 3)), o.setIndex(new n.BufferAttribute(f, 1));
+    const v = new n.InstancedBufferGeometry();
+    v.index = o.index, v.setAttribute("position", o.getAttribute("position"));
+    const g = new Uint32Array(r);
+    for (let p = 0; p < r; p++)
+      g[p] = p * e;
+    return v.setAttribute("splatInstanceIndex", new n.InstancedBufferAttribute(g, 1, !1)), v.instanceCount = 0, v;
+  }
+  /**
+   * Create chunks data (bounding box min/max) for the sorter.
+   * @returns Float32Array containing chunk data [minX, minY, minZ, maxX, maxY, maxZ] or null.
+   */
+  createChunks() {
+    const s = this.splatData.boundingBox;
+    return s.min.x === 1 / 0 || s.max.x === -1 / 0 ? null : new Float32Array([
+      s.min.x,
+      s.min.y,
+      s.min.z,
+      s.max.x,
+      s.max.y,
+      s.max.z
+    ]);
+  }
+  /**
+   * Update the viewport size
+   * @param width Viewport width
+   * @param height Viewport height
+   */
+  updateViewport(s, e) {
+    s === this._vpW && e === this._vpH || (this._vpW = s, this._vpH = e, this.material.updateViewport(s, e));
+  }
+  /**
+   * Sorts splats based on camera position and direction.
+   * @param camera The camera to sort against.
+   */
+  sort(s) {
+    s.getWorldPosition(this._camPosW), s.getWorldDirection(this._camDirW), this.invModelMatrix.copy(this.matrixWorld).invert(), this._camPosL.copy(this._camPosW).applyMatrix4(this.invModelMatrix), this._camDirL.copy(this._camDirW).transformDirection(this.invModelMatrix);
+    const e = this.lastCameraPositionLocal.distanceToSquared(this._camPosL) > 1e-6, r = this.lastCameraDirectionLocal.dot(this._camDirL) < 0.999;
+    this.options.autoSort && (e || r) && (this.lastCameraPositionLocal.copy(this._camPosL), this.lastCameraDirectionLocal.copy(this._camDirL), this.sorter.setCamera(this._camPosL, this._camDirL));
+  }
+  /**
+   * THREE.js hook called before rendering the object.
+   * Used here to trigger sorting and update viewport.
+   * @param renderer The renderer
+   * @param scene The scene
+   * @param camera The camera
+   */
+  // prettier-ignore
+  // @ts-expect-error scene is not used
+  onBeforeRender(s, e, r) {
+    this.sort(r), s.getSize(this._size), this.updateViewport(this._size.x, this._size.y);
+  }
+  /**
+   * Dispose of resources
+   */
+  dispose() {
+    this.sorter.removeEventListener("updated", this.onSorterUpdated), this.sorter.dispose(), this.geometry.dispose(), this.material.dispose(), this.textureManager.dispose();
+  }
+};
+/** Number of splats combined into a single instanced draw call. */
+c(j, "INSTANCE_SIZE", 128);
+let it = j;
+class bt extends n.Loader {
+  /**
+   * Load a PLY file with Gaussian Splat data
+   * @param url URL of the PLY file
+   * @param onLoad Optional callback when loading is complete
+   * @param onProgress Optional progress callback
+   * @param onError Optional error callback
+   */
+  load(t, s, e, r) {
+    const o = new n.FileLoader(this.manager);
+    o.setResponseType("arraybuffer"), o.setRequestHeader(this.requestHeader), o.setPath(this.path), o.setWithCredentials(this.withCredentials), o.load(
+      t,
+      (i) => {
+        try {
+          if (s) {
+            const a = this.parse(i);
+            s(a);
+          }
+        } catch (a) {
+          r ? r(a) : console.error(a), this.manager.itemError(t);
+        }
+      },
+      e,
+      r
+    );
+  }
+  /**
+   * Load a PLY file asynchronously and return a Promise
+   * @param url URL of the PLY file
+   * @param onProgress Optional progress callback
+   * @returns A Promise that resolves with the parsed SplatData
+   */
+  loadAsync(t, s) {
+    return new Promise((e, r) => {
+      const o = new n.FileLoader(this.manager);
+      o.setResponseType("arraybuffer"), o.setRequestHeader(this.requestHeader), o.setPath(this.path), o.setWithCredentials(this.withCredentials), o.load(
+        t,
+        (i) => {
+          try {
+            const a = this.parse(i);
+            e(a);
+          } catch (a) {
+            r(a), this.manager.itemError(t);
+          }
+        },
+        s,
+        (i) => {
+          r(i), this.manager.itemError(t);
+        }
+      );
+    });
+  }
+  /**
+   * Parse PLY buffer data into SplatData
+   * @param buffer ArrayBuffer containing PLY data
+   * @returns Parsed SplatData
+   */
+  parse(t) {
+    const s = new TextDecoder(), e = new Uint8Array(t), r = [112, 108, 121, 10], o = `
+end_header
+`;
+    for (let x = 0; x < r.length; x++)
+      if (e[x] !== r[x])
+        throw new Error("Invalid PLY file: Missing magic bytes");
+    let i = 0;
+    for (let x = 0; x < e.length - o.length; x++) {
+      let u = !0;
+      for (let S = 0; S < o.length; S++)
+        if (e[x + S] !== o.charCodeAt(S)) {
+          u = !1;
+          break;
+        }
+      if (u) {
+        i = x + o.length;
+        break;
+      }
+    }
+    if (i === 0)
+      throw new Error("Invalid PLY file: Could not find end of header");
+    const d = s.decode(e.subarray(0, i)).split(`
+`), f = [];
+    let v = null;
+    for (let x = 1; x < d.length; x++) {
+      const u = d[x].trim();
+      if (u === "" || u === "end_header") continue;
+      const S = u.split(" ");
+      switch (S[0]) {
+        case "format":
+          v = S[1];
+          break;
+        case "element":
+          f.push({
+            name: S[1],
+            count: parseInt(S[2], 10),
+            properties: []
+          });
+          break;
+        case "property":
+          if (f.length === 0)
+            throw new Error(
+              "Invalid PLY file: Property without element"
+            );
+          f[f.length - 1].properties.push({
+            type: S[1],
+            name: S[2],
+            storage: null
+          });
+          break;
+      }
+    }
+    if (v !== "binary_little_endian")
+      throw new Error(`Unsupported PLY format: ${v}`);
+    const g = f.find((x) => x.name === "vertex");
+    if (!g)
+      throw new Error("Invalid PLY file: No vertex element found");
+    const p = new ut(g.count), h = new DataView(t);
+    let l = i;
+    const b = (x) => g.properties.findIndex((u) => u.name === x), T = b("x"), O = b("y"), q = b("z"), E = [
+      b("rot_0"),
+      b("rot_1"),
+      b("rot_2"),
+      b("rot_3")
+    ], R = [
+      b("scale_0"),
+      b("scale_1"),
+      b("scale_2")
+    ], W = [
+      b("f_dc_0"),
+      b("f_dc_1"),
+      b("f_dc_2")
+    ], k = b("opacity");
+    if ([
+      T,
+      O,
+      q,
+      ...E,
+      ...R,
+      ...W,
+      k
+    ].some((x) => x === -1))
+      throw new Error("Invalid PLY file: Missing required properties");
+    const F = 0.28209479177387814, M = (x) => {
+      if (x > 0) return 1 / (1 + Math.exp(-x));
+      const u = Math.exp(x);
+      return u / (1 + u);
+    }, m = new n.Vector3(), B = new n.Quaternion(), V = new n.Vector3(), P = new n.Color();
+    for (let x = 0; x < g.count; x++) {
+      const u = [];
+      for (let I = 0; I < g.properties.length; I++) {
+        const K = g.properties[I].type;
+        let z;
+        switch (K) {
+          case "char":
+            z = h.getInt8(l), l += 1;
+            break;
+          case "uchar":
+            z = h.getUint8(l), l += 1;
+            break;
+          case "short":
+            z = h.getInt16(l, !0), l += 2;
+            break;
+          case "ushort":
+            z = h.getUint16(l, !0), l += 2;
+            break;
+          case "int":
+            z = h.getInt32(l, !0), l += 4;
+            break;
+          case "uint":
+            z = h.getUint32(l, !0), l += 4;
+            break;
+          case "float":
+            z = h.getFloat32(l, !0), l += 4;
+            break;
+          case "double":
+            z = h.getFloat64(l, !0), l += 8;
+            break;
+          default:
+            throw new Error(`Unsupported property type: ${K}`);
+        }
+        u.push(z);
+      }
+      m.set(
+        u[T],
+        u[O],
+        u[q]
+      ), B.set(
+        u[E[1]],
+        // PLY stores rot 1,2,3,0 (x,y,z,w)
+        u[E[2]],
+        u[E[3]],
+        u[E[0]]
+      ).normalize(), V.set(
+        u[R[0]],
+        // Read directly assuming it's log scale
+        u[R[1]],
+        u[R[2]]
+      ), P.set(
+        0.5 + u[W[0]] * F,
+        0.5 + u[W[1]] * F,
+        0.5 + u[W[2]] * F
+      ), P.r = Math.max(0, Math.min(1, P.r)), P.g = Math.max(0, Math.min(1, P.g)), P.b = Math.max(0, Math.min(1, P.b));
+      const S = M(u[k]);
+      p.setSplat(
+        x,
+        m,
+        B,
+        V,
+        // Pass log scale directly
+        P,
+        S
+      );
+    }
+    return p.calculateBoundingBox(), p;
+  }
+}
+const Mt = "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
+};