@viggle/splat-engine-three 0.0.0-stage → 0.1.0

package/dist/webgpu.js

@@ -0,0 +1,813 @@
+import {
+  Animation,
+  Armature,
+  Character,
+  CharacterBundleError,
+  EngineDisposedError,
+  Environment,
+  PointLight,
+  SkyLight,
+  Splat,
+  SplatCharacter,
+  SplatClipLoader,
+  SplatEngine,
+  SplatMesh,
+  SplatPLYLoader,
+  SunLight,
+  VSplatLoader,
+  WebGLSplatBackend,
+  decodeCharacterBundle,
+  loadCharacterBundle,
+  loadCharacterBundleFromBytes,
+  makeRegionMask,
+  packSplats,
+  parseGaussianPly,
+  registerWebGPUBackend
+} from "./chunks/chunk-MM6DJU6S.js";
+
+// src/splat/webgpu/lighting.ts
+import * as TSL from "three/tsl";
+import { Vector4 } from "three/webgpu";
+var { Fn, If, Loop, float, int, length, uniform, uniformArray } = TSL;
+var MAX_POINT_LIGHTS = 16;
+var WebGPULighting = class {
+  _engine;
+  _sunColor;
+  _sunIntensity;
+  _ambient;
+  _pointCount;
+  _pointPosRange;
+  _pointColor;
+  _pointPosRangeNode;
+  _pointColorNode;
+  _version = -1;
+  constructor(engine) {
+    this._engine = engine;
+    this._sunColor = uniform(engine.lightingUniforms.uSunColor.value);
+    this._ambient = uniform(engine.lightingUniforms.uAmbientColor.value);
+    this._sunIntensity = uniform(0);
+    this._pointCount = uniform(0, "int");
+    this._pointPosRange = Array.from({ length: MAX_POINT_LIGHTS }, () => new Vector4());
+    this._pointColor = Array.from({ length: MAX_POINT_LIGHTS }, () => new Vector4());
+    this._pointPosRangeNode = uniformArray(this._pointPosRange, "vec4");
+    this._pointColorNode = uniformArray(this._pointColor, "vec4");
+  }
+  /**
+   * Refresh the uniforms from the engine's lighting registry.
+   * @returns A number that changes whenever the lighting does.
+   */
+  sync() {
+    const engine = this._engine;
+    engine.syncLighting();
+    if (engine.lightingVersion === this._version) return this._version;
+    this._version = engine.lightingVersion;
+    this._sunIntensity.value = engine.lightingUniforms.uSunIntensity.value;
+    let count = 0;
+    for (const p of engine.lighting.points) {
+      if (!p.enabled) continue;
+      if (count === MAX_POINT_LIGHTS) break;
+      this._pointPosRange[count].set(p.position.x, p.position.y, p.position.z, p.range);
+      this._pointColor[count].set(p.color.r, p.color.g, p.color.b, p.intensity);
+      count++;
+    }
+    this._pointCount.value = count;
+    return this._version;
+  }
+  /**
+   * The multiplier applied to a splat's baked colour: ambient, plus sun, plus
+   * range-attenuated point lights. With no lights it is exactly 1.
+   */
+  litFactor(worldCenter) {
+    return Fn(() => {
+      const lit = this._ambient.add(this._sunColor.mul(this._sunIntensity)).toVar();
+      Loop({ start: int(0), end: this._pointCount, type: "int", condition: "<" }, ({ i }) => {
+        const posRange = this._pointPosRangeNode.element(i);
+        const colorInt = this._pointColorNode.element(i);
+        const dist = length(posRange.xyz.sub(worldCenter)).toVar();
+        If(dist.lessThan(posRange.w), () => {
+          const t = dist.div(posRange.w);
+          const atten = float(1).sub(t.mul(t)).toVar();
+          lit.addAssign(colorInt.xyz.mul(colorInt.w).mul(atten.mul(atten)));
+        });
+      });
+      return lit;
+    })();
+  }
+};
+
+// src/splat/webgpu/splat-mesh.ts
+import * as TSL3 from "three/tsl";
+import {
+  BufferAttribute,
+  DoubleSide,
+  InstancedBufferGeometry,
+  Matrix3,
+  Matrix4,
+  NodeMaterial,
+  Quaternion,
+  SRGBColorSpace,
+  Sphere,
+  StorageBufferAttribute as StorageBufferAttribute2,
+  Vector2,
+  Vector3,
+  Vector4 as Vector42
+} from "three/webgpu";
+
+// src/splat/webgpu/radix-sort.ts
+import * as TSL2 from "three/tsl";
+import { StorageBufferAttribute } from "three/webgpu";
+var { Fn: Fn2, If: If2, Loop: Loop2, atomicAdd, atomicStore, instanceIndex, storage, uint } = TSL2;
+var SORT_KEY_BITS = 16;
+var RADIX = 256;
+var BLOCK = 256;
+var GpuRadixSort = class {
+  count;
+  /** Write each element's key here (`uint`, low 16 bits significant) before {@link GpuRadixSort.sortNodes} run. */
+  keysWrite;
+  /** Element indices in ascending key order, valid after {@link GpuRadixSort.sortNodes} have run. */
+  orderRead;
+  /** Run before the pass that writes keys: clears both digit histograms. */
+  resetNode;
+  /** Run, in order, after the pass that writes keys. */
+  sortNodes;
+  _firstHistogram;
+  constructor(count) {
+    this.count = count;
+    const blocks = Math.max(1, Math.ceil(count / BLOCK));
+    const histogramSize = blocks * RADIX;
+    const keysAttribute = new StorageBufferAttribute(new Uint32Array(count), 1);
+    const histogramAttributes = [
+      new StorageBufferAttribute(new Uint32Array(histogramSize), 1),
+      new StorageBufferAttribute(new Uint32Array(histogramSize), 1)
+    ];
+    const digitAttribute = new StorageBufferAttribute(new Uint32Array(RADIX), 1);
+    const halfSortedAttribute = new StorageBufferAttribute(new Uint32Array(count), 1);
+    const orderAttribute = new StorageBufferAttribute(new Uint32Array(count), 1);
+    this.keysWrite = storage(keysAttribute, "uint", count);
+    const keys = storage(keysAttribute, "uint", count).toReadOnly();
+    this.orderRead = storage(orderAttribute, "uint", count).toReadOnly();
+    this._firstHistogram = storage(histogramAttributes[0], "uint", histogramSize).toAtomic();
+    const secondHistogramAtomic = storage(histogramAttributes[1], "uint", histogramSize).toAtomic();
+    const digits = storage(digitAttribute, "uint", RADIX);
+    const halfSortedWrite = storage(halfSortedAttribute, "uint", count);
+    const halfSorted = storage(halfSortedAttribute, "uint", count).toReadOnly();
+    const orderWrite = storage(orderAttribute, "uint", count);
+    this.resetNode = Fn2(() => {
+      atomicStore(this._firstHistogram.element(instanceIndex), uint(0));
+      atomicStore(secondHistogramAtomic.element(instanceIndex), uint(0));
+    })().compute(histogramSize, [256]).setName("SplatSortReset");
+    const prefixBlocks = (pass) => {
+      const histogram = storage(histogramAttributes[pass], "uint", histogramSize);
+      return Fn2(() => {
+        const sum = uint(0).toVar();
+        Loop2({ start: 0, end: blocks, type: "uint", name: "b", condition: "<" }, ({ b }) => {
+          const slot = b.mul(RADIX).add(instanceIndex).toVar();
+          const n = histogram.element(slot).toVar();
+          histogram.element(slot).assign(sum);
+          sum.addAssign(n);
+        });
+        digits.element(instanceIndex).assign(sum);
+      })().compute(RADIX, [64]).setName(`SplatSortPrefixBlocks${pass}`);
+    };
+    const prefixDigits = (pass) => Fn2(() => {
+      const sum = uint(0).toVar();
+      Loop2({ start: 0, end: RADIX, type: "uint", name: "d", condition: "<" }, ({ d }) => {
+        const n = digits.element(d).toVar();
+        digits.element(d).assign(sum);
+        sum.addAssign(n);
+      });
+    })().compute(1).setName(`SplatSortPrefixDigits${pass}`);
+    const scatter = (pass, input, output) => {
+      const histogram = storage(histogramAttributes[pass], "uint", histogramSize);
+      const digitBases = storage(digitAttribute, "uint", RADIX).toReadOnly();
+      return Fn2(() => {
+        const first = instanceIndex.mul(BLOCK).toVar();
+        Loop2({ start: 0, end: BLOCK, type: "uint", name: "j", condition: "<" }, ({ j }) => {
+          const position = first.add(j).toVar();
+          If2(position.lessThan(uint(count)), () => {
+            const element = (input ? input.element(position) : position).toVar();
+            const key = keys.element(element).toVar();
+            const digit = (pass === 0 ? key.bitAnd(uint(RADIX - 1)) : key.shiftRight(uint(8)).bitAnd(uint(RADIX - 1))).toVar();
+            const slot = instanceIndex.mul(RADIX).add(digit).toVar();
+            const within = histogram.element(slot).toVar();
+            histogram.element(slot).assign(within.add(1));
+            output.element(digitBases.element(digit).add(within)).assign(element);
+          });
+        });
+      })().compute(blocks, [64]).setName(`SplatSortScatter${pass}`);
+    };
+    const secondHistogramNode = Fn2(() => {
+      const element = halfSorted.element(instanceIndex).toVar();
+      const digit = keys.element(element).shiftRight(uint(8)).bitAnd(uint(RADIX - 1)).toVar();
+      const block = instanceIndex.div(uint(BLOCK));
+      atomicAdd(secondHistogramAtomic.element(block.mul(RADIX).add(digit)), uint(1));
+    })().compute(count, [256]).setName("SplatSortHistogram1");
+    this.sortNodes = [
+      prefixBlocks(0),
+      prefixDigits(0),
+      scatter(0, null, halfSortedWrite),
+      secondHistogramNode,
+      prefixBlocks(1),
+      prefixDigits(1),
+      scatter(1, halfSorted, orderWrite)
+    ];
+  }
+  /**
+   * Count `key`'s low digit for the element at `index`. Call from inside the
+   * compute pass that writes the keys.
+   */
+  countFirstDigit(index, key) {
+    const block = index.div(uint(BLOCK));
+    const digit = key.bitAnd(uint(RADIX - 1));
+    atomicAdd(this._firstHistogram.element(block.mul(RADIX).add(digit)), uint(1));
+  }
+};
+
+// src/splat/webgpu/splat-mesh.ts
+var {
+  Discard,
+  Fn: Fn3,
+  If: If3,
+  Loop: Loop3,
+  clamp,
+  dot,
+  exp,
+  float: float2,
+  instanceIndex: instanceIndex2,
+  length: length2,
+  log,
+  max,
+  min,
+  mix,
+  normalize,
+  positionGeometry,
+  select,
+  sqrt,
+  storage: storage2,
+  uint: uint2,
+  uintBitsToFloat,
+  uniform: uniform2,
+  uniformArray: uniformArray2,
+  unpackHalf2x16,
+  uvec4,
+  varyingProperty,
+  vec2,
+  vec3,
+  vec4
+} = TSL3;
+var SORT_BINS = 1 << SORT_KEY_BITS;
+var WORKGROUP_SIZE = 256;
+var MAX_VARIANT_GROUPS = 64;
+var EXP4 = Math.exp(-4);
+var INV_EXP4 = 1 / (1 - EXP4);
+var _position = new Vector3();
+var _quaternion = new Quaternion();
+var _scale = new Vector3();
+var _viewport = new Vector42();
+var _sphere = new Sphere();
+var _viewCenter = new Vector3();
+var _direction = new Vector3();
+var INPUT_SLOTS = 80;
+var WebGPUSplatImpl = class {
+  geometry;
+  material;
+  /** Skinning for the sort happens in compute; the CPU never touches a splat. */
+  needsCpuCenters = false;
+  _host;
+  _splat;
+  _lighting;
+  _paletteArray;
+  _paletteAttribute;
+  _paletteVersion = -1;
+  _boneAttribute = null;
+  _groupAttribute = null;
+  _variantMask = new Array(MAX_VARIANT_GROUPS).fill(1);
+  /** [sort reset, project] - everything that depends on the camera or the pose. */
+  _projectNodes = [];
+  /** The sort proper - needed only when the depth ORDER may have changed. */
+  _sortNodes = [];
+  // What the last compute run saw. Compared field by field each frame so an
+  // unchanged splat costs a draw call and nothing else.
+  _lastInputs = new Float64Array(INPUT_SLOTS).fill(NaN);
+  _inputs = new Float64Array(INPUT_SLOTS);
+  _lastSortDirection = new Vector3(NaN, NaN, NaN);
+  _buildId = 0;
+  _sortedBuildId = -1;
+  _allNodes = null;
+  // Per-drawable uniforms, refreshed in onBeforeRender.
+  _u = {
+    model: uniform2(new Matrix4()),
+    modelLinear: uniform2(new Matrix3()),
+    modelRotation: uniform2(new Vector42(0, 0, 0, 1)),
+    modelScale: uniform2(new Vector3(1, 1, 1)),
+    view: uniform2(new Matrix4()),
+    viewRow0: uniform2(new Vector3()),
+    viewRow1: uniform2(new Vector3()),
+    viewRow2: uniform2(new Vector3()),
+    projection: uniform2(new Matrix4()),
+    viewport: uniform2(new Vector2(1, 1)),
+    minPixelSize: uniform2(0),
+    // x: far depth, y: 1 / (far - near), along the view axis.
+    sortRange: uniform2(new Vector2(1, 1)),
+    tint: uniform2(new Vector42(1, 1, 1, 0)),
+    grade: uniform2(new Vector2(1, 1)),
+    outputLinear: uniform2(0),
+    variantMask: uniformArray2(this._variantMask, "float")
+  };
+  constructor(host, splat, lighting) {
+    const geometry = new InstancedBufferGeometry();
+    geometry.setAttribute(
+      "position",
+      new BufferAttribute(new Float32Array([-1, -1, 0, 1, -1, 0, 1, 1, 0, -1, 1, 0]), 3)
+    );
+    geometry.setIndex([0, 1, 2, 0, 2, 3]);
+    geometry.instanceCount = splat.numSplats;
+    geometry.boundingSphere = new Sphere();
+    const material = new NodeMaterial();
+    material.name = "SplatMaterial";
+    material.transparent = true;
+    material.depthTest = true;
+    material.depthWrite = false;
+    material.side = DoubleSide;
+    material.forceSinglePass = true;
+    material.premultipliedAlpha = true;
+    material.fog = false;
+    this.geometry = geometry;
+    this.material = material;
+    this._host = host;
+    this._splat = splat;
+    this._lighting = lighting;
+    this._build();
+    this.syncBounds();
+  }
+  /** The sort runs in the same frame as the draw; the order is never stale. */
+  get sortPending() {
+    return false;
+  }
+  /** Force the next frame to re-project and re-sort even if nothing appears to have changed. */
+  requestSort() {
+    this._lastInputs[0] = NaN;
+    this._lastSortDirection.set(NaN, NaN, NaN);
+  }
+  syncDefines() {
+    this._build();
+  }
+  syncBounds() {
+    this._splat.localBounds.getBoundingSphere(this.geometry.boundingSphere);
+  }
+  syncBoneData() {
+    const attribute = this._boneAttribute;
+    if (!attribute) return;
+    packBoneInfluences(this._splat, attribute.array);
+    attribute.needsUpdate = true;
+    this.requestSort();
+  }
+  syncVariantGroups() {
+    const attribute = this._groupAttribute;
+    const ids = this._splat.groupIds;
+    if (!attribute || !ids) return;
+    attribute.array.set(ids);
+    attribute.needsUpdate = true;
+    this.requestSort();
+  }
+  /**
+   * (Re)create the storage buffers, compute nodes and material nodes. Runs at
+   * construction, and again when a feature toggle changes the shader or the
+   * palette outgrows its buffer.
+   */
+  _build() {
+    const splat = this._splat;
+    const count = splat.numSplats;
+    const packed = splat.packed;
+    const u = this._u;
+    const lighting = this._lighting;
+    const skinned = !!splat.splatWeights;
+    const splatData = new Uint32Array(count * 8);
+    const srcA = packed.transformA;
+    const srcB = new Uint32Array(packed.transformB.buffer, packed.transformB.byteOffset, count * 2);
+    const srcC = new Uint32Array(packed.color.buffer, packed.color.byteOffset, count * 2);
+    for (let i = 0; i < count; i++) {
+      const o = i * 8;
+      splatData[o] = srcA[i * 4];
+      splatData[o + 1] = srcA[i * 4 + 1];
+      splatData[o + 2] = srcA[i * 4 + 2];
+      splatData[o + 3] = srcA[i * 4 + 3];
+      splatData[o + 4] = srcB[i * 2];
+      splatData[o + 5] = srcB[i * 2 + 1];
+      splatData[o + 6] = srcC[i * 2];
+      splatData[o + 7] = srcC[i * 2 + 1];
+    }
+    const splats = storage2(new StorageBufferAttribute2(splatData, 4), "uvec4", count * 2).toReadOnly();
+    this._paletteArray = splat.transformPalette.data;
+    this._paletteAttribute = new StorageBufferAttribute2(this._paletteArray, 4);
+    this._paletteVersion = -1;
+    const palette = storage2(this._paletteAttribute, "vec4", this._paletteArray.length / 4).toReadOnly();
+    let bones = null;
+    this._boneAttribute = null;
+    if (skinned) {
+      this._boneAttribute = new StorageBufferAttribute2(packBoneInfluences(splat, new Uint32Array(count * 4)), 4);
+      bones = storage2(this._boneAttribute, "uvec4", count).toReadOnly();
+    }
+    let groupIds = null;
+    this._groupAttribute = null;
+    if (splat.variantMaskEnabled && splat.groupIds) {
+      if (splat.variantMask && splat.variantMask.length > MAX_VARIANT_GROUPS) {
+        throw new Error(
+          `WebGPUSplatBackend: ${splat.variantMask.length} variant groups requested, but this backend supports at most ${MAX_VARIANT_GROUPS}`
+        );
+      }
+      this._groupAttribute = new StorageBufferAttribute2(Uint32Array.from(splat.groupIds), 1);
+      groupIds = storage2(this._groupAttribute, "uint", count).toReadOnly();
+    }
+    const workAttribute = new StorageBufferAttribute2(new Float32Array(count * 12), 4);
+    const workWrite = storage2(workAttribute, "vec4", count * 3);
+    const sort = new GpuRadixSort(count);
+    const readPaletteRows = (slot) => {
+      const base = slot.mul(3).toVar();
+      const r0 = palette.element(base).toVar();
+      const r1 = palette.element(base.add(1)).toVar();
+      const r2 = palette.element(base.add(2)).toVar();
+      const empty = max(
+        length2(vec3(r0.x, r1.x, r2.x)),
+        max(length2(vec3(r0.y, r1.y, r2.y)), length2(vec3(r0.z, r1.z, r2.z)))
+      ).lessThanEqual(1e-4);
+      return [
+        select(empty, vec4(1, 0, 0, 0), r0),
+        select(empty, vec4(0, 1, 0, 0), r1),
+        select(empty, vec4(0, 0, 1, 0), r2)
+      ];
+    };
+    const quatMul = (a, b) => vec4(
+      a.w.mul(b.x).add(a.x.mul(b.w)).add(a.y.mul(b.z)).sub(a.z.mul(b.y)),
+      a.w.mul(b.y).sub(a.x.mul(b.z)).add(a.y.mul(b.w)).add(a.z.mul(b.x)),
+      a.w.mul(b.z).add(a.x.mul(b.y)).sub(a.y.mul(b.x)).add(a.z.mul(b.w)),
+      a.w.mul(b.w).sub(a.x.mul(b.x)).sub(a.y.mul(b.y)).sub(a.z.mul(b.z))
+    );
+    const sRGBToLinear = (c) => mix(
+      c.mul(0.9478672986).add(0.0521327014).pow(vec3(2.4)),
+      c.mul(0.0773993808),
+      c.lessThanEqual(vec3(0.04045))
+    );
+    const projectNode = Fn3(() => {
+      const tA = splats.element(instanceIndex2.mul(2)).toVar();
+      const tB = splats.element(instanceIndex2.mul(2).add(1)).toVar();
+      const modelCenter = uintBitsToFloat(tA.xyz).toVar();
+      const rotXY = unpackHalf2x16(tA.w).toVar();
+      const scaleXY = unpackHalf2x16(tB.x).toVar();
+      const scaleZRotZ = unpackHalf2x16(tB.y).toVar();
+      const packedRot = vec3(rotXY.x, rotXY.y, scaleZRotZ.y).toVar();
+      const srcRotation = vec4(packedRot, sqrt(max(float2(0), float2(1).sub(dot(packedRot, packedRot))))).toVar();
+      const srcScale = vec3(scaleXY.x, scaleXY.y, scaleZRotZ.x).toVar();
+      const row0 = vec4(1, 0, 0, 0).toVar();
+      const row1 = vec4(0, 1, 0, 0).toVar();
+      const row2 = vec4(0, 0, 1, 0).toVar();
+      if (skinned) {
+        const influences = bones.element(instanceIndex2).toVar();
+        const idx = influences.bitAnd(uvec4(65535)).toVar();
+        const weights = vec4(influences.shiftRight(uvec4(16))).div(65535).toVar();
+        const total = weights.x.add(weights.y).add(weights.z).add(weights.w).toVar();
+        If3(total.greaterThan(1e-3), () => {
+          const b0 = vec4(0).toVar();
+          const b1 = vec4(0).toVar();
+          const b2 = vec4(0).toVar();
+          for (const k of ["x", "y", "z", "w"]) {
+            If3(weights[k].greaterThan(1e-3), () => {
+              const [p0, p1, p2] = readPaletteRows(idx[k]);
+              b0.addAssign(p0.mul(weights[k]));
+              b1.addAssign(p1.mul(weights[k]));
+              b2.addAssign(p2.mul(weights[k]));
+            });
+          }
+          const inv = float2(1).div(total);
+          b0.mulAssign(inv);
+          b1.mulAssign(inv);
+          b2.mulAssign(inv);
+          const reasonable = max(
+            length2(vec3(b0.x, b1.x, b2.x)),
+            max(length2(vec3(b0.y, b1.y, b2.y)), length2(vec3(b0.z, b1.z, b2.z)))
+          ).greaterThan(1e-4);
+          If3(reasonable, () => {
+            row0.assign(b0);
+            row1.assign(b1);
+            row2.assign(b2);
+          });
+        });
+      }
+      const center4 = vec4(modelCenter, 1).toVar();
+      const modelDeformed = vec3(dot(row0, center4), dot(row1, center4), dot(row2, center4)).toVar();
+      const worldCenter = u.model.mul(vec4(modelDeformed, 1)).xyz.toVar();
+      const worldRotation = quatMul(u.modelRotation, srcRotation).toVar();
+      If3(worldRotation.w.lessThan(0), () => {
+        worldRotation.assign(worldRotation.negate());
+      });
+      const worldScale = u.modelScale.mul(srcScale).toVar();
+      if (skinned) {
+        const c0 = u.modelLinear.mul(vec3(row0.x, row1.x, row2.x)).toVar();
+        const c1 = u.modelLinear.mul(vec3(row0.y, row1.y, row2.y)).toVar();
+        const c2 = u.modelLinear.mul(vec3(row0.z, row1.z, row2.z)).toVar();
+        const s = vec3(length2(c0), length2(c1), length2(c2)).toVar();
+        If3(s.x.greaterThan(1e-5).and(s.y.greaterThan(1e-5)).and(s.z.greaterThan(1e-5)), () => {
+          const x = c0.div(s.x).toVar();
+          const y = c1.div(s.y).toVar();
+          const z = c2.div(s.z).toVar();
+          const q = vec4(0, 0, 0, 1).toVar();
+          const trace = x.x.add(y.y).add(z.z).toVar();
+          If3(trace.greaterThan(0), () => {
+            const k = sqrt(trace.add(1)).mul(2).toVar();
+            q.assign(vec4(y.z.sub(z.y).div(k), z.x.sub(x.z).div(k), x.y.sub(y.x).div(k), k.mul(0.25)));
+          }).ElseIf(x.x.greaterThan(y.y).and(x.x.greaterThan(z.z)), () => {
+            const k = sqrt(float2(1).add(x.x).sub(y.y).sub(z.z)).mul(2).toVar();
+            q.assign(vec4(k.mul(0.25), y.x.add(x.y).div(k), z.x.add(x.z).div(k), y.z.sub(z.y).div(k)));
+          }).ElseIf(y.y.greaterThan(z.z), () => {
+            const k = sqrt(float2(1).add(y.y).sub(x.x).sub(z.z)).mul(2).toVar();
+            q.assign(vec4(y.x.add(x.y).div(k), k.mul(0.25), z.y.add(y.z).div(k), z.x.sub(x.z).div(k)));
+          }).Else(() => {
+            const k = sqrt(float2(1).add(z.z).sub(x.x).sub(y.y)).mul(2).toVar();
+            q.assign(vec4(z.x.add(x.z).div(k), z.y.add(y.z).div(k), k.mul(0.25), x.y.sub(y.x).div(k)));
+          });
+          const composed = normalize(quatMul(q, srcRotation)).toVar();
+          If3(composed.w.lessThan(0), () => {
+            composed.assign(composed.negate());
+          });
+          worldRotation.assign(composed);
+        });
+        if (splat.nonRigidCovariance) {
+          worldScale.mulAssign(s);
+        }
+      }
+      const ortho = u.projection.element(3).w.equal(1);
+      const centerView = u.view.mul(vec4(worldCenter, 1)).toVar();
+      const centerProj = u.projection.mul(centerView).toVar();
+      centerProj.z.assign(clamp(centerProj.z, float2(0), centerProj.w.abs()));
+      const qx = worldRotation.x, qy = worldRotation.y, qz = worldRotation.z, qw = worldRotation.w;
+      const m0 = vec3(
+        float2(1).sub(qy.mul(qy).add(qz.mul(qz)).mul(2)),
+        qx.mul(qy).add(qw.mul(qz)).mul(2),
+        qx.mul(qz).sub(qw.mul(qy)).mul(2)
+      ).mul(worldScale.x).toVar();
+      const m1 = vec3(
+        qx.mul(qy).sub(qw.mul(qz)).mul(2),
+        float2(1).sub(qx.mul(qx).add(qz.mul(qz)).mul(2)),
+        qy.mul(qz).add(qw.mul(qx)).mul(2)
+      ).mul(worldScale.y).toVar();
+      const m2 = vec3(
+        qx.mul(qz).add(qw.mul(qy)).mul(2),
+        qy.mul(qz).sub(qw.mul(qx)).mul(2),
+        float2(1).sub(qx.mul(qx).add(qy.mul(qy)).mul(2))
+      ).mul(worldScale.z).toVar();
+      const focal = u.viewport.x.mul(u.projection.element(0).x).toVar();
+      const vp = select(ortho, vec3(0, 0, 1), centerView.xyz).toVar();
+      const J1 = focal.div(vp.z).toVar();
+      const J2 = vp.xy.mul(J1.negate().div(vp.z)).toVar();
+      const t0 = u.viewRow0.mul(J1).add(u.viewRow2.mul(J2.x)).toVar();
+      const t1 = u.viewRow1.mul(J1).add(u.viewRow2.mul(J2.y)).toVar();
+      const a = vec3(dot(t0, m0), dot(t0, m1), dot(t0, m2)).toVar();
+      const b = vec3(dot(t1, m0), dot(t1, m1), dot(t1, m2)).toVar();
+      const cov00 = dot(a, a).toVar();
+      const cov01 = dot(a, b).toVar();
+      const cov11 = dot(b, b).toVar();
+      const diagonal1 = cov00.add(0.3).toVar();
+      const diagonal2 = cov11.add(0.3).toVar();
+      const mid = diagonal1.add(diagonal2).mul(0.5).toVar();
+      const radius = length2(vec2(diagonal1.sub(diagonal2).mul(0.5), cov01)).toVar();
+      const lambda1 = mid.add(radius).toVar();
+      const lambda2 = max(mid.sub(radius), 0.1).toVar();
+      const vmin = min(float2(1024), min(u.viewport.x, u.viewport.y)).toVar();
+      const l1 = min(sqrt(lambda1.mul(2)), vmin).mul(2).toVar();
+      const l2 = min(sqrt(lambda2.mul(2)), vmin).mul(2).toVar();
+      const lmax = max(l1, l2).toVar();
+      const c = vec2(centerProj.w).div(u.viewport).toVar();
+      const diagonalVector = normalize(vec2(cov01, lambda1.sub(diagonal1))).toVar();
+      const v1 = diagonalVector.mul(l1).mul(c).toVar();
+      const v2 = vec2(diagonalVector.y, diagonalVector.x.negate()).mul(l2).mul(c).toVar();
+      const colorRG = unpackHalf2x16(tB.z).toVar();
+      const colorBA = unpackHalf2x16(tB.w).toVar();
+      const rgb = vec3(colorRG.x, colorRG.y, colorBA.x).toVar();
+      const alpha = colorBA.y.toVar();
+      if (splat.antiAlias) {
+        const detOrig = cov00.mul(cov11).sub(cov01.mul(cov01));
+        const detBlur = diagonal1.mul(diagonal2).sub(cov01.mul(cov01));
+        alpha.mulAssign(sqrt(max(detOrig.div(detBlur), 0)));
+      }
+      rgb.mulAssign(lighting.litFactor(worldCenter));
+      rgb.assign(mix(rgb, u.tint.xyz, clamp(u.tint.w, 0, 1)));
+      If3(u.grade.x.notEqual(1).or(u.grade.y.notEqual(1)), () => {
+        const graded = rgb.sub(0.5).mul(u.grade.x).add(0.5).toVar();
+        const luma = dot(graded, vec3(0.2126, 0.7152, 0.0722));
+        rgb.assign(clamp(mix(vec3(luma), graded, u.grade.y), 0, 1));
+      });
+      rgb.assign(max(rgb, vec3(0)));
+      If3(u.outputLinear.greaterThan(0.5), () => {
+        rgb.assign(sRGBToLinear(rgb));
+      });
+      const behind = ortho.not().and(centerView.z.greaterThan(0));
+      const tooSmall = lmax.lessThan(u.minPixelSize);
+      const offscreen = centerProj.x.abs().sub(lmax.mul(c.x)).greaterThan(centerProj.w).or(centerProj.y.abs().sub(lmax.mul(c.y)).greaterThan(centerProj.w));
+      const transparent = alpha.mul(255).lessThanEqual(1);
+      const culled = behind.or(tooSmall).or(offscreen).or(transparent).toVar();
+      if (groupIds) {
+        const hidden = u.variantMask.element(groupIds.element(instanceIndex2)).lessThan(0.5);
+        culled.assign(culled.or(hidden));
+      }
+      const slot = instanceIndex2.mul(3).toVar();
+      workWrite.element(slot).assign(select(culled, vec4(0, 0, 2, 1), centerProj));
+      workWrite.element(slot.add(1)).assign(select(culled, vec4(0), vec4(v1, v2)));
+      workWrite.element(slot.add(2)).assign(vec4(rgb, select(culled, float2(0), alpha)));
+      const depth = centerView.z.negate();
+      const normalized = clamp(u.sortRange.x.sub(depth).mul(u.sortRange.y), 0, 1);
+      const key = uint2(normalized.mul(SORT_BINS - 1)).toVar();
+      sort.keysWrite.element(instanceIndex2).assign(key);
+      sort.countFirstDigit(instanceIndex2, key);
+    })().compute(count, [WORKGROUP_SIZE]).setName("SplatProject");
+    this._projectNodes = [sort.resetNode, projectNode];
+    this._sortNodes = sort.sortNodes;
+    this._allNodes = null;
+    this._buildId++;
+    const workRead = storage2(workAttribute, "vec4", count * 3).toReadOnly();
+    const orderRead = sort.orderRead;
+    const gaussianUV = varyingProperty("vec2", "vGaussianUV");
+    const gaussianColor = varyingProperty("vec4", "vGaussianColor");
+    const material = this.material;
+    material.vertexNode = Fn3(() => {
+      const slot = orderRead.element(instanceIndex2).mul(3).toVar();
+      const centerProj = workRead.element(slot).toVar();
+      const axes = workRead.element(slot.add(1)).toVar();
+      const shade = workRead.element(slot.add(2)).toVar();
+      const clip = min(float2(1), sqrt(log(max(shade.w.mul(255), 1))).mul(0.5)).toVar();
+      const corner = positionGeometry.xy.toVar();
+      const offset = axes.xy.mul(corner.x).add(axes.zw.mul(corner.y)).mul(clip);
+      gaussianUV.assign(corner.mul(clip));
+      gaussianColor.assign(shade);
+      return centerProj.add(vec4(offset, 0, 0));
+    })();
+    material.colorNode = Fn3(() => {
+      const A = dot(gaussianUV, gaussianUV).toVar();
+      If3(A.greaterThan(1), () => {
+        Discard();
+      });
+      const alpha = exp(A.mul(-4)).sub(EXP4).mul(INV_EXP4).mul(gaussianColor.w).toVar();
+      If3(alpha.lessThan(1 / 255), () => {
+        Discard();
+      });
+      return vec4(gaussianColor.xyz, alpha);
+    })();
+    material.needsUpdate = true;
+  }
+  beforeRender(renderer, camera) {
+    const splat = this._splat;
+    const u = this._u;
+    const palette = splat.transformPalette;
+    if (palette.data !== this._paletteArray) {
+      this._build();
+    }
+    if (palette.version !== this._paletteVersion) {
+      this._paletteVersion = palette.version;
+      this._paletteAttribute.needsUpdate = true;
+    }
+    const target = renderer.getRenderTarget();
+    if (target) {
+      u.viewport.value.set(target.viewport.z, target.viewport.w);
+    } else {
+      renderer.getViewport(_viewport);
+      const pixelRatio = renderer.getPixelRatio();
+      u.viewport.value.set(Math.floor(_viewport.z * pixelRatio), Math.floor(_viewport.w * pixelRatio));
+    }
+    const linear = target ? target.texture.colorSpace !== SRGBColorSpace : renderer.needsFrameBufferTarget === true;
+    u.outputLinear.value = linear ? 1 : 0;
+    const world = this._host.matrixWorld;
+    u.model.value.copy(world);
+    u.modelLinear.value.setFromMatrix4(world);
+    world.decompose(_position, _quaternion, _scale);
+    u.modelRotation.value.set(_quaternion.x, _quaternion.y, _quaternion.z, _quaternion.w);
+    u.modelScale.value.copy(_scale);
+    const view = camera.matrixWorldInverse;
+    const ve = view.elements;
+    u.view.value.copy(view);
+    u.viewRow0.value.set(ve[0], ve[4], ve[8]);
+    u.viewRow1.value.set(ve[1], ve[5], ve[9]);
+    u.viewRow2.value.set(ve[2], ve[6], ve[10]);
+    u.projection.value.copy(camera.projectionMatrix);
+    u.minPixelSize.value = splat.minPixelSize;
+    u.tint.value.copy(splat.tint);
+    u.grade.value.copy(splat.grade);
+    const mask = splat.variantMask;
+    if (mask) for (let i = 0; i < mask.length; i++) this._variantMask[i] = mask[i];
+    _sphere.copy(this.geometry.boundingSphere).applyMatrix4(world);
+    _viewCenter.copy(_sphere.center).applyMatrix4(view);
+    const centerDepth = -_viewCenter.z;
+    const far = centerDepth + _sphere.radius;
+    const near = centerDepth - _sphere.radius;
+    u.sortRange.value.set(far, 1 / Math.max(far - near, 1e-6));
+    const lightingVersion = this._lighting.sync();
+    const inputs = this._inputs;
+    let n = 0;
+    inputs.set(world.elements, n);
+    n += 16;
+    inputs.set(ve, n);
+    n += 16;
+    inputs.set(camera.projectionMatrix.elements, n);
+    n += 16;
+    inputs[n++] = u.viewport.value.x;
+    inputs[n++] = u.viewport.value.y;
+    inputs[n++] = u.outputLinear.value;
+    inputs[n++] = splat.minPixelSize;
+    inputs[n++] = splat.tint.x;
+    inputs[n++] = splat.tint.y;
+    inputs[n++] = splat.tint.z;
+    inputs[n++] = splat.tint.w;
+    inputs[n++] = splat.grade.x;
+    inputs[n++] = splat.grade.y;
+    inputs[n++] = far;
+    inputs[n++] = near;
+    inputs[n++] = lightingVersion;
+    inputs[n++] = palette.version;
+    inputs[n++] = this._buildId;
+    inputs[n++] = splat.variantMaskVersion;
+    const last = this._lastInputs;
+    let changed = false;
+    for (let i = 0; i < n; i++) {
+      if (inputs[i] !== last[i]) {
+        changed = true;
+        break;
+      }
+    }
+    if (!changed) return;
+    last.set(inputs);
+    const me = world.elements;
+    const fx = -ve[2], fy = -ve[6], fz = -ve[10];
+    _direction.set(
+      me[0] * fx + me[1] * fy + me[2] * fz,
+      me[4] * fx + me[5] * fy + me[6] * fz,
+      me[8] * fx + me[9] * fy + me[10] * fz
+    );
+    const orderMayChange = !!splat.splatWeights || !_direction.equals(this._lastSortDirection) || this._sortedBuildId !== this._buildId;
+    if (orderMayChange) {
+      this._lastSortDirection.copy(_direction);
+      this._sortedBuildId = this._buildId;
+      renderer.compute(this._allNodes ??= [...this._projectNodes, ...this._sortNodes]);
+    } else {
+      renderer.compute(this._projectNodes);
+    }
+  }
+  dispose() {
+    this.geometry.dispose();
+    this.material.dispose();
+    for (const node of [...this._projectNodes, ...this._sortNodes]) node.dispose?.();
+  }
+};
+function packBoneInfluences(splat, out) {
+  const slots = splat.boneIndicesData;
+  const weights = splat.boneWeightsData;
+  const n = splat.numSplats * 4;
+  for (let i = 0; i < n; i++) {
+    const w = Math.max(0, Math.min(65535, Math.round(weights[i] * 65535)));
+    out[i] = (slots[i] & 65535 | w << 16) >>> 0;
+  }
+  return out;
+}
+
+// src/splat/webgpu/backend.ts
+var WebGPUSplatBackend = class {
+  _lighting = /* @__PURE__ */ new WeakMap();
+  createImpl(host, splat, engine) {
+    let lighting = this._lighting.get(engine);
+    if (!lighting) {
+      lighting = new WebGPULighting(engine);
+      this._lighting.set(engine, lighting);
+    }
+    return new WebGPUSplatImpl(host, splat, lighting);
+  }
+};
+
+// src/webgpu.ts
+registerWebGPUBackend(new WebGPUSplatBackend());
+export {
+  Animation,
+  Armature,
+  Character,
+  CharacterBundleError,
+  EngineDisposedError,
+  Environment,
+  MAX_POINT_LIGHTS,
+  MAX_VARIANT_GROUPS,
+  PointLight,
+  SkyLight,
+  Splat,
+  SplatCharacter,
+  Animation as SplatClip,
+  SplatClipLoader,
+  SplatEngine,
+  SplatMesh,
+  SplatPLYLoader,
+  SunLight,
+  VSplatLoader,
+  WebGLSplatBackend,
+  WebGPUSplatBackend,
+  decodeCharacterBundle,
+  loadCharacterBundle,
+  loadCharacterBundleFromBytes,
+  makeRegionMask,
+  packSplats,
+  parseGaussianPly
+};
+//# sourceMappingURL=webgpu.js.map