@speridlabs/visus 2.3.0 → 2.4.1

package/dist/main.es.js

@@ -1,14 +1,14 @@
-var pt = Object.defineProperty;
-var ft = (k, t, o) => t in k ? pt(k, t, { enumerable: !0, configurable: !0, writable: !0, value: o }) : k[t] = o;
-var h = (k, t, o) => ft(k, typeof t != "symbol" ? t + "" : t, o);
-import * as i from "three";
-class ct {
+var _e = Object.defineProperty;
+var Ve = (a, e, t) => e in a ? _e(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t;
+var w = (a, e, t) => Ve(a, typeof e != "symbol" ? e + "" : e, t);
+import * as h from "three";
+class ye {
   constructor() {
-    h(this, "min", new i.Vector3(1 / 0, 1 / 0, 1 / 0));
-    h(this, "max", new i.Vector3(-1 / 0, -1 / 0, -1 / 0));
-    h(this, "center", new i.Vector3());
+    w(this, "min", new h.Vector3(1 / 0, 1 / 0, 1 / 0));
+    w(this, "max", new h.Vector3(-1 / 0, -1 / 0, -1 / 0));
+    w(this, "center", new h.Vector3());
     /** Half extents (size/2) */
-    h(this, "halfExtents", new i.Vector3());
+    w(this, "halfExtents", new h.Vector3());
   }
   /**
    * Reset the bounding box to its initial state
@@ -20,15 +20,15 @@ class ct {
    * Expand the bounding box to include the given point
    * @param point Point to include in the bounding box
    */
-  expandByPoint(t) {
-    this.min.x = Math.min(this.min.x, t.x), this.min.y = Math.min(this.min.y, t.y), this.min.z = Math.min(this.min.z, t.z), this.max.x = Math.max(this.max.x, t.x), this.max.y = Math.max(this.max.y, t.y), this.max.z = Math.max(this.max.z, t.z), this.updateDerived();
+  expandByPoint(e) {
+    this.min.x = Math.min(this.min.x, e.x), this.min.y = Math.min(this.min.y, e.y), this.min.z = Math.min(this.min.z, e.z), this.max.x = Math.max(this.max.x, e.x), this.max.y = Math.max(this.max.y, e.y), this.max.z = Math.max(this.max.z, e.z), this.updateDerived();
   }
   /**
    * Expand this bounding box to include another bounding box
    * @param box Bounding box to include
    */
-  expandByBox(t) {
-    this.min.x = Math.min(this.min.x, t.min.x), this.min.y = Math.min(this.min.y, t.min.y), this.min.z = Math.min(this.min.z, t.min.z), this.max.x = Math.max(this.max.x, t.max.x), this.max.y = Math.max(this.max.y, t.max.y), this.max.z = Math.max(this.max.z, t.max.z), this.updateDerived();
+  expandByBox(e) {
+    this.min.x = Math.min(this.min.x, e.min.x), this.min.y = Math.min(this.min.y, e.min.y), this.min.z = Math.min(this.min.z, e.min.z), this.max.x = Math.max(this.max.x, e.max.x), this.max.y = Math.max(this.max.y, e.max.y), this.max.z = Math.max(this.max.z, e.max.z), this.updateDerived();
   }
   /**
    * Update the center and half extents based on min/max
@@ -41,39 +41,38 @@ class ct {
    * @param point Point to check
    * @returns True if the point is inside the box
    */
-  containsPoint(t) {
-    return t.x >= this.min.x && t.x <= this.max.x && t.y >= this.min.y && t.y <= this.max.y && t.z >= this.min.z && t.z <= this.max.z;
+  containsPoint(e) {
+    return e.x >= this.min.x && e.x <= this.max.x && e.y >= this.min.y && e.y <= this.max.y && e.z >= this.min.z && e.z <= this.max.z;
   }
   /**
    * Create a Three.js Box3 from this bounding box
    * @returns THREE.Box3 representation
    */
   toBox3() {
-    return new i.Box3().set(this.min, this.max);
+    return new h.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 ct();
-    return t.min.copy(this.min), t.max.copy(this.max), t.center.copy(this.center), t.halfExtents.copy(this.halfExtents), t;
+    const e = new ye();
+    return e.min.copy(this.min), e.max.copy(this.max), e.center.copy(this.center), e.halfExtents.copy(this.halfExtents), e;
   }
 }
-class mt {
-  // TODO: there is no sh spherical harmonics
-  constructor(t = 0) {
-    h(this, "numSplats", 0);
-    h(this, "positions");
-    h(this, "rotations");
-    h(this, "scales");
-    h(this, "colors");
-    h(this, "opacities");
-    h(this, "boundingBox", new ct());
-    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);
+class Oe {
+  constructor(e = 0) {
+    w(this, "numSplats", 0);
+    w(this, "positions");
+    w(this, "rotations");
+    w(this, "scales");
+    w(this, "colors");
+    w(this, "opacities");
+    w(this, "boundingBox", new ye());
+    this.numSplats = e, this.allocateBuffers(e);
+  }
+  allocateBuffers(e) {
+    this.positions = new Float32Array(e * 3), this.rotations = new Float32Array(e * 4), this.scales = new Float32Array(e * 3), this.colors = new Float32Array(e * 3), this.opacities = new Float32Array(e);
   }
   /**
    * Set data for a specific splat
@@ -84,49 +83,49 @@ class mt {
    * @param color Color
    * @param opacity Opacity value
    */
-  setSplat(t, o, e, r, s, n) {
-    if (t >= this.numSplats)
+  setSplat(e, t, s, r, n, o) {
+    if (e >= this.numSplats)
       throw new Error(
-        `Splat index out of bounds: ${t} >= ${this.numSplats}`
+        `Splat index out of bounds: ${e} >= ${this.numSplats}`
       );
-    const a = t * 3, l = t * 4, x = t * 3, b = t * 3;
-    this.positions[a] = o.x, this.positions[a + 1] = o.y, this.positions[a + 2] = o.z, this.rotations[l] = e.x, this.rotations[l + 1] = e.y, this.rotations[l + 2] = e.z, this.rotations[l + 3] = e.w, this.scales[x] = r.x, this.scales[x + 1] = r.y, this.scales[x + 2] = r.z, this.colors[b] = s.r, this.colors[b + 1] = s.g, this.colors[b + 2] = s.b, this.opacities[t] = n;
+    const i = e * 3, u = e * 4, m = e * 3, x = e * 3;
+    this.positions[i] = t.x, this.positions[i + 1] = t.y, this.positions[i + 2] = t.z, this.rotations[u] = s.x, this.rotations[u + 1] = s.y, this.rotations[u + 2] = s.z, this.rotations[u + 3] = s.w, this.scales[m] = r.x, this.scales[m + 1] = r.y, this.scales[m + 2] = r.z, this.colors[x] = n.r, this.colors[x + 1] = n.g, this.colors[x + 2] = n.b, this.opacities[e] = o;
   }
   /**
    * Get a splat's data
    * @param index Splat index
    * @returns Object containing splat data (linear scale)
    */
-  getSplat(t) {
-    if (t >= this.numSplats)
+  getSplat(e) {
+    if (e >= this.numSplats)
       throw new Error(
-        `Splat index out of bounds: ${t} >= ${this.numSplats}`
+        `Splat index out of bounds: ${e} >= ${this.numSplats}`
       );
-    const o = t * 3, e = t * 4, r = t * 3, s = t * 3;
+    const t = e * 3, s = e * 4, r = e * 3, n = e * 3;
     return {
-      position: new i.Vector3(
-        this.positions[o],
-        this.positions[o + 1],
-        this.positions[o + 2]
+      position: new h.Vector3(
+        this.positions[t],
+        this.positions[t + 1],
+        this.positions[t + 2]
       ),
-      rotation: new i.Quaternion(
-        this.rotations[e],
-        this.rotations[e + 1],
-        this.rotations[e + 2],
-        this.rotations[e + 3]
+      rotation: new h.Quaternion(
+        this.rotations[s],
+        this.rotations[s + 1],
+        this.rotations[s + 2],
+        this.rotations[s + 3]
       ),
       // Convert log scale back to linear scale for external use
-      scale: new i.Vector3(
+      scale: new h.Vector3(
         Math.exp(this.scales[r]),
         Math.exp(this.scales[r + 1]),
         Math.exp(this.scales[r + 2])
       ),
-      color: new i.Color(
-        this.colors[s],
-        this.colors[s + 1],
-        this.colors[s + 2]
+      color: new h.Color(
+        this.colors[n],
+        this.colors[n + 1],
+        this.colors[n + 2]
       ),
-      opacity: this.opacities[t]
+      opacity: this.opacities[e]
     };
   }
   /**
@@ -135,14 +134,14 @@ class mt {
    */
   calculateBoundingBox() {
     this.boundingBox.reset();
-    const t = new i.Vector3();
-    for (let o = 0; o < this.numSplats; o++) {
-      const e = o * 3;
-      t.set(
-        this.positions[e],
-        this.positions[e + 1],
-        this.positions[e + 2]
-      ), this.boundingBox.expandByPoint(t);
+    const e = new h.Vector3();
+    for (let t = 0; t < this.numSplats; t++) {
+      const s = t * 3;
+      e.set(
+        this.positions[s],
+        this.positions[s + 1],
+        this.positions[s + 2]
+      ), this.boundingBox.expandByPoint(e);
     }
     return this.boundingBox;
   }
@@ -151,64 +150,139 @@ class mt {
    * This is for visualization/debugging purposes only, not for rendering
    */
   createDebugGeometry() {
-    const t = new i.BufferGeometry();
-    t.setAttribute(
+    const e = new h.BufferGeometry();
+    e.setAttribute(
       "position",
-      new i.BufferAttribute(this.positions, 3)
+      new h.BufferAttribute(this.positions, 3)
     );
-    const o = new Float32Array(this.numSplats * 3), e = new i.Quaternion(), r = new i.Euler();
-    for (let s = 0; s < this.numSplats; s++) {
-      const n = s * 4, a = s * 3;
-      e.set(
-        this.rotations[n],
-        this.rotations[n + 1],
-        this.rotations[n + 2],
-        this.rotations[n + 3]
-      ), r.setFromQuaternion(e), o[a] = r.x, o[a + 1] = r.y, o[a + 2] = r.z;
+    const t = new Float32Array(this.numSplats * 3), s = new h.Quaternion(), r = new h.Euler();
+    for (let n = 0; n < this.numSplats; n++) {
+      const o = n * 4, i = n * 3;
+      s.set(
+        this.rotations[o],
+        this.rotations[o + 1],
+        this.rotations[o + 2],
+        this.rotations[o + 3]
+      ), r.setFromQuaternion(s), t[i] = r.x, t[i + 1] = r.y, t[i + 2] = r.z;
     }
-    return t.setAttribute(
+    return e.setAttribute(
       "rotation",
-      new i.BufferAttribute(o, 3)
-    ), t.setAttribute(
+      new h.BufferAttribute(t, 3)
+    ), e.setAttribute(
       "scale",
-      new i.BufferAttribute(this.scales, 3)
-    ), t.setAttribute(
+      new h.BufferAttribute(this.scales, 3)
+    ), e.setAttribute(
       "color",
-      new i.BufferAttribute(this.colors, 3)
-    ), t.setAttribute(
+      new h.BufferAttribute(this.colors, 3)
+    ), e.setAttribute(
       "opacity",
-      new i.BufferAttribute(this.opacities, 1)
-    ), t;
+      new h.BufferAttribute(this.opacities, 1)
+    ), e;
+  }
+  dispose() {
+    this.numSplats = 0, this.scales = new Float32Array(0), this.colors = new Float32Array(0), this.positions = new Float32Array(0), this.rotations = new Float32Array(0), this.opacities = new Float32Array(0);
+  }
+}
+class ze {
+  // Upper 8 bits of 16-bit means
+  constructor(e, t, s) {
+    w(this, "ranges");
+    w(this, "numSplats", 0);
+    w(this, "boundingBox", new ye());
+    // Original SOGS textures
+    w(this, "sh0");
+    // SH DC coefficients + alpha
+    w(this, "quats");
+    // Quaternion components + mode
+    w(this, "scales");
+    // Scale values (8-bit)
+    w(this, "means_l");
+    // Lower 8 bits of 16-bit means
+    w(this, "means_u");
+    this.ranges = t, this.numSplats = e, this.sh0 = s.sh0, this.quats = s.quats, this.scales = s.scales, this.means_l = s.means_l, this.means_u = s.means_u, this.boundingBox = this.calculateBoundingBox();
+  }
+  calculateBoundingBox() {
+    this.boundingBox.reset();
+    const { mins: e, maxs: t } = this.ranges.means, s = (r) => Math.sign(r) * (Math.exp(Math.abs(r)) - 1);
+    return this.boundingBox.center.set(
+      (s(e[0]) + s(t[0])) * 0.5,
+      (s(e[1]) + s(t[1])) * 0.5,
+      (s(e[2]) + s(t[2])) * 0.5
+    ), this.boundingBox.halfExtents.set(
+      (s(t[0]) - s(e[0])) * 0.5,
+      (s(t[1]) - s(e[1])) * 0.5,
+      (s(t[2]) - s(e[2])) * 0.5
+    ), this.boundingBox;
+  }
+  dispose() {
+    this.sh0.dispose(), this.quats.dispose(), this.scales.dispose(), this.means_l.dispose(), this.means_u.dispose();
+  }
+}
+class Be {
+  // RGBA32UI - (Position + Rotation + Scale)
+  // RGBA32UI Texture Content:
+  // .r = Means Lower (RGB)
+  // .g = Means Upper (RGB)
+  // .b = Rotation (RGBA)
+  // .a = Scale (RGB)
+  constructor(e, t, s, r, n, o, i, u) {
+    // Info data - cpu
+    w(this, "numSplats");
+    w(this, "textureWidth");
+    w(this, "textureHeight");
+    w(this, "ranges");
+    w(this, "centers");
+    // TODO: see if necesary or can be compressed somehow
+    w(this, "boundingBox");
+    // GPU Textures
+    w(this, "packedColor");
+    // RGBA8 - (Color + Opacity)
+    // RGBA8 Texture Content:
+    // .rgb = Color, .a = Opacity
+    w(this, "packedGeometry");
+    this.numSplats = e, this.textureWidth = t, this.textureHeight = s, this.boundingBox = u, this.ranges = i, this.centers = r, this.packedColor = o, this.packedGeometry = n;
   }
+  /**
+   * Optional: Reconstruct a full JS object for a specific splat.
+   * Useful for raycasting or debugging.
+   */
+  // public getSplat(index: number) {
+  //     throw new Error('Not implemented yet');
+  // }
+  dispose() {
+    this.centers = new Float32Array(0), this.packedColor = new Uint8Array(0), this.packedGeometry = new Uint32Array(0);
+  }
+  // public abstract deserialize(): ISplat;
+  // public abstract returnPacked(): ISplat;
 }
-class xt extends i.EventDispatcher {
+class Le extends h.EventDispatcher {
   constructor() {
     super();
-    h(this, "worker");
-    h(this, "centers", null);
-    h(this, "orderTexture", null);
+    w(this, "worker");
+    w(this, "centers", null);
+    w(this, "orderTexture", null);
     /** Bounding box data for optimization */
-    h(this, "chunks", null);
-    h(this, "lastCameraPosition", new i.Vector3());
-    h(this, "lastCameraDirection", new i.Vector3());
-    const o = this.createWorkerCode(), e = new Blob([o], { type: "application/javascript" });
-    this.worker = new Worker(URL.createObjectURL(e)), this.worker.onmessage = this.onWorkerMessage.bind(this);
+    w(this, "chunks", null);
+    w(this, "lastCameraPosition", new h.Vector3());
+    w(this, "lastCameraDirection", new h.Vector3());
+    const t = this.createWorkerCode(), s = new Blob([t], { type: "application/javascript" });
+    this.worker = new Worker(URL.createObjectURL(s)), this.worker.onmessage = this.onWorkerMessage.bind(this);
   }
   /**
    * Handles messages received from the sorting worker.
    * @param event The message event from the worker.
    */
-  onWorkerMessage(o) {
+  onWorkerMessage(t) {
     if (!this.orderTexture || !this.orderTexture.image)
       return console.error("SplatSorter: Order texture not initialized!");
-    const { order: e, count: r } = o.data, s = this.orderTexture.image.data;
-    if (!(s instanceof Uint32Array))
+    const { order: s, count: r } = t.data, n = this.orderTexture.image.data;
+    if (!(n instanceof Uint32Array))
       return console.error(
         "SplatSorter: Order texture data is not a Uint32Array!"
       );
-    s.set(new Uint32Array(e)), this.orderTexture.source.data.updateRanges || (this.orderTexture.source.data.updateRanges = []), this.orderTexture.needsUpdate = !0;
-    const n = s.buffer.slice(0), a = { order: n };
-    this.worker.postMessage(a, [n]), this.dispatchEvent({ type: "updated", count: r });
+    n.set(new Uint32Array(s)), this.orderTexture.source.data.updateRanges || (this.orderTexture.source.data.updateRanges = []), this.orderTexture.needsUpdate = !0;
+    const o = n.buffer.slice(0), i = { order: o };
+    this.worker.postMessage(i, [o]), this.dispatchEvent({ type: "updated", count: r });
   }
   /**
    * Initializes the sorter with necessary data and textures.
@@ -217,38 +291,38 @@ class xt extends i.EventDispatcher {
    * @param chunks Optional: A Float32Array containing bounding box chunk data [minX, minY, minZ, maxX, maxY, maxZ, ...] for optimization.
    * @param transferOwnership Optional: If true, transfers ownership of centers buffer to worker (saves memory, main thread loses access). Default: false.
    */
-  init(o, e, r, s = !1) {
-    if (!o || !(o.image.data instanceof Uint32Array))
+  init(t, s, r, n = !1) {
+    if (!t || !(t.image.data instanceof Uint32Array))
       throw new Error("SplatSorter: Invalid orderTexture provided. Must be DataTexture with Uint32Array data.");
-    if (!e || e.length % 3 !== 0)
+    if (!s || s.length % 3 !== 0)
       throw new Error("SplatSorter: Invalid centers array provided. Length must be multiple of 3.");
-    if (o.image.data.length < e.length / 3)
+    if (t.image.data.length < s.length / 3)
       throw new Error("SplatSorter: orderTexture data buffer is smaller than the number of splats.");
-    if (e.buffer.byteLength === 0)
+    if (s.buffer.byteLength === 0)
       throw new Error(
         "SplatSorter: positions buffer is detached (likely React StrictMode + cached asset). "
       );
-    const n = e.length / 3;
-    this.orderTexture = o, s ? this.centers = null : this.centers = e.slice();
-    const a = this.orderTexture.image.data;
-    for (let u = 0; u < n; u++) a[u] = u;
+    const o = s.length / 3;
+    this.orderTexture = t, n ? this.centers = null : this.centers = s.slice();
+    const i = this.orderTexture.image.data;
+    for (let l = 0; l < o; l++) i[l] = l;
     this.orderTexture.source.data.updateRanges || (this.orderTexture.source.data.updateRanges = []), this.orderTexture.needsUpdate = !0;
-    const l = a.buffer.slice(0), x = s ? e.buffer : e.buffer.slice(0), b = {
-      order: l,
-      centers: x
-    }, C = [
-      l,
-      x
+    const u = i.buffer.slice(0), m = n ? s.buffer : s.buffer.slice(0), x = {
+      order: u,
+      centers: m
+    }, c = [
+      u,
+      m
     ];
     if (r) {
       this.chunks = r.slice();
-      const u = this.chunks.buffer.slice(0);
-      b.chunks = u, C.push(u);
+      const l = this.chunks.buffer.slice(0);
+      x.chunks = l, c.push(l);
     }
-    this.worker.postMessage(b, C), queueMicrotask(() => {
+    this.worker.postMessage(x, c), queueMicrotask(() => {
       this.dispatchEvent({
         type: "updated",
-        count: n
+        count: o
       });
     });
   }
@@ -257,53 +331,53 @@ class xt extends i.EventDispatcher {
    * The sorter will only consider splats whose original indices are present in the mapping.
    * @param mapping A Uint32Array where each element is the *original* index of a splat to include, or null to reset mapping.
    */
-  setMapping(o) {
+  setMapping(t) {
     if (!this.centers)
       return console.warn(
         "SplatSorter: Cannot set mapping before initialization."
       );
-    let e;
+    let s;
     const r = [];
-    if (!o) {
-      const l = this.centers.buffer.slice(0);
-      return e = {
-        centers: l,
+    if (!t) {
+      const u = this.centers.buffer.slice(0);
+      return s = {
+        centers: u,
         mapping: null
-      }, r.push(l), this.worker.postMessage(e, r);
+      }, r.push(u), this.worker.postMessage(s, r);
     }
-    const s = new Float32Array(o.length * 3);
-    for (let l = 0; l < o.length; l++) {
-      const x = o[l];
-      if (x * 3 + 2 >= this.centers.length) {
+    const n = new Float32Array(t.length * 3);
+    for (let u = 0; u < t.length; u++) {
+      const m = t[u];
+      if (m * 3 + 2 >= this.centers.length) {
         console.warn(
-          `SplatSorter: Mapping index ${x} out of bounds.`
+          `SplatSorter: Mapping index ${m} out of bounds.`
         );
         continue;
       }
-      const b = x * 3, C = l * 3;
-      s[C + 0] = this.centers[b + 0], s[C + 1] = this.centers[b + 1], s[C + 2] = this.centers[b + 2];
+      const x = m * 3, c = u * 3;
+      n[c + 0] = this.centers[x + 0], n[c + 1] = this.centers[x + 1], n[c + 2] = this.centers[x + 2];
     }
-    const n = s.buffer.slice(0), a = o.buffer.slice(0);
-    e = {
-      centers: n,
-      mapping: a
-    }, r.push(n, a), this.worker.postMessage(e, r);
+    const o = n.buffer.slice(0), i = t.buffer.slice(0);
+    s = {
+      centers: o,
+      mapping: i
+    }, r.push(o, i), this.worker.postMessage(s, 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(o, e) {
-    const r = this.lastCameraPosition.distanceToSquared(o) > 1e-7, s = this.lastCameraDirection.dot(e) < 0.9999;
-    if (!r && !s)
+  setCamera(t, s) {
+    const r = this.lastCameraPosition.distanceToSquared(t) > 1e-7, n = this.lastCameraDirection.dot(s) < 0.9999;
+    if (!r && !n)
       return;
-    this.lastCameraPosition.copy(o), this.lastCameraDirection.copy(e);
-    const n = {
-      cameraPosition: { x: o.x, y: o.y, z: o.z },
-      cameraDirection: { x: e.x, y: e.y, z: e.z }
+    this.lastCameraPosition.copy(t), this.lastCameraDirection.copy(s);
+    const o = {
+      cameraPosition: { x: t.x, y: t.y, z: t.z },
+      cameraDirection: { x: s.x, y: s.y, z: s.z }
     };
-    this.worker.postMessage(n);
+    this.worker.postMessage(o);
   }
   /**
    * Terminates the Web Worker and cleans up resources.
@@ -317,258 +391,186 @@ class xt extends i.EventDispatcher {
    */
   createWorkerCode() {
     return `(${(function() {
-      let e = null, r = null, s = null, n = null, a = null, l = null, x = !1;
-      const b = { x: 0, y: 0, z: 0 }, C = { x: 0, y: 0, z: 0 }, u = { x: 0, y: 0, z: 0 }, y = { x: 0, y: 0, z: 0 };
-      let v = null, S = null;
-      const I = 32, q = new Array(I).fill(0), Y = new Array(I).fill(0), W = new Array(I).fill(0), ot = (w, d, P) => {
-        for (; w <= d; ) {
-          const M = d + w >> 1, f = P(M);
-          if (f > 0) w = M + 1;
-          else if (f < 0) d = M - 1;
-          else return M;
+      let s = null, r = null, n = null, o = null, i = null, u = null, m = !1;
+      const x = { x: 0, y: 0, z: 0 }, c = { x: 0, y: 0, z: 0 }, l = { x: 0, y: 0, z: 0 }, p = { x: 0, y: 0, z: 0 };
+      let y = null, M = null;
+      const v = 32, S = new Array(v).fill(0), k = new Array(v).fill(0), B = new Array(v).fill(0), j = (b, A, C) => {
+        for (; b <= A; ) {
+          const g = A + b >> 1, d = C(g);
+          if (d > 0) b = g + 1;
+          else if (d < 0) A = g - 1;
+          else return g;
         }
-        return ~w;
-      }, L = () => {
-        if (!e || !r || !a || !l)
+        return ~b;
+      }, R = () => {
+        if (!s || !r || !i || !u)
           return;
         if (r.length === 0) {
-          const c = {
-            order: e.buffer,
+          const f = {
+            order: s.buffer,
             count: 0
           };
-          self.postMessage(c, [e.buffer]), e = null;
+          self.postMessage(f, [s.buffer]), s = null;
           return;
         }
-        const w = a.x, d = a.y, P = a.z, M = l.x, f = l.y, A = l.z, T = 1e-4, j = Math.abs(w - b.x) > T || Math.abs(d - b.y) > T || Math.abs(P - b.z) > T, J = Math.abs(M - C.x) > T || Math.abs(f - C.y) > T || Math.abs(A - C.z) > T;
-        if (!x && !j && !J)
+        const b = i.x, A = i.y, C = i.z, g = u.x, d = u.y, I = u.z, q = 1e-4, T = Math.abs(b - x.x) > q || Math.abs(A - x.y) > q || Math.abs(C - x.z) > q, W = Math.abs(g - c.x) > q || Math.abs(d - c.y) > q || Math.abs(I - c.z) > q;
+        if (!m && !T && !W)
           return;
-        x = !1, b.x = w, b.y = d, b.z = P, C.x = M, C.y = f, C.z = A;
-        let $ = 1 / 0, D = -1 / 0;
-        for (let c = 0; c < 8; ++c) {
-          const g = c & 1 ? u.x : y.x, B = c & 2 ? u.y : y.y, m = c & 4 ? u.z : y.z, z = g * M + B * f + m * A;
-          $ = Math.min($, z), D = Math.max(D, z);
+        m = !1, x.x = b, x.y = A, x.z = C, c.x = g, c.y = d, c.z = I;
+        let U = 1 / 0, F = -1 / 0;
+        for (let f = 0; f < 8; ++f) {
+          const E = f & 1 ? l.x : p.x, V = f & 2 ? l.y : p.y, D = f & 4 ? l.z : p.z, O = E * g + V * d + D * I;
+          U = Math.min(U, O), F = Math.max(F, O);
         }
-        const _ = r.length / 3, N = D - $, R = (1 << Math.max(
+        const P = r.length / 3, J = F - U, L = (1 << Math.max(
           10,
-          Math.min(20, Math.ceil(Math.log2(_ / 4)))
+          Math.min(20, Math.ceil(Math.log2(P / 4)))
         )) + 1;
-        if ((!v || v.length !== _) && (v = new Uint32Array(_)), !S || S.length !== R ? S = new Uint32Array(R) : S.fill(0), N < 1e-7) {
-          for (let c = 0; c < _; ++c) v[c] = 0;
-          S[0] = _;
-        } else if (s && s.length > 0) {
-          const c = s.length / 6;
-          q.fill(0);
-          for (let m = 0; m < c; ++m) {
-            const z = m * 6, E = s[z + 0], U = s[z + 1], O = s[z + 2], F = s[z + 3], V = E * M + U * f + O * A - $, X = V - F, Z = V + F, K = Math.max(
+        if ((!y || y.length !== P) && (y = new Uint32Array(P)), !M || M.length !== L ? M = new Uint32Array(L) : M.fill(0), J < 1e-7) {
+          for (let f = 0; f < P; ++f) y[f] = 0;
+          M[0] = P;
+        } else if (n && n.length > 0) {
+          const f = n.length / 6;
+          S.fill(0);
+          for (let D = 0; D < f; ++D) {
+            const O = D * 6, Y = n[O + 0], Z = n[O + 1], Q = n[O + 2], N = n[O + 3], K = Y * g + Z * d + Q * I - U, se = K - N, re = K + N, he = Math.max(
               0,
-              Math.floor(X * I / N)
-            ), Q = Math.min(
-              I,
-              Math.ceil(Z * I / N)
+              Math.floor(se * v / J)
+            ), ue = Math.min(
+              v,
+              Math.ceil(re * v / J)
             );
-            for (let H = K; H < Q; ++H)
-              q[H]++;
+            for (let oe = he; oe < ue; ++oe)
+              S[oe]++;
           }
-          let g = 0;
-          for (let m = 0; m < I; ++m) g += q[m];
-          W[0] = 0, Y[0] = 0;
-          for (let m = 1; m < I; ++m)
-            W[m - 1] = q[m - 1] / g * R >>> 0, Y[m] = Y[m - 1] + W[m - 1];
-          W[I - 1] = q[I - 1] / g * R >>> 0;
-          const B = N / I;
-          for (let m = 0; m < _; ++m) {
-            const z = m * 3, E = r[z + 0], U = r[z + 1], O = r[z + 2], F = E * M + U * f + O * A, X = (D - F) / B, Z = Math.max(
+          let E = 0;
+          for (let D = 0; D < v; ++D) E += S[D];
+          B[0] = 0, k[0] = 0;
+          for (let D = 1; D < v; ++D)
+            B[D - 1] = S[D - 1] / E * L >>> 0, k[D] = k[D - 1] + B[D - 1];
+          B[v - 1] = S[v - 1] / E * L >>> 0;
+          const V = J / v;
+          for (let D = 0; D < P; ++D) {
+            const O = D * 3, Y = r[O + 0], Z = r[O + 1], Q = r[O + 2], N = Y * g + Z * d + Q * I, se = (F - N) / V, re = Math.max(
               0,
               Math.min(
-                I - 1,
-                Math.floor(X)
+                v - 1,
+                Math.floor(se)
               )
-            ), K = X - Z, Q = Y[Z] + W[Z] * K >>> 0, H = Math.min(Q, R - 1);
-            v[m] = H, S[H]++;
+            ), he = se - re, ue = k[re] + B[re] * he >>> 0, oe = Math.min(ue, L - 1);
+            y[D] = oe, M[oe]++;
           }
         } else {
-          const c = (R - 1) / N;
-          for (let g = 0; g < _; ++g) {
-            const B = g * 3, m = r[B + 0], z = r[B + 1], E = r[B + 2], U = m * M + z * f + E * A, F = (D - U) * c >>> 0, V = Math.min(F, R - 1);
-            v[g] = V, S[V]++;
+          const f = (L - 1) / J;
+          for (let E = 0; E < P; ++E) {
+            const V = E * 3, D = r[V + 0], O = r[V + 1], Y = r[V + 2], Z = D * g + O * d + Y * I, N = (F - Z) * f >>> 0, K = Math.min(N, L - 1);
+            y[E] = K, M[K]++;
           }
         }
-        for (let c = 1; c < R; c++)
-          S[c] += S[c - 1];
-        for (let c = _ - 1; c >= 0; c--) {
-          const g = v[c], B = --S[g];
-          e[B] = n ? n[c] : c;
+        for (let f = 1; f < L; f++)
+          M[f] += M[f - 1];
+        for (let f = P - 1; f >= 0; f--) {
+          const E = y[f], V = --M[E];
+          s[V] = o ? o[f] : f;
         }
-        const st = w * M + d * f + P * A, tt = (c) => {
-          if (!e) return -1 / 0;
-          const g = e[c], B = g;
-          if (!r || B * 3 + 2 >= r.length)
+        const X = b * g + A * d + C * I, $ = (f) => {
+          if (!s) return -1 / 0;
+          const E = s[f], V = E;
+          if (!r || V * 3 + 2 >= r.length)
             return -1 / 0;
-          const m = B * 3;
-          return r[m] * M + r[m + 1] * f + r[m + 2] * A - st;
+          const D = V * 3;
+          return r[D] * g + r[D + 1] * d + r[D + 2] * I - X;
         };
-        let et = _;
-        if (_ > 0 && tt(_ - 1) < 0) {
-          const c = ot(
+        let H = P;
+        if (P > 0 && $(P - 1) < 0) {
+          const f = j(
             0,
-            _ - 1,
-            tt
+            P - 1,
+            $
           );
-          et = c < 0 ? ~c : c;
+          H = f < 0 ? ~f : f;
         }
-        const p = {
-          order: e.buffer,
-          count: et
+        const z = {
+          order: s.buffer,
+          count: H
         };
-        self.postMessage(p, [e.buffer]), e = null;
+        self.postMessage(z, [s.buffer]), s = null;
       };
-      self.onmessage = (w) => {
-        const d = w.data;
-        d.order && (e = new Uint32Array(d.order));
-        let P = !1;
-        if (d.centers && (r = new Float32Array(d.centers), P = !0, x = !0), Object.prototype.hasOwnProperty.call(d, "mapping") && (n = d.mapping ? new Uint32Array(d.mapping) : null, x = !0), d.chunks) {
-          if (s = new Float32Array(d.chunks), s.length > 0 && s[3] > 0)
-            for (let M = 0; M < s.length / 6; ++M) {
-              const f = M * 6, A = s[f + 0], T = s[f + 1], j = s[f + 2], J = s[f + 3], $ = s[f + 4], D = s[f + 5];
-              s[f + 0] = (A + J) * 0.5, s[f + 1] = (T + $) * 0.5, s[f + 2] = (j + D) * 0.5, s[f + 3] = Math.sqrt(
-                (J - A) ** 2 + ($ - T) ** 2 + (D - j) ** 2
+      self.onmessage = (b) => {
+        const A = b.data;
+        A.order && (s = new Uint32Array(A.order));
+        let C = !1;
+        if (A.centers && (r = new Float32Array(A.centers), C = !0, m = !0), Object.prototype.hasOwnProperty.call(A, "mapping") && (o = A.mapping ? new Uint32Array(A.mapping) : null, m = !0), A.chunks) {
+          if (n = new Float32Array(A.chunks), n.length > 0 && n[3] > 0)
+            for (let g = 0; g < n.length / 6; ++g) {
+              const d = g * 6, I = n[d + 0], q = n[d + 1], T = n[d + 2], W = n[d + 3], U = n[d + 4], F = n[d + 5];
+              n[d + 0] = (I + W) * 0.5, n[d + 1] = (q + U) * 0.5, n[d + 2] = (T + F) * 0.5, n[d + 3] = Math.sqrt(
+                (W - I) ** 2 + (U - q) ** 2 + (F - T) ** 2
               ) * 0.5;
             }
-          x = !0;
+          m = !0;
         }
-        if (P && r && r.length > 0) {
-          u.x = y.x = r[0], u.y = y.y = r[1], u.z = y.z = r[2];
-          for (let M = 1; M < r.length / 3; M++) {
-            const f = M * 3;
-            u.x = Math.min(u.x, r[f + 0]), y.x = Math.max(y.x, r[f + 0]), u.y = Math.min(u.y, r[f + 1]), y.y = Math.max(y.y, r[f + 1]), u.z = Math.min(u.z, r[f + 2]), y.z = Math.max(y.z, r[f + 2]);
+        if (C && r && r.length > 0) {
+          l.x = p.x = r[0], l.y = p.y = r[1], l.z = p.z = r[2];
+          for (let g = 1; g < r.length / 3; g++) {
+            const d = g * 3;
+            l.x = Math.min(l.x, r[d + 0]), p.x = Math.max(p.x, r[d + 0]), l.y = Math.min(l.y, r[d + 1]), p.y = Math.max(p.y, r[d + 1]), l.z = Math.min(l.z, r[d + 2]), p.z = Math.max(p.z, r[d + 2]);
           }
-        } else P && r && r.length === 0 && (u.x = y.x = u.y = y.y = u.z = y.z = 0);
-        d.cameraPosition && (a = d.cameraPosition), d.cameraDirection && (l = d.cameraDirection), L();
+        } else C && r && r.length === 0 && (l.x = p.x = l.y = p.y = l.z = p.z = 0);
+        A.cameraPosition && (i = A.cameraPosition), A.cameraDirection && (u = A.cameraDirection), R();
       };
     }).toString()})();`;
   }
 }
-const gt = (k, t) => {
-  const o = ht(k), e = ht(t);
-  return o | e << 16;
-};
-function ht(k) {
-  const t = new Float32Array([k]), e = new Int32Array(t.buffer)[0];
-  let r = e >> 16 & 32768, s = e >> 12 & 2047;
-  const n = e >> 23 & 255;
-  return n < 103 ? r : n > 142 ? (r |= 31744, r |= (n === 255 ? 0 : 1) && e & 8388607, r) : n < 113 ? (s |= 2048, r |= (s >> 114 - n) + (s >> 113 - n & 1), r) : (r |= n - 112 << 10 | s >> 1, r += s & 1, r);
-}
-const yt = new ArrayBuffer(4), ut = new DataView(yt), vt = (k) => (ut.setUint32(0, k, !0), ut.getFloat32(0, !0));
-class wt {
-  /**
-   * Create a new TextureManager for a set of splats
-   * @param splatData The splat data to manage textures for
-   */
-  constructor(t) {
-    h(this, "textureWidth");
-    h(this, "textureHeight");
-    h(this, "transformA");
-    // position xyz and rotation quaternion y,z components
-    h(this, "transformB");
-    // rotation quaternion x and scale xyz
-    h(this, "colorTexture");
-    // color an opacity
-    h(this, "orderTexture");
-    const o = t.numSplats;
-    this.textureWidth = Math.ceil(Math.sqrt(o)), this.textureHeight = Math.ceil(o / this.textureWidth), this.transformA = this.createTransformATexture(t), this.transformB = this.createTransformBTexture(t), this.colorTexture = this.createColorTexture(t), this.orderTexture = this.createOrderTexture(o);
-  }
-  /**
-   * Create the transform A texture (positions and quaternion w component)
-   * @param splatData The splat data
-   * @returns DataTexture containing position data
-   */
-  createTransformATexture(t) {
-    const o = t.numSplats, e = new Float32Array(
-      this.textureWidth * this.textureHeight * 4
-    );
-    for (let s = 0; s < o; s++) {
-      const n = s * 4, a = s * 3, l = s * 4;
-      e[n] = t.positions[a], e[n + 1] = t.positions[a + 1], e[n + 2] = t.positions[a + 2];
-      const x = t.rotations[l + 0], b = t.rotations[l + 1], C = gt(x, b);
-      e[n + 3] = vt(C);
-    }
-    const r = new i.DataTexture(
-      e,
-      this.textureWidth,
-      this.textureHeight,
-      i.RGBAFormat,
-      i.FloatType
-      // Store as Float32, shader will reinterpret bits
-    );
-    return r.magFilter = i.NearestFilter, r.minFilter = i.NearestFilter, r.source.data.updateRanges || (r.source.data.updateRanges = []), r.needsUpdate = !0, r;
+class Ge {
+  constructor(e) {
+    w(this, "packedGeometry");
+    // RGBA32UI
+    w(this, "packedColor");
+    // RGBA8
+    w(this, "orderTexture");
+    // RB32UI
+    w(this, "width");
+    w(this, "height");
+    this.width = e.textureWidth, this.height = e.textureHeight, this.packedColor = this.createColorTexture(e), this.packedGeometry = this.createGeometryTexture(e), this.orderTexture = this.createOrderTexture(e.numSplats);
   }
-  /**
-   * Create the transform B texture (scale and rotation xyz)
-   * @param splatData The splat data
-   * @returns DataTexture containing scale and rotation data
-   */
-  createTransformBTexture(t) {
-    const o = t.numSplats, e = new Float32Array(
-      this.textureWidth * this.textureHeight * 4
+  createGeometryTexture(e) {
+    const t = new h.DataTexture(
+      e.packedGeometry,
+      this.width,
+      this.height,
+      h.RGBAIntegerFormat,
+      h.UnsignedIntType
     );
-    for (let s = 0; s < o; s++) {
-      const n = s * 4, a = s * 3, l = s * 4;
-      e[n] = t.scales[a], e[n + 1] = t.scales[a + 1], e[n + 2] = t.scales[a + 2], e[n + 3] = t.rotations[l + 2];
-    }
-    const r = new i.DataTexture(
-      e,
-      this.textureWidth,
-      this.textureHeight,
-      i.RGBAFormat,
-      i.FloatType
-    );
-    return r.magFilter = i.NearestFilter, r.minFilter = i.NearestFilter, r.source.data.updateRanges || (r.source.data.updateRanges = []), r.needsUpdate = !0, r;
+    return t.internalFormat = "RGBA32UI", t.minFilter = h.NearestFilter, t.magFilter = h.NearestFilter, t.needsUpdate = !0, t;
   }
-  /**
-   * Create the color texture (RGB and opacity)
-   * @param splatData The splat data
-   * @returns DataTexture containing color data
-   */
-  createColorTexture(t) {
-    const o = t.numSplats, e = new Float32Array(
-      this.textureWidth * this.textureHeight * 4
-    );
-    for (let s = 0; s < o; s++) {
-      const n = s * 4, a = s * 3;
-      e[n] = t.colors[a], e[n + 1] = t.colors[a + 1], e[n + 2] = t.colors[a + 2], e[n + 3] = t.opacities[s];
-    }
-    const r = new i.DataTexture(
-      e,
-      this.textureWidth,
-      this.textureHeight,
-      i.RGBAFormat,
-      i.FloatType
+  createColorTexture(e) {
+    const t = new h.DataTexture(
+      e.packedColor,
+      this.width,
+      this.height,
+      h.RGBAFormat,
+      h.UnsignedByteType
     );
-    return r.source.data.updateRanges || (r.source.data.updateRanges = []), r.needsUpdate = !0, r;
+    return t.minFilter = h.NearestFilter, t.magFilter = h.NearestFilter, t.needsUpdate = !0, t;
   }
-  /**
-   * Create the order texture for sorting
-   * @param numSplats Number of splats
-   * @returns DataTexture for storing order indices
-   */
-  createOrderTexture(t) {
-    const o = new Uint32Array(this.textureWidth * this.textureHeight);
-    for (let r = 0; r < t; r++)
-      o[r] = r;
-    const e = new i.DataTexture(
-      o,
-      this.textureWidth,
-      this.textureHeight,
-      i.RedIntegerFormat,
-      i.UnsignedIntType
+  createOrderTexture(e) {
+    const t = new Uint32Array(this.width * this.height);
+    for (let r = 0; r < e; r++) t[r] = r;
+    const s = new h.DataTexture(
+      t,
+      this.width,
+      this.height,
+      h.RedIntegerFormat,
+      h.UnsignedIntType
     );
-    return e.source.data.updateRanges || (e.source.data.updateRanges = []), e.needsUpdate = !0, e;
+    return s.minFilter = h.NearestFilter, s.magFilter = h.NearestFilter, s.needsUpdate = !0, s;
   }
   dispose() {
-    this.transformA.dispose(), this.transformB.dispose(), this.colorTexture.dispose(), this.orderTexture.dispose();
+    this.packedGeometry.dispose(), this.packedColor.dispose(), this.orderTexture.dispose();
   }
 }
-const bt = (
+const We = (
   /* glsl */
   `
 precision highp float;
@@ -576,55 +578,47 @@ 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
+uniform int texWidth;
+uniform vec2 viewport;
+uniform uint numSplats;
 
-// 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
+// --- Unified Packed Textures ---
+uniform usampler2D packedGeometry; // RGBA32UI: Geometry (Pos, Rot, Scale)
+uniform sampler2D packedColor;    // RGBA8: Color (RGB) + Opacity (A)
+uniform usampler2D splatOrder;    // R32UI: Sort Index
 
-// --- Attributes ---
-// Instancing attribute: base index for this block of splats
-attribute uint splatInstanceIndex;
+// --- Decompression Ranges ---
+uniform vec3 meansMin;
+uniform vec3 meansMax;
+uniform vec3 scalesMin;
+uniform vec3 scalesMax;
+uniform vec3 sh0Min;
+uniform vec3 sh0Max;
 
-// 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)
+// --- Attributes ---
+in uint splatInstanceIndex;
 
-// --- Varyings ---
-varying vec4 vColor;
-varying vec2 vUv; // For gaussian calculation in fragment shader
+// --- Outputs ---
+out vec4 vColor;
+out vec2 vUv;
 
 // --- Constants ---
-#define INSTANCE_BUFFER_SIZE 128.0 // Must match the size in SplatMesh
+const vec4 DISCARD_VERTEX = vec4(0.0, 0.0, 2.0, 1.0);
+const float SH_C0 = 0.28209479177387814; // 1/(2*sqrt(pi))
+const float QUAT_NORM = 1.41421356237; // sqrt(2)
 
 // --- 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) 
+// Extract raw bytes as integers (no /255 )
+uvec4 unpackBytes(uint v) {
+    return (uvec4(v) >> uvec4(24u, 16u, 8u, 0u)) & 0xffu;
 }
 
-// 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;
+    vec4 Y = R2.y * R;
+    vec4 Z = R2.z * R;
     float W = R2.w * R.w;
 
     return mat3(
@@ -640,199 +634,176 @@ mat3 quatToMat3(vec4 R) {
     );
 }
 
-// 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
+        scale.x * rot[0],
+        scale.y * rot[1],
+        scale.z * rot[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;
+// --- Main ---
+void main() {
+    // Calculate Instance ID & Source Data UV
+    uint instanceOffset = uint(position.z);
+    uint orderIndex = 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
+    if (orderIndex >= numSplats) {
+        gl_Position = DISCARD_VERTEX;
         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;
+    uint w = uint(texWidth);
+    ivec2 orderUV = ivec2(int(orderIndex % w), int(orderIndex / w));
 
-    ivec2 dataUV = ivec2(originalSplatIndex % texWidth, originalSplatIndex / texWidth);
+    // Fetch original splat ID from the order texture
+    uint splatID = texelFetch(splatOrder, orderUV, 0).r;
+    ivec2 dataUV = ivec2(int(splatID % w), int(splatID / w));
 
-    // Fetch data from textures
-    vec4 texTransformA = texelFetch(transformA, dataUV, 0);
-    vec4 texTransformB = texelFetch(transformB, dataUV, 0);
-    vec4 texColor = texelFetch(splatColor, dataUV, 0);
+    // Fetch Packed Data
+    // x: Means Low, y: Means High, z: Rotation, w: Scale
+    uvec4 geom = texelFetch(packedGeometry, dataUV, 0); 
+    vec4 colorRaw = texelFetch(packedColor, 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;
+    // Decompress Position (Means) (assume world-space)
+    // Reconstruct 16-bit values from two 8-bit channels
+    uvec3 lo = unpackBytes(geom.x).xyz;
+    uvec3 hi = unpackBytes(geom.y).xyz;
 
-    vec3 splatScale = exp(splatLogScale); // Convert log scale to actual scale
+    // (hi << 8) | lo  => 0..65535  then normalize
+    vec3 meansNorm = vec3((hi << 8u) | lo) * (1.0 / 65535.0);
+    vec3 modelCenter = mix(meansMin, meansMax, meansNorm);
 
-    // --- Center Projection ---
+    // Decompress Rotation (Quaternions)
+    uvec4 qB = unpackBytes(geom.z);
+    vec3 abc = (vec3(qB.xyz) * (1.0 / 255.0) - 0.5) * QUAT_NORM;
+    float d = sqrt(max(0.0, 1.0 - dot(abc, abc)));
+    uint mode = qB.w; // already 0..3
 
-    // 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;
-    }
+    // Reconstruct Quaternion (x, y, z, w)
+    // quat in (w,x,y,z)
+    vec4 quat;
+    if (mode == 0u)      quat = vec4(d, abc);            // (w, x, y, z)
+    else if (mode == 1u) quat = vec4(abc.x, d, abc.yz);  // stored (w,y,z)
+    else if (mode == 2u) quat = vec4(abc.xy, d, abc.z);  // stored (w,x,z)
+    else                 quat = vec4(abc, d);            // stored (w,x,y)
+
+    // Decompress Scale
+    uvec3 sB = unpackBytes(geom.w).xyz;
+    vec3 sNorm = vec3(sB) * (1.0 / 255.0);
+    vec3 sLerp = mix(scalesMin, scalesMax, sNorm);
+    vec3 scale = exp(sLerp); // log scale stored
+
+    // Decompress Color & Opacity
+    vec4 clr;
+    vec3 sh = mix(sh0Min, sh0Max, colorRaw.rgb);
+    clr.rgb = vec3(0.5) + sh * SH_C0;
+    clr.a = colorRaw.a; // Opacity passed directly (linear or sigmoid handled by loader)
 
-    // Project to clip space
-    vec4 centerClip = projectionMatrix * centerClipRaw;
+    // --- Standard Gaussian Splat Projection ---
 
-    // --- Covariance Calculation & Projection ---
+    // View Space Setup
+    mat4 modelView = modelViewMatrix;
+    vec4 centerView = modelView * vec4(modelCenter, 1.0);
 
-    // Calculating model space covariance (Vrk)
+    // Cull behind camera
+    if (centerView.z > -0.2) {
+        gl_Position = DISCARD_VERTEX;
+        return;
+    }
+
+    // Covariance in 3D
     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]
-    );
+    getModelCovariance(scale, quat, covA, covB);
 
-    // Calculate Jacobian J (screen space change wrt view space change)
-    //    Requres focal lenghts and view-space center depth (tz)
+    // Project to 2D
     float focalX = viewport.x * projectionMatrix[0][0];
     float focalY = viewport.y * projectionMatrix[1][1];
-    float tz = centerView.z;
-    float tz2 = tz * tz;
+    float J1 = focalX / centerView.z;
+    vec2 J2 = -J1 / centerView.z * centerView.xy;
 
-    // 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
+        J1,   0.0,  J2.x,
+        0.0,  J1,   J2.y,
+        0.0,  0.0,  0.0
     );
 
-    // Calculate W 
-    mat3 W = transpose(mat3(modelViewMatrix));
-    // Calculate T = W * J
+    mat3 W = transpose(mat3(modelView));
     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
-    }
+    mat3 Vrk = mat3(
+        covA.x, covA.y, covA.z,
+        covA.y, covB.x, covB.y,
+        covA.z, covB.y, covB.z
+    );
+    mat3 cov = transpose(T) * Vrk * T;
 
-    v2_eigen = vec2(-v1_eigen.y, v1_eigen.x); // Perpendicular eigenvector
+    // Eigendecomposition for Quad dimensions
+    float diagonal1 = cov[0][0] + 0.3;
+    float offDiagonal = cov[0][1];
+    float diagonal2 = cov[1][1] + 0.3;
 
-    // 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 mid = 0.5 * (diagonal1 + diagonal2);
+    float radius = length(vec2((diagonal1 - diagonal2) * 0.5, offDiagonal));
+    float lambda1 = mid + radius;
+    float lambda2 = max(mid - radius, 0.1);
 
-    float vmin = min(512.0, min(viewport.x, viewport.y));
-    l1 = min(l1, 2.0 * vmin);
-    l2 = min(l2, 2.0 * vmin);
+    // Screen space quad vectors
+    float vmin = min(1024.0, min(viewport.x, viewport.y)); // Safety clamp
+    float l1 = 2.0 * min(sqrt(2.0 * lambda1), vmin);
+    float l2 = 2.0 * min(sqrt(2.0 * lambda2), 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;
+    // Discard tiny splats
+    if (l1 < 2.0 && l2 < 2.0) {
+        gl_Position = DISCARD_VERTEX;
+        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
+    vec2 diagVec = normalize(vec2(offDiagonal, lambda1 - diagonal1));
+    vec2 v1 = l1 * diagVec;
+    vec2 v2 = l2 * vec2(diagVec.y, -diagVec.x);
 
-    // 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);
+    // Vertex Position (Quad Expansion)
+    vec4 centerProj = projectionMatrix * centerView;
+    vec2 c = centerProj.ww / viewport; // Correction for clip space
+    
+    // Frustum cull
+    if (any(greaterThan(abs(centerProj.xy) - vec2(max(l1, l2)) * c, centerProj.ww))) {
+        gl_Position = DISCARD_VERTEX;
         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 ---
+    // Quad offset based on 'position' attribute (-1 to 1)
+    vec2 offset = (position.x * v1 + position.y * v2) * c;
+    
+    // Corner Clipping (for gaussian shape)
+    // Assuming simple linear opacity here, otherwise inverse sigmoid logic required
+    float alpha = max(clr.a, 1.0/255.0);
+    float clip = min(1.0, sqrt(-log(1.0 / 255.0 / alpha)) / 2.0);
+    
+    offset *= clip;
+    vec2 clippedUV = position.xy * clip;
 
-    vColor = vec4(splatColor, splatOpacity);
-    vUv = clippedCornerOffset;
+    gl_Position = centerProj + vec4(offset, 0.0, 0.0);
+    
+    // Outputs
+    vUv = clippedUV;
+    vColor = vec4(max(clr.rgb, vec3(0.0)), clr.a);
 }
 `
-), Mt = (
+), Ne = (
   /* 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
+in vec4 vColor; // Color and opacity passed from vertex shader
+in vec2 vUv;    // Quad UV coordinates (-1 to 1) passed from vertex shader
+
+out vec4 fragColor; // Output variable
 
 // Fast approximate e^x based on https://nic.schraudolph.org/pubs/Schraudolph99.pdf
 const float EXP_A = 12102203.0;     // ≈ 2^23 / ln(2)
@@ -856,139 +827,129 @@ void main(void) {
     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);
+    fragColor = vec4(vColor.rgb * alpha, alpha);
 }
 `
 );
-class Ct extends i.ShaderMaterial {
-  constructor(t = {}) {
-    const o = {
-      // Textures (values set via methods)
-      transformA: { value: null },
-      transformB: { value: null },
-      splatColor: { value: null },
+class je extends h.ShaderMaterial {
+  constructor(e = {}) {
+    const t = {
+      // Packed Textures
+      packedGeometry: { value: null },
+      // RGBA32UI: .r=MeansLow, .g=MeansHigh, .b=Quats, .a=Scales
+      packedColor: { value: null },
+      // RGBA8: .rgb=Color, .a=Opacity
       splatOrder: { value: null },
-      // Other uniforms
-      viewport: { value: new i.Vector2(1, 1) },
-      // Will be updated
+      // Index map
+      // Decompression Ranges
+      meansMin: { value: new h.Vector3() },
+      meansMax: { value: new h.Vector3() },
+      scalesMin: { value: new h.Vector3() },
+      scalesMax: { value: new h.Vector3() },
+      sh0Min: { value: new h.Vector3() },
+      sh0Max: { value: new h.Vector3() },
+      // Render State
+      texWidth: { value: 0 },
+      viewport: { value: new h.Vector2(1, 1) },
       numSplats: { value: 0 }
-      // Max splats to render (updated by sorter)
     };
     super({
-      vertexShader: bt,
-      fragmentShader: Mt,
-      uniforms: o,
+      uniforms: t,
+      vertexShader: We,
+      fragmentShader: Ne,
       transparent: !0,
-      blending: i.CustomBlending,
-      // Premultiplied alpha blending:
-      // color = src_color * src_alpha + dst_color * (1 - src_alpha)
-      // alpha = src_alpha * 1 + dst_alpha * (1 - src_alpha)
-      blendSrc: i.OneFactor,
-      // Using ONE because shader outputs premultiplied color (color * alpha)
-      blendDst: i.OneMinusSrcAlphaFactor,
-      blendSrcAlpha: i.OneFactor,
-      // source alpha comes from shader
-      blendDstAlpha: i.OneMinusSrcAlphaFactor,
-      blendEquation: i.AddEquation,
-      blendEquationAlpha: i.AddEquation,
+      glslVersion: h.GLSL3,
+      blendSrc: h.OneFactor,
+      blendSrcAlpha: h.OneFactor,
+      blending: h.CustomBlending,
+      blendEquation: h.AddEquation,
+      blendEquationAlpha: h.AddEquation,
+      blendDst: h.OneMinusSrcAlphaFactor,
+      blendDstAlpha: h.OneMinusSrcAlphaFactor,
       depthTest: !0,
       depthWrite: !1,
-      // Disable depth write for transparency
-      side: i.DoubleSide,
-      // Render both sides (or CULLFACE_NONE equivalent)
-      // Optional settings from constructor
-      alphaTest: t.alphaTest !== void 0 ? t.alphaTest : 0,
-      // Typically 0 for blending
-      toneMapped: t.toneMapped !== void 0 ? t.toneMapped : !1
-      // prettier-ignore
-    }), t.alphaHash && (this.alphaHash = !0, this.depthWrite = !0, this.blending = i.NoBlending);
+      side: h.DoubleSide,
+      alphaTest: e.alphaTest ?? 0,
+      toneMapped: e.toneMapped ?? !1
+    }), e.alphaHash && (this.alphaHash = !0, this.depthWrite = !0, this.blending = h.NoBlending);
+  }
+  setTexWidth(e) {
+    this.uniforms.texWidth.value = e | 0;
   }
   /**
    * Update the viewport size
    * @param width Viewport width
    * @param height Viewport height
    */
-  updateViewport(t, o) {
-    this.uniforms.viewport.value.set(t, o);
+  updateViewport(e, t) {
+    this.uniforms.viewport.value.set(e, t);
   }
   /**
-   * Set transform texture A (positions)
-   * @param texture Texture containing positions
+   * Set the main packed geometry texture (RGBA32UI)
    */
-  setTransformA(t) {
-    this.uniforms.transformA.value = t;
+  setPackedGeometry(e) {
+    this.uniforms.packedGeometry.value = e;
   }
   /**
-   * Set transform texture B (rotation, scale)
-   * @param texture Texture containing rotation and scale data
+   * Set the packed color texture (RGBA8)
    */
-  setTransformB(t) {
-    this.uniforms.transformB.value = t;
+  setPackedColor(e) {
+    this.uniforms.packedColor.value = e;
   }
   /**
-   * Set color texture
-   * @param texture Texture containing colors
+   * Set order texture for sorting
    */
-  setColorTexture(t) {
-    this.uniforms.splatColor.value = t;
+  setOrderTexture(e) {
+    this.uniforms.splatOrder.value = e;
   }
   /**
-   * Set order texture
-   * @param texture Texture containing sort order
+   * Set the ranges needed to decompress the packed floats
    */
-  setOrderTexture(t) {
-    this.uniforms.splatOrder.value = t;
+  setRanges(e) {
+    this.uniforms.meansMin.value.copy(e.means.min), this.uniforms.meansMax.value.copy(e.means.max), this.uniforms.scalesMin.value.copy(e.scales.min), this.uniforms.scalesMax.value.copy(e.scales.max), this.uniforms.sh0Min.value.copy(e.sh0.min), this.uniforms.sh0Max.value.copy(e.sh0.max);
   }
   /**
    * Set number of splats to render
    * @param count Number of splats
    */
-  setNumSplats(t) {
-    this.uniforms.numSplats.value = t;
+  setNumSplats(e) {
+    this.uniforms.numSplats.value = e;
   }
 }
-const rt = class rt extends i.Mesh {
+const fe = class fe extends h.Mesh {
   // Match shader constant
   /**
    * Create a new SplatMesh for rendering Gaussian splats
    * @param splatData The splat data to render
    * @param options Rendering options
    */
-  constructor(o, e = {}) {
-    const r = new Ct(e), s = rt.createInstancedGeometry(o.numSplats, rt.INSTANCE_SIZE);
-    super(s, r);
-    h(this, "sorter");
-    h(this, "splatData");
-    h(this, "options");
-    h(this, "textureManager");
-    h(this, "material");
-    h(this, "geometry");
-    h(this, "lastCameraPositionLocal", new i.Vector3());
-    h(this, "lastCameraDirectionLocal", new i.Vector3());
-    h(this, "invModelMatrix", new i.Matrix4());
+  constructor(t, s = {}) {
+    const r = new je(s), n = fe.createInstancedGeometry(t.numSplats, fe.INSTANCE_SIZE);
+    super(n, r);
+    w(this, "sorter");
+    w(this, "options");
+    w(this, "splatData");
+    w(this, "textureManager");
+    w(this, "material");
+    w(this, "geometry");
+    w(this, "lastCameraPositionLocal", new h.Vector3());
+    w(this, "lastCameraDirectionLocal", new h.Vector3());
+    w(this, "invModelMatrix", new h.Matrix4());
     // Cached inverse matrix
-    h(this, "_vpW", -1);
-    h(this, "_vpH", -1);
-    h(this, "_size", new i.Vector2());
-    h(this, "_camPosW", new i.Vector3());
-    h(this, "_camDirW", new i.Vector3());
-    h(this, "_camPosL", new i.Vector3());
-    h(this, "_camDirL", new i.Vector3());
-    h(this, "onSorterUpdated", (o) => {
-      const e = o.count;
-      this.geometry.instanceCount = Math.ceil(e / rt.INSTANCE_SIZE), this.material.setNumSplats(e);
+    w(this, "_vpW", -1);
+    w(this, "_vpH", -1);
+    w(this, "_size", new h.Vector2());
+    w(this, "_camPosW", new h.Vector3());
+    w(this, "_camDirW", new h.Vector3());
+    w(this, "_camPosL", new h.Vector3());
+    w(this, "_camDirL", new h.Vector3());
+    w(this, "onSorterUpdated", (t) => {
+      const s = t.count;
+      this.geometry.instanceCount = Math.ceil(s / fe.INSTANCE_SIZE), this.material.setNumSplats(s);
     });
-    this.geometry = s, this.material = r, this.splatData = o, this.frustumCulled = !1, this.options = {
-      autoSort: !0,
-      ...e
-    }, this.textureManager = new wt(o), this.sorter = new xt();
-    let n = this.createChunks() || void 0;
-    n === null && console.warn("Visus: Could not create sorter chunks, bounding box might be invalid."), n = void 0, this.sorter.addEventListener("updated", this.onSorterUpdated), this.sorter.init(
-      this.textureManager.orderTexture,
-      this.splatData.positions,
-      n ?? void 0,
-      !this.options.keepSplatData
-    ), 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 = o.boundingBox.toBox3(), this.geometry.boundingSphere = new i.Sphere(), this.geometry.boundingBox.getBoundingSphere(this.geometry.boundingSphere), this.options.keepSplatData || (this.splatData = null);
+    this.geometry = n, this.material = r, this.options = { autoSort: !0, ...s }, this.splatData = t, this.frustumCulled = !1, this.sorter = new Le(), this.textureManager = new Ge(t);
+    let o = this.createChunks() || void 0;
+    o === null && console.warn("Visus: Could not create sorter chunks, bounding box might be invalid."), o = void 0, this.sorter.addEventListener("updated", this.onSorterUpdated), this.sorter.init(this.textureManager.orderTexture, this.splatData.centers, o ?? void 0, !this.options.keepSplatData), this.material.setRanges(t.ranges), this.material.setTexWidth(t.textureWidth), this.material.setPackedColor(this.textureManager.packedColor), this.material.setOrderTexture(this.textureManager.orderTexture), this.material.setPackedGeometry(this.textureManager.packedGeometry), this.material.setNumSplats(0), this.geometry.boundingBox = t.boundingBox.toBox3(), this.geometry.boundingSphere = new h.Sphere(), this.geometry.boundingBox.getBoundingSphere(this.geometry.boundingSphere), this.options.keepSplatData || (this.splatData = null);
   }
   /**
    * Creates the instanced geometry for rendering splats.
@@ -996,8 +957,8 @@ const rt = class rt extends i.Mesh {
    * @param instanceSize Number of splats per instance.
    * @returns InstancedBufferGeometry
    */
-  static createInstancedGeometry(o, e) {
-    const r = Math.ceil(o / e), s = new i.BufferGeometry(), n = new Float32Array([
+  static createInstancedGeometry(t, s) {
+    const r = Math.ceil(t / s), n = new h.BufferGeometry(), o = new Float32Array([
       // x, y, splat_index_in_instance
       -1,
       -1,
@@ -1011,24 +972,24 @@ const rt = class rt extends i.Mesh {
       -1,
       1,
       0
-    ]), a = new Uint16Array([0, 1, 2, 0, 2, 3]), l = new Float32Array(4 * 3 * e);
-    for (let u = 0; u < e; u++) {
-      const y = u * 4 * 3;
-      for (let v = 0; v < 4; v++)
-        l[y + v * 3 + 0] = n[v * 3 + 0], l[y + v * 3 + 1] = n[v * 3 + 1], l[y + v * 3 + 2] = u;
+    ]), i = new Uint16Array([0, 1, 2, 0, 2, 3]), u = new Float32Array(4 * 3 * s);
+    for (let l = 0; l < s; l++) {
+      const p = l * 4 * 3;
+      for (let y = 0; y < 4; y++)
+        u[p + y * 3 + 0] = o[y * 3 + 0], u[p + y * 3 + 1] = o[y * 3 + 1], u[p + y * 3 + 2] = l;
     }
-    const x = new Uint32Array(6 * e);
-    for (let u = 0; u < e; u++) {
-      const y = u * 6, v = u * 4;
-      x[y + 0] = a[0] + v, x[y + 1] = a[1] + v, x[y + 2] = a[2] + v, x[y + 3] = a[3] + v, x[y + 4] = a[4] + v, x[y + 5] = a[5] + v;
+    const m = new Uint32Array(6 * s);
+    for (let l = 0; l < s; l++) {
+      const p = l * 6, y = l * 4;
+      m[p + 0] = i[0] + y, m[p + 1] = i[1] + y, m[p + 2] = i[2] + y, m[p + 3] = i[3] + y, m[p + 4] = i[4] + y, m[p + 5] = i[5] + y;
     }
-    s.setAttribute("position", new i.BufferAttribute(l, 3)), s.setIndex(new i.BufferAttribute(x, 1));
-    const b = new i.InstancedBufferGeometry();
-    b.index = s.index, b.setAttribute("position", s.getAttribute("position"));
-    const C = new Uint32Array(r);
-    for (let u = 0; u < r; u++)
-      C[u] = u * e;
-    return b.setAttribute("splatInstanceIndex", new i.InstancedBufferAttribute(C, 1, !1)), b.instanceCount = 0, b;
+    n.setAttribute("position", new h.BufferAttribute(u, 3)), n.setIndex(new h.BufferAttribute(m, 1));
+    const x = new h.InstancedBufferGeometry();
+    x.index = n.index, x.setAttribute("position", n.getAttribute("position"));
+    const c = new Uint32Array(r);
+    for (let l = 0; l < r; l++)
+      c[l] = l * s;
+    return x.setAttribute("splatInstanceIndex", new h.InstancedBufferAttribute(c, 1, !1)), x.instanceCount = 0, x;
   }
   /**
    * Create chunks data (bounding box min/max) for the sorter.
@@ -1037,14 +998,14 @@ const rt = class rt extends i.Mesh {
   createChunks() {
     if (!this.splatData)
       return null;
-    const o = this.splatData.boundingBox;
-    return o.min.x === 1 / 0 || o.max.x === -1 / 0 ? null : new Float32Array([
-      o.min.x,
-      o.min.y,
-      o.min.z,
-      o.max.x,
-      o.max.y,
-      o.max.z
+    const t = this.splatData.boundingBox;
+    return t.min.x === 1 / 0 || t.max.x === -1 / 0 ? null : new Float32Array([
+      t.min.x,
+      t.min.y,
+      t.min.z,
+      t.max.x,
+      t.max.y,
+      t.max.z
     ]);
   }
   /**
@@ -1052,17 +1013,17 @@ const rt = class rt extends i.Mesh {
    * @param width Viewport width
    * @param height Viewport height
    */
-  updateViewport(o, e) {
-    o === this._vpW && e === this._vpH || (this._vpW = o, this._vpH = e, this.material.updateViewport(o, e));
+  updateViewport(t, s) {
+    t === this._vpW && s === this._vpH || (this._vpW = t, this._vpH = s, this.material.updateViewport(t, s));
   }
   /**
    * Sorts splats based on camera position and direction.
    * @param camera The camera to sort against.
    */
-  sort(o) {
-    o.getWorldPosition(this._camPosW), o.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));
+  sort(t) {
+    t.getWorldPosition(this._camPosW), t.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 s = this.lastCameraPositionLocal.distanceToSquared(this._camPosL) > 1e-6, r = this.lastCameraDirectionLocal.dot(this._camDirL) < 0.999;
+    this.options.autoSort && (s || 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.
@@ -1073,8 +1034,8 @@ const rt = class rt extends i.Mesh {
    */
   // prettier-ignore
   // @ts-expect-error scene is not used
-  onBeforeRender(o, e, r) {
-    this.sort(r), o.getSize(this._size), this.updateViewport(this._size.x, this._size.y);
+  onBeforeRender(t, s, r) {
+    this.sort(r), t.getSize(this._size), this.updateViewport(this._size.x, this._size.y);
   }
   /**
    * Dispose of resources
@@ -1084,40 +1045,162 @@ const rt = class rt extends i.Mesh {
   }
 };
 /** Number of splats combined into a single instanced draw call. */
-h(rt, "INSTANCE_SIZE", 128);
-let dt = rt;
-class At extends i.Loader {
-  constructor(o) {
-    super(o);
-    h(this, "requestId", 0);
-    h(this, "worker");
-    h(this, "pendingCallbacks", /* @__PURE__ */ new Map());
+w(fe, "INSTANCE_SIZE", 128);
+let De = fe;
+const me = 0.28209479177387814;
+class Se {
+  /**
+   * Packs PLY data (Float32) into the Unified SOGS-like Format.
+   */
+  // prettier-ignore
+  static packPly(e) {
+    const t = e.numSplats, s = Math.ceil(Math.sqrt(t)), r = Math.ceil(t / s), n = s * r, { ranges: o, colorScale: i } = this.calculatePlyRanges(e), u = new Uint32Array(n * 4), m = new Uint8Array(n * 4), x = new h.Quaternion();
+    for (let c = 0; c < t; c++) {
+      const l = c * 4, p = c * 3, y = c * 4, M = e.positions[p + 0], v = e.positions[p + 1], S = e.positions[p + 2], k = this.clamp01(this.norm(M, o.means.min.x, o.means.max.x)), B = this.clamp01(this.norm(v, o.means.min.y, o.means.max.y)), j = this.clamp01(this.norm(S, o.means.min.z, o.means.max.z)), R = k * 65535 | 0, b = B * 65535 | 0, A = j * 65535 | 0;
+      u[l + 0] = this.pack4Bytes(R & 255, b & 255, A & 255, 0), u[l + 1] = this.pack4Bytes(R >> 8, b >> 8, A >> 8, 0), x.set(e.rotations[y], e.rotations[y + 1], e.rotations[y + 2], e.rotations[y + 3]).normalize();
+      let C = x.w, g = x.x, d = x.y, I = x.z;
+      const q = Math.abs(C), T = Math.abs(g), W = Math.abs(d), U = Math.abs(I);
+      let F = 0, P = q;
+      T > P && (P = T, F = 1), W > P && (P = W, F = 2), U > P && (P = U, F = 3), (F === 0 ? C : F === 1 ? g : F === 2 ? d : I) < 0 && (C = -C, g = -g, d = -d, I = -I);
+      let G = 0, L = 0, X = 0;
+      F === 0 && (G = g, L = d, X = I), F === 1 && (G = C, L = d, X = I), F === 2 && (G = C, L = g, X = I), F === 3 && (G = C, L = g, X = d);
+      const $ = (re) => Math.min(255, Math.max(0, Math.round((0.5 + re / Math.SQRT2) * 255)));
+      u[l + 2] = this.pack4Bytes($(G), $(L), $(X), F);
+      const H = this.norm(e.scales[p + 0], o.scales.min.x, o.scales.max.x), z = this.norm(e.scales[p + 1], o.scales.min.y, o.scales.max.y), f = this.norm(e.scales[p + 2], o.scales.min.z, o.scales.max.z);
+      u[l + 3] = this.pack4Bytes(Math.floor(H * 255), Math.floor(z * 255), Math.floor(f * 255), 0);
+      const E = this.clamp01(e.colors[p + 0] * i), V = this.clamp01(e.colors[p + 1] * i), D = this.clamp01(e.colors[p + 2] * i), O = (E - 0.5) / me, Y = (V - 0.5) / me, Z = (D - 0.5) / me, Q = this.clamp01(this.norm(O, o.sh0.min.x, o.sh0.max.x)), N = this.clamp01(this.norm(Y, o.sh0.min.y, o.sh0.max.y)), K = this.clamp01(this.norm(Z, o.sh0.min.z, o.sh0.max.z)), se = this.clamp01(e.opacities[c]);
+      m[l + 0] = Math.round(Q * 255), m[l + 1] = Math.round(N * 255), m[l + 2] = Math.round(K * 255), m[l + 3] = Math.round(se * 255);
+    }
+    return new Be(t, s, r, e.positions, u, m, o, e.boundingBox);
+  }
+  /**
+   * Packs SOGS data.
+   * Interleaves the separate textures into the Unified RGBA32UI buffer.
+   * Decodes centers for sorting.
+   */
+  // prettier-ignore
+  static packSogs(e) {
+    const t = e.numSplats, s = Math.ceil(Math.sqrt(t)), r = Math.ceil(t / s), n = s * r, o = this.convertSogsRanges(e.ranges), i = e.ranges.means.mins[0], u = e.ranges.means.mins[1], m = e.ranges.means.mins[2], x = e.ranges.means.maxs[0], c = e.ranges.means.maxs[1], l = e.ranges.means.maxs[2], p = (g) => Math.sign(g) * (Math.exp(Math.abs(g)) - 1), y = new h.Vector3(
+      p(i),
+      p(u),
+      p(m)
+    ), M = new h.Vector3(
+      p(x),
+      p(c),
+      p(l)
+    );
+    o.means.min.copy(y), o.means.max.copy(M);
+    const v = e, S = this.getPixels(v.means_l), k = this.getPixels(v.means_u), B = this.getPixels(v.quats), j = this.getPixels(v.scales), R = this.getPixels(v.sh0), b = new Uint32Array(n * 4), A = new Uint8Array(n * 4), C = new Float32Array(t * 3);
+    for (let g = 0; g < t; g++) {
+      const d = g * 4, I = k[d + 0], q = S[d + 0], T = k[d + 1], W = S[d + 1], U = k[d + 2], F = S[d + 2], P = (I << 8 | q) / 65535, J = (T << 8 | W) / 65535, G = (U << 8 | F) / 65535, L = this.sogsDecode(P, i, x), X = this.sogsDecode(J, u, c), $ = this.sogsDecode(G, m, l);
+      C[g * 3 + 0] = L, C[g * 3 + 1] = X, C[g * 3 + 2] = $;
+      const H = this.clamp01(this.norm(L, y.x, M.x)) * 65535 | 0, z = this.clamp01(this.norm(X, y.y, M.y)) * 65535 | 0, f = this.clamp01(this.norm($, y.z, M.z)) * 65535 | 0;
+      b[d + 0] = this.pack4Bytes(H & 255, z & 255, f & 255, 0), b[d + 1] = this.pack4Bytes(H >> 8, z >> 8, f >> 8, 0), b[d + 3] = this.pack4Bytes(j[d], j[d + 1], j[d + 2], 0);
+      const V = B[d + 3] - 252;
+      b[d + 2] = this.pack4Bytes(B[d + 0], B[d + 1], B[d + 2], V), A[d + 0] = R[d], A[d + 1] = R[d + 1], A[d + 2] = R[d + 2];
+      const D = R[d + 3] / 255, O = e.ranges.sh0.mins[3] + (e.ranges.sh0.maxs[3] - e.ranges.sh0.mins[3]) * D, Y = 1 / (1 + Math.exp(-O));
+      A[d + 3] = Math.round(Math.max(0, Math.min(1, Y)) * 255);
+    }
+    return new Be(t, s, r, C, b, A, o, e.boundingBox);
+  }
+  // --- Helpers ---
+  // prettier-ignore
+  static pack4Bytes(e, t, s, r) {
+    return (e & 255) << 24 | (t & 255) << 16 | (s & 255) << 8 | r & 255;
+  }
+  // prettier-ignore
+  static getPixels(e) {
+    const t = e.image, s = t.width, r = t.height;
+    if (t.data && (t.data instanceof Uint8Array || t.data instanceof Uint8ClampedArray)) return new Uint8Array(t.data);
+    const n = document.createElement("canvas");
+    n.width = s, n.height = r;
+    const o = n.getContext("2d", { willReadFrequently: !0 });
+    if (!o) throw new Error("Canvas init failed");
+    return o.drawImage(t, 0, 0), new Uint8Array(o.getImageData(0, 0, s, r).data);
+  }
+  static convertSogsRanges(e) {
+    const t = (s) => new h.Vector3(s[0], s[1], s[2]);
+    return {
+      sh0: { min: t(e.sh0.mins), max: t(e.sh0.maxs) },
+      means: { min: t(e.means.mins), max: t(e.means.maxs) },
+      scales: { min: t(e.scales.mins), max: t(e.scales.maxs) }
+    };
+  }
+  static calculatePlyRanges(e) {
+    const t = new h.Vector3(1 / 0, 1 / 0, 1 / 0), s = new h.Vector3(-1 / 0, -1 / 0, -1 / 0), r = new h.Vector3(1 / 0, 1 / 0, 1 / 0), n = new h.Vector3(-1 / 0, -1 / 0, -1 / 0), o = new h.Vector3(1 / 0, 1 / 0, 1 / 0), i = new h.Vector3(-1 / 0, -1 / 0, -1 / 0);
+    let u = 0;
+    for (let x = 0; x < e.numSplats; x++) {
+      const c = x * 3, l = e.positions[c + 0], p = e.positions[c + 1], y = e.positions[c + 2];
+      t.x = Math.min(t.x, l), s.x = Math.max(s.x, l), t.y = Math.min(t.y, p), s.y = Math.max(s.y, p), t.z = Math.min(t.z, y), s.z = Math.max(s.z, y), r.x = Math.min(r.x, e.scales[c]), n.x = Math.max(n.x, e.scales[c]), r.y = Math.min(r.y, e.scales[c + 1]), n.y = Math.max(n.y, e.scales[c + 1]), r.z = Math.min(r.z, e.scales[c + 2]), n.z = Math.max(n.z, e.scales[c + 2]), u = Math.max(
+        u,
+        e.colors[c],
+        e.colors[c + 1],
+        e.colors[c + 2]
+      );
+    }
+    const m = u > 1.5 ? 1 / 255 : 1;
+    for (let x = 0; x < e.numSplats; x++) {
+      const c = x * 3, l = this.clamp01(e.colors[c + 0] * m), p = this.clamp01(e.colors[c + 1] * m), y = this.clamp01(e.colors[c + 2] * m), M = (l - 0.5) / me, v = (p - 0.5) / me, S = (y - 0.5) / me;
+      o.x = Math.min(o.x, M), i.x = Math.max(i.x, M), o.y = Math.min(o.y, v), i.y = Math.max(i.y, v), o.z = Math.min(o.z, S), i.z = Math.max(i.z, S);
+    }
+    return {
+      colorScale: m,
+      ranges: {
+        sh0: { min: o, max: i },
+        means: { min: t, max: s },
+        scales: { min: r, max: n }
+      }
+    };
+  }
+  static clamp01(e) {
+    return Math.max(0, Math.min(1, e));
+  }
+  // prettier-ignore
+  // private static lerp(a: number, b: number, t: number) { return a + (b - a) * t; } // prettier-ignore
+  // private static invSogsMap(v: number) { return Math.sign(v) * Math.log(Math.abs(v) + 1) } // prettier-ignore
+  static norm(e, t, s) {
+    return (e - t) / (s - t || 1);
+  }
+  // prettier-ignore
+  static sogsDecode(e, t, s) {
+    const r = t + (s - t) * e;
+    return Math.sign(r) * (Math.exp(Math.abs(r)) - 1);
+  }
+}
+class dt extends h.Loader {
+  constructor(t) {
+    super(t);
+    w(this, "requestId", 0);
+    w(this, "worker");
+    w(this, "pendingCallbacks", /* @__PURE__ */ new Map());
     this.withCredentials = !0;
-    const e = this.createWorkerCode(), r = new Blob([e], { type: "application/javascript" });
+    const s = this.createWorkerCode(), r = new Blob([s], { type: "application/javascript" });
     this.worker = new Worker(URL.createObjectURL(r)), this.worker.onmessage = this.onWorkerMessage.bind(this);
   }
   /**
    * Handles messages received from the parsing worker
    * @param event The message event from the worker
    */
-  onWorkerMessage(o) {
-    const { requestId: e, error: r, result: s } = o.data, n = this.pendingCallbacks.get(e);
-    if (!n) return console.warn(`PlyLoader: Received response for unknown request ${e}`);
-    if (this.pendingCallbacks.delete(e), r) return n.reject(new Error(r));
-    if (!s) return n.reject(new Error("Worker returned no result"));
+  onWorkerMessage(t) {
+    const { requestId: s, error: r, result: n } = t.data, o = this.pendingCallbacks.get(s);
+    if (!o) return console.warn(`PlyLoader: Received response for unknown request ${s}`);
+    if (this.pendingCallbacks.delete(s), r) return o.reject(new Error(r));
+    if (!n) return o.reject(new Error("Worker returned no result"));
     try {
-      const a = new mt(0);
-      a.numSplats = s.numSplats, a.positions = new Float32Array(s.positions), a.rotations = new Float32Array(s.rotations), a.scales = new Float32Array(s.scales), a.colors = new Float32Array(s.colors), a.opacities = new Float32Array(s.opacities), a.boundingBox.min.set(
-        s.boundingBox.minX,
-        s.boundingBox.minY,
-        s.boundingBox.minZ
-      ), a.boundingBox.max.set(
-        s.boundingBox.maxX,
-        s.boundingBox.maxY,
-        s.boundingBox.maxZ
-      ), this.worker.terminate(), n.resolve(a);
-    } catch (a) {
-      n.reject(a);
+      const i = new Oe(0);
+      i.numSplats = n.numSplats, i.positions = new Float32Array(n.positions), i.rotations = new Float32Array(n.rotations), i.scales = new Float32Array(n.scales), i.colors = new Float32Array(n.colors), i.opacities = new Float32Array(n.opacities), i.boundingBox.min.set(
+        n.boundingBox.minX,
+        n.boundingBox.minY,
+        n.boundingBox.minZ
+      ), i.boundingBox.max.set(
+        n.boundingBox.maxX,
+        n.boundingBox.maxY,
+        n.boundingBox.maxZ
+      ), this.worker.terminate();
+      const u = Se.packPly(i);
+      i.dispose(), o.resolve(u);
+    } catch (i) {
+      o.reject(i);
     }
   }
   /**
@@ -1127,19 +1210,19 @@ class At extends i.Loader {
    * @param onProgress Optional progress callback
    * @param onError Optional error callback
    */
-  load(o, e, r, s) {
-    const n = new i.FileLoader(this.manager);
-    n.setResponseType("arraybuffer"), n.setRequestHeader(this.requestHeader), n.setPath(this.path), n.setWithCredentials(this.withCredentials), n.load(
-      o,
-      (a) => {
-        this.parseAsync(a).then((l) => {
-          e && e(l);
-        }).catch((l) => {
-          s ? s(l) : console.error(l), this.manager.itemError(o);
+  load(t, s, r, n) {
+    const o = new h.FileLoader(this.manager);
+    o.setResponseType("arraybuffer"), o.setRequestHeader(this.requestHeader), o.setPath(this.path), o.setWithCredentials(this.withCredentials), o.load(
+      t,
+      (i) => {
+        this.parseAsync(i).then((u) => {
+          s && s(u);
+        }).catch((u) => {
+          n ? n(u) : console.error(u), this.manager.itemError(t);
         });
       },
       r,
-      s
+      n
     );
   }
   /**
@@ -1148,19 +1231,19 @@ class At extends i.Loader {
    * @param onProgress Optional progress callback
    * @returns A Promise that resolves with the parsed SplatData
    */
-  loadAsync(o, e) {
-    return new Promise((r, s) => {
-      const n = new i.FileLoader(this.manager);
-      n.setResponseType("arraybuffer"), n.setRequestHeader(this.requestHeader), n.setPath(this.path), n.setWithCredentials(this.withCredentials), n.load(
-        o,
-        (a) => {
-          this.parseAsync(a).then(r).catch((l) => {
-            s(l), this.manager.itemError(o);
+  loadAsync(t, s) {
+    return new Promise((r, n) => {
+      const o = new h.FileLoader(this.manager);
+      o.setResponseType("arraybuffer"), o.setRequestHeader(this.requestHeader), o.setPath(this.path), o.setWithCredentials(this.withCredentials), o.load(
+        t,
+        (i) => {
+          this.parseAsync(i).then(r).catch((u) => {
+            n(u), this.manager.itemError(t);
           });
         },
-        e,
-        (a) => {
-          s(a), this.manager.itemError(o);
+        s,
+        (i) => {
+          n(i), this.manager.itemError(t);
         }
       );
     });
@@ -1170,15 +1253,15 @@ class At extends i.Loader {
    * @param buffer ArrayBuffer containing PLY data
    * @returns Promise that resolves with parsed SplatData
    */
-  parseAsync(o) {
-    return new Promise((e, r) => {
-      const s = this.requestId++;
-      this.pendingCallbacks.set(s, { resolve: e, reject: r });
-      const n = {
-        requestId: s,
-        buffer: o
+  parseAsync(t) {
+    return new Promise((s, r) => {
+      const n = this.requestId++;
+      this.pendingCallbacks.set(n, { resolve: s, reject: r });
+      const o = {
+        requestId: n,
+        buffer: t
       };
-      this.worker.postMessage(n, [o]);
+      this.worker.postMessage(o, [t]);
     });
   }
   /**
@@ -1194,209 +1277,745 @@ class At extends i.Loader {
   createWorkerCode() {
     return `(${(function() {
       self.onmessage = (r) => {
-        const { requestId: s, buffer: n } = r.data;
+        const { requestId: n, buffer: o } = r.data;
         try {
-          const a = e(n), l = {
-            requestId: s,
-            result: a
+          const i = s(o), u = {
+            requestId: n,
+            result: i
           };
-          self.postMessage(l, [
-            a.positions,
-            a.rotations,
-            a.scales,
-            a.colors,
-            a.opacities
+          self.postMessage(u, [
+            i.positions,
+            i.rotations,
+            i.scales,
+            i.colors,
+            i.opacities
           ]);
-        } catch (a) {
-          const l = {
-            requestId: s,
-            error: a instanceof Error ? a.message : String(a)
+        } catch (i) {
+          const u = {
+            requestId: n,
+            error: i instanceof Error ? i.message : String(i)
           };
-          self.postMessage(l);
+          self.postMessage(u);
         }
       };
-      function e(r) {
-        const s = new TextDecoder(), n = new Uint8Array(r), a = [112, 108, 121, 10], l = `
+      function s(r) {
+        const n = new TextDecoder(), o = new Uint8Array(r), i = [112, 108, 121, 10], u = `
 end_header
 `;
-        for (let p = 0; p < a.length; p++)
-          if (n[p] !== a[p])
+        for (let z = 0; z < i.length; z++)
+          if (o[z] !== i[z])
             throw new Error(
               "Invalid PLY file: Missing magic bytes"
             );
-        let x = 0;
-        for (let p = 0; p < n.length - l.length; p++) {
-          let c = !0;
-          for (let g = 0; g < l.length; g++)
-            if (n[p + g] !== l.charCodeAt(g)) {
-              c = !1;
+        let m = 0;
+        for (let z = 0; z < o.length - u.length; z++) {
+          let f = !0;
+          for (let E = 0; E < u.length; E++)
+            if (o[z + E] !== u.charCodeAt(E)) {
+              f = !1;
               break;
             }
-          if (c) {
-            x = p + l.length;
+          if (f) {
+            m = z + u.length;
             break;
           }
         }
-        if (x === 0)
+        if (m === 0)
           throw new Error(
             "Invalid PLY file: Could not find end of header"
           );
-        const C = s.decode(
-          n.subarray(0, x)
+        const c = n.decode(
+          o.subarray(0, m)
         ).split(`
-`), u = [];
-        let y = null;
-        for (let p = 1; p < C.length; p++) {
-          const c = C[p].trim();
-          if (c === "" || c === "end_header") continue;
-          const g = c.split(" ");
-          switch (g[0]) {
+`), l = [];
+        let p = null;
+        for (let z = 1; z < c.length; z++) {
+          const f = c[z].trim();
+          if (f === "" || f === "end_header") continue;
+          const E = f.split(" ");
+          switch (E[0]) {
             case "format":
-              y = g[1];
+              p = E[1];
               break;
             case "element":
-              u.push({
-                name: g[1],
-                count: parseInt(g[2], 10),
+              l.push({
+                name: E[1],
+                count: parseInt(E[2], 10),
                 properties: []
               });
               break;
             case "property":
-              if (u.length === 0)
+              if (l.length === 0)
                 throw new Error(
                   "Invalid PLY file: Property without element"
                 );
-              u[u.length - 1].properties.push({
-                type: g[1],
-                name: g[2]
+              l[l.length - 1].properties.push({
+                type: E[1],
+                name: E[2]
               });
               break;
           }
         }
-        if (y !== "binary_little_endian")
-          throw new Error(`Unsupported PLY format: ${y}`);
-        const v = u.find((p) => p.name === "vertex");
-        if (!v)
+        if (p !== "binary_little_endian")
+          throw new Error(`Unsupported PLY format: ${p}`);
+        const y = l.find((z) => z.name === "vertex");
+        if (!y)
           throw new Error(
             "Invalid PLY file: No vertex element found"
           );
-        const S = v.count, I = new Float32Array(S * 3), q = new Float32Array(S * 4), Y = new Float32Array(S * 3), W = new Float32Array(S * 3), ot = new Float32Array(S), L = new DataView(r);
-        let w = x;
-        const d = (p) => v.properties.findIndex(
-          (c) => c.name === p
-        ), P = d("x"), M = d("y"), f = d("z"), A = [
-          d("rot_0"),
-          d("rot_1"),
-          d("rot_2"),
-          d("rot_3")
+        const M = y.count, v = new Float32Array(M * 3), S = new Float32Array(M * 4), k = new Float32Array(M * 3), B = new Float32Array(M * 3), j = new Float32Array(M), R = new DataView(r);
+        let b = m;
+        const A = (z) => y.properties.findIndex(
+          (f) => f.name === z
+        ), C = A("x"), g = A("y"), d = A("z"), I = [
+          A("rot_0"),
+          A("rot_1"),
+          A("rot_2"),
+          A("rot_3")
+        ], q = [
+          A("scale_0"),
+          A("scale_1"),
+          A("scale_2")
         ], T = [
-          d("scale_0"),
-          d("scale_1"),
-          d("scale_2")
-        ], j = [
-          d("f_dc_0"),
-          d("f_dc_1"),
-          d("f_dc_2")
-        ], J = d("opacity");
+          A("f_dc_0"),
+          A("f_dc_1"),
+          A("f_dc_2")
+        ], W = A("opacity");
         if ([
-          P,
-          M,
-          f,
-          ...A,
+          C,
+          g,
+          d,
+          ...I,
+          ...q,
           ...T,
-          ...j,
-          J
-        ].some((p) => p === -1))
+          W
+        ].some((z) => z === -1))
           throw new Error(
             "Invalid PLY file: Missing required properties"
           );
-        const D = 0.28209479177387814, _ = (p) => {
-          if (p > 0) return 1 / (1 + Math.exp(-p));
-          const c = Math.exp(p);
-          return c / (1 + c);
+        const F = 0.28209479177387814, P = (z) => {
+          if (z > 0) return 1 / (1 + Math.exp(-z));
+          const f = Math.exp(z);
+          return f / (1 + f);
         };
-        let N = 1 / 0, nt = 1 / 0, R = 1 / 0, st = -1 / 0, tt = -1 / 0, et = -1 / 0;
-        for (let p = 0; p < S; p++) {
-          const c = [];
-          for (let it = 0; it < v.properties.length; it++) {
-            const lt = v.properties[it].type;
-            let G;
-            switch (lt) {
+        let J = 1 / 0, G = 1 / 0, L = 1 / 0, X = -1 / 0, $ = -1 / 0, H = -1 / 0;
+        for (let z = 0; z < M; z++) {
+          const f = [];
+          for (let we = 0; we < y.properties.length; we++) {
+            const Ce = y.properties[we].type;
+            let ce;
+            switch (Ce) {
               case "char":
-                G = L.getInt8(w), w += 1;
+                ce = R.getInt8(b), b += 1;
                 break;
               case "uchar":
-                G = L.getUint8(w), w += 1;
+                ce = R.getUint8(b), b += 1;
                 break;
               case "short":
-                G = L.getInt16(w, !0), w += 2;
+                ce = R.getInt16(b, !0), b += 2;
                 break;
               case "ushort":
-                G = L.getUint16(w, !0), w += 2;
+                ce = R.getUint16(b, !0), b += 2;
                 break;
               case "int":
-                G = L.getInt32(w, !0), w += 4;
+                ce = R.getInt32(b, !0), b += 4;
                 break;
               case "uint":
-                G = L.getUint32(w, !0), w += 4;
+                ce = R.getUint32(b, !0), b += 4;
                 break;
               case "float":
-                G = L.getFloat32(w, !0), w += 4;
+                ce = R.getFloat32(b, !0), b += 4;
                 break;
               case "double":
-                G = L.getFloat64(w, !0), w += 8;
+                ce = R.getFloat64(b, !0), b += 8;
                 break;
               default:
                 throw new Error(
-                  `Unsupported property type: ${lt}`
+                  `Unsupported property type: ${Ce}`
                 );
             }
-            c.push(G);
+            f.push(ce);
           }
-          const g = c[P], B = c[M], m = c[f], z = p * 3;
-          I[z] = g, I[z + 1] = B, I[z + 2] = m, N = Math.min(N, g), nt = Math.min(nt, B), R = Math.min(R, m), st = Math.max(st, g), tt = Math.max(tt, B), et = Math.max(et, m);
-          let E = c[A[1]], U = c[A[2]], O = c[A[3]], F = c[A[0]];
-          const V = Math.sqrt(
-            E * E + U * U + O * O + F * F
+          const E = f[C], V = f[g], D = f[d], O = z * 3;
+          v[O] = E, v[O + 1] = V, v[O + 2] = D, J = Math.min(J, E), G = Math.min(G, V), L = Math.min(L, D), X = Math.max(X, E), $ = Math.max($, V), H = Math.max(H, D);
+          let Y = f[I[1]], Z = f[I[2]], Q = f[I[3]], N = f[I[0]];
+          const K = Math.sqrt(
+            Y * Y + Z * Z + Q * Q + N * N
           );
-          V > 0 && (E /= V, U /= V, O /= V, F /= V), F < 0 && (E = -E, U = -U, O = -O, F = -F);
-          const X = p * 4;
-          q[X] = E, q[X + 1] = U, q[X + 2] = O, q[X + 3] = F;
-          const Z = p * 3;
-          Y[Z] = c[T[0]], Y[Z + 1] = c[T[1]], Y[Z + 2] = c[T[2]];
-          let K = 0.5 + c[j[0]] * D, Q = 0.5 + c[j[1]] * D, H = 0.5 + c[j[2]] * D;
-          K = Math.max(0, Math.min(1, K)), Q = Math.max(0, Math.min(1, Q)), H = Math.max(0, Math.min(1, H));
-          const at = p * 3;
-          W[at] = K, W[at + 1] = Q, W[at + 2] = H, ot[p] = _(c[J]);
+          K > 0 && (Y /= K, Z /= K, Q /= K, N /= K), N < 0 && (Y = -Y, Z = -Z, Q = -Q, N = -N);
+          const se = z * 4;
+          S[se] = Y, S[se + 1] = Z, S[se + 2] = Q, S[se + 3] = N;
+          const re = z * 3;
+          k[re] = f[q[0]], k[re + 1] = f[q[1]], k[re + 2] = f[q[2]];
+          let he = 0.5 + f[T[0]] * F, ue = 0.5 + f[T[1]] * F, oe = 0.5 + f[T[2]] * F;
+          he = Math.max(0, Math.min(1, he)), ue = Math.max(0, Math.min(1, ue)), oe = Math.max(0, Math.min(1, oe));
+          const ge = z * 3;
+          B[ge] = he, B[ge + 1] = ue, B[ge + 2] = oe, j[z] = P(f[W]);
         }
         return {
-          numSplats: S,
-          positions: I.buffer,
-          rotations: q.buffer,
-          scales: Y.buffer,
-          colors: W.buffer,
-          opacities: ot.buffer,
+          numSplats: M,
+          positions: v.buffer,
+          rotations: S.buffer,
+          scales: k.buffer,
+          colors: B.buffer,
+          opacities: j.buffer,
           boundingBox: {
-            minX: N,
-            minY: nt,
-            minZ: R,
-            maxX: st,
-            maxY: tt,
-            maxZ: et
+            minX: J,
+            minY: G,
+            minZ: L,
+            maxX: X,
+            maxY: $,
+            maxZ: H
           }
         };
       }
     }).toString()})();`;
   }
 }
-const zt = "0.3.0";
+var ee = Uint8Array, de = Uint16Array, He = Int32Array, Fe = new ee([
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  3,
+  4,
+  4,
+  4,
+  4,
+  5,
+  5,
+  5,
+  5,
+  0,
+  /* unused */
+  0,
+  0,
+  /* impossible */
+  0
+]), qe = new ee([
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  2,
+  2,
+  3,
+  3,
+  4,
+  4,
+  5,
+  5,
+  6,
+  6,
+  7,
+  7,
+  8,
+  8,
+  9,
+  9,
+  10,
+  10,
+  11,
+  11,
+  12,
+  12,
+  13,
+  13,
+  /* unused */
+  0,
+  0
+]), Ye = new ee([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]), Pe = function(a, e) {
+  for (var t = new de(31), s = 0; s < 31; ++s)
+    t[s] = e += 1 << a[s - 1];
+  for (var r = new He(t[30]), s = 1; s < 30; ++s)
+    for (var n = t[s]; n < t[s + 1]; ++n)
+      r[n] = n - t[s] << 5 | s;
+  return { b: t, r };
+}, Re = Pe(Fe, 2), Te = Re.b, $e = Re.r;
+Te[28] = 258, $e[258] = 28;
+var Ze = Pe(qe, 0), Xe = Ze.b, Ae = new de(32768);
+for (var _ = 0; _ < 32768; ++_) {
+  var le = (_ & 43690) >> 1 | (_ & 21845) << 1;
+  le = (le & 52428) >> 2 | (le & 13107) << 2, le = (le & 61680) >> 4 | (le & 3855) << 4, Ae[_] = ((le & 65280) >> 8 | (le & 255) << 8) >> 1;
+}
+var pe = function(a, e, t) {
+  for (var s = a.length, r = 0, n = new de(e); r < s; ++r)
+    a[r] && ++n[a[r] - 1];
+  var o = new de(e);
+  for (r = 1; r < e; ++r)
+    o[r] = o[r - 1] + n[r - 1] << 1;
+  var i;
+  if (t) {
+    i = new de(1 << e);
+    var u = 15 - e;
+    for (r = 0; r < s; ++r)
+      if (a[r])
+        for (var m = r << 4 | a[r], x = e - a[r], c = o[a[r] - 1]++ << x, l = c | (1 << x) - 1; c <= l; ++c)
+          i[Ae[c] >> u] = m;
+  } else
+    for (i = new de(s), r = 0; r < s; ++r)
+      a[r] && (i[r] = Ae[o[a[r] - 1]++] >> 15 - a[r]);
+  return i;
+}, xe = new ee(288);
+for (var _ = 0; _ < 144; ++_)
+  xe[_] = 8;
+for (var _ = 144; _ < 256; ++_)
+  xe[_] = 9;
+for (var _ = 256; _ < 280; ++_)
+  xe[_] = 7;
+for (var _ = 280; _ < 288; ++_)
+  xe[_] = 8;
+var Ue = new ee(32);
+for (var _ = 0; _ < 32; ++_)
+  Ue[_] = 5;
+var Qe = /* @__PURE__ */ pe(xe, 9, 1), Je = /* @__PURE__ */ pe(Ue, 5, 1), ve = function(a) {
+  for (var e = a[0], t = 1; t < a.length; ++t)
+    a[t] > e && (e = a[t]);
+  return e;
+}, ne = function(a, e, t) {
+  var s = e / 8 | 0;
+  return (a[s] | a[s + 1] << 8) >> (e & 7) & t;
+}, Me = function(a, e) {
+  var t = e / 8 | 0;
+  return (a[t] | a[t + 1] << 8 | a[t + 2] << 16) >> (e & 7);
+}, Ke = function(a) {
+  return (a + 7) / 8 | 0;
+}, ke = function(a, e, t) {
+  return (e == null || e < 0) && (e = 0), (t == null || t > a.length) && (t = a.length), new ee(a.subarray(e, t));
+}, et = [
+  "unexpected EOF",
+  "invalid block type",
+  "invalid length/literal",
+  "invalid distance",
+  "stream finished",
+  "no stream handler",
+  ,
+  "no callback",
+  "invalid UTF-8 data",
+  "extra field too long",
+  "date not in range 1980-2099",
+  "filename too long",
+  "stream finishing",
+  "invalid zip data"
+  // determined by unknown compression method
+], te = function(a, e, t) {
+  var s = new Error(e || et[a]);
+  if (s.code = a, Error.captureStackTrace && Error.captureStackTrace(s, te), !t)
+    throw s;
+  return s;
+}, tt = function(a, e, t, s) {
+  var r = a.length, n = s ? s.length : 0;
+  if (!r || e.f && !e.l)
+    return t || new ee(0);
+  var o = !t, i = o || e.i != 2, u = e.i;
+  o && (t = new ee(r * 3));
+  var m = function(Z) {
+    var Q = t.length;
+    if (Z > Q) {
+      var N = new ee(Math.max(Q * 2, Z));
+      N.set(t), t = N;
+    }
+  }, x = e.f || 0, c = e.p || 0, l = e.b || 0, p = e.l, y = e.d, M = e.m, v = e.n, S = r * 8;
+  do {
+    if (!p) {
+      x = ne(a, c, 1);
+      var k = ne(a, c + 1, 3);
+      if (c += 3, k)
+        if (k == 1)
+          p = Qe, y = Je, M = 9, v = 5;
+        else if (k == 2) {
+          var b = ne(a, c, 31) + 257, A = ne(a, c + 10, 15) + 4, C = b + ne(a, c + 5, 31) + 1;
+          c += 14;
+          for (var g = new ee(C), d = new ee(19), I = 0; I < A; ++I)
+            d[Ye[I]] = ne(a, c + I * 3, 7);
+          c += A * 3;
+          for (var q = ve(d), T = (1 << q) - 1, W = pe(d, q, 1), I = 0; I < C; ) {
+            var U = W[ne(a, c, T)];
+            c += U & 15;
+            var B = U >> 4;
+            if (B < 16)
+              g[I++] = B;
+            else {
+              var F = 0, P = 0;
+              for (B == 16 ? (P = 3 + ne(a, c, 3), c += 2, F = g[I - 1]) : B == 17 ? (P = 3 + ne(a, c, 7), c += 3) : B == 18 && (P = 11 + ne(a, c, 127), c += 7); P--; )
+                g[I++] = F;
+            }
+          }
+          var J = g.subarray(0, b), G = g.subarray(b);
+          M = ve(J), v = ve(G), p = pe(J, M, 1), y = pe(G, v, 1);
+        } else
+          te(1);
+      else {
+        var B = Ke(c) + 4, j = a[B - 4] | a[B - 3] << 8, R = B + j;
+        if (R > r) {
+          u && te(0);
+          break;
+        }
+        i && m(l + j), t.set(a.subarray(B, R), l), e.b = l += j, e.p = c = R * 8, e.f = x;
+        continue;
+      }
+      if (c > S) {
+        u && te(0);
+        break;
+      }
+    }
+    i && m(l + 131072);
+    for (var L = (1 << M) - 1, X = (1 << v) - 1, $ = c; ; $ = c) {
+      var F = p[Me(a, c) & L], H = F >> 4;
+      if (c += F & 15, c > S) {
+        u && te(0);
+        break;
+      }
+      if (F || te(2), H < 256)
+        t[l++] = H;
+      else if (H == 256) {
+        $ = c, p = null;
+        break;
+      } else {
+        var z = H - 254;
+        if (H > 264) {
+          var I = H - 257, f = Fe[I];
+          z = ne(a, c, (1 << f) - 1) + Te[I], c += f;
+        }
+        var E = y[Me(a, c) & X], V = E >> 4;
+        E || te(3), c += E & 15;
+        var G = Xe[V];
+        if (V > 3) {
+          var f = qe[V];
+          G += Me(a, c) & (1 << f) - 1, c += f;
+        }
+        if (c > S) {
+          u && te(0);
+          break;
+        }
+        i && m(l + 131072);
+        var D = l + z;
+        if (l < G) {
+          var O = n - G, Y = Math.min(G, D);
+          for (O + l < 0 && te(3); l < Y; ++l)
+            t[l] = s[O + l];
+        }
+        for (; l < D; ++l)
+          t[l] = t[l - G];
+      }
+    }
+    e.l = p, e.p = $, e.b = l, e.f = x, p && (x = 1, e.m = M, e.d = y, e.n = v);
+  } while (!x);
+  return l != t.length && o ? ke(t, 0, l) : t.subarray(0, l);
+}, st = /* @__PURE__ */ new ee(0), ie = function(a, e) {
+  return a[e] | a[e + 1] << 8;
+}, ae = function(a, e) {
+  return (a[e] | a[e + 1] << 8 | a[e + 2] << 16 | a[e + 3] << 24) >>> 0;
+}, be = function(a, e) {
+  return ae(a, e) + ae(a, e + 4) * 4294967296;
+};
+function rt(a, e) {
+  return tt(a, { i: 2 }, e && e.out, e && e.dictionary);
+}
+var Ie = typeof TextDecoder < "u" && /* @__PURE__ */ new TextDecoder(), nt = 0;
+try {
+  Ie.decode(st, { stream: !0 }), nt = 1;
+} catch {
+}
+var at = function(a) {
+  for (var e = "", t = 0; ; ) {
+    var s = a[t++], r = (s > 127) + (s > 223) + (s > 239);
+    if (t + r > a.length)
+      return { s: e, r: ke(a, t - 1) };
+    r ? r == 3 ? (s = ((s & 15) << 18 | (a[t++] & 63) << 12 | (a[t++] & 63) << 6 | a[t++] & 63) - 65536, e += String.fromCharCode(55296 | s >> 10, 56320 | s & 1023)) : r & 1 ? e += String.fromCharCode((s & 31) << 6 | a[t++] & 63) : e += String.fromCharCode((s & 15) << 12 | (a[t++] & 63) << 6 | a[t++] & 63) : e += String.fromCharCode(s);
+  }
+};
+function ot(a, e) {
+  if (e) {
+    for (var t = "", s = 0; s < a.length; s += 16384)
+      t += String.fromCharCode.apply(null, a.subarray(s, s + 16384));
+    return t;
+  } else {
+    if (Ie)
+      return Ie.decode(a);
+    var r = at(a), n = r.s, t = r.r;
+    return t.length && te(8), n;
+  }
+}
+var it = function(a, e) {
+  return e + 30 + ie(a, e + 26) + ie(a, e + 28);
+}, ct = function(a, e, t) {
+  var s = ie(a, e + 28), r = ot(a.subarray(e + 46, e + 46 + s), !(ie(a, e + 8) & 2048)), n = e + 46 + s, o = ae(a, e + 20), i = t && o == 4294967295 ? lt(a, n) : [o, ae(a, e + 24), ae(a, e + 42)], u = i[0], m = i[1], x = i[2];
+  return [ie(a, e + 10), u, m, r, n + ie(a, e + 30) + ie(a, e + 32), x];
+}, lt = function(a, e) {
+  for (; ie(a, e) != 1; e += 4 + ie(a, e + 2))
+    ;
+  return [be(a, e + 12), be(a, e + 4), be(a, e + 20)];
+};
+function ht(a, e) {
+  for (var t = {}, s = a.length - 22; ae(a, s) != 101010256; --s)
+    (!s || a.length - s > 65558) && te(13);
+  var r = ie(a, s + 8);
+  if (!r)
+    return {};
+  var n = ae(a, s + 16), o = n == 4294967295 || r == 65535;
+  if (o) {
+    var i = ae(a, s - 12);
+    o = ae(a, i) == 101075792, o && (r = ae(a, i + 32), n = ae(a, i + 48));
+  }
+  for (var u = 0; u < r; ++u) {
+    var m = ct(a, n, o), x = m[0], c = m[1], l = m[2], p = m[3], y = m[4], M = m[5], v = it(a, M);
+    n = y, x ? x == 8 ? t[p] = rt(a.subarray(v, v + c), { out: new ee(l) }) : te(14, "unknown compression type " + x) : t[p] = ke(a, v, v + c);
+  }
+  return t;
+}
+const Ee = (a) => {
+  if (typeof a != "object" || a === null) throw new Error("Invalid SOGS metadata: not an object");
+  const e = a, t = e.version ?? 1;
+  if (t !== 1) throw new Error(`Unsupported SOGS version: ${String(t)}`);
+  const s = (M) => {
+    const v = e[M];
+    if (typeof v != "object" || v === null) throw new Error(`Invalid SOGS metadata section: ${M}`);
+    return v;
+  }, r = s("means"), n = s("sh0"), o = s("quats"), i = s("scales"), u = typeof e.count == "number" && Number.isFinite(e.count) ? e.count : void 0, m = Array.isArray(r.shape) ? r.shape : void 0, x = m && typeof m[0] == "number" ? m[0] : void 0;
+  if (u === void 0 && x === void 0)
+    throw new Error(
+      "Invalid SOGS metadata: unable to determine splat count"
+    );
+  if (u !== void 0 && x !== void 0 && u !== x)
+    throw new Error(
+      "Inconsistent SOGS metadata: count does not match means.shape[0]"
+    );
+  const c = u ?? x, l = (M, v) => {
+    const S = M.mins, k = M.maxs;
+    if (!Array.isArray(S) || S.length !== 3)
+      throw new Error(`${v}.mins must be length-3`);
+    if (!Array.isArray(k) || k.length !== 3)
+      throw new Error(`${v}.maxs must be length-3`);
+    if (![...S, ...k].every(
+      (B) => typeof B == "number" && Number.isFinite(B)
+    ))
+      throw new Error(`${v}.mins/maxs must be finite numbers`);
+    return {
+      mins: [S[0], S[1], S[2]],
+      maxs: [k[0], k[1], k[2]]
+    };
+  }, p = (M, v) => {
+    const S = M.mins, k = M.maxs;
+    if (!Array.isArray(S) || S.length !== 4)
+      throw new Error(`${v}.mins must be length-4`);
+    if (!Array.isArray(k) || k.length !== 4)
+      throw new Error(`${v}.maxs must be length-4`);
+    if (![...S, ...k].every(
+      (B) => typeof B == "number" && Number.isFinite(B)
+    ))
+      throw new Error(`${v}.mins/maxs must be finite numbers`);
+    return {
+      mins: [S[0], S[1], S[2], S[3]],
+      maxs: [k[0], k[1], k[2], k[3]]
+    };
+  }, y = (M, v) => {
+    const S = M.files;
+    if (!Array.isArray(S)) throw new Error(`${v}.files is not an array`);
+    if (!S.every((k) => typeof k == "string")) throw new Error(`${v}.files contains non-strings`);
+    return S;
+  };
+  return {
+    numSplats: c,
+    files: {
+      sh0: y(n, "sh0"),
+      means: y(r, "means"),
+      quats: y(o, "quats"),
+      scales: y(i, "scales")
+    },
+    ranges: {
+      sh0: p(n, "sh0"),
+      means: l(r, "means"),
+      scales: l(i, "scales")
+    }
+  };
+};
+class ft extends h.Loader {
+  constructor(e) {
+    super(e), this.withCredentials = !0;
+  }
+  /**
+   * Detect if a buffer is a ZIP file by checking magic bytes
+   * ZIP files start with signature: PK\x03\x04 (0x50 0x4B 0x03 0x04)
+   */
+  isZipBuffer(e) {
+    if (e.byteLength < 4) return !1;
+    const t = new Uint8Array(e, 0, 4);
+    return t[0] === 80 && t[1] === 75 && t[2] === 3 && t[3] === 4;
+  }
+  /**
+   * Load a SOGS file (meta.json + textures)
+   * @param url URL of the meta.json file
+   * @param onLoad Optional callback when loading is complete
+   * @param onProgress Optional progress callback
+   * @param onError Optional error callback
+   */
+  load(e, t, s, r) {
+    const n = new h.FileLoader(this.manager);
+    n.setResponseType("arraybuffer"), n.setRequestHeader(this.requestHeader), n.setPath(this.path), n.setWithCredentials(this.withCredentials), n.load(
+      e,
+      (o) => {
+        this.parseAsync(e, o).then((i) => {
+          t && t(i);
+        }).catch((i) => {
+          this.manager.itemError(e), r && r(i), console.error("Error loading SOGS meta:", i);
+        });
+      },
+      s,
+      r
+    );
+  }
+  /**
+   * Load a SOGS file asynchronously and return a Promise
+   * @param url URL of the meta.json file
+   * @param onProgress Optional progress callback
+   * @returns A Promise that resolves with the parsed SplatData
+   */
+  loadAsync(e, t) {
+    return new Promise((s, r) => {
+      const n = new h.FileLoader(this.manager);
+      n.setResponseType("arraybuffer"), n.setRequestHeader(this.requestHeader), n.setPath(this.path), n.setWithCredentials(this.withCredentials), n.load(
+        e,
+        (o) => {
+          this.parseAsync(e, o).then(s).catch((i) => {
+            r(i), this.manager.itemError(e);
+          });
+        },
+        t,
+        (o) => {
+          r(o), this.manager.itemError(e);
+        }
+      );
+    });
+  }
+  async parseAsync(e, t) {
+    if (!(t instanceof ArrayBuffer)) throw new Error("SOGS loader: expected ArrayBuffer payload");
+    if (this.isZipBuffer(t)) return this.parseZipAsync(t);
+    const r = new TextDecoder("utf-8").decode(t), n = JSON.parse(r);
+    return this.parseMetaAsync(e, n);
+  }
+  async parseMetaAsync(e, t) {
+    const { numSplats: s, files: r, ranges: n } = Ee(t), o = new h.TextureLoader(this.manager);
+    o.setPath(this.path), o.setRequestHeader(this.requestHeader), o.setWithCredentials(this.withCredentials);
+    const i = (S, k) => {
+      try {
+        return new URL(k, S).toString();
+      } catch {
+        return S.substring(0, S.lastIndexOf("/") + 1) + k;
+      }
+    }, u = (S, k) => {
+      const B = i(e, S);
+      return new Promise((j, R) => {
+        o.load(
+          B,
+          (b) => {
+            b.generateMipmaps = !1, b.magFilter = h.NearestFilter, b.minFilter = h.NearestFilter, b.flipY = !1, j(b);
+          },
+          void 0,
+          (b) => {
+            const A = b instanceof Error ? b.message : String(b);
+            R(
+              new Error(
+                `SOGS loader: failed to load ${k} (${S}): ${A}`
+              )
+            );
+          }
+        );
+      });
+    };
+    if (!Array.isArray(r.sh0) || r.sh0.length < 1) throw new Error("SOGS loader: files.sh0 must have at least 1 entry (sh0)");
+    if (!Array.isArray(r.means) || r.means.length < 2) throw new Error("SOGS loader: files.means must have at least 2 entries (means_l, means_u)");
+    if (!Array.isArray(r.quats) || r.quats.length < 1) throw new Error("SOGS loader: files.quats must have at least 1 entry");
+    if (!Array.isArray(r.scales) || r.scales.length < 1) throw new Error("SOGS loader: files.scales must have at least 1 entry");
+    const [m, x, c, l, p] = await Promise.all([
+      u(r.means[0], "means_l"),
+      u(r.means[1], "means_u"),
+      u(r.quats[0], "quats"),
+      u(r.scales[0], "scales"),
+      u(r.sh0[0], "sh0")
+    ]), y = { means_l: m, means_u: x, quats: c, scales: l, sh0: p }, M = new ze(s, n, y), v = Se.packSogs(M);
+    return M.dispose(), v;
+  }
+  async parseZipAsync(e) {
+    const t = ht(new Uint8Array(e)), s = Object.keys(t), r = s.find((C) => C.toLowerCase().endsWith("meta.json")) ?? null;
+    if (!r) throw new Error("SOGS loader: zip missing meta.json");
+    const n = r.includes("/") ? r.slice(0, r.lastIndexOf("/") + 1) : "", o = new TextDecoder(), i = JSON.parse(o.decode(t[r])), { numSplats: u, files: m, ranges: x } = Ee(i), c = (C) => C.replace(/\\/g, "/").replace(/^\.?\//, ""), l = (C) => {
+      const g = c(C), d = [c(n + g), g];
+      for (const T of d) {
+        const W = t[T];
+        if (W) return W;
+      }
+      const I = g.split("/").pop(), q = s.find((T) => c(T).endsWith("/" + g)) ?? s.find((T) => c(T).endsWith("/" + I)) ?? s.find((T) => c(T) === I) ?? null;
+      if (q) return t[q];
+      throw new Error(`SOGS loader: zip missing file "${C}"`);
+    }, p = (C) => {
+      const g = C.toLowerCase();
+      return g.endsWith(".png") ? "image/png" : g.endsWith(".jpg") || g.endsWith(".jpeg") ? "image/jpeg" : g.endsWith(".webp") ? "image/webp" : "application/octet-stream";
+    }, y = new h.TextureLoader(this.manager);
+    y.setRequestHeader(this.requestHeader), y.setWithCredentials(this.withCredentials);
+    const M = (C, g) => {
+      const d = l(C), I = new Blob([d], {
+        type: p(C)
+      }), q = URL.createObjectURL(I);
+      return new Promise((T, W) => {
+        y.load(
+          q,
+          (U) => {
+            URL.revokeObjectURL(q), U.generateMipmaps = !1, U.magFilter = h.NearestFilter, U.minFilter = h.NearestFilter, U.flipY = !1, T(U);
+          },
+          void 0,
+          (U) => {
+            URL.revokeObjectURL(q);
+            const F = U instanceof Error ? U.message : String(U);
+            W(
+              new Error(
+                `SOGS loader: failed to load ${g} from zip (${C}): ${F}`
+              )
+            );
+          }
+        );
+      });
+    };
+    if (!Array.isArray(m.sh0) || m.sh0.length < 1) throw new Error("SOGS loader: files.sh0 must have at least 1 entry (sh0)");
+    if (!Array.isArray(m.means) || m.means.length < 2) throw new Error("SOGS loader: files.means must have at least 2 entries (means_l, means_u)");
+    if (!Array.isArray(m.quats) || m.quats.length < 1) throw new Error("SOGS loader: files.quats must have at least 1 entry");
+    if (!Array.isArray(m.scales) || m.scales.length < 1) throw new Error("SOGS loader: files.scales must have at least 1 entry");
+    const [v, S, k, B, j] = await Promise.all([
+      M(m.means[0], "means_l"),
+      M(m.means[1], "means_u"),
+      M(m.quats[0], "quats"),
+      M(m.scales[0], "scales"),
+      M(m.sh0[0], "sh0")
+    ]), R = { means_l: v, means_u: S, quats: k, scales: B, sh0: j }, b = new ze(u, x, R), A = Se.packSogs(b);
+    return b.dispose(), A;
+  }
+}
+const pt = "0.3.0";
 export {
-  ct as BoundingBox,
-  At as PlyLoader,
-  mt as SplatData,
-  Ct as SplatMaterial,
-  dt as SplatMesh,
-  xt as SplatSorter,
-  wt as TextureManager,
-  zt as VERSION
+  ye as BoundingBox,
+  dt as PlyLoader,
+  ft as SogsLoader,
+  Be as SplatData,
+  je as SplatMaterial,
+  De as SplatMesh,
+  Le as SplatSorter,
+  Ge as TextureManager,
+  pt as VERSION
 };