@threepipe/plugin-gaussian-splatting 0.1.0

package/dist/index.mjs

@@ -0,0 +1,876 @@
+/**
+ * @license
+ * @threepipe/plugin-gaussian-splatting v0.1.0
+ * Copyright 2022-2024 repalash <palash@shaders.app>
+ * Apache-2.0 License
+ */
+import { MathUtils, Vector2, shaderReplaceString, PerspectiveCamera, PhysicalMaterial, ShaderMaterial2, UnlitMaterial, InstancedBufferGeometry, iGeometryCommons, Matrix4, InstancedBufferAttribute, BufferAttribute, Box3, Sphere, Vector3, Mesh2, Loader, FileLoader, AViewerPluginSync, Importer, createStyles } from "threepipe";
+import { Sphere as Sphere$1, Matrix4 as Matrix4$1, Ray, Vector3 as Vector3$1 } from "threepipe";
+const computeFocalLengths = (width, height, fov, aspect, dpr) => {
+  const fovRad = 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 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 Vector2() },
+      focal: { value: new Vector2() },
+      minAlpha: { value: 0.02 }
+    };
+    this.parsFragmentSnippet = gaussianSplatShaders.pars_frag;
+    this.parsVertexSnippet = gaussianSplatShaders.pars_vert;
+    this.shaderExtender = (shader, material) => {
+      shader.vertexShader = shaderReplaceString(
+        shader.vertexShader,
+        "#include <begin_vertex>",
+        "vec3 transformed = vec3( center );"
+      );
+      if (shader.vertexShader.includes("#include <beginnormal_vertex>")) {
+        shader.vertexShader = shaderReplaceString(
+          shader.vertexShader,
+          "#include <beginnormal_vertex>",
+          "\nobjectNormal = vec3(1,0,0);\n",
+          { append: true }
+        );
+      }
+      shader.vertexShader = shaderReplaceString(
+        shader.vertexShader,
+        "#include <project_vertex>",
+        gaussianSplatShaders.main_vert,
+        { append: true }
+      );
+      if (!material.isGBufferMaterial && !material.userData.isGBufferMaterial) {
+        shader.fragmentShader = shaderReplaceString(
+          shader.fragmentShader,
+          "#include <map_fragment>",
+          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 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 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 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 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 ShaderMaterial2 {
+  constructor() {
+    super({
+      uniforms: {
+        viewport: { value: new Vector2() },
+        focal: { value: new 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 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 PerspectiveCamera) {
+        fov = this._currentCamera.fov;
+        aspect = this._currentCamera.aspect;
+      }
+      this.uniforms.focal.value = computeFocalLengths(width, height, fov, aspect, dpr);
+      this.uniforms.viewport.value = new 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 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 InstancedBufferGeometry {
+  constructor(_worker, _vertexCount, _maxSplats, _onLoad) {
+    super();
+    this._worker = _worker;
+    this._vertexCount = _vertexCount;
+    this._maxSplats = _maxSplats;
+    this._onLoad = _onLoad;
+    this.isGaussianSplatGeometry = true;
+    this.setDirty = iGeometryCommons.setDirty;
+    this.refreshUi = iGeometryCommons.refreshUi;
+    this.appliedMeshes = /* @__PURE__ */ new Set();
+    this._viewProj = [];
+    this._sortRunning = false;
+    this._initialized = false;
+    this._centersBuffer = new Float32Array(0);
+    iGeometryCommons.upgradeGeometry.call(this);
+    this.initAttributes();
+  }
+  async update(camera, meshMatrixWorld) {
+    if (this._sortRunning || !this._initialized || !this._worker) {
+      return;
+    }
+    camera.updateMatrixWorld(true);
+    this._viewProj = new 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 InstancedBufferAttribute(color, 4, true));
+    this.setAttribute("quat", new InstancedBufferAttribute(quat, 4, true));
+    this.setAttribute("scale", new InstancedBufferAttribute(scale, 3, true));
+    this.setAttribute("center", new InstancedBufferAttribute(center, 3, true));
+    this.setAttribute("position", new 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 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 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 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 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 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 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 Sphere$1();
+    sphere.copy(geometry.boundingSphere);
+    sphere.applyMatrix4(matrixWorld);
+    sphere.radius += threshold;
+    if (!raycaster.ray.intersectsSphere(sphere))
+      return;
+    const inverseMatrix = new Matrix4$1();
+    const ray = new 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 Vector3$1();
+    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 Vector3$1();
+        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("" + new URL("assets/worker-dK7pvmNj.js", import.meta.url).href, import.meta.url), { 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 Loader {
+  constructor(manager) {
+    super(manager);
+    this.materialConstructor = (_) => new GaussianSplatMaterialUnlit();
+    this.onGeometryLoad = (_) => {
+      return;
+    };
+  }
+  load(url, onLoad, onProgress, onError) {
+    const loader = new 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 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 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);
+    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 {
+}
+export {
+  GaussianSplattingPlugin,
+  index as threeGaussianSplat
+};
+//# sourceMappingURL=index.mjs.map