@threepipe/plugin-gaussian-splatting 0.1.0

package/dist/index.js

@@ -0,0 +1,879 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("threepipe"), require("three")) : typeof define === "function" && define.amd ? define(["exports", "threepipe", "three"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["@threepipe/plugin-gaussian-splatting"] = {}, global.threepipe, global.threepipe));
+})(this, function(exports2, threepipe, three) {
+  "use strict";/**
+ * @license
+ * @threepipe/plugin-gaussian-splatting v0.1.0
+ * Copyright 2022-2024 repalash <palash@shaders.app>
+ * Apache-2.0 License
+ */
+
+  var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
+  const computeFocalLengths = (width, height, fov, aspect, dpr) => {
+    const fovRad = threepipe.MathUtils.degToRad(fov);
+    const fovXRad = 2 * Math.atan(Math.tan(fovRad / 2) * aspect);
+    const fy = dpr * height / (2 * Math.tan(fovRad / 2));
+    const fx = dpr * width / (2 * Math.tan(fovXRad / 2));
+    return new threepipe.Vector2(fx, fy);
+  };
+  const fragmentParsShaderSource = "precision mediump float;varying vec4 vColor;varying vec3 vConic;varying vec2 vCenter;uniform vec2 viewport;uniform vec2 focal;uniform float minAlpha;";
+  const vertexParsShaderSource = "precision mediump float;\n#ifndef SHADER_NAME\nattribute vec3 position;uniform mat4 modelViewMatrix;uniform mat4 projectionMatrix;mat3 transpose(mat3 m){return mat3(m[0][0],m[1][0],m[2][0],m[0][1],m[1][1],m[2][1],m[0][2],m[1][2],m[2][2]);}\n#endif\nattribute vec4 color;attribute vec4 quat;attribute vec3 scale;attribute vec3 center;uniform vec2 focal;uniform vec2 viewport;varying vec4 vColor;varying vec3 vConic;varying vec2 vCenter;varying vec2 vPosition;mat3 compute_cov3d(vec3 scale,vec4 rot){mat3 S=mat3(scale.x,0.0,0.0,0.0,scale.y,0.0,0.0,0.0,scale.z);mat3 R=mat3(1.0-2.0*(rot.z*rot.z+rot.w*rot.w),2.0*(rot.y*rot.z-rot.x*rot.w),2.0*(rot.y*rot.w+rot.x*rot.z),2.0*(rot.y*rot.z+rot.x*rot.w),1.0-2.0*(rot.y*rot.y+rot.w*rot.w),2.0*(rot.z*rot.w-rot.x*rot.y),2.0*(rot.y*rot.w-rot.x*rot.z),2.0*(rot.z*rot.w+rot.x*rot.y),1.0-2.0*(rot.y*rot.y+rot.z*rot.z));mat3 M=S*R;return transpose(M)*M;}vec3 compute_cov2d(vec3 center,vec3 scale,vec4 rot){mat3 Vrk=compute_cov3d(scale,rot);vec4 t=modelViewMatrix*vec4(center,1.0);vec2 lims=1.3*0.5*viewport/focal;t.xy=min(lims,max(-lims,t.xy/t.z))*t.z;mat3 J=mat3(focal.x/t.z,0.,-(focal.x*t.x)/(t.z*t.z),0.,focal.y/t.z,-(focal.y*t.y)/(t.z*t.z),0.,0.,0.);mat3 W=transpose(mat3(modelViewMatrix));mat3 T=W*J;mat3 cov=transpose(T)*transpose(Vrk)*T;return vec3(cov[0][0]+0.3,cov[0][1],cov[1][1]+0.3);}";
+  const vertexShaderSource = "vec3 cov2d=compute_cov2d(center,scale,quat);float det=cov2d.x*cov2d.z-cov2d.y*cov2d.y;vec3 conic=vec3(cov2d.z,cov2d.y,cov2d.x)/det;float mid=0.5*(cov2d.x+cov2d.z);float lambda1=mid+sqrt(max(0.1,mid*mid-det));float lambda2=mid-sqrt(max(0.1,mid*mid-det));vec2 v1=7.0*sqrt(lambda1)*normalize(vec2(cov2d.y,lambda1-cov2d.x));vec2 v2=7.0*sqrt(lambda2)*normalize(vec2(-(lambda1-cov2d.x),cov2d.y));vColor=color;vConic=conic;vCenter=vec2(gl_Position)/gl_Position.w;vPosition=vec2(vCenter+position.x*(position.y<0.0 ? v1 : v2)/viewport);gl_Position=vec4(vPosition,gl_Position.z/gl_Position.w,1);";
+  const fragmentShaderSource = "vec2 d=(vCenter-2.0*(gl_FragCoord.xy/viewport-vec2(0.5,0.5)))*viewport*0.5;float power=-0.5*(vConic.x*d.x*d.x+vConic.z*d.y*d.y)+vConic.y*d.x*d.y;if(power>0.0)discard;float alpha=min(0.99,vColor.a*exp(power));if(alpha<minAlpha)discard;gl_FragColor=vec4(vColor.rgb,alpha);";
+  const gaussianSplatShaders = {
+    main_frag: "\n" + fragmentShaderSource + "\n",
+    main_vert: "\n" + vertexShaderSource + "\n",
+    pars_frag: fragmentParsShaderSource,
+    pars_vert: vertexParsShaderSource
+  };
+  class GaussianSplatMaterialExtension {
+    constructor() {
+      this.isGaussianSplatMaterialExtension = true;
+      this.extraUniforms = {
+        viewport: { value: new threepipe.Vector2() },
+        focal: { value: new threepipe.Vector2() },
+        minAlpha: { value: 0.02 }
+      };
+      this.parsFragmentSnippet = gaussianSplatShaders.pars_frag;
+      this.parsVertexSnippet = gaussianSplatShaders.pars_vert;
+      this.shaderExtender = (shader, material) => {
+        shader.vertexShader = threepipe.shaderReplaceString(
+          shader.vertexShader,
+          "#include <begin_vertex>",
+          "vec3 transformed = vec3( center );"
+        );
+        if (shader.vertexShader.includes("#include <beginnormal_vertex>")) {
+          shader.vertexShader = threepipe.shaderReplaceString(
+            shader.vertexShader,
+            "#include <beginnormal_vertex>",
+            "\nobjectNormal = vec3(1,0,0);\n",
+            { append: true }
+          );
+        }
+        shader.vertexShader = threepipe.shaderReplaceString(
+          shader.vertexShader,
+          "#include <project_vertex>",
+          gaussianSplatShaders.main_vert,
+          { append: true }
+        );
+        if (!material.isGBufferMaterial && !material.userData.isGBufferMaterial) {
+          shader.fragmentShader = threepipe.shaderReplaceString(
+            shader.fragmentShader,
+            "#include <map_fragment>",
+            threepipe.shaderReplaceString(
+              gaussianSplatShaders.main_frag,
+              /gl_FragColor\s*=/,
+              // because of minification
+              "diffuseColor*="
+            ),
+            { prepend: true }
+          );
+        }
+        return shader;
+      };
+      this.isCompatible = (material) => !!material.isPhysicalMaterial || !!material.isUnlitMaterial || !!material.isGBufferMaterial || !!material.userData.isGBufferMaterial;
+      this._refresh = () => {
+        var _a, _b;
+        if (!this._currentCamera)
+          return;
+        const size = new threepipe.Vector2();
+        (_a = this._renderer) == null ? void 0 : _a.getSize(size);
+        const dpr = ((_b = this._renderer) == null ? void 0 : _b.getPixelRatio()) || 1;
+        let fov = 75;
+        let aspect = size.x / size.y;
+        if (this._currentCamera instanceof threepipe.PerspectiveCamera) {
+          fov = this._currentCamera.fov;
+          aspect = this._currentCamera.aspect;
+        }
+        this.extraUniforms.focal.value = computeFocalLengths(size.x, size.y, fov, aspect, dpr);
+        this.extraUniforms.viewport.value = new threepipe.Vector2(size.x * dpr, size.y * dpr);
+      };
+      window.addEventListener("resize", this._refresh);
+    }
+    set minAlpha(value) {
+      this.extraUniforms.minAlpha.value = value;
+      this.setDirty && this.setDirty();
+    }
+    dispose() {
+      window.removeEventListener("resize", this._refresh);
+    }
+    update(camera, renderer) {
+      if (this._currentCamera === camera && this._renderer === renderer)
+        return;
+      this._renderer = renderer;
+      this._currentCamera = camera;
+      this._refresh();
+    }
+  }
+  class GaussianSplatMaterialPhysical extends threepipe.PhysicalMaterial {
+    constructor() {
+      super({
+        depthTest: true,
+        depthWrite: false,
+        transparent: true,
+        vertexColors: false
+      });
+      this.isGaussianSplatMaterialPhysical = true;
+      this.gsplatExtension = new GaussianSplatMaterialExtension();
+      this.registerMaterialExtensions([this.gsplatExtension]);
+    }
+    dispose() {
+      this.gsplatExtension.dispose();
+      return super.dispose();
+    }
+  }
+  class GaussianSplatMaterialRaw extends threepipe.ShaderMaterial2 {
+    constructor() {
+      super({
+        uniforms: {
+          viewport: { value: new threepipe.Vector2() },
+          focal: { value: new threepipe.Vector2() },
+          minAlpha: { value: 0.02 }
+        },
+        fragmentShader: `${gaussianSplatShaders.pars_frag}
+void main () {
+${gaussianSplatShaders.main_frag}
+}`,
+        vertexShader: `${gaussianSplatShaders.pars_vert}
+void main () {
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(center, 1);
+    ${gaussianSplatShaders.main_vert}
+}`,
+        depthTest: true,
+        depthWrite: false,
+        transparent: true
+      }, true);
+      this.isGaussianSplatMaterialRaw = true;
+      this._refresh = () => {
+        var _a, _b;
+        if (!this._currentCamera)
+          return;
+        const size = new threepipe.Vector2();
+        (_a = this._renderer) == null ? void 0 : _a.getSize(size);
+        const width = size.x;
+        const height = size.y;
+        const dpr = ((_b = this._renderer) == null ? void 0 : _b.getPixelRatio()) || 1;
+        let fov = 75;
+        let aspect = width / height;
+        if (this._currentCamera instanceof threepipe.PerspectiveCamera) {
+          fov = this._currentCamera.fov;
+          aspect = this._currentCamera.aspect;
+        }
+        this.uniforms.focal.value = computeFocalLengths(width, height, fov, aspect, dpr);
+        this.uniforms.viewport.value = new threepipe.Vector2(width * dpr, height * dpr);
+      };
+      window.addEventListener("resize", this._refresh);
+    }
+    set minAlpha(value) {
+      this.uniforms.minAlpha.value = value;
+      this.needsUpdate = true;
+    }
+    dispose() {
+      window.removeEventListener("resize", this._refresh);
+      return super.dispose();
+    }
+    update(camera, renderer) {
+      this._renderer = renderer;
+      this._currentCamera = camera;
+      this._refresh();
+    }
+  }
+  class GaussianSplatMaterialUnlit extends threepipe.UnlitMaterial {
+    constructor() {
+      super({
+        depthTest: true,
+        depthWrite: false,
+        transparent: true,
+        vertexColors: false
+      });
+      this.isGaussianSplatMaterialUnlit = true;
+      this.gsplatExtension = new GaussianSplatMaterialExtension();
+      this.registerMaterialExtensions([this.gsplatExtension]);
+    }
+    dispose() {
+      this.gsplatExtension.dispose();
+      return super.dispose();
+    }
+  }
+  /**
+   * @license
+   * Copyright 2019 Google LLC
+   * SPDX-License-Identifier: Apache-2.0
+   */
+  const proxyMarker = Symbol("Comlink.proxy");
+  const createEndpoint = Symbol("Comlink.endpoint");
+  const releaseProxy = Symbol("Comlink.releaseProxy");
+  const finalizer = Symbol("Comlink.finalizer");
+  const throwMarker = Symbol("Comlink.thrown");
+  const isObject = (val) => typeof val === "object" && val !== null || typeof val === "function";
+  const proxyTransferHandler = {
+    canHandle: (val) => isObject(val) && val[proxyMarker],
+    serialize(obj) {
+      const { port1, port2 } = new MessageChannel();
+      expose(obj, port1);
+      return [port2, [port2]];
+    },
+    deserialize(port) {
+      port.start();
+      return wrap(port);
+    }
+  };
+  const throwTransferHandler = {
+    canHandle: (value) => isObject(value) && throwMarker in value,
+    serialize({ value }) {
+      let serialized;
+      if (value instanceof Error) {
+        serialized = {
+          isError: true,
+          value: {
+            message: value.message,
+            name: value.name,
+            stack: value.stack
+          }
+        };
+      } else {
+        serialized = { isError: false, value };
+      }
+      return [serialized, []];
+    },
+    deserialize(serialized) {
+      if (serialized.isError) {
+        throw Object.assign(new Error(serialized.value.message), serialized.value);
+      }
+      throw serialized.value;
+    }
+  };
+  const transferHandlers = /* @__PURE__ */ new Map([
+    ["proxy", proxyTransferHandler],
+    ["throw", throwTransferHandler]
+  ]);
+  function isAllowedOrigin(allowedOrigins, origin) {
+    for (const allowedOrigin of allowedOrigins) {
+      if (origin === allowedOrigin || allowedOrigin === "*") {
+        return true;
+      }
+      if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
+    ep.addEventListener("message", function callback(ev) {
+      if (!ev || !ev.data) {
+        return;
+      }
+      if (!isAllowedOrigin(allowedOrigins, ev.origin)) {
+        console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);
+        return;
+      }
+      const { id, type, path } = Object.assign({ path: [] }, ev.data);
+      const argumentList = (ev.data.argumentList || []).map(fromWireValue);
+      let returnValue;
+      try {
+        const parent = path.slice(0, -1).reduce((obj2, prop) => obj2[prop], obj);
+        const rawValue = path.reduce((obj2, prop) => obj2[prop], obj);
+        switch (type) {
+          case "GET":
+            {
+              returnValue = rawValue;
+            }
+            break;
+          case "SET":
+            {
+              parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);
+              returnValue = true;
+            }
+            break;
+          case "APPLY":
+            {
+              returnValue = rawValue.apply(parent, argumentList);
+            }
+            break;
+          case "CONSTRUCT":
+            {
+              const value = new rawValue(...argumentList);
+              returnValue = proxy(value);
+            }
+            break;
+          case "ENDPOINT":
+            {
+              const { port1, port2 } = new MessageChannel();
+              expose(obj, port2);
+              returnValue = transfer(port1, [port1]);
+            }
+            break;
+          case "RELEASE":
+            {
+              returnValue = void 0;
+            }
+            break;
+          default:
+            return;
+        }
+      } catch (value) {
+        returnValue = { value, [throwMarker]: 0 };
+      }
+      Promise.resolve(returnValue).catch((value) => {
+        return { value, [throwMarker]: 0 };
+      }).then((returnValue2) => {
+        const [wireValue, transferables] = toWireValue(returnValue2);
+        ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+        if (type === "RELEASE") {
+          ep.removeEventListener("message", callback);
+          closeEndPoint(ep);
+          if (finalizer in obj && typeof obj[finalizer] === "function") {
+            obj[finalizer]();
+          }
+        }
+      }).catch((error) => {
+        const [wireValue, transferables] = toWireValue({
+          value: new TypeError("Unserializable return value"),
+          [throwMarker]: 0
+        });
+        ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+      });
+    });
+    if (ep.start) {
+      ep.start();
+    }
+  }
+  function isMessagePort(endpoint) {
+    return endpoint.constructor.name === "MessagePort";
+  }
+  function closeEndPoint(endpoint) {
+    if (isMessagePort(endpoint))
+      endpoint.close();
+  }
+  function wrap(ep, target) {
+    return createProxy(ep, [], target);
+  }
+  function throwIfProxyReleased(isReleased) {
+    if (isReleased) {
+      throw new Error("Proxy has been released and is not useable");
+    }
+  }
+  function releaseEndpoint(ep) {
+    return requestResponseMessage(ep, {
+      type: "RELEASE"
+    }).then(() => {
+      closeEndPoint(ep);
+    });
+  }
+  const proxyCounter = /* @__PURE__ */ new WeakMap();
+  const proxyFinalizers = "FinalizationRegistry" in globalThis && new FinalizationRegistry((ep) => {
+    const newCount = (proxyCounter.get(ep) || 0) - 1;
+    proxyCounter.set(ep, newCount);
+    if (newCount === 0) {
+      releaseEndpoint(ep);
+    }
+  });
+  function registerProxy(proxy2, ep) {
+    const newCount = (proxyCounter.get(ep) || 0) + 1;
+    proxyCounter.set(ep, newCount);
+    if (proxyFinalizers) {
+      proxyFinalizers.register(proxy2, ep, proxy2);
+    }
+  }
+  function unregisterProxy(proxy2) {
+    if (proxyFinalizers) {
+      proxyFinalizers.unregister(proxy2);
+    }
+  }
+  function createProxy(ep, path = [], target = function() {
+  }) {
+    let isProxyReleased = false;
+    const proxy2 = new Proxy(target, {
+      get(_target, prop) {
+        throwIfProxyReleased(isProxyReleased);
+        if (prop === releaseProxy) {
+          return () => {
+            unregisterProxy(proxy2);
+            releaseEndpoint(ep);
+            isProxyReleased = true;
+          };
+        }
+        if (prop === "then") {
+          if (path.length === 0) {
+            return { then: () => proxy2 };
+          }
+          const r = requestResponseMessage(ep, {
+            type: "GET",
+            path: path.map((p) => p.toString())
+          }).then(fromWireValue);
+          return r.then.bind(r);
+        }
+        return createProxy(ep, [...path, prop]);
+      },
+      set(_target, prop, rawValue) {
+        throwIfProxyReleased(isProxyReleased);
+        const [value, transferables] = toWireValue(rawValue);
+        return requestResponseMessage(ep, {
+          type: "SET",
+          path: [...path, prop].map((p) => p.toString()),
+          value
+        }, transferables).then(fromWireValue);
+      },
+      apply(_target, _thisArg, rawArgumentList) {
+        throwIfProxyReleased(isProxyReleased);
+        const last = path[path.length - 1];
+        if (last === createEndpoint) {
+          return requestResponseMessage(ep, {
+            type: "ENDPOINT"
+          }).then(fromWireValue);
+        }
+        if (last === "bind") {
+          return createProxy(ep, path.slice(0, -1));
+        }
+        const [argumentList, transferables] = processArguments(rawArgumentList);
+        return requestResponseMessage(ep, {
+          type: "APPLY",
+          path: path.map((p) => p.toString()),
+          argumentList
+        }, transferables).then(fromWireValue);
+      },
+      construct(_target, rawArgumentList) {
+        throwIfProxyReleased(isProxyReleased);
+        const [argumentList, transferables] = processArguments(rawArgumentList);
+        return requestResponseMessage(ep, {
+          type: "CONSTRUCT",
+          path: path.map((p) => p.toString()),
+          argumentList
+        }, transferables).then(fromWireValue);
+      }
+    });
+    registerProxy(proxy2, ep);
+    return proxy2;
+  }
+  function myFlat(arr) {
+    return Array.prototype.concat.apply([], arr);
+  }
+  function processArguments(argumentList) {
+    const processed = argumentList.map(toWireValue);
+    return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];
+  }
+  const transferCache = /* @__PURE__ */ new WeakMap();
+  function transfer(obj, transfers) {
+    transferCache.set(obj, transfers);
+    return obj;
+  }
+  function proxy(obj) {
+    return Object.assign(obj, { [proxyMarker]: true });
+  }
+  function toWireValue(value) {
+    for (const [name, handler] of transferHandlers) {
+      if (handler.canHandle(value)) {
+        const [serializedValue, transferables] = handler.serialize(value);
+        return [
+          {
+            type: "HANDLER",
+            name,
+            value: serializedValue
+          },
+          transferables
+        ];
+      }
+    }
+    return [
+      {
+        type: "RAW",
+        value
+      },
+      transferCache.get(value) || []
+    ];
+  }
+  function fromWireValue(value) {
+    switch (value.type) {
+      case "HANDLER":
+        return transferHandlers.get(value.name).deserialize(value.value);
+      case "RAW":
+        return value.value;
+    }
+  }
+  function requestResponseMessage(ep, msg, transfers) {
+    return new Promise((resolve) => {
+      const id = generateUUID();
+      ep.addEventListener("message", function l(ev) {
+        if (!ev.data || !ev.data.id || ev.data.id !== id) {
+          return;
+        }
+        ep.removeEventListener("message", l);
+        resolve(ev.data);
+      });
+      if (ep.start) {
+        ep.start();
+      }
+      ep.postMessage(Object.assign({ id }, msg), transfers);
+    });
+  }
+  function generateUUID() {
+    return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
+  }
+  class GaussianSplatGeometry extends threepipe.InstancedBufferGeometry {
+    constructor(_worker, _vertexCount, _maxSplats, _onLoad) {
+      super();
+      this._worker = _worker;
+      this._vertexCount = _vertexCount;
+      this._maxSplats = _maxSplats;
+      this._onLoad = _onLoad;
+      this.isGaussianSplatGeometry = true;
+      this.setDirty = threepipe.iGeometryCommons.setDirty;
+      this.refreshUi = threepipe.iGeometryCommons.refreshUi;
+      this.appliedMeshes = /* @__PURE__ */ new Set();
+      this._viewProj = [];
+      this._sortRunning = false;
+      this._initialized = false;
+      this._centersBuffer = new Float32Array(0);
+      threepipe.iGeometryCommons.upgradeGeometry.call(this);
+      this.initAttributes();
+    }
+    async update(camera, meshMatrixWorld) {
+      if (this._sortRunning || !this._initialized || !this._worker) {
+        return;
+      }
+      camera.updateMatrixWorld(true);
+      this._viewProj = new threepipe.Matrix4().multiply(camera.projectionMatrix).multiply(camera.matrixWorldInverse).multiply(meshMatrixWorld).elements;
+      this._sortRunning = true;
+      const viewProj = new Float32Array(this._viewProj);
+      const result = await this._worker.runSort(viewProj);
+      const { quat, scale, center, color } = this._extractViews(result);
+      if (this._centersBuffer.length !== center.length)
+        this._centersBuffer = new Float32Array(center);
+      else
+        this._centersBuffer.set(center);
+      this.attributes.color.array = color;
+      this.attributes.quat.array = quat;
+      this.attributes.scale.array = scale;
+      this.attributes.center.array = this._centersBuffer;
+      const pms = Promise.all([
+        new Promise((resolve) => this.attributes.color.onUpload(resolve)),
+        new Promise((resolve) => this.attributes.quat.onUpload(resolve)),
+        new Promise((resolve) => this.attributes.scale.onUpload(resolve))
+        // new Promise<void>(resolve => (this.attributes.center as InstancedBufferAttribute).onUpload(resolve)),
+      ]);
+      this.attributes.color.needsUpdate = true;
+      this.attributes.quat.needsUpdate = true;
+      this.attributes.scale.needsUpdate = true;
+      this.attributes.center.needsUpdate = true;
+      this.setDirty();
+      await pms;
+      await this._worker.returnBuffer(transfer(result, [result]));
+      this._sortRunning = false;
+    }
+    async initAttributes() {
+      const viewProj = new Float32Array(this._viewProj);
+      const result = await this._worker.runSort(viewProj);
+      const { quat, scale, center, color } = this._extractViews(result);
+      this.setAttribute("color", new threepipe.InstancedBufferAttribute(color, 4, true));
+      this.setAttribute("quat", new threepipe.InstancedBufferAttribute(quat, 4, true));
+      this.setAttribute("scale", new threepipe.InstancedBufferAttribute(scale, 3, true));
+      this.setAttribute("center", new threepipe.InstancedBufferAttribute(center, 3, true));
+      this.setAttribute("position", new threepipe.BufferAttribute(new Float32Array([1, -1, 0, 1, 1, 0, -1, -1, 0, -1, 1, 0]), 3, true));
+      this.attributes.position.needsUpdate = true;
+      this.setIndex(new threepipe.BufferAttribute(new Uint16Array([0, 1, 2, 2, 3, 0]), 1, true));
+      this.instanceCount = Math.min(quat.length / 4, this._maxSplats);
+      this.computeBoundingBox();
+      this.computeBoundingSphere();
+      this._initialized = true;
+      this.setDirty();
+      this._onLoad && this._onLoad(this);
+    }
+    _extractViews(receivedBuffer) {
+      const combined = new Float32Array(receivedBuffer);
+      const quatLength = 4 * this._vertexCount;
+      const scaleLength = 3 * this._vertexCount;
+      const centerLength = 3 * this._vertexCount;
+      const colorLength = 4 * this._vertexCount;
+      const quatOffset = 0;
+      const scaleOffset = quatOffset + quatLength;
+      const centerOffset = scaleOffset + scaleLength;
+      const colorOffset = centerOffset + centerLength;
+      const quat = combined.subarray(quatOffset, quatOffset + quatLength);
+      const scale = combined.subarray(scaleOffset, scaleOffset + scaleLength);
+      const center = combined.subarray(centerOffset, centerOffset + centerLength);
+      const color = combined.subarray(colorOffset, colorOffset + colorLength);
+      return { quat, scale, center, color };
+    }
+    computeBoundingBox() {
+      if (!this.getAttribute("center"))
+        return super.computeBoundingBox();
+      const box = this.boundingBox ?? (this.boundingBox = new threepipe.Box3());
+      box.setFromBufferAttribute(this.getAttribute("center"));
+      if (isNaN(this.boundingBox.min.x) || isNaN(this.boundingBox.min.y) || isNaN(this.boundingBox.min.z)) {
+        console.error('GaussianSplatGeometry.computeBoundingBox(): Computed min/max have NaN values. The "position" attribute is likely to have NaN values.', this);
+      }
+    }
+    computeBoundingSphere() {
+      if (this.boundingSphere === null)
+        this.boundingSphere = new threepipe.Sphere();
+      const position = this.attributes.center;
+      if (position && position.isGLBufferAttribute) {
+        console.error('THREE.BufferGeometry.computeBoundingSphere(): GLBufferAttribute requires a manual bounding sphere. Alternatively set "mesh.frustumCulled" to "false".', this);
+        this.boundingSphere.set(new threepipe.Vector3(), Infinity);
+        return;
+      }
+      if (position) {
+        const center = this.boundingSphere.center;
+        if (!this.boundingBox)
+          this.computeBoundingBox();
+        this.boundingBox.getCenter(center);
+        let maxRadiusSq = 0;
+        const vector = new threepipe.Vector3();
+        for (let i = 0, il = position.count; i < il; i++) {
+          vector.fromBufferAttribute(position, i);
+          maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(vector));
+        }
+        this.boundingSphere.radius = Math.sqrt(maxRadiusSq);
+        if (isNaN(this.boundingSphere.radius)) {
+          console.error('THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.', this);
+        }
+      }
+    }
+  }
+  class GaussianSplatMesh extends threepipe.Mesh2 {
+    constructor(geometry, material) {
+      super(geometry, material);
+      this.isGaussianSplatMesh = true;
+      this.frustumCulled = false;
+    }
+    async update(camera, renderer) {
+      var _a;
+      if ((_a = this.material) == null ? void 0 : _a.isGaussianSplatMaterialRaw) {
+        this.material.update(camera, renderer);
+      } else if (this.material) {
+        const ext = this.material.gsplatExtension ?? this.material.materialExtensions.find((e) => e.isGaussianSplatMaterialExtension);
+        ext && ext.update(camera, renderer);
+      }
+      this.updateMatrixWorld(true);
+      return this.geometry.update(camera, this.matrixWorld);
+    }
+    raycast(raycaster, intersects) {
+      const geometry = this.geometry;
+      const matrixWorld = this.matrixWorld;
+      const threshold = 0.02;
+      if (geometry.boundingSphere === null)
+        geometry.computeBoundingSphere();
+      const sphere = new three.Sphere();
+      sphere.copy(geometry.boundingSphere);
+      sphere.applyMatrix4(matrixWorld);
+      sphere.radius += threshold;
+      if (!raycaster.ray.intersectsSphere(sphere))
+        return;
+      const inverseMatrix = new three.Matrix4();
+      const ray = new three.Ray();
+      inverseMatrix.copy(matrixWorld).invert();
+      ray.copy(raycaster.ray).applyMatrix4(inverseMatrix);
+      const localThreshold = threshold / ((this.scale.x + this.scale.y + this.scale.z) / 3);
+      const localThresholdSq = localThreshold * localThreshold;
+      const attributes = geometry.attributes;
+      const positionAttribute = attributes.center;
+      const position = new three.Vector3();
+      for (let i = 0, l = positionAttribute.count; i < l; i++) {
+        position.fromBufferAttribute(positionAttribute, i);
+        const rayPointDistanceSq = ray.distanceSqToPoint(position);
+        if (rayPointDistanceSq < localThresholdSq) {
+          const intersectPoint = new three.Vector3();
+          ray.closestPointToPoint(position, intersectPoint);
+          intersectPoint.applyMatrix4(matrixWorld);
+          const distance = raycaster.ray.origin.distanceTo(intersectPoint);
+          if (distance < raycaster.near || distance > raycaster.far)
+            return;
+          intersects.push({
+            distance,
+            distanceToRay: Math.sqrt(rayPointDistanceSq),
+            point: intersectPoint,
+            face: null,
+            object: this
+          });
+        }
+      }
+    }
+  }
+  const styles = "";
+  const SPLAT_ROW_LENGTH = 3 * 4 + 3 * 4 + 4 + 4;
+  function trimBuffer(_buffer, _maxSplats, _vertexCount) {
+    const actualVertexCount = Math.min(_vertexCount, _maxSplats);
+    const actualBufferSize = SPLAT_ROW_LENGTH * actualVertexCount;
+    const buffer = _buffer.slice(0, actualBufferSize);
+    return { buffer, vertexCount: actualVertexCount };
+  }
+  class SortWorkerManager {
+    constructor() {
+      this._workers = [];
+      this._maxWorkers = 8;
+      this.onError = (e) => {
+        console.error(e);
+        console.error(
+          "ERROR: Line ",
+          e.lineno,
+          " in ",
+          e.filename,
+          ": ",
+          e.message
+        );
+      };
+      const worker = new Worker(new URL("" + (typeof document === "undefined" && typeof location === "undefined" ? require("url").pathToFileURL(__dirname + "/assets/worker-dK7pvmNj.js").href : new URL("assets/worker-dK7pvmNj.js", typeof document === "undefined" ? location.href : document.currentScript && document.currentScript.src || document.baseURI).href), typeof document === "undefined" && typeof location === "undefined" ? require("url").pathToFileURL(__filename).href : typeof document === "undefined" ? location.href : _documentCurrentScript && _documentCurrentScript.src || new URL("index.js", document.baseURI).href), { type: "module" });
+      worker.addEventListener("error", this.onError, false);
+      this._workerCtor = wrap(worker);
+    }
+    async createWorker(data, maxSplats = 1e6) {
+      if (this._workers.length < this._maxWorkers) {
+        const vertexCount = Math.floor(data.length / SPLAT_ROW_LENGTH);
+        const bufferInfo = trimBuffer(data, maxSplats, vertexCount);
+        const globalBuffer = transfer(bufferInfo.buffer, [bufferInfo.buffer.buffer]);
+        const worker = await new this._workerCtor(vertexCount, globalBuffer);
+        await worker.load();
+        this._workers.push(worker);
+        return worker;
+      }
+      console.error("Max workers reached");
+      throw new Error("Max workers reached");
+    }
+    async disposeWorker(worker) {
+      const index2 = this._workers.indexOf(worker);
+      if (index2 !== -1) {
+        this._workers.splice(index2, 1);
+        await worker.dispose();
+      }
+    }
+  }
+  class SplatLoader extends threepipe.Loader {
+    constructor(manager) {
+      super(manager);
+      this.materialConstructor = (_) => new GaussianSplatMaterialUnlit();
+      this.onGeometryLoad = (_) => {
+        return;
+      };
+    }
+    load(url, onLoad, onProgress, onError) {
+      const loader = new threepipe.FileLoader(this.manager);
+      loader.setPath(this.path);
+      loader.setResponseType("arraybuffer");
+      loader.setRequestHeader(this.requestHeader);
+      loader.setWithCredentials(this.withCredentials);
+      loader.load(url, async (buffer) => {
+        try {
+          const data = new Uint8Array(buffer);
+          const maxSplats = 1e6;
+          const vertexCount = Math.floor(data.length / SPLAT_ROW_LENGTH);
+          const worker = await this.sortWorkerManager.createWorker(data, maxSplats);
+          const geometry = new GaussianSplatGeometry(worker, vertexCount, maxSplats, this.onGeometryLoad);
+          const mesh = new GaussianSplatMesh(geometry, this.materialConstructor(geometry));
+          mesh.rotation.x = Math.PI;
+          if (!url.startsWith("blob:") && !url.startsWith("data:"))
+            mesh.name = url.split("/").pop().split("?")[0];
+          onLoad && onLoad(mesh);
+        } catch (e) {
+          if (onError)
+            onError(e);
+          else
+            console.error(e);
+          this.manager.itemError(url);
+        }
+      }, onProgress, onError);
+    }
+    async loadAsync(url, onProgress) {
+      return new Promise((resolve, reject) => this.load(url, resolve, onProgress, reject));
+    }
+  }
+  const _ThreeGaussianSplatPlugin = class _ThreeGaussianSplatPlugin extends threepipe.AViewerPluginSync {
+    constructor() {
+      super();
+      this.enabled = true;
+      this.dependencies = [];
+      this.toJSON = null;
+      this.splats = [];
+      this._ready = false;
+      this._activeCameraUpdate = () => {
+        if (!this._ready || this.isDisabled())
+          return;
+        this.splats.forEach(async (splat) => splat.update(this._viewer.scene.mainCamera, this._viewer.renderManager.webglRenderer));
+      };
+      this._geometryUpdate = (event) => {
+        var _a;
+        if (!this._ready || this.isDisabled() || !((_a = event.geometry) == null ? void 0 : _a.isGaussianSplatGeometry))
+          return;
+        event.geometry.appliedMeshes.forEach(async (splat) => splat.update ? splat.update(this._viewer.scene.mainCamera, this._viewer.renderManager.webglRenderer) : void 0);
+      };
+      this._sortWorkerManager = new SortWorkerManager();
+      this._importer = new threepipe.Importer(class extends SplatLoader {
+        constructor() {
+          super(...arguments);
+          this.onDispose = () => {
+            return;
+          };
+          this.onCreate = () => {
+            return;
+          };
+        }
+        transform(res, _) {
+          res.addEventListener("dispose", () => this.onDispose(res));
+          this.onCreate(res);
+          return res;
+        }
+      }, ["splat"], [], true, (l) => {
+        if (!l)
+          return l;
+        l.sortWorkerManager = this._sortWorkerManager;
+        l.onDispose = (mesh) => {
+          this.splats = this.splats.filter((splat) => splat !== mesh);
+        };
+        l.onCreate = (mesh) => {
+          this.splats.push(mesh);
+        };
+        l.onGeometryLoad = (_) => {
+          var _a;
+          (_a = this._viewer) == null ? void 0 : _a.setDirty();
+        };
+        return l;
+      });
+    }
+    onAdded(viewer) {
+      super.onAdded(viewer);
+      threepipe.createStyles(styles);
+      viewer.assetManager.importer.addImporter(this._importer);
+      viewer.scene.addEventListener("mainCameraUpdate", this._activeCameraUpdate);
+      viewer.scene.addEventListener("geometryUpdate", this._geometryUpdate);
+      this._ready = true;
+    }
+    onRemove(viewer) {
+      viewer.assetManager.importer.removeImporter(this._importer);
+    }
+    // protected _viewerListeners = {
+    //     preRender: (_: IViewerEvent) => {
+    //     },
+    // }
+  };
+  _ThreeGaussianSplatPlugin.PluginType = "ThreeGaussianSplatPlugin";
+  let ThreeGaussianSplatPlugin = _ThreeGaussianSplatPlugin;
+  /**
+   * ThreeGaussianSplatPlugin: Threejs utilities and threepipe plugin and material extension for Gaussian Splatting
+   *
+   * @license
+   * A port of -
+   * https://github.com/zappar-xr/three-gaussian-splat
+   * MIT License (c) 2023 Zappar Limited
+   * Which is based on -
+   * gsplat.js, MIT License (c) 2023 Dylan Ebert
+   * antimatter15/splat, MIT License (c) 2023 Kevin Kwok
+   */
+  const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+    __proto__: null,
+    GaussianSplatGeometry,
+    GaussianSplatMaterialExtension,
+    GaussianSplatMaterialPhysical,
+    GaussianSplatMaterialRaw,
+    GaussianSplatMaterialUnlit,
+    GaussianSplatMesh,
+    SplatLoader,
+    ThreeGaussianSplatPlugin,
+    computeFocalLengths,
+    gaussianSplatShaders
+  }, Symbol.toStringTag, { value: "Module" }));
+  class GaussianSplattingPlugin extends ThreeGaussianSplatPlugin {
+  }
+  exports2.GaussianSplattingPlugin = GaussianSplattingPlugin;
+  exports2.threeGaussianSplat = index;
+  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+});
+//# sourceMappingURL=index.js.map