@speridlabs/visus 0.1.0 → 0.2.0

package/dist/react.es.js

@@ -1,7 +1,10 @@
-import te, { useRef as ne, useMemo as oe, useEffect as ae } from "react";
-import { extend as se, useLoader as ue } from "@react-three/fiber";
-import { b as L, P as le } from "./ply-CQ9dyX1o.mjs";
-var _ = { exports: {} }, R = {};
+var me = Object.defineProperty;
+var xe = (z, e, s) => e in z ? me(z, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : z[e] = s;
+var v = (z, e, s) => xe(z, typeof e != "symbol" ? e + "" : e, s);
+import ye, { useRef as ge, useMemo as ve, useEffect as we } from "react";
+import { extend as be, useLoader as Me } from "@react-three/fiber";
+import * as i from "three";
+var se = { exports: {} }, te = {};
 /**
  * @license React
  * react-jsx-runtime.production.js
@@ -11,29 +14,29 @@ var _ = { exports: {} }, R = {};
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var F;
-function ce() {
-  if (F) return R;
-  F = 1;
-  var c = Symbol.for("react.transitional.element"), d = Symbol.for("react.fragment");
-  function m(i, a, s) {
-    var u = null;
-    if (s !== void 0 && (u = "" + s), a.key !== void 0 && (u = "" + a.key), "key" in a) {
-      s = {};
-      for (var p in a)
-        p !== "key" && (s[p] = a[p]);
-    } else s = a;
-    return a = s.ref, {
-      $$typeof: c,
-      type: i,
-      key: u,
-      ref: a !== void 0 ? a : null,
-      props: s
+var ue;
+function Se() {
+  if (ue) return te;
+  ue = 1;
+  var z = Symbol.for("react.transitional.element"), e = Symbol.for("react.fragment");
+  function s(o, n, t) {
+    var a = null;
+    if (t !== void 0 && (a = "" + t), n.key !== void 0 && (a = "" + n.key), "key" in n) {
+      t = {};
+      for (var c in n)
+        c !== "key" && (t[c] = n[c]);
+    } else t = n;
+    return n = t.ref, {
+      $$typeof: z,
+      type: o,
+      key: a,
+      ref: n !== void 0 ? n : null,
+      props: t
     };
   }
-  return R.Fragment = d, R.jsx = m, R.jsxs = m, R;
+  return te.Fragment = e, te.jsx = s, te.jsxs = s, te;
 }
-var b = {};
+var re = {};
 /**
  * @license React
  * react-jsx-runtime.development.js
@@ -43,266 +46,1551 @@ var b = {};
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var I;
-function ie() {
-  return I || (I = 1, process.env.NODE_ENV !== "production" && function() {
-    function c(e) {
-      if (e == null) return null;
-      if (typeof e == "function")
-        return e.$$typeof === K ? null : e.displayName || e.name || null;
-      if (typeof e == "string") return e;
-      switch (e) {
-        case T:
+var he;
+function Te() {
+  return he || (he = 1, process.env.NODE_ENV !== "production" && function() {
+    function z(r) {
+      if (r == null) return null;
+      if (typeof r == "function")
+        return r.$$typeof === w ? null : r.displayName || r.name || null;
+      if (typeof r == "string") return r;
+      switch (r) {
+        case S:
           return "Fragment";
-        case V:
+        case j:
           return "Profiler";
-        case J:
+        case O:
           return "StrictMode";
-        case B:
+        case $:
           return "Suspense";
-        case H:
+        case D:
           return "SuspenseList";
-        case Q:
+        case C:
           return "Activity";
       }
-      if (typeof e == "object")
-        switch (typeof e.tag == "number" && console.error(
+      if (typeof r == "object")
+        switch (typeof r.tag == "number" && console.error(
           "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
-        ), e.$$typeof) {
-          case q:
+        ), r.$$typeof) {
+          case d:
             return "Portal";
-          case G:
-            return (e.displayName || "Context") + ".Provider";
-          case z:
-            return (e._context.displayName || "Context") + ".Consumer";
-          case X:
-            var r = e.render;
-            return e = e.displayName, e || (e = r.displayName || r.name || "", e = e !== "" ? "ForwardRef(" + e + ")" : "ForwardRef"), e;
-          case Z:
-            return r = e.displayName || null, r !== null ? r : c(e.type) || "Memo";
-          case y:
-            r = e._payload, e = e._init;
+          case q:
+            return (r.displayName || "Context") + ".Provider";
+          case W:
+            return (r._context.displayName || "Context") + ".Consumer";
+          case H:
+            var f = r.render;
+            return r = r.displayName, r || (r = f.displayName || f.name || "", r = r !== "" ? "ForwardRef(" + r + ")" : "ForwardRef"), r;
+          case k:
+            return f = r.displayName || null, f !== null ? f : z(r.type) || "Memo";
+          case F:
+            f = r._payload, r = r._init;
             try {
-              return c(e(r));
+              return z(r(f));
             } catch {
             }
         }
       return null;
     }
-    function d(e) {
-      return "" + e;
+    function e(r) {
+      return "" + r;
     }
-    function m(e) {
+    function s(r) {
       try {
-        d(e);
-        var r = !1;
+        e(r);
+        var f = !1;
       } catch {
-        r = !0;
+        f = !0;
       }
-      if (r) {
-        r = console;
-        var t = r.error, n = typeof Symbol == "function" && Symbol.toStringTag && e[Symbol.toStringTag] || e.constructor.name || "Object";
-        return t.call(
-          r,
+      if (f) {
+        f = console;
+        var T = f.error, R = typeof Symbol == "function" && Symbol.toStringTag && r[Symbol.toStringTag] || r.constructor.name || "Object";
+        return T.call(
+          f,
           "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
-          n
-        ), d(e);
+          R
+        ), e(r);
       }
     }
-    function i(e) {
-      if (e === T) return "<>";
-      if (typeof e == "object" && e !== null && e.$$typeof === y)
+    function o(r) {
+      if (r === S) return "<>";
+      if (typeof r == "object" && r !== null && r.$$typeof === F)
         return "<...>";
       try {
-        var r = c(e);
-        return r ? "<" + r + ">" : "<...>";
+        var f = z(r);
+        return f ? "<" + f + ">" : "<...>";
       } catch {
         return "<...>";
       }
     }
-    function a() {
-      var e = k.A;
-      return e === null ? null : e.getOwner();
+    function n() {
+      var r = P.A;
+      return r === null ? null : r.getOwner();
     }
-    function s() {
+    function t() {
       return Error("react-stack-top-frame");
     }
-    function u(e) {
-      if (j.call(e, "key")) {
-        var r = Object.getOwnPropertyDescriptor(e, "key").get;
-        if (r && r.isReactWarning) return !1;
+    function a(r) {
+      if (V.call(r, "key")) {
+        var f = Object.getOwnPropertyDescriptor(r, "key").get;
+        if (f && f.isReactWarning) return !1;
       }
-      return e.key !== void 0;
+      return r.key !== void 0;
     }
-    function p(e, r) {
-      function t() {
-        g || (g = !0, console.error(
+    function c(r, f) {
+      function T() {
+        y || (y = !0, console.error(
           "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
-          r
+          f
         ));
       }
-      t.isReactWarning = !0, Object.defineProperty(e, "key", {
-        get: t,
+      T.isReactWarning = !0, Object.defineProperty(r, "key", {
+        get: T,
         configurable: !0
       });
     }
-    function W() {
-      var e = c(this.type);
-      return N[e] || (N[e] = !0, console.error(
+    function l() {
+      var r = z(this.type);
+      return A[r] || (A[r] = !0, console.error(
         "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
-      )), e = this.props.ref, e !== void 0 ? e : null;
-    }
-    function U(e, r, t, n, f, l, S, P) {
-      return t = l.ref, e = {
-        $$typeof: A,
-        type: e,
-        key: r,
-        props: l,
-        _owner: f
-      }, (t !== void 0 ? t : null) !== null ? Object.defineProperty(e, "ref", {
+      )), r = this.props.ref, r !== void 0 ? r : null;
+    }
+    function m(r, f, T, R, N, h, I, B) {
+      return T = h.ref, r = {
+        $$typeof: x,
+        type: r,
+        key: f,
+        props: h,
+        _owner: N
+      }, (T !== void 0 ? T : null) !== null ? Object.defineProperty(r, "ref", {
         enumerable: !1,
-        get: W
-      }) : Object.defineProperty(e, "ref", { enumerable: !1, value: null }), e._store = {}, Object.defineProperty(e._store, "validated", {
+        get: l
+      }) : Object.defineProperty(r, "ref", { enumerable: !1, value: null }), r._store = {}, Object.defineProperty(r._store, "validated", {
         configurable: !1,
         enumerable: !1,
         writable: !0,
         value: 0
-      }), Object.defineProperty(e, "_debugInfo", {
+      }), Object.defineProperty(r, "_debugInfo", {
         configurable: !1,
         enumerable: !1,
         writable: !0,
         value: null
-      }), Object.defineProperty(e, "_debugStack", {
+      }), Object.defineProperty(r, "_debugStack", {
         configurable: !1,
         enumerable: !1,
         writable: !0,
-        value: S
-      }), Object.defineProperty(e, "_debugTask", {
+        value: I
+      }), Object.defineProperty(r, "_debugTask", {
         configurable: !1,
         enumerable: !1,
         writable: !0,
-        value: P
-      }), Object.freeze && (Object.freeze(e.props), Object.freeze(e)), e;
-    }
-    function O(e, r, t, n, f, l, S, P) {
-      var o = r.children;
-      if (o !== void 0)
-        if (n)
-          if (ee(o)) {
-            for (n = 0; n < o.length; n++)
-              x(o[n]);
-            Object.freeze && Object.freeze(o);
+        value: B
+      }), Object.freeze && (Object.freeze(r.props), Object.freeze(r)), r;
+    }
+    function M(r, f, T, R, N, h, I, B) {
+      var u = f.children;
+      if (u !== void 0)
+        if (R)
+          if (U(u)) {
+            for (R = 0; R < u.length; R++)
+              b(u[R]);
+            Object.freeze && Object.freeze(u);
           } else
             console.error(
               "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
             );
-        else x(o);
-      if (j.call(r, "key")) {
-        o = c(e);
-        var E = Object.keys(r).filter(function(re) {
-          return re !== "key";
+        else b(u);
+      if (V.call(f, "key")) {
+        u = z(r);
+        var _ = Object.keys(f).filter(function(G) {
+          return G !== "key";
         });
-        n = 0 < E.length ? "{key: someKey, " + E.join(": ..., ") + ": ...}" : "{key: someKey}", M[o + n] || (E = 0 < E.length ? "{" + E.join(": ..., ") + ": ...}" : "{}", console.error(
+        R = 0 < _.length ? "{key: someKey, " + _.join(": ..., ") + ": ...}" : "{key: someKey}", J[u + R] || (_ = 0 < _.length ? "{" + _.join(": ..., ") + ": ...}" : "{}", console.error(
           `A props object containing a "key" prop is being spread into JSX:
   let props = %s;
   <%s {...props} />
 React keys must be passed directly to JSX without using spread:
   let props = %s;
   <%s key={someKey} {...props} />`,
-          n,
-          o,
-          E,
-          o
-        ), M[o + n] = !0);
+          R,
+          u,
+          _,
+          u
+        ), J[u + R] = !0);
       }
-      if (o = null, t !== void 0 && (m(t), o = "" + t), u(r) && (m(r.key), o = "" + r.key), "key" in r) {
-        t = {};
-        for (var w in r)
-          w !== "key" && (t[w] = r[w]);
-      } else t = r;
-      return o && p(
-        t,
-        typeof e == "function" ? e.displayName || e.name || "Unknown" : e
-      ), U(
-        e,
-        o,
-        l,
-        f,
-        a(),
-        t,
-        S,
-        P
+      if (u = null, T !== void 0 && (s(T), u = "" + T), a(f) && (s(f.key), u = "" + f.key), "key" in f) {
+        T = {};
+        for (var Y in f)
+          Y !== "key" && (T[Y] = f[Y]);
+      } else T = f;
+      return u && c(
+        T,
+        typeof r == "function" ? r.displayName || r.name || "Unknown" : r
+      ), m(
+        r,
+        u,
+        h,
+        N,
+        n(),
+        T,
+        I,
+        B
       );
     }
-    function x(e) {
-      typeof e == "object" && e !== null && e.$$typeof === A && e._store && (e._store.validated = 1);
+    function b(r) {
+      typeof r == "object" && r !== null && r.$$typeof === x && r._store && (r._store.validated = 1);
     }
-    var v = te, A = Symbol.for("react.transitional.element"), q = Symbol.for("react.portal"), T = Symbol.for("react.fragment"), J = Symbol.for("react.strict_mode"), V = Symbol.for("react.profiler"), z = Symbol.for("react.consumer"), G = Symbol.for("react.context"), X = Symbol.for("react.forward_ref"), B = Symbol.for("react.suspense"), H = Symbol.for("react.suspense_list"), Z = Symbol.for("react.memo"), y = Symbol.for("react.lazy"), Q = Symbol.for("react.activity"), K = Symbol.for("react.client.reference"), k = v.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, j = Object.prototype.hasOwnProperty, ee = Array.isArray, h = console.createTask ? console.createTask : function() {
+    var p = ye, x = Symbol.for("react.transitional.element"), d = Symbol.for("react.portal"), S = Symbol.for("react.fragment"), O = Symbol.for("react.strict_mode"), j = Symbol.for("react.profiler"), W = Symbol.for("react.consumer"), q = Symbol.for("react.context"), H = Symbol.for("react.forward_ref"), $ = Symbol.for("react.suspense"), D = Symbol.for("react.suspense_list"), k = Symbol.for("react.memo"), F = Symbol.for("react.lazy"), C = Symbol.for("react.activity"), w = Symbol.for("react.client.reference"), P = p.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, V = Object.prototype.hasOwnProperty, U = Array.isArray, g = console.createTask ? console.createTask : function() {
       return null;
     };
-    v = {
-      "react-stack-bottom-frame": function(e) {
-        return e();
+    p = {
+      "react-stack-bottom-frame": function(r) {
+        return r();
       }
     };
-    var g, N = {}, C = v["react-stack-bottom-frame"].bind(
-      v,
-      s
-    )(), Y = h(i(s)), M = {};
-    b.Fragment = T, b.jsx = function(e, r, t, n, f) {
-      var l = 1e4 > k.recentlyCreatedOwnerStacks++;
-      return O(
-        e,
+    var y, A = {}, E = p["react-stack-bottom-frame"].bind(
+      p,
+      t
+    )(), L = g(o(t)), J = {};
+    re.Fragment = S, re.jsx = function(r, f, T, R, N) {
+      var h = 1e4 > P.recentlyCreatedOwnerStacks++;
+      return M(
         r,
-        t,
-        !1,
-        n,
         f,
-        l ? Error("react-stack-top-frame") : C,
-        l ? h(i(e)) : Y
+        T,
+        !1,
+        R,
+        N,
+        h ? Error("react-stack-top-frame") : E,
+        h ? g(o(r)) : L
       );
-    }, b.jsxs = function(e, r, t, n, f) {
-      var l = 1e4 > k.recentlyCreatedOwnerStacks++;
-      return O(
-        e,
+    }, re.jsxs = function(r, f, T, R, N) {
+      var h = 1e4 > P.recentlyCreatedOwnerStacks++;
+      return M(
         r,
-        t,
-        !0,
-        n,
         f,
-        l ? Error("react-stack-top-frame") : C,
-        l ? h(i(e)) : Y
+        T,
+        !0,
+        R,
+        N,
+        h ? Error("react-stack-top-frame") : E,
+        h ? g(o(r)) : L
+      );
+    };
+  }()), re;
+}
+var de;
+function Ce() {
+  return de || (de = 1, process.env.NODE_ENV === "production" ? se.exports = Se() : se.exports = Te()), se.exports;
+}
+var Ae = Ce();
+class le {
+  constructor() {
+    v(this, "min", new i.Vector3(1 / 0, 1 / 0, 1 / 0));
+    v(this, "max", new i.Vector3(-1 / 0, -1 / 0, -1 / 0));
+    v(this, "center", new i.Vector3());
+    /** Half extents (size/2) */
+    v(this, "halfExtents", new i.Vector3());
+  }
+  /**
+   * Reset the bounding box to its initial state
+   */
+  reset() {
+    this.min.set(1 / 0, 1 / 0, 1 / 0), this.max.set(-1 / 0, -1 / 0, -1 / 0), this.center.set(0, 0, 0), this.halfExtents.set(0, 0, 0);
+  }
+  /**
+   * Expand the bounding box to include the given point
+   * @param point Point to include in the bounding box
+   */
+  expandByPoint(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(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
+   */
+  updateDerived() {
+    this.center.addVectors(this.min, this.max).multiplyScalar(0.5), this.halfExtents.subVectors(this.max, this.min).multiplyScalar(0.5);
+  }
+  /**
+   * Check if this box contains a point
+   * @param point Point to check
+   * @returns True if the point is inside the box
+   */
+  containsPoint(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);
+  }
+  /**
+   * Create a clone of this bounding box
+   * @returns New bounding box with the same values
+   */
+  clone() {
+    const e = new le();
+    return e.min.copy(this.min), e.max.copy(this.max), e.center.copy(this.center), e.halfExtents.copy(this.halfExtents), e;
+  }
+}
+class ze {
+  // TODO: there is no sh spherical harmonics
+  constructor(e = 0) {
+    v(this, "numSplats", 0);
+    v(this, "positions");
+    v(this, "rotations");
+    v(this, "scales");
+    v(this, "colors");
+    v(this, "opacities");
+    v(this, "centers");
+    v(this, "boundingBox", new le());
+    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), this.centers = new Float32Array(e * 3);
+  }
+  /**
+   * Set data for a specific splat
+   * @param index Splat index
+   * @param position Position vector
+   * @param rotation Quaternion
+   * @param scale Scale vector (expects LOG SCALE)
+   * @param color Color
+   * @param opacity Opacity value
+   */
+  setSplat(e, s, o, n, t, a) {
+    if (e >= this.numSplats)
+      throw new Error(
+        `Splat index out of bounds: ${e} >= ${this.numSplats}`
+      );
+    const c = e * 3, l = e * 4, m = e * 3, M = e * 3;
+    this.positions[c] = s.x, this.positions[c + 1] = s.y, this.positions[c + 2] = s.z, this.rotations[l] = o.x, this.rotations[l + 1] = o.y, this.rotations[l + 2] = o.z, this.rotations[l + 3] = o.w, this.scales[m] = n.x, this.scales[m + 1] = n.y, this.scales[m + 2] = n.z, this.colors[M] = t.r, this.colors[M + 1] = t.g, this.colors[M + 2] = t.b, this.opacities[e] = a, this.centers[c] = s.x, this.centers[c + 1] = s.y, this.centers[c + 2] = s.z;
+  }
+  /**
+   * Get a splat's data
+   * @param index Splat index
+   * @returns Object containing splat data (linear scale)
+   */
+  getSplat(e) {
+    if (e >= this.numSplats)
+      throw new Error(
+        `Splat index out of bounds: ${e} >= ${this.numSplats}`
+      );
+    const s = e * 3, o = e * 4, n = e * 3, t = e * 3;
+    return {
+      position: new i.Vector3(
+        this.positions[s],
+        this.positions[s + 1],
+        this.positions[s + 2]
+      ),
+      rotation: new i.Quaternion(
+        this.rotations[o],
+        this.rotations[o + 1],
+        this.rotations[o + 2],
+        this.rotations[o + 3]
+      ),
+      // Convert log scale back to linear scale for external use
+      scale: new i.Vector3(
+        Math.exp(this.scales[n]),
+        Math.exp(this.scales[n + 1]),
+        Math.exp(this.scales[n + 2])
+      ),
+      color: new i.Color(
+        this.colors[t],
+        this.colors[t + 1],
+        this.colors[t + 2]
+      ),
+      opacity: this.opacities[e]
+    };
+  }
+  /**
+   * Calculate the bounding box for all splats
+   * NOTE: Currently it only uses positions, not the actual splat bounds
+   */
+  calculateBoundingBox() {
+    this.boundingBox.reset();
+    const e = new i.Vector3();
+    for (let s = 0; s < this.numSplats; s++) {
+      const o = s * 3;
+      e.set(
+        this.positions[o],
+        this.positions[o + 1],
+        this.positions[o + 2]
+      ), this.boundingBox.expandByPoint(e);
+    }
+    return this.boundingBox;
+  }
+  /**
+   * Create a Three.js BufferGeometry from this splat data
+   * This is for visualization/debugging purposes only, not for rendering
+   */
+  createDebugGeometry() {
+    const e = new i.BufferGeometry();
+    e.setAttribute(
+      "position",
+      new i.BufferAttribute(this.positions, 3)
+    );
+    const s = new Float32Array(this.numSplats * 3), o = new i.Quaternion(), n = new i.Euler();
+    for (let t = 0; t < this.numSplats; t++) {
+      const a = t * 4, c = t * 3;
+      o.set(
+        this.rotations[a],
+        this.rotations[a + 1],
+        this.rotations[a + 2],
+        this.rotations[a + 3]
+      ), n.setFromQuaternion(o), s[c] = n.x, s[c + 1] = n.y, s[c + 2] = n.z;
+    }
+    return e.setAttribute(
+      "rotation",
+      new i.BufferAttribute(s, 3)
+    ), e.setAttribute(
+      "scale",
+      new i.BufferAttribute(this.scales, 3)
+    ), e.setAttribute(
+      "color",
+      new i.BufferAttribute(this.colors, 3)
+    ), e.setAttribute(
+      "opacity",
+      new i.BufferAttribute(this.opacities, 1)
+    ), e;
+  }
+}
+class ke extends i.Loader {
+  /**
+   * Load a PLY file with Gaussian Splat data
+   * @param url URL of the PLY file
+   * @param onLoad Optional callback when loading is complete
+   * @param onProgress Optional progress callback
+   * @param onError Optional error callback
+   */
+  load(e, s, o, n) {
+    const t = new i.FileLoader(this.manager);
+    t.setResponseType("arraybuffer"), t.setRequestHeader(this.requestHeader), t.setPath(this.path), t.setWithCredentials(this.withCredentials), t.load(
+      e,
+      (a) => {
+        try {
+          if (s) {
+            const c = this.parse(a);
+            s(c);
+          }
+        } catch (c) {
+          n ? n(c) : console.error(c), this.manager.itemError(e);
+        }
+      },
+      o,
+      n
+    );
+  }
+  /**
+   * Load a PLY file asynchronously and return a Promise
+   * @param url URL of the PLY file
+   * @param onProgress Optional progress callback
+   * @returns A Promise that resolves with the parsed SplatData
+   */
+  loadAsync(e, s) {
+    return new Promise((o, n) => {
+      const t = new i.FileLoader(this.manager);
+      t.setResponseType("arraybuffer"), t.setRequestHeader(this.requestHeader), t.setPath(this.path), t.setWithCredentials(this.withCredentials), t.load(
+        e,
+        (a) => {
+          try {
+            const c = this.parse(a);
+            o(c);
+          } catch (c) {
+            n(c), this.manager.itemError(e);
+          }
+        },
+        s,
+        (a) => {
+          n(a), this.manager.itemError(e);
+        }
+      );
+    });
+  }
+  /**
+   * Parse PLY buffer data into SplatData
+   * @param buffer ArrayBuffer containing PLY data
+   * @returns Parsed SplatData
+   */
+  parse(e) {
+    const s = new TextDecoder(), o = new Uint8Array(e), n = [112, 108, 121, 10], t = `
+end_header
+`;
+    for (let g = 0; g < n.length; g++)
+      if (o[g] !== n[g])
+        throw new Error("Invalid PLY file: Missing magic bytes");
+    let a = 0;
+    for (let g = 0; g < o.length - t.length; g++) {
+      let y = !0;
+      for (let A = 0; A < t.length; A++)
+        if (o[g + A] !== t.charCodeAt(A)) {
+          y = !1;
+          break;
+        }
+      if (y) {
+        a = g + t.length;
+        break;
+      }
+    }
+    if (a === 0)
+      throw new Error("Invalid PLY file: Could not find end of header");
+    const l = s.decode(
+      o.slice(0, a)
+    ).split(`
+`), m = [];
+    let M = null;
+    for (let g = 1; g < l.length; g++) {
+      const y = l[g].trim();
+      if (y === "" || y === "end_header") continue;
+      const A = y.split(" ");
+      switch (A[0]) {
+        case "format":
+          M = A[1];
+          break;
+        case "element":
+          m.push({
+            name: A[1],
+            count: parseInt(A[2], 10),
+            properties: []
+          });
+          break;
+        case "property":
+          if (m.length === 0)
+            throw new Error(
+              "Invalid PLY file: Property without element"
+            );
+          m[m.length - 1].properties.push({
+            type: A[1],
+            name: A[2],
+            storage: null
+          });
+          break;
+      }
+    }
+    if (M !== "binary_little_endian")
+      throw new Error(`Unsupported PLY format: ${M}`);
+    const b = m.find((g) => g.name === "vertex");
+    if (!b)
+      throw new Error("Invalid PLY file: No vertex element found");
+    const p = new ze(b.count), x = new DataView(e);
+    let d = a;
+    const S = (g) => b.properties.findIndex((y) => y.name === g), O = S("x"), j = S("y"), W = S("z"), q = [
+      S("rot_0"),
+      S("rot_1"),
+      S("rot_2"),
+      S("rot_3")
+    ], H = [
+      S("scale_0"),
+      S("scale_1"),
+      S("scale_2")
+    ], $ = [
+      S("f_dc_0"),
+      S("f_dc_1"),
+      S("f_dc_2")
+    ], D = S("opacity");
+    if ([
+      O,
+      j,
+      W,
+      ...q,
+      ...H,
+      ...$,
+      D
+    ].some((g) => g === -1))
+      throw new Error("Invalid PLY file: Missing required properties");
+    const F = 0.28209479177387814, C = (g) => {
+      if (g > 0) return 1 / (1 + Math.exp(-g));
+      const y = Math.exp(g);
+      return y / (1 + y);
+    }, w = new i.Vector3(), P = new i.Quaternion(), V = new i.Vector3(), U = new i.Color();
+    for (let g = 0; g < b.count; g++) {
+      const y = [];
+      for (let E = 0; E < b.properties.length; E++) {
+        const J = b.properties[E].type;
+        let r;
+        switch (J) {
+          case "char":
+            r = x.getInt8(d), d += 1;
+            break;
+          case "uchar":
+            r = x.getUint8(d), d += 1;
+            break;
+          case "short":
+            r = x.getInt16(d, !0), d += 2;
+            break;
+          case "ushort":
+            r = x.getUint16(d, !0), d += 2;
+            break;
+          case "int":
+            r = x.getInt32(d, !0), d += 4;
+            break;
+          case "uint":
+            r = x.getUint32(d, !0), d += 4;
+            break;
+          case "float":
+            r = x.getFloat32(d, !0), d += 4;
+            break;
+          case "double":
+            r = x.getFloat64(d, !0), d += 8;
+            break;
+          default:
+            throw new Error(`Unsupported property type: ${J}`);
+        }
+        y.push(r);
+      }
+      w.set(
+        y[O],
+        y[j],
+        y[W]
+      ), P.set(
+        // TODO: dangerous see if true
+        y[q[1]],
+        // PLY stores rot  1,2,3,0 (x,y,z,w)
+        y[q[2]],
+        y[q[3]],
+        y[q[0]]
+      ).normalize(), V.set(
+        y[H[0]],
+        // Read directly assuming it's log scale
+        y[H[1]],
+        y[H[2]]
+      ), U.set(
+        0.5 + y[$[0]] * F,
+        0.5 + y[$[1]] * F,
+        0.5 + y[$[2]] * F
+      ), U.r = Math.max(0, Math.min(1, U.r)), U.g = Math.max(0, Math.min(1, U.g)), U.b = Math.max(0, Math.min(1, U.b));
+      const A = C(y[D]);
+      p.setSplat(
+        g,
+        w,
+        P,
+        V,
+        // Pass log scale directly
+        U,
+        A
+      );
+    }
+    return p.calculateBoundingBox(), p;
+  }
+}
+class _e extends i.EventDispatcher {
+  constructor() {
+    super();
+    v(this, "worker");
+    v(this, "centers", null);
+    v(this, "orderTexture", null);
+    /** Bounding box data for optimization */
+    v(this, "chunks", null);
+    v(this, "lastCameraPosition", new i.Vector3());
+    v(this, "lastCameraDirection", new i.Vector3());
+    const s = this.createWorkerCode(), o = new Blob([s], { type: "application/javascript" });
+    this.worker = new Worker(URL.createObjectURL(o)), this.worker.onmessage = this.onWorkerMessage.bind(this);
+  }
+  /**
+   * Handles messages received from the sorting worker.
+   * @param event The message event from the worker.
+   */
+  onWorkerMessage(s) {
+    if (!this.orderTexture || !this.orderTexture.image)
+      return console.error("SplatSorter: Order texture not initialized!");
+    const { order: o, count: n } = s.data, t = this.orderTexture.image.data;
+    if (!(t instanceof Uint32Array))
+      return console.error(
+        "SplatSorter: Order texture data is not a Uint32Array!"
+      );
+    t.set(new Uint32Array(o)), this.orderTexture.needsUpdate = !0;
+    const a = t.buffer.slice(0), c = { order: a };
+    this.worker.postMessage(c, [a]), this.dispatchEvent({ type: "updated", count: n });
+  }
+  /**
+   * Initializes the sorter with necessary data and textures.
+   * @param orderTexture The THREE.DataTexture (R32UI) to store the sorted splat indices.
+   * @param centers A Float32Array containing the center position (x, y, z) for each splat.
+   * @param chunks Optional: A Float32Array containing bounding box chunk data [minX, minY, minZ, maxX, maxY, maxZ, ...] for optimization.
+   */
+  init(s, o, n) {
+    if (!s || !(s.image.data instanceof Uint32Array))
+      throw new Error("SplatSorter: Invalid orderTexture provided. Must be DataTexture with Uint32Array data.");
+    if (!o || o.length % 3 !== 0)
+      throw new Error("SplatSorter: Invalid centers array provided. Length must be multiple of 3.");
+    if (s.image.data.length < o.length / 3)
+      throw new Error("SplatSorter: orderTexture data buffer is smaller than the number of splats.");
+    const t = o.length / 3;
+    this.orderTexture = s, this.centers = o.slice();
+    const a = this.orderTexture.image.data;
+    for (let b = 0; b < t; b++) a[b] = b;
+    this.orderTexture.needsUpdate = !0;
+    const c = a.buffer.slice(0), l = this.centers.buffer.slice(0), m = {
+      order: c,
+      centers: l
+    }, M = [
+      c,
+      l
+    ];
+    if (n) {
+      this.chunks = n.slice();
+      const b = this.chunks.buffer.slice(0);
+      m.chunks = b, M.push(b);
+    }
+    this.worker.postMessage(m, M);
+  }
+  /**
+   * Applies an optional mapping to filter or reorder splats before sorting.
+   * The sorter will only consider splats whose original indices are present in the mapping.
+   * @param mapping A Uint32Array where each element is the *original* index of a splat to include, or null to reset mapping.
+   */
+  setMapping(s) {
+    if (!this.centers)
+      return console.warn(
+        "SplatSorter: Cannot set mapping before initialization."
       );
+    let o;
+    const n = [];
+    if (!s) {
+      const l = this.centers.buffer.slice(0);
+      return o = {
+        centers: l,
+        mapping: null
+      }, n.push(l), this.worker.postMessage(o, n);
+    }
+    const t = new Float32Array(s.length * 3);
+    for (let l = 0; l < s.length; l++) {
+      const m = s[l];
+      if (m * 3 + 2 >= this.centers.length) {
+        console.warn(
+          `SplatSorter: Mapping index ${m} out of bounds.`
+        );
+        continue;
+      }
+      const M = m * 3, b = l * 3;
+      t[b + 0] = this.centers[M + 0], t[b + 1] = this.centers[M + 1], t[b + 2] = this.centers[M + 2];
+    }
+    const a = t.buffer.slice(0), c = s.buffer.slice(0);
+    o = {
+      centers: a,
+      mapping: c
+    }, n.push(a, c), this.worker.postMessage(o, n);
+  }
+  /**
+   * Updates the camera parameters used for sorting.
+   * @param position The camera's position in the sorter's local coordinate space.
+   * @param direction The camera's forward direction in the sorter's local coordinate space.
+   */
+  setCamera(s, o) {
+    const n = this.lastCameraPosition.distanceToSquared(s) > 1e-7, t = this.lastCameraDirection.dot(o) < 0.9999;
+    if (!n && !t)
+      return;
+    this.lastCameraPosition.copy(s), this.lastCameraDirection.copy(o);
+    const a = {
+      cameraPosition: { x: s.x, y: s.y, z: s.z },
+      cameraDirection: { x: o.x, y: o.y, z: o.z }
     };
-  }()), b;
+    this.worker.postMessage(a);
+  }
+  /**
+   * Terminates the Web Worker and cleans up resources.
+   */
+  dispose() {
+    this.worker && this.worker.terminate(), this.orderTexture = null, this.centers = null, this.chunks = null;
+  }
+  /**
+   * Creates the self-contained code for the sorting Web Worker.
+   * @returns A string containing the JavaScript code for the worker.
+   */
+  createWorkerCode() {
+    return `(${(function() {
+      let o = null, n = null, t = null, a = null, c = null, l = null, m = !1;
+      const M = { x: 0, y: 0, z: 0 }, b = { x: 0, y: 0, z: 0 }, p = { x: 0, y: 0, z: 0 }, x = { x: 0, y: 0, z: 0 };
+      let d = null, S = null;
+      const O = 32, j = new Array(O).fill(0), W = new Array(O).fill(0), q = new Array(O).fill(0), H = (D, k, F) => {
+        for (; D <= k; ) {
+          const C = k + D >> 1, w = F(C);
+          if (w > 0) D = C + 1;
+          else if (w < 0) k = C - 1;
+          else return C;
+        }
+        return ~D;
+      }, $ = () => {
+        if (!o || !n || !c || !l)
+          return;
+        if (n.length === 0) {
+          const h = {
+            order: o.buffer,
+            count: 0
+          };
+          self.postMessage(h, [o.buffer]), o = null;
+          return;
+        }
+        const D = c.x, k = c.y, F = c.z, C = l.x, w = l.y, P = l.z, V = 1e-4, U = Math.abs(D - M.x) > V || Math.abs(k - M.y) > V || Math.abs(F - M.z) > V, g = Math.abs(C - b.x) > V || Math.abs(w - b.y) > V || Math.abs(P - b.z) > V;
+        if (!m && !U && !g)
+          return;
+        m = !1, M.x = D, M.y = k, M.z = F, b.x = C, b.y = w, b.z = P;
+        let y = 1 / 0, A = -1 / 0;
+        for (let h = 0; h < 8; ++h) {
+          const I = h & 1 ? p.x : x.x, B = h & 2 ? p.y : x.y, u = h & 4 ? p.z : x.z, _ = I * C + B * w + u * P;
+          y = Math.min(y, _), A = Math.max(A, _);
+        }
+        const E = n.length / 3, L = A - y, r = (1 << Math.max(
+          10,
+          Math.min(20, Math.ceil(Math.log2(E / 4)))
+        )) + 1;
+        if ((!d || d.length !== E) && (d = new Uint32Array(E)), !S || S.length !== r ? S = new Uint32Array(r) : S.fill(0), L < 1e-7) {
+          for (let h = 0; h < E; ++h) d[h] = 0;
+          S[0] = E;
+        } else if (t && t.length > 0) {
+          const h = t.length / 6;
+          j.fill(0);
+          for (let u = 0; u < h; ++u) {
+            const _ = u * 6, Y = t[_ + 0], G = t[_ + 1], ne = t[_ + 2], Z = t[_ + 3], X = Y * C + G * w + ne * P - y, oe = X - Z, ee = X + Z, ie = Math.max(
+              0,
+              Math.floor(oe * O / L)
+            ), ce = Math.min(
+              O,
+              Math.ceil(ee * O / L)
+            );
+            for (let Q = ie; Q < ce; ++Q)
+              j[Q]++;
+          }
+          let I = 0;
+          for (let u = 0; u < O; ++u) I += j[u];
+          q[0] = 0, W[0] = 0;
+          for (let u = 1; u < O; ++u)
+            q[u - 1] = j[u - 1] / I * r >>> 0, W[u] = W[u - 1] + q[u - 1];
+          q[O - 1] = j[O - 1] / I * r >>> 0;
+          const B = L / O;
+          for (let u = 0; u < E; ++u) {
+            const _ = u * 3, Y = n[_ + 0], G = n[_ + 1], ne = n[_ + 2], Z = Y * C + G * w + ne * P, oe = (A - Z) / B, ee = Math.max(
+              0,
+              Math.min(
+                O - 1,
+                Math.floor(oe)
+              )
+            ), ie = oe - ee, ce = W[ee] + q[ee] * ie >>> 0, Q = Math.min(ce, r - 1);
+            d[u] = Q, S[Q]++;
+          }
+        } else {
+          const h = (r - 1) / L;
+          for (let I = 0; I < E; ++I) {
+            const B = I * 3, u = n[B + 0], _ = n[B + 1], Y = n[B + 2], G = u * C + _ * w + Y * P, Z = (A - G) * h >>> 0, X = Math.min(Z, r - 1);
+            d[I] = X, S[X]++;
+          }
+        }
+        for (let h = 1; h < r; h++)
+          S[h] += S[h - 1];
+        for (let h = E - 1; h >= 0; h--) {
+          const I = d[h], B = --S[I];
+          o[B] = a ? a[h] : h;
+        }
+        const f = D * C + k * w + F * P, T = (h) => {
+          if (!o) return -1 / 0;
+          const I = o[h], B = I;
+          if (!n || B * 3 + 2 >= n.length)
+            return -1 / 0;
+          const u = B * 3;
+          return n[u] * C + n[u + 1] * w + n[u + 2] * P - f;
+        };
+        let R = E;
+        if (E > 0 && T(E - 1) < 0) {
+          const h = H(
+            0,
+            E - 1,
+            T
+          );
+          R = h < 0 ? ~h : h;
+        }
+        const N = {
+          order: o.buffer,
+          count: R
+        };
+        self.postMessage(N, [o.buffer]), o = null;
+      };
+      self.onmessage = (D) => {
+        const k = D.data;
+        k.order && (o = new Uint32Array(k.order));
+        let F = !1;
+        if (k.centers && (n = new Float32Array(k.centers), F = !0, m = !0), Object.prototype.hasOwnProperty.call(k, "mapping") && (a = k.mapping ? new Uint32Array(k.mapping) : null, m = !0), k.chunks) {
+          if (t = new Float32Array(k.chunks), t.length > 0 && t[3] > 0)
+            for (let C = 0; C < t.length / 6; ++C) {
+              const w = C * 6, P = t[w + 0], V = t[w + 1], U = t[w + 2], g = t[w + 3], y = t[w + 4], A = t[w + 5];
+              t[w + 0] = (P + g) * 0.5, t[w + 1] = (V + y) * 0.5, t[w + 2] = (U + A) * 0.5, t[w + 3] = Math.sqrt(
+                (g - P) ** 2 + (y - V) ** 2 + (A - U) ** 2
+              ) * 0.5;
+            }
+          m = !0;
+        }
+        if (F && n && n.length > 0) {
+          p.x = x.x = n[0], p.y = x.y = n[1], p.z = x.z = n[2];
+          for (let C = 1; C < n.length / 3; C++) {
+            const w = C * 3;
+            p.x = Math.min(p.x, n[w + 0]), x.x = Math.max(x.x, n[w + 0]), p.y = Math.min(p.y, n[w + 1]), x.y = Math.max(x.y, n[w + 1]), p.z = Math.min(p.z, n[w + 2]), x.z = Math.max(x.z, n[w + 2]);
+          }
+        } else F && n && n.length === 0 && (p.x = x.x = p.y = x.y = p.z = x.z = 0);
+        k.cameraPosition && (c = k.cameraPosition), k.cameraDirection && (l = k.cameraDirection), $();
+      };
+    }).toString()})();`;
+  }
+}
+const Ee = (z, e) => {
+  const s = Math.max(
+    0,
+    Math.min(65535, Math.round((z + 1) / 2 * 65535))
+  ), o = Math.max(
+    0,
+    Math.min(65535, Math.round((e + 1) / 2 * 65535))
+  );
+  return s << 16 | o;
+}, Re = new ArrayBuffer(4), fe = new DataView(Re), Ie = (z) => (fe.setUint32(0, z, !0), fe.getFloat32(0, !0));
+class Pe {
+  /**
+   * Create a new TextureManager for a set of splats
+   * @param splatData The splat data to manage textures for
+   */
+  constructor(e) {
+    v(this, "transformA");
+    // position xyz and rotation quaternion y,z components
+    v(this, "transformB");
+    // rotation quaternion x and scale xyz
+    v(this, "colorTexture");
+    // color an opacity
+    v(this, "orderTexture");
+    v(this, "textureWidth");
+    v(this, "textureHeight");
+    const s = e.numSplats;
+    this.textureWidth = Math.ceil(Math.sqrt(s)), this.textureHeight = Math.ceil(s / this.textureWidth), this.transformA = this.createTransformATexture(e), this.transformB = this.createTransformBTexture(e), this.colorTexture = this.createColorTexture(e), this.orderTexture = this.createOrderTexture(s);
+  }
+  /**
+   * Create the transform A texture (positions and quaternion w component)
+   * @param splatData The splat data
+   * @returns DataTexture containing position data
+   */
+  createTransformATexture(e) {
+    const s = e.numSplats, o = new Float32Array(
+      this.textureWidth * this.textureHeight * 4
+    );
+    for (let t = 0; t < s; t++) {
+      const a = t * 4, c = t * 3, l = t * 4;
+      o[a] = e.positions[c], o[a + 1] = e.positions[c + 1], o[a + 2] = e.positions[c + 2];
+      const m = e.rotations[l + 1], M = e.rotations[l + 2], b = Ee(m, M);
+      o[a + 3] = Ie(b);
+    }
+    const n = new i.DataTexture(
+      o,
+      this.textureWidth,
+      this.textureHeight,
+      i.RGBAFormat,
+      i.FloatType
+      // Store as Float32, shader will reinterpret bits
+    );
+    return n.needsUpdate = !0, n.magFilter = i.NearestFilter, n.minFilter = i.NearestFilter, n;
+  }
+  /**
+   * Create the transform B texture (scale and rotation xyz)
+   * @param splatData The splat data
+   * @returns DataTexture containing scale and rotation data
+   */
+  createTransformBTexture(e) {
+    const s = e.numSplats, o = new Float32Array(
+      this.textureWidth * this.textureHeight * 4
+    );
+    for (let t = 0; t < s; t++) {
+      const a = t * 4, c = t * 3, l = t * 4;
+      o[a] = e.scales[c], o[a + 1] = e.scales[c + 1], o[a + 2] = e.scales[c + 2], o[a + 3] = e.rotations[l];
+    }
+    const n = new i.DataTexture(
+      o,
+      this.textureWidth,
+      this.textureHeight,
+      i.RGBAFormat,
+      i.FloatType
+    );
+    return n.needsUpdate = !0, n.magFilter = i.NearestFilter, n.minFilter = i.NearestFilter, n;
+  }
+  /**
+   * Create the color texture (RGB and opacity)
+   * @param splatData The splat data
+   * @returns DataTexture containing color data
+   */
+  createColorTexture(e) {
+    const s = e.numSplats, o = new Float32Array(
+      this.textureWidth * this.textureHeight * 4
+    );
+    for (let t = 0; t < s; t++) {
+      const a = t * 4, c = t * 3;
+      o[a] = e.colors[c], o[a + 1] = e.colors[c + 1], o[a + 2] = e.colors[c + 2], o[a + 3] = e.opacities[t];
+    }
+    const n = new i.DataTexture(
+      o,
+      this.textureWidth,
+      this.textureHeight,
+      i.RGBAFormat,
+      i.FloatType
+    );
+    return n.needsUpdate = !0, n;
+  }
+  /**
+   * Create the order texture for sorting
+   * @param numSplats Number of splats
+   * @returns DataTexture for storing order indices
+   */
+  createOrderTexture(e) {
+    const s = new Uint32Array(this.textureWidth * this.textureHeight);
+    for (let n = 0; n < e; n++)
+      s[n] = n;
+    const o = new i.DataTexture(
+      s,
+      this.textureWidth,
+      this.textureHeight,
+      i.RedIntegerFormat,
+      i.UnsignedIntType
+    );
+    return o.needsUpdate = !0, o;
+  }
+  dispose() {
+    this.transformA.dispose(), this.transformB.dispose(), this.colorTexture.dispose(), this.orderTexture.dispose();
+  }
+}
+const Oe = (
+  /* glsl */
+  `
+precision highp float;
+precision highp int;
+precision highp usampler2D;
+precision highp sampler2D;
+
+// --- Uniforms (Provided by Three.js) ---
+// uniform mat4 modelViewMatrix; // Don't redeclare
+// uniform mat4 projectionMatrix; // Don't redeclare
+uniform vec2 viewport;          // Viewport dimensions (width, height)
+uniform uint numSplats;         // Total number of splats potentially renderable by sorter
+
+// Textures
+uniform highp sampler2D transformA;   // vec4: pos.xyz, packed_rot.yz
+uniform highp sampler2D transformB;   // vec4: log_scale.xyz, rot.x
+uniform highp sampler2D splatColor;   // vec4: color.rgb, opacity
+uniform highp usampler2D splatOrder;  // uint: original splat index
+
+// --- Attributes ---
+// Instancing attribute: base index for this block of splats
+attribute uint splatInstanceIndex;
+
+// Per-vertex attribute of the quad (Built-in, don't redeclare 'position')
+// attribute vec3 position; // Use the built-in 'position'
+// position.xy: corner coords (-1..1)
+// position.z: index within the instance block (0..INSTANCE_BUFFER_SIZE-1)
+
+// --- Varyings ---
+varying vec4 vColor;
+varying vec2 vUv; // For gaussian calculation in fragment shader
+
+// --- Constants ---
+#define INSTANCE_BUFFER_SIZE 128.0 // Must match the size in SplatMesh
+
+// --- Helper Functions ---
+
+// Unpack two 16-bit floats (halfs) from a single 32-bit float (packed as uint bits)
+vec2 unpackHalf2x16FromFloat(float packedFloat) {
+    uint packedUInt = floatBitsToUint(packedFloat);
+    uint y_bits = packedUInt >> 16;
+    uint z_bits = packedUInt & uint(0xFFFF);
+
+    // NOTE: This assumes packing used "packNormalizedFloatToUint16Pair"
+    // which maps [-1, 1] to [0, 65535]. Adjust if packing method changes.
+    float y = (float(y_bits) / 65535.0) * 2.0 - 1.0;
+    float z = (float(z_bits) / 65535.0) * 2.0 - 1.0;
+    return vec2(y, z);
+}
+
+// Reconstruct quaternion from packed components (x, yz_packed)
+vec4 unpackRotation(float yz_packed, float x) {
+    vec2 yz = unpackHalf2x16FromFloat(yz_packed);
+    float y = yz.x;
+    float z = yz.y;
+    float w_squared = 1.0 - x*x - y*y - z*z;
+    float w = (w_squared < 0.0) ? 0.0 : sqrt(w_squared); // Calculate w
+    return vec4(x, y, z, w);
 }
-var $;
-function fe() {
-  return $ || ($ = 1, process.env.NODE_ENV === "production" ? _.exports = ce() : _.exports = ie()), _.exports;
+
+// Convert quaternion to 3x3 rotation matrix
+mat3 quatToMat3(vec4 q) {
+    float x = q.x, y = q.y, z = q.z, w = q.w;
+    float x2 = x + x, y2 = y + y, z2 = z + z;
+    float xx = x * x2, xy = x * y2, xz = x * z2;
+    float yy = y * y2, yz = y * z2, zz = z * z2;
+    float wx = w * x2, wy = w * y2, wz = w * z2;
+
+    return mat3(
+        1.0 - (yy + zz), xy + wz, xz - wy,
+        xy - wz, 1.0 - (xx + zz), yz + wx,
+        xz + wy, yz - wx, 1.0 - (xx + yy)
+    );
 }
-var de = fe();
-let D = !1;
-typeof window < "u" && !D && (se({ splatPrimitive: L }), D = !0);
-const Re = ({
-  plyUrl: c,
-  splatOptions: d = {},
-  ...m
+
+// Calculate model-space covariance components R * S^2 * transpose(R)
+void getModelCovariance(vec3 scale, vec4 rotation, out vec3 covA, out vec3 covB) {
+    mat3 R = quatToMat3(rotation);
+
+    // Define M = R * S (where S is the diagonal scale matrix)
+    // Note R is column-major, so R[0] is the first column, etc.
+    // We want M's rows to be R's rows scaled by the corresponding scale factor.
+    mat3 M = mat3(
+        R[0][0] * scale.x, R[0][1] * scale.y, R[0][2] * scale.z, // Row 0 = (R_row0 * S)
+        R[1][0] * scale.x, R[1][1] * scale.y, R[1][2] * scale.z, // Row 1 = (R_row1 * S)
+        R[2][0] * scale.x, R[2][1] * scale.y, R[2][2] * scale.z  // Row 2 = (R_row2 * S)
+    );
+
+    // Now compute Vrk = M * transpose(M)
+    // Vrk[i][j] = dot(M[i], M[j]) where M[i] is the i-th row vector of M.
+    covA = vec3(dot(M[0], M[0]), dot(M[0], M[1]), dot(M[0], M[2])); // Vrk[0][0], Vrk[0][1], Vrk[0][2]
+    covB = vec3(dot(M[1], M[1]), dot(M[1], M[2]), dot(M[2], M[2])); // Vrk[1][1], Vrk[1][2], Vrk[2][2]
+}
+
+// --- Main Function ---
+void main(void) {
+    // Calculate the final splat index for this vertex
+    uint instanceOffset = uint(position.z); // Read index within instance from Z
+    uint orderedSplatIndex = splatInstanceIndex + instanceOffset;
+
+    // Discard if this splat index is beyond the sorted count
+    if (orderedSplatIndex >= numSplats) {
+        gl_Position = vec4(2.0, 2.0, 2.0, 1.0); // Off-screen
+        return;
+    }
+
+    // --- Source Data Lookup ---
+    uint texWidth = uint(textureSize(splatOrder, 0).x);
+    ivec2 orderUV = ivec2(orderedSplatIndex % texWidth, orderedSplatIndex / texWidth);
+    uint originalSplatIndex = texelFetch(splatOrder, orderUV, 0).r;
+
+    ivec2 dataUV = ivec2(originalSplatIndex % texWidth, originalSplatIndex / texWidth);
+
+    // Fetch data from textures
+    vec4 texTransformA = texelFetch(transformA, dataUV, 0);
+    vec4 texTransformB = texelFetch(transformB, dataUV, 0);
+    vec4 texColor = texelFetch(splatColor, dataUV, 0);
+
+    vec3 splatPosition = texTransformA.xyz;
+    vec3 splatLogScale = texTransformB.xyz; // Assume stored as log scale
+    vec4 splatRotation = unpackRotation(texTransformA.w, texTransformB.w); // Unpack rot yz, x
+    vec3 splatColor = texColor.rgb;
+    float splatOpacity = texColor.a;
+
+    vec3 splatScale = exp(splatLogScale); // Convert log scale to actual scale
+
+    // --- Center Projection ---
+
+    // Compute normalized view-space center
+    vec4 centerClipRaw = modelViewMatrix * vec4(splatPosition, 1.0);
+    vec3 centerView  = centerClipRaw.xyz / centerClipRaw.w;
+
+    // Early out if splat is behind the camera
+    if (centerView.z > -0.2) { // Use small epsilon
+        gl_Position = vec4(2.0, 2.0, 2.0, 1.0);
+        return;
+    }
+
+    // Project to clip space
+    vec4 centerClip = projectionMatrix * centerClipRaw;
+
+    // --- Covariance Calculation & Projection ---
+
+    // Calculating model space covariance (Vrk)
+    vec3 covA, covB;
+    getModelCovariance(splatScale, splatRotation, covA, covB);
+    mat3 Vrk = mat3(
+        covA.x, covA.y, covA.z,
+        covA.y, covB.x, covB.y, // covB.x is Vrk[1][1]
+        covA.z, covB.y, covB.z  // covB.y is Vrk[1][2], covB.z is Vrk[2][2]
+    );
+
+    // Calculate Jacobian J (screen space change wrt view space change)
+    //    Requres focal lenghts and view-space center depth (tz)
+    float focalX = viewport.x * projectionMatrix[0][0];
+    float focalY = viewport.y * projectionMatrix[1][1];
+    float tz = centerView.z;
+    float tz2 = tz * tz;
+
+    // Jacobian J = [fx/tz,  0,    -fx*tx/tz^2]
+    //              [0,     fy/tz, -fy*ty/tz^2]
+    mat3 J = mat3(
+        focalX / tz,     0.0,  -focalX * centerView.x / tz2,
+        0.0,     focalY / tz,  -focalY * centerView.y / tz2,
+        0.0,             0.0,                0.0
+    );
+
+    // Calculate W 
+    mat3 W = transpose(mat3(modelViewMatrix));
+    // Calculate T = W * J
+    mat3 T = W * J;
+    // Calculate Projected 2D Covariance: SigmaProj = transpose(T) * Vrk * T
+    mat3 SigmaProj = transpose(T) * Vrk * T;
+
+    // Extract 2D components and add bias
+    float cov2D_11 = SigmaProj[0][0] + 0.3;
+    float cov2D_12 = SigmaProj[0][1];
+    float cov2D_22 = SigmaProj[1][1] + 0.3;
+
+    // --- Calculate 2D Screen Space Rotation & Scale ---
+
+    float det = cov2D_11 * cov2D_22 - cov2D_12 * cov2D_12;
+    // Ensure determinant is non-negative before sqrt
+    if (det <= 0.0) {
+      gl_Position = vec4(2.0, 2.0, 2.0, 1.0); // Discard degenerated
+      return;
+    }
+
+    float trace = cov2D_11 + cov2D_22;
+    float traceOver2 = 0.5 * trace;
+    float discriminantSqrt = sqrt(max(traceOver2 * traceOver2 - det, 0.0)); // Avoid sqrt(negative)
+
+    float lambda1 = traceOver2 + discriminantSqrt; // Larger eigenvalue
+    float lambda2 = max(0.1, traceOver2 - discriminantSqrt); // Smaller eigenvalue, clamped
+
+    // Compute eigenvectors 
+
+    vec2 v1_eigen, v2_eigen;
+    
+    // Handle diagonal case
+    if(abs(cov2D_12) < 1e-16) {
+        v1_eigen = vec2(1.0, 0.0);
+    } else {
+        v1_eigen = normalize(vec2(cov2D_12, lambda1 - cov2D_11)); // diagonal choice
+    }
+
+    v2_eigen = vec2(-v1_eigen.y, v1_eigen.x); // Perpendicular eigenvector
+
+    // Calculate SCALED vectors (l1, l2, incorparate factor)
+    float scaleFactor = 2.0 * sqrt(2.0); // ~2.8284
+    float l1 = sqrt(lambda1) * scaleFactor; // scaleX
+    float l2 = sqrt(lambda2) * scaleFactor; // scaleY
+
+    // Early out tiny splats
+    if (l1 < 2.0 && l2 < 2.0) { // Check if smaller than ~2 pixel
+         gl_Position = vec4(2.0, 2.0, 2.0, 1.0);
+         return;
+    }
+
+    // Scaled eigenvectors for offset calculation
+    vec2 v1_scaled = l1 * v1_eigen;
+    vec2 v2_scaled = l2 * v2_eigen;
+
+    // --- FRUSTUM CHECK  ---
+
+    vec2 clipRadius = vec2(max(l1, l2)) * (centerClip.w / viewport);
+
+    // Check if the bounding circle's edge is outside the [-w, w] range in clip space for x or y
+    if (any(greaterThan(abs(centerClip.xy) + clipRadius, vec2(abs(centerClip.w))))) {
+         gl_Position = vec4(2.0, 2.0, 2.0, 1.0); // Off-screen
+         return;
+    }
+
+    // --- END FRUSTUM CHECK ---
+
+    // --- Final Vertex Position ---
+
+    vec2 cornerOffset = position.xy; // (-1,-1) to (1,1)
+
+    // Clip the quad so only high-alpha core is visible
+    float alpha = max(splatOpacity, 1e-6);     // avoid log(0)
+    float clip  = min(1.0, sqrt(-log(1.0 / 255.0 / alpha)) / 2.0);
+
+    // Apply clip to the corner offset *before* calculating screen space offset
+    vec2 clippedCornerOffset = cornerOffset * clip;
+    vec2 screenOffsetPixels = clippedCornerOffset.x * v1_scaled + clippedCornerOffset.y * v2_scaled;
+    //vec2 screenOffsetPixels = vec2(clippedCornerOffset.x, clippedCornerOffset.y);
+
+    // Convert pixel offset to clip space offset
+    vec2 clipOffset = screenOffsetPixels * (centerClip.w / viewport);
+
+
+    // Apply offset to center clip position
+    gl_Position = centerClip + vec4(clipOffset, 0.0, 0.0);
+
+    // --- Pass data to Fragment Shader ---
+
+    vColor = vec4(splatColor, splatOpacity);
+    vUv = clippedCornerOffset;
+}
+`
+), Fe = (
+  /* glsl */
+  `
+precision highp float;
+
+varying vec4 vColor; // Color and opacity passed from vertex shader
+varying vec2 vUv;    // Quad UV coordinates (-1 to 1) passed from vertex shader
+
+void main(void) {
+
+    float distSq = dot(vUv, vUv); // Calculate squared distance from center (in the quad's coordinate system)
+    if (distSq > 1.0) discard; // Discard fragments outside the circle inscribed in the quad
+
+    // Calculate Gaussian function: alpha = opacity * exp(-distSq * factor)
+    // The factor 4.0 corresponds to the original implementation's scaling.
+    // factor = 1 / (2 * sigma^2), where sigma controls the spread.
+    // Using 4.0 implies sigma^2 = 1/8.
+    float alpha = exp(-distSq * 4.0) * vColor.a;
+
+    if (alpha < 1.0 / 255.0) discard; // Discard fragments with very low alpha
+
+    // Premultiply color by alpha (required for correct blending)
+    gl_FragColor = vec4(vColor.rgb * alpha, alpha);
+}
+`
+);
+class Be extends i.ShaderMaterial {
+  constructor(e = {}) {
+    const s = {
+      // Textures (values set via methods)
+      transformA: { value: null },
+      transformB: { value: null },
+      splatColor: { value: null },
+      splatOrder: { value: null },
+      // Other uniforms
+      viewport: { value: new i.Vector2(1, 1) },
+      // Will be updated
+      numSplats: { value: 0 }
+      // Max splats to render (updated by sorter)
+    };
+    super({
+      vertexShader: Oe,
+      fragmentShader: Fe,
+      uniforms: s,
+      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,
+      depthTest: !0,
+      depthWrite: !1,
+      // Disable depth write for transparency
+      side: i.DoubleSide,
+      // Render both sides (or CULLFACE_NONE equivalent)
+      // Optional settings from constructor
+      alphaTest: e.alphaTest !== void 0 ? e.alphaTest : 0,
+      // Typically 0 for blending
+      toneMapped: e.toneMapped !== void 0 ? e.toneMapped : !1
+      // prettier-ignore
+    }), e.alphaHash && (this.alphaHash = !0, this.depthWrite = !0, this.blending = i.NoBlending);
+  }
+  /**
+   * Update the viewport size
+   * @param width Viewport width
+   * @param height Viewport height
+   */
+  updateViewport(e, s) {
+    this.uniforms.viewport.value.set(e, s);
+  }
+  /**
+   * Set transform texture A (positions)
+   * @param texture Texture containing positions
+   */
+  setTransformA(e) {
+    this.uniforms.transformA.value = e;
+  }
+  /**
+   * Set transform texture B (rotation, scale)
+   * @param texture Texture containing rotation and scale data
+   */
+  setTransformB(e) {
+    this.uniforms.transformB.value = e;
+  }
+  /**
+   * Set color texture
+   * @param texture Texture containing colors
+   */
+  setColorTexture(e) {
+    this.uniforms.splatColor.value = e;
+  }
+  /**
+   * Set order texture
+   * @param texture Texture containing sort order
+   */
+  setOrderTexture(e) {
+    this.uniforms.splatOrder.value = e;
+  }
+  /**
+   * Set number of splats to render
+   * @param count Number of splats
+   */
+  setNumSplats(e) {
+    this.uniforms.numSplats.value = e;
+  }
+}
+const K = class K extends i.Mesh {
+  // Match shader constant
+  /**
+   * Create a new SplatMesh for rendering Gaussian splats
+   * @param splatData The splat data to render
+   * @param options Rendering options
+   */
+  constructor(s, o = {}) {
+    const n = new Be(o), t = K.createInstancedGeometry(s.numSplats, K.INSTANCE_SIZE);
+    super(t, n);
+    v(this, "sorter");
+    v(this, "splatData");
+    v(this, "options");
+    v(this, "textureManager");
+    v(this, "material");
+    v(this, "geometry");
+    v(this, "lastCameraPositionLocal", new i.Vector3());
+    v(this, "lastCameraDirectionLocal", new i.Vector3());
+    v(this, "invModelMatrix", new i.Matrix4());
+    this.geometry = t, this.material = n, this.splatData = s, this.frustumCulled = !1, this.options = { autoSort: !0, ...o }, this.textureManager = new Pe(s), this.sorter = new _e();
+    let a = this.createChunks() || void 0;
+    a === null && console.warn("Visus: Could not create sorter chunks, bounding box might be invalid."), a = void 0, this.sorter.init(
+      this.textureManager.orderTexture,
+      this.splatData.centers,
+      a ?? void 0
+    ), this.sorter.addEventListener(
+      "updated",
+      (c) => {
+        const l = c.count;
+        this.geometry.instanceCount = Math.ceil(l / K.INSTANCE_SIZE), this.material.setNumSplats(l);
+      }
+    ), this.material.setTransformA(this.textureManager.transformA), this.material.setTransformB(this.textureManager.transformB), this.material.setColorTexture(this.textureManager.colorTexture), this.material.setOrderTexture(this.textureManager.orderTexture), this.material.setNumSplats(0), this.geometry.boundingBox = s.boundingBox.toBox3(), this.geometry.boundingSphere = new i.Sphere(), this.geometry.boundingBox.getBoundingSphere(this.geometry.boundingSphere);
+  }
+  /**
+   * Creates the instanced geometry for rendering splats.
+   * @param totalSplats Total number of splats in the data.
+   * @param instanceSize Number of splats per instance.
+   * @returns InstancedBufferGeometry
+   */
+  static createInstancedGeometry(s, o) {
+    const n = Math.ceil(s / o), t = new i.BufferGeometry(), a = new Float32Array([
+      // x, y, splat_index_in_instance
+      -1,
+      -1,
+      0,
+      1,
+      -1,
+      0,
+      1,
+      1,
+      0,
+      -1,
+      1,
+      0
+    ]), c = new Uint16Array([0, 1, 2, 0, 2, 3]), l = new Float32Array(4 * 3 * o);
+    for (let p = 0; p < o; p++) {
+      const x = p * 4 * 3;
+      for (let d = 0; d < 4; d++)
+        l[x + d * 3 + 0] = a[d * 3 + 0], l[x + d * 3 + 1] = a[d * 3 + 1], l[x + d * 3 + 2] = p;
+    }
+    const m = new Uint32Array(6 * o);
+    for (let p = 0; p < o; p++) {
+      const x = p * 6, d = p * 4;
+      m[x + 0] = c[0] + d, m[x + 1] = c[1] + d, m[x + 2] = c[2] + d, m[x + 3] = c[3] + d, m[x + 4] = c[4] + d, m[x + 5] = c[5] + d;
+    }
+    t.setAttribute("position", new i.BufferAttribute(l, 3)), t.setIndex(new i.BufferAttribute(m, 1));
+    const M = new i.InstancedBufferGeometry();
+    M.index = t.index, M.setAttribute("position", t.getAttribute("position"));
+    const b = new Uint32Array(n);
+    for (let p = 0; p < n; p++)
+      b[p] = p * o;
+    return M.setAttribute("splatInstanceIndex", new i.InstancedBufferAttribute(b, 1, !1)), M.instanceCount = 0, M;
+  }
+  /**
+   * Create chunks data (bounding box min/max) for the sorter.
+   * @returns Float32Array containing chunk data [minX, minY, minZ, maxX, maxY, maxZ] or null.
+   */
+  createChunks() {
+    const s = this.splatData.boundingBox;
+    return s.min.x === 1 / 0 || s.max.x === -1 / 0 ? null : new Float32Array([
+      s.min.x,
+      s.min.y,
+      s.min.z,
+      s.max.x,
+      s.max.y,
+      s.max.z
+    ]);
+  }
+  /**
+   * Update the viewport size
+   * @param width Viewport width
+   * @param height Viewport height
+   */
+  updateViewport(s, o) {
+    this.material.updateViewport(s, o);
+  }
+  /**
+   * Sorts splats based on camera position and direction.
+   * @param camera The camera to sort against.
+   */
+  sort(s) {
+    const o = new i.Vector3(), n = new i.Vector3();
+    s.getWorldPosition(o), s.getWorldDirection(n), this.invModelMatrix.copy(this.matrixWorld).invert();
+    const t = o.applyMatrix4(this.invModelMatrix), a = n.transformDirection(this.invModelMatrix), c = this.lastCameraPositionLocal.distanceToSquared(t) > 1e-6, l = this.lastCameraDirectionLocal.dot(a) < 0.999;
+    this.options.autoSort && (c || l) && (this.lastCameraPositionLocal.copy(t), this.lastCameraDirectionLocal.copy(a), this.sorter.setCamera(t, a));
+  }
+  /**
+   * THREE.js hook called before rendering the object.
+   * Used here to trigger sorting and update viewport.
+   * @param renderer The renderer
+   * @param scene The scene
+   * @param camera The camera
+   */
+  // prettier-ignore
+  // @ts-expect-error scene is not used
+  onBeforeRender(s, o, n) {
+    this.sort(n);
+    const t = s.getSize(new i.Vector2());
+    let { width: a, height: c } = t;
+    const l = s.xr;
+    if (l.enabled && l.isPresenting) {
+      const m = l.getCamera().cameras[0].view;
+      m && (a = m.width, c = m.height);
+    }
+    this.updateViewport(a, c);
+  }
+  /**
+   * Dispose of resources
+   */
+  dispose() {
+    this.sorter.dispose(), this.geometry.dispose(), this.material.dispose(), this.textureManager.dispose();
+  }
+};
+// Cached inverse matrix
+/** Number of splats combined into a single instanced draw call. */
+v(K, "INSTANCE_SIZE", 128);
+let ae = K, pe = !1;
+typeof window < "u" && !pe && (be({ splatPrimitive: ae }), pe = !0);
+const qe = ({
+  plyUrl: z,
+  splatOptions: e = {},
+  ...s
 }) => {
-  const i = ne(null), a = ue(le, c), s = oe(
-    () => [a, d || {}],
-    [a, d]
+  const o = ge(null), n = Me(ke, z), t = ve(
+    () => [n, e || {}],
+    [n, e]
   );
-  return ae(() => {
-    const u = i.current;
-    return u && !(u instanceof L) && console.warn(
+  return we(() => {
+    const a = o.current;
+    return a && !(a instanceof ae) && console.warn(
       "Visus: The 'Splat' component's internal mesh ref is not an instance of the core SplatMesh. This usually means `extend` was not called correctly. Please ensure you have called `extend({ splatPrimitive: SplatMesh })` in your R3F setup, where 'SplatMesh' is the class imported from 'visus' (or 'visus/react')."
     ), () => {
-      u && typeof u.dispose == "function" && u.dispose();
+      a && typeof a.dispose == "function" && a.dispose();
     };
-  }, []), /* @__PURE__ */ de.jsx("splatPrimitive", { ref: i, args: s, ...m });
+  }, []), /* @__PURE__ */ Ae.jsx("splatPrimitive", { ref: o, args: t, ...s });
 };
 export {
-  le as PlyLoader,
-  Re as Splat,
-  L as SplatMesh
+  ke as PlyLoader,
+  qe as Splat,
+  ae as SplatMesh
 };