@speridlabs/visus 0.1.0 → 0.2.0

package/dist/main.es.js

@@ -1,12 +1,1301 @@
-import { B as r, P as s, S as o, c as S, b as l, a as p, T as n } from "./ply-CQ9dyX1o.mjs";
-const a = "0.1.0";
+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";
+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());
+    /** Half extents (size/2) */
+    f(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 ht {
+  // TODO: there is no sh spherical harmonics
+  constructor(t = 0) {
+    f(this, "numSplats", 0);
+    f(this, "positions");
+    f(this, "rotations");
+    f(this, "scales");
+    f(this, "colors");
+    f(this, "opacities");
+    f(this, "centers");
+    f(this, "boundingBox", new et());
+    this.numSplats = t, this.allocateBuffers(t);
+  }
+  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, r, e, o, s, i) {
+    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;
+  }
+  /**
+   * 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 r = t * 3, e = t * 4, o = t * 3, s = t * 3;
+    return {
+      position: new n.Vector3(
+        this.positions[r],
+        this.positions[r + 1],
+        this.positions[r + 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[o]),
+        Math.exp(this.scales[o + 1]),
+        Math.exp(this.scales[o + 2])
+      ),
+      color: new n.Color(
+        this.colors[s],
+        this.colors[s + 1],
+        this.colors[s + 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 r = 0; r < this.numSplats; r++) {
+      const e = r * 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 r = new Float32Array(this.numSplats * 3), e = new n.Quaternion(), o = new n.Euler();
+    for (let s = 0; s < this.numSplats; s++) {
+      const i = 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;
+    }
+    return t.setAttribute(
+      "rotation",
+      new n.BufferAttribute(r, 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 ut extends n.EventDispatcher {
+  constructor() {
+    super();
+    f(this, "worker");
+    f(this, "centers", null);
+    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" });
+    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) {
+    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;
+    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 });
+  }
+  /**
+   * 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(r, e, o) {
+    if (!r || !(r.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)
+      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.needsUpdate = !0;
+    const a = i.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);
+    }
+    this.worker.postMessage(h, v);
+  }
+  /**
+   * 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(r) {
+    if (!this.centers)
+      return console.warn(
+        "SplatSorter: Cannot set mapping before initialization."
+      );
+    let e;
+    const o = [];
+    if (!r) {
+      const c = this.centers.buffer.slice(0);
+      return e = {
+        centers: c,
+        mapping: null
+      }, o.push(c), this.worker.postMessage(e, o);
+    }
+    const s = new Float32Array(r.length * 3);
+    for (let c = 0; c < r.length; c++) {
+      const h = r[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 i = s.buffer.slice(0), a = r.buffer.slice(0);
+    e = {
+      centers: i,
+      mapping: a
+    }, o.push(i, a), this.worker.postMessage(e, o);
+  }
+  /**
+   * 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)
+      return;
+    this.lastCameraPosition.copy(r), this.lastCameraDirection.copy(e);
+    const i = {
+      cameraPosition: { x: r.x, y: r.y, z: r.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, 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 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);
+          if (m > 0) F = M + 1;
+          else if (m < 0) z = M - 1;
+          else return M;
+        }
+        return ~F;
+      }, W = () => {
+        if (!e || !o || !a || !c)
+          return;
+        if (o.length === 0) {
+          const y = {
+            order: e.buffer,
+            count: 0
+          };
+          self.postMessage(y, [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;
+        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);
+        }
+        const I = o.length / 3, L = C - d, S = (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 !== S ? b = new Uint32Array(S) : b.fill(0), L < 1e-7) {
+          for (let y = 0; y < I; ++y) l[y] = 0;
+          b[0] = I;
+        } else if (s && s.length > 0) {
+          const y = 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(
+              0,
+              Math.floor(K * A / L)
+            ), tt = Math.min(
+              A,
+              Math.ceil($ * A / L)
+            );
+            for (let j = X; j < tt; ++j)
+              O[j]++;
+          }
+          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(
+              0,
+              Math.min(
+                A - 1,
+                Math.floor(K)
+              )
+            ), X = K - $, tt = q[$] + R[$] * X >>> 0, j = Math.min(tt, S - 1);
+            l[w] = j, b[j]++;
+          }
+        } 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]++;
+          }
+        }
+        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;
+        }
+        const it = F * M + z * m + _ * B, rt = (y) => {
+          if (!e) return -1 / 0;
+          const T = e[y], U = T;
+          if (!o || U * 3 + 2 >= o.length)
+            return -1 / 0;
+          const w = U * 3;
+          return o[w] * M + o[w + 1] * m + o[w + 2] * B - it;
+        };
+        let st = I;
+        if (I > 0 && rt(I - 1) < 0) {
+          const y = E(
+            0,
+            I - 1,
+            rt
+          );
+          st = y < 0 ? ~y : y;
+        }
+        const at = {
+          order: e.buffer,
+          count: st
+        };
+        self.postMessage(at, [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)
+            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
+              ) * 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++) {
+            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]);
+          }
+        } 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();
+      };
+    }).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 {
+  /**
+   * Create a new TextureManager for a set of splats
+   * @param splatData The splat data to manage textures for
+   */
+  constructor(t) {
+    f(this, "transformA");
+    // position xyz and rotation quaternion y,z components
+    f(this, "transformB");
+    // rotation quaternion x and scale xyz
+    f(this, "colorTexture");
+    // color an opacity
+    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);
+  }
+  /**
+   * Create the transform A texture (positions and quaternion w component)
+   * @param splatData The splat data
+   * @returns DataTexture containing position data
+   */
+  createTransformATexture(t) {
+    const r = 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);
+    }
+    const o = new n.DataTexture(
+      e,
+      this.textureWidth,
+      this.textureHeight,
+      n.RGBAFormat,
+      n.FloatType
+      // Store as Float32, shader will reinterpret bits
+    );
+    return o.needsUpdate = !0, o.magFilter = n.NearestFilter, o.minFilter = n.NearestFilter, o;
+  }
+  /**
+   * Create the transform B texture (scale and rotation xyz)
+   * @param splatData The splat data
+   * @returns DataTexture containing scale and rotation data
+   */
+  createTransformBTexture(t) {
+    const r = 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];
+    }
+    const o = new n.DataTexture(
+      e,
+      this.textureWidth,
+      this.textureHeight,
+      n.RGBAFormat,
+      n.FloatType
+    );
+    return o.needsUpdate = !0, o.magFilter = n.NearestFilter, o.minFilter = n.NearestFilter, o;
+  }
+  /**
+   * Create the color texture (RGB and opacity)
+   * @param splatData The splat data
+   * @returns DataTexture containing color data
+   */
+  createColorTexture(t) {
+    const r = 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];
+    }
+    const o = new n.DataTexture(
+      e,
+      this.textureWidth,
+      this.textureHeight,
+      n.RGBAFormat,
+      n.FloatType
+    );
+    return o.needsUpdate = !0, o;
+  }
+  /**
+   * Create the order texture for sorting
+   * @param numSplats Number of splats
+   * @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,
+      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 xt = (
+  /* 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 ---
+
+// 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);
+}
+
+// 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;
+    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);
+}
+
+// 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;
+
+    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)
+    );
+}
+
+// Calculate model-space covariance components R * S^2 * transpose(R)
+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)
+    );
+
+    // 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]
+}
+
+// --- 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 yz, x
+    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
+
+    // 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  ---
+
+    vec2 clipRadius = vec2(max(l1, l2)) * (centerClip.w / viewport);
+
+    // Check if the bounding circle's edge is outside the [-w, w] range in clip space for x or y
+    if (any(greaterThan(abs(centerClip.xy) + clipRadius, vec2(abs(centerClip.w))))) {
+         gl_Position = vec4(2.0, 2.0, 2.0, 1.0); // Off-screen
+         return;
+    }
+
+    // --- 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;
+    //vec2 screenOffsetPixels = vec2(clippedCornerOffset.x, clippedCornerOffset.y);
+
+    // 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;
+}
+`
+), yt = (
+  /* 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
+
+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 = exp(-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 gt extends n.ShaderMaterial {
+  constructor(t = {}) {
+    const r = {
+      // 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: xt,
+      fragmentShader: yt,
+      uniforms: r,
+      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, r) {
+    this.uniforms.viewport.value.set(t, r);
+  }
+  /**
+   * 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 Y = class Y 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(r, e = {}) {
+    const o = new gt(e), s = Y.createInstancedGeometry(r.numSplats, Y.INSTANCE_SIZE);
+    super(s, o);
+    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(
+      this.textureManager.orderTexture,
+      this.splatData.centers,
+      i ?? 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.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);
+  }
+  /**
+   * 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(r, e) {
+    const o = Math.ceil(r / e), s = 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]), c = new Float32Array(4 * 3 * e);
+    for (let p = 0; p < e; p++) {
+      const u = p * 4 * 3;
+      for (let l = 0; l < 4; l++)
+        c[u + l * 3 + 0] = i[l * 3 + 0], c[u + l * 3 + 1] = i[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();
+    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;
+  }
+  /**
+   * 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
+    ]);
+  }
+  /**
+   * Update the viewport size
+   * @param width Viewport width
+   * @param height Viewport height
+   */
+  updateViewport(r, e) {
+    this.material.updateViewport(r, 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));
+  }
+  /**
+   * 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(r, e, o) {
+    this.sort(o);
+    const s = r.getSize(new n.Vector2());
+    let { width: i, height: a } = s;
+    const c = r.xr;
+    if (c.enabled && c.isPresenting) {
+      const h = c.getCamera().cameras[0].view;
+      h && (i = h.width, a = h.height);
+    }
+    this.updateViewport(i, a);
+  }
+  /**
+   * Dispose of resources
+   */
+  dispose() {
+    this.sorter.dispose(), this.geometry.dispose(), this.material.dispose(), this.textureManager.dispose();
+  }
+};
+// Cached inverse matrix
+/** Number of splats combined into a single instanced draw call. */
+f(Y, "INSTANCE_SIZE", 128);
+let nt = Y;
+class wt 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, r, e, o) {
+    const s = new n.FileLoader(this.manager);
+    s.setResponseType("arraybuffer"), s.setRequestHeader(this.requestHeader), s.setPath(this.path), s.setWithCredentials(this.withCredentials), s.load(
+      t,
+      (i) => {
+        try {
+          if (r) {
+            const a = this.parse(i);
+            r(a);
+          }
+        } catch (a) {
+          o ? o(a) : console.error(a), this.manager.itemError(t);
+        }
+      },
+      e,
+      o
+    );
+  }
+  /**
+   * 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, r) {
+    return new Promise((e, o) => {
+      const s = new n.FileLoader(this.manager);
+      s.setResponseType("arraybuffer"), s.setRequestHeader(this.requestHeader), s.setPath(this.path), s.setWithCredentials(this.withCredentials), s.load(
+        t,
+        (i) => {
+          try {
+            const a = this.parse(i);
+            e(a);
+          } catch (a) {
+            o(a), this.manager.itemError(t);
+          }
+        },
+        r,
+        (i) => {
+          o(i), this.manager.itemError(t);
+        }
+      );
+    });
+  }
+  /**
+   * Parse PLY buffer data into SplatData
+   * @param buffer ArrayBuffer containing PLY data
+   * @returns Parsed SplatData
+   */
+  parse(t) {
+    const r = new TextDecoder(), e = new Uint8Array(t), o = [112, 108, 121, 10], s = `
+end_header
+`;
+    for (let x = 0; x < o.length; x++)
+      if (e[x] !== o[x])
+        throw new Error("Invalid PLY file: Missing magic bytes");
+    let i = 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)) {
+          d = !1;
+          break;
+        }
+      if (d) {
+        i = x + s.length;
+        break;
+      }
+    }
+    if (i === 0)
+      throw new Error("Invalid PLY file: Could not find end of header");
+    const c = r.decode(
+      e.slice(0, i)
+    ).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]) {
+        case "format":
+          v = C[1];
+          break;
+        case "element":
+          h.push({
+            name: C[1],
+            count: parseInt(C[2], 10),
+            properties: []
+          });
+          break;
+        case "property":
+          if (h.length === 0)
+            throw new Error(
+              "Invalid PLY file: Property without element"
+            );
+          h[h.length - 1].properties.push({
+            type: C[1],
+            name: C[2],
+            storage: null
+          });
+          break;
+      }
+    }
+    if (v !== "binary_little_endian")
+      throw new Error(`Unsupported PLY format: ${v}`);
+    const g = h.find((x) => x.name === "vertex");
+    if (!g)
+      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 = [
+      b("rot_0"),
+      b("rot_1"),
+      b("rot_2"),
+      b("rot_3")
+    ], E = [
+      b("scale_0"),
+      b("scale_1"),
+      b("scale_2")
+    ], W = [
+      b("f_dc_0"),
+      b("f_dc_1"),
+      b("f_dc_2")
+    ], F = b("opacity");
+    if ([
+      A,
+      O,
+      q,
+      ...R,
+      ...E,
+      ...W,
+      F
+    ].some((x) => x === -1))
+      throw new Error("Invalid PLY file: Missing required properties");
+    const _ = 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++) {
+      const d = [];
+      for (let I = 0; I < g.properties.length; I++) {
+        const Q = g.properties[I].type;
+        let S;
+        switch (Q) {
+          case "char":
+            S = u.getInt8(l), l += 1;
+            break;
+          case "uchar":
+            S = u.getUint8(l), l += 1;
+            break;
+          case "short":
+            S = u.getInt16(l, !0), l += 2;
+            break;
+          case "ushort":
+            S = u.getUint16(l, !0), l += 2;
+            break;
+          case "int":
+            S = u.getInt32(l, !0), l += 4;
+            break;
+          case "uint":
+            S = u.getUint32(l, !0), l += 4;
+            break;
+          case "float":
+            S = u.getFloat32(l, !0), l += 4;
+            break;
+          case "double":
+            S = u.getFloat64(l, !0), l += 8;
+            break;
+          default:
+            throw new Error(`Unsupported property type: ${Q}`);
+        }
+        d.push(S);
+      }
+      m.set(
+        d[A],
+        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
+        d[E[1]],
+        d[E[2]]
+      ), V.set(
+        0.5 + d[W[0]] * _,
+        0.5 + d[W[1]] * _,
+        0.5 + d[W[2]] * _
+      ), 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]);
+      p.setSplat(
+        x,
+        m,
+        B,
+        P,
+        // Pass log scale directly
+        V,
+        C
+      );
+    }
+    return p.calculateBoundingBox(), p;
+  }
+}
+const bt = "0.2.0";
 export {
-  r as BoundingBox,
-  s as PlyLoader,
-  o as SplatData,
-  S as SplatMaterial,
-  l as SplatMesh,
-  p as SplatSorter,
-  n as TextureManager,
-  a as VERSION
+  et as BoundingBox,
+  wt as PlyLoader,
+  ht as SplatData,
+  gt as SplatMaterial,
+  nt as SplatMesh,
+  ut as SplatSorter,
+  mt as TextureManager,
+  bt as VERSION
 };