gaussian-splat-lite 1.2.0 → 1.2.1

package/dist/gaussian-splat-lite.module.js

@@ -1,6 +1,6 @@
 import * as THREE from "three";
-import { Vector3, Vector2, Matrix4, ColorManagement, NeverDepth, AlwaysDepth, Color, NoToneMapping, ShaderMaterial, NoBlending, GLSL3, WebGLRenderTarget, DepthTexture, HalfFloatType, FloatType, WebGLCoordinateSystem, DefaultLoadingManager, Loader } from "three";
-import { NodeUpdateType, NodeMaterial, QuadMesh, StorageArrayTexture, IndirectStorageBufferAttribute, StorageBufferAttribute, TempNode, RenderTarget, RendererUtils } from "three/webgpu";
+import { Vector3, Vector2, Matrix4, ColorManagement, NeverDepth, AlwaysDepth, Color, ShaderMaterial, NoBlending, GLSL3, NoToneMapping, SRGBTransfer, WebGLRenderTarget, DepthTexture, HalfFloatType, FloatType, WebGLCoordinateSystem, DefaultLoadingManager, Loader } from "three";
+import { NodeUpdateType, NodeMaterial, QuadMesh, StorageArrayTexture, IndirectStorageBufferAttribute, StorageBufferAttribute, TempNode, RenderTarget, RendererUtils, CubeRenderTarget, PMREMGenerator } from "three/webgpu";
 import * as TSL from "three/tsl";
 import { FullScreenQuad, Pass } from "three/addons/postprocessing/Pass.js";
 function getTransferable(ctx) {
@@ -2001,9 +2001,9 @@ class SplatMesh extends THREE.Object3D {
     }
     return ((_a2 = this.splats) == null ? void 0 : _a2.getBoundingBox(centersOnly, target)) ?? target.makeEmpty();
   }
-  frameUpdate({ time, deltaTime, globalEdits }) {
+  frameUpdate({ time, deltaTime, globalEdits }, callbacks = true) {
     var _a2, _b;
-    (_a2 = this.onFrame) == null ? void 0 : _a2.call(this, { mesh: this, time, deltaTime });
+    if (callbacks) (_a2 = this.onFrame) == null ? void 0 : _a2.call(this, { mesh: this, time, deltaTime });
     const source = this.splats;
     if (!source) {
       return;
@@ -2175,7 +2175,7 @@ function isWebGPURenderer(renderer) {
   return "isWebGPURenderer" in renderer && renderer.isWebGPURenderer === true;
 }
 function usesNativeWebGPU(renderer) {
-  return isWebGPURenderer(renderer) && renderer.backend.isWebGPUBackend === true;
+  return isWebGPURenderer(renderer) && renderer.coordinateSystem === THREE.WebGPUCoordinateSystem;
 }
 function getViews(camera) {
   const array = camera;
@@ -2249,7 +2249,9 @@ function textureBinding(uniforms, name, array = false) {
   placeholder.generateMipmaps = false;
   placeholder.needsUpdate = true;
   const getTexture = () => uniforms[name].value;
-  return uintTexture(placeholder).onObjectUpdate(getTexture);
+  const binding = uintTexture(placeholder).onObjectUpdate(getTexture);
+  binding.getUniformHash = () => binding.uuid;
+  return binding;
 }
 function load2D(binding, coord) {
   const texel = binding.load(coord);
@@ -2260,6 +2262,7 @@ function loadArray(binding, coord) {
   return updateTextureLoad(binding, binding.load(coord.xy).depth(coord.z));
 }
 function updateTextureLoad(binding, texel) {
+  texel.getUniformHash = (builder) => binding.getUniformHash(builder);
   texel.updateBeforeType = NodeUpdateType.OBJECT;
   texel.updateBefore = (frame) => {
     frame.updateNode(binding);
@@ -2895,7 +2898,7 @@ const emptyOrdering = new THREE.DataTexture(
   THREE.UnsignedIntType
 );
 emptyOrdering.needsUpdate = true;
-const DEFAULT_MIN_ALPHA = 0.5 / 255;
+const DEFAULT_MIN_ALPHA = 1 / 255;
 function makeSplatUniforms() {
   const emptySplats = emptySplatTexture;
   const uniforms = {
@@ -2916,8 +2919,6 @@ function makeSplatUniforms() {
     maxStdDev: { value: 1 },
     // Minimum pixel radius for splat rendering
     minPixelRadius: { value: 1 },
-    // Maximum pixel radius for splat rendering
-    maxPixelRadius: { value: 256 },
     // Minimum alpha value for splat rendering
     minAlpha: { value: DEFAULT_MIN_ALPHA },
     // Add to projected 2D splat covariance diagonal (thickens and brightens)
@@ -2928,7 +2929,7 @@ function makeSplatUniforms() {
     clipXY: { value: 1.25 },
     // Debug renderSize scale factor
     focalAdjustment: { value: 2 },
-    // Whether to decode stored sRGB Splat colors before blending
+    // Resolved from GaussianSplatRenderer.encodeLinear or the active blend space.
     encodeLinear: { value: false },
     // Exact draw count; the final instance may contain unused quads.
     splatCount: { value: 0 },
@@ -2985,7 +2986,7 @@ function makeGenerateUniforms() {
 }
 var splatDefines_default = "const uint SPLAT_TEX_WIDTH_BITS = 11u;\nconst uint SPLAT_TEX_HEIGHT_BITS = 11u;\nconst uint SPLAT_TEX_LAYER_BITS = SPLAT_TEX_WIDTH_BITS + SPLAT_TEX_HEIGHT_BITS;\n\nconst uint SPLAT_TEX_WIDTH = 1u << SPLAT_TEX_WIDTH_BITS;\nconst uint SPLAT_TEX_HEIGHT = 1u << SPLAT_TEX_HEIGHT_BITS;\n\nconst uint SPLAT_TEX_WIDTH_MASK = SPLAT_TEX_WIDTH - 1u;\nconst uint SPLAT_TEX_HEIGHT_MASK = SPLAT_TEX_HEIGHT - 1u;\n\nconst float PI = 3.1415926535897932384626433832795;\n\nvec3 srgbToLinear(vec3 rgb) {\n    \n    return mix(\n        pow(rgb * 0.9478672986 + vec3(0.0521327014), vec3(2.4)),\n        rgb * 0.0773993808, lessThanEqual(rgb, vec3(0.04045)));\n}\n\nuint encodeQuatOctXy1010R12(vec4 q) {\n    \n    if (q.w < 0.0) {\n        q = -q;\n    }\n    \n    float theta = 2.0 * acos(clamp(q.w, 0.0, 1.0));\n\n    \n    \n    \n    float sum = abs(q.x) + abs(q.y) + abs(q.z);\n    \n    vec2 p = (sum < 1e-6) ? vec2(1.0, 0.0) : q.xy / sum;\n    \n    if (q.z < 0.0) {\n        float oldPx = p.x;\n        p.x = (1.0 - abs(p.y)) * (p.x >= 0.0 ? 1.0 : -1.0);\n        p.y = (1.0 - abs(oldPx)) * (p.y >= 0.0 ? 1.0 : -1.0);\n    }\n    \n    float u_f = p.x * 0.5 + 0.5;\n    float v_f = p.y * 0.5 + 0.5;\n    \n    uint quantU = uint(clamp(round(u_f * 1023.0), 0.0, 1023.0));\n    uint quantV = uint(clamp(round(v_f * 1023.0), 0.0, 1023.0));\n    \n    \n    \n    uint angleInt = uint(clamp(round((theta / PI) * 4095.0), 0.0, 4095.0));\n    \n    \n    return (angleInt << 20u) | (quantV << 10u) | quantU;\n}\n\nvec4 decodeQuatOctXy1010R12(uint encoded) {\n    \n    uint quantU = encoded & uint(0x3FFu);               \n    uint quantV = (encoded >> 10u) & uint(0x3FFu);         \n    uint angleInt = encoded >> 20u;                      \n\n    \n    float u_f = float(quantU) / 1023.0;\n    float v_f = float(quantV) / 1023.0;\n    vec2 f = vec2(u_f * 2.0 - 1.0, v_f * 2.0 - 1.0);\n\n    vec3 axis = vec3(f.xy, 1.0 - abs(f.x) - abs(f.y));\n    float t = max(-axis.z, 0.0);\n    axis.x += (axis.x >= 0.0) ? -t : t;\n    axis.y += (axis.y >= 0.0) ? -t : t;\n    axis = normalize(axis);\n    \n    \n    float theta = (float(angleInt) / 4095.0) * PI;\n    float halfTheta = theta * 0.5;\n    float s = sin(halfTheta);\n    float w = cos(halfTheta);\n    \n    return vec4(axis * s, w);\n}\n\nvec3 decodeSplatCenter(uvec4 splatData) {\n    return vec3(\n        uintBitsToFloat(splatData.x),\n        uintBitsToFloat(splatData.y),\n        uintBitsToFloat(splatData.z)\n    );\n}\n\nvoid encodeSplatLnScale(\n    out uvec4 splatData, out uvec4 splatData2,\n    vec3 center, vec3 lnScales, vec4 quaternion, vec4 rgba, float shapeAmount\n) {\n    splatData.x = floatBitsToUint(center.x);\n    splatData.y = floatBitsToUint(center.y);\n    splatData.z = floatBitsToUint(center.z);\n    splatData.w = packHalf2x16(clamp(vec2(rgba.a, shapeAmount), 0.0, 1.0));\n\n    splatData2.x = packHalf2x16(rgba.rg);\n    splatData2.y = packHalf2x16(vec2(rgba.b, lnScales.x));\n    splatData2.z = packHalf2x16(lnScales.yz);\n    splatData2.w = encodeQuatOctXy1010R12(quaternion);\n}\n\nvec2 decodeSplatAlphaShapeAmount(uvec4 splatData) {\n    return unpackHalf2x16(splatData.w);\n}\n\nvoid decodeSplatAttributesLnScale(\n    uvec4 splatData2,\n    float alpha,\n    out vec3 lnScales, out vec4 quaternion, out vec4 rgba\n) {\n    rgba.a = alpha;\n\n    rgba.rg = unpackHalf2x16(splatData2.x);\n    vec2 split = unpackHalf2x16(splatData2.y);\n    rgba.b = split.x;\n    lnScales.x = split.y;\n    lnScales.yz = unpackHalf2x16(splatData2.z);\n    quaternion = decodeQuatOctXy1010R12(splatData2.w);\n}\n\nvec3 decodeSplatShRgb(uint encoded) {\n    uint biasedBase = (encoded >> 27u) & 0x1fu;\n    \n    \n    float divisor = uintBitsToFloat((biasedBase + 112u) << 23u) / 255.0;\n\n    vec3 rgb = vec3(uvec3(encoded & 0xffu, (encoded >> 8u) & 0xffu, (encoded >> 16u) & 0xffu));\n    rgb *= divisor;\n\n    return vec3(\n        ((encoded & 0x1000000u) != 0u) ? -rgb.r : rgb.r,\n        ((encoded & 0x2000000u) != 0u) ? -rgb.g : rgb.g,\n        ((encoded & 0x4000000u) != 0u) ? -rgb.b : rgb.b\n    );\n}\n\nvec3 quatVec(vec4 q, vec3 v) {\n    \n    vec3 t = 2.0 * cross(q.xyz, v);\n    return v + q.w * t + cross(q.xyz, t);\n}\n\nvec4 quatQuat(vec4 q1, vec4 q2) {\n    return vec4(\n        q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y,\n        q1.w * q2.y - q1.x * q2.z + q1.y * q2.w + q1.z * q2.x,\n        q1.w * q2.z + q1.x * q2.y - q1.y * q2.x + q1.z * q2.w,\n        q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z\n    );\n}\n\nmat3 scaleQuaternionToMatrix(vec3 s, vec4 q) {\n    \n    return mat3(\n        s.x * (1.0 - 2.0 * (q.y * q.y + q.z * q.z)),\n        s.x * (2.0 * (q.x * q.y + q.w * q.z)),\n        s.x * (2.0 * (q.x * q.z - q.w * q.y)),\n        s.y * (2.0 * (q.x * q.y - q.w * q.z)),\n        s.y * (1.0 - 2.0 * (q.x * q.x + q.z * q.z)),\n        s.y * (2.0 * (q.y * q.z + q.w * q.x)),\n        s.z * (2.0 * (q.x * q.z + q.w * q.y)),\n        s.z * (2.0 * (q.y * q.z - q.w * q.x)),\n        s.z * (1.0 - 2.0 * (q.x * q.x + q.y * q.y))\n    );\n}\n\nivec3 splatTexCoord(int index) {\n    uint x = uint(index) & SPLAT_TEX_WIDTH_MASK;\n    uint y = (uint(index) >> SPLAT_TEX_WIDTH_BITS) & SPLAT_TEX_HEIGHT_MASK;\n    uint z = uint(index) >> SPLAT_TEX_LAYER_BITS;\n    return ivec3(x, y, z);\n}";
 var splatFragment_default = "precision highp float;\nprecision highp int;\n\nuniform float minAlpha;\n#if GSL_STOCHASTIC\nuniform highp usampler2D stochasticNoise;\n#endif\n\nout vec4 fragColor;\n\nflat in uvec4 vSplat;\nin vec2 vSplatUv;\n#if GSL_STOCHASTIC\n\nflat in uint vStochasticOffset;\n#endif\n\n#include <logdepthbuf_pars_fragment>\n\nvoid main() {\n    float z2 = dot(vSplatUv, vSplatUv);\n    if (z2 > uintBitsToFloat(vSplat.w)) {\n        discard;\n    }\n\n    vec2 blueKernelPower = unpackHalf2x16(vSplat.y);\n    float kernelPower = blueKernelPower.y;\n    float kernelAlpha = exp(-0.5 * z2);\n    if (kernelPower != 0.0) {\n        kernelAlpha = 1.0 - pow(1.0 - kernelAlpha, kernelPower);\n    }\n    float alpha = uintBitsToFloat(vSplat.z) * kernelAlpha;\n\n    if (alpha < minAlpha) {\n        discard;\n    }\n    #if GSL_STOCHASTIC\n    uvec2 offset = uvec2(vStochasticOffset, vStochasticOffset >> 5u);\n    ivec2 coord = ivec2((uvec2(gl_FragCoord.xy) + offset) & uvec2(31u));\n    coord.y += int(vStochasticOffset >> 10u) * 32;\n    float randomValue = (float(texelFetch(stochasticNoise, coord, 0).r) + 0.5) / 32768.0;\n    if (randomValue >= alpha) {\n        discard;\n    }\n    #endif\n\n    \n    vec4 rgba = vec4(unpackHalf2x16(vSplat.x), blueKernelPower.x, alpha);\n\n    #if GSL_STOCHASTIC\n        fragColor = vec4(rgba.rgb, 1.0);\n    #elif defined(PREMULTIPLIED_ALPHA)\n        fragColor = vec4(rgba.rgb * rgba.a, rgba.a);\n    #else\n        fragColor = rgba;\n    #endif\n\n    #include <logdepthbuf_fragment>\n}";
-var splatVertex_default = "precision highp float;\nprecision highp int;\nprecision highp usampler2DArray;\n\n#include <splatDefines>\n\nflat out uvec4 vSplat;\nout vec2 vSplatUv;\n#if GSL_STOCHASTIC\n\nflat out uint vStochasticOffset;\n#endif\n\nuniform vec2 renderSize;\nuniform vec4 renderToViewQuat;\nuniform vec3 renderToViewPos;\n\nuniform float renderToViewScale;\nuniform float maxStdDev;\nuniform float minPixelRadius;\nuniform float maxPixelRadius;\nuniform float minAlpha;\nuniform float blurAmount;\nuniform float preBlurAmount;\nuniform float clipXY;\nuniform float focalAdjustment;\nuniform bool encodeLinear;\nuniform uint splatCount;\n\nuniform usampler2D ordering;\nuniform usampler2DArray splats;\nuniform usampler2DArray splats2;\n\n#if GSL_STOCHASTIC\nuniform bool stochasticOrdering;\nuniform uint stochasticSample;\nuniform vec2 viewportOrigin;\nuniform usampler2DArray stochasticSeeds;\n#endif\n\nbool isPerspectiveMatrix( mat4 m ) {\n    return m[ 2 ][ 3 ] == -1.0;\n}\n\n#include <logdepthbuf_pars_vertex>\n\nuint hashU32(uint value) {\n    value ^= value >> 16u;\n    value *= 0x7feb352du;\n    value ^= value >> 15u;\n    value *= 0x846ca68bu;\n    value ^= value >> 16u;\n    return value;\n}\n\nfloat gaussianSupportRadius(float alpha, float maximumRadius) {\n    if (minAlpha <= 0.0) return maximumRadius;\n    float radiusSquared = 2.0 * log(alpha / minAlpha);\n    return min(maximumRadius, sqrt(max(0.0, radiusSquared)));\n}\n\nfloat wideSupportRadius(float alpha, float power, float maximumRadius) {\n    if (minAlpha <= 0.0) return maximumRadius;\n    \n    \n    float radiusSquared = 2.0 * log(alpha * power / minAlpha);\n    return min(maximumRadius, sqrt(max(0.0, radiusSquared)));\n}\n\nvoid main() {\n    \n    gl_Position = vec4(0.0, 0.0, 2.0, 1.0);\n\n    uint index = uint(gl_InstanceID) * uint(SPLATS_PER_INSTANCE) + uint(position.z);\n    if (index >= splatCount) return;\n\n    uint splatIndex;\n    #if GSL_STOCHASTIC\n    if (!stochasticOrdering) {\n        \n        splatIndex = index;\n    } else\n    #endif\n    {\n        ivec2 orderingCoord = ivec2(int((index >> 2u) & 4095u), int(index >> 14u));\n        splatIndex = texelFetch(ordering, orderingCoord, 0)[index & 3u];\n    }\n    if (splatIndex == 0xffffffffu) {\n        \n        return;\n    }\n\n    ivec3 texCoord = splatTexCoord(int(splatIndex));\n    uvec4 splat1 = texelFetch(splats, texCoord, 0);\n    vec2 alphaShapeAmount = decodeSplatAlphaShapeAmount(splat1);\n    float alpha = alphaShapeAmount.x;\n    if ((alpha == 0.0) || (alpha < minAlpha)) {\n        return;\n    }\n    vec3 center = decodeSplatCenter(splat1);\n    \n    vec3 viewCenter = renderToViewScale * quatVec(renderToViewQuat, center) + renderToViewPos;\n\n    \n    if (isPerspectiveMatrix(projectionMatrix) && viewCenter.z >= 0.0) {\n        return;\n    }\n\n    \n    vec4 clipCenter = projectionMatrix * vec4(viewCenter, 1.0);\n\n    \n    if (abs(clipCenter.z) >= clipCenter.w) {\n        return;\n    }\n\n    \n    float clip = clipXY * clipCenter.w;\n    if (abs(clipCenter.x) > clip || abs(clipCenter.y) > clip) {\n        return;\n    }\n\n    \n    \n    vec3 lnScales;\n    vec4 quaternion, rgba;\n    uvec4 splat2 = texelFetch(splats2, texCoord, 0);\n    decodeSplatAttributesLnScale(splat2, alpha, lnScales, quaternion, rgba);\n    vec3 scales = exp(lnScales);\n    if (all(equal(scales, vec3(0.0)))) {\n        return;\n    }\n\n    \n    rgba.rgb = max(rgba.rgb, vec3(0.0));\n\n    \n    \n    float kernelShape = 1.0 + 4.0 * min(alphaShapeAmount.y, 1.0);\n    \n    \n    float kernelPower = 0.0;\n    if (kernelShape > 1.0) {\n        kernelPower = exp(\n            (kernelShape * kernelShape - 1.0) / 2.718281828459045\n        );\n    }\n\n    \n    float maximumSupportRadius = maxStdDev\n        + 0.7 * max(kernelShape - 1.0, 0.0);\n    float supportRadius = maximumSupportRadius;\n\n    scales *= renderToViewScale;\n\n    \n    vec4 viewQuaternion = quatQuat(renderToViewQuat, quaternion);\n\n    \n    mat3 RS = scaleQuaternionToMatrix(scales, viewQuaternion);\n\n    \n    vec2 scaledRenderSize = renderSize * focalAdjustment;\n    vec2 focal = 0.5 * scaledRenderSize * vec2(projectionMatrix[0][0], projectionMatrix[1][1]);\n\n    vec3 j0;\n    vec3 j1;\n    if (isOrthographic) {\n        j0 = vec3(focal.x, 0.0, 0.0);\n        j1 = vec3(0.0, focal.y, 0.0);\n    } else {\n        float invZ = 1.0 / viewCenter.z;\n        vec2 J1 = focal * invZ;\n        vec2 J2 = -(J1 * viewCenter.xy) * invZ;\n        j0 = vec3(J1.x, 0.0, J2.x);\n        j1 = vec3(0.0, J1.y, J2.y);\n    }\n\n    \n    \n    vec3 p0 = transpose(RS) * j0;\n    vec3 p1 = transpose(RS) * j1;\n    float a = dot(p0, p0);\n    float b = dot(p0, p1);\n    float d = dot(p1, p1);\n\n    \n    a += preBlurAmount;\n    d += preBlurAmount;\n\n    float detOrig = a * d - b * b;\n    \n    a += blurAmount;\n    d += blurAmount;\n    float det = a * d - b * b;\n    if (det <= 0.0) return;\n\n    \n    float blurAdjust = sqrt(max(0.0, detOrig / det));\n    alpha *= blurAdjust;\n    if (!(alpha > 0.0) || alpha < minAlpha) {\n        return;\n    }\n\n    \n    if (kernelPower == 0.0) {\n        supportRadius = gaussianSupportRadius(alpha, supportRadius);\n    } else {\n        supportRadius = wideSupportRadius(alpha, kernelPower, supportRadius);\n    }\n    vSplatUv = position.xy * supportRadius;\n\n    \n    float eigenAvg = 0.5 * (a + d);\n    float eigenDelta = length(vec2(0.5 * (a - d), b));\n    float eigen1 = eigenAvg + eigenDelta;\n    \n    float eigen2 = max(eigenAvg - eigenDelta, 1e-4);\n\n    vec2 eigenVec1 = (abs(b) > 0.001)\n        ? normalize(vec2(b, eigen1 - a))\n        : ((a >= d) ? vec2(1.0, 0.0) : vec2(0.0, 1.0));\n    vec2 eigenVec2 = vec2(eigenVec1.y, -eigenVec1.x);\n\n    \n    \n    float maxProjectedRadius = maxPixelRadius * focalAdjustment;\n    float scale1 = min(maxProjectedRadius, maximumSupportRadius * sqrt(eigen1));\n    float scale2 = min(maxProjectedRadius, maximumSupportRadius * sqrt(eigen2));\n    float supportScale = (maximumSupportRadius > 0.0)\n        ? supportRadius / maximumSupportRadius\n        : 0.0;\n    \n    \n    float cullScale = (kernelPower == 0.0) ? supportScale : 1.0;\n    \n    float minProjectedRadius = minPixelRadius * focalAdjustment;\n    if (scale1 * cullScale < minProjectedRadius && scale2 * cullScale < minProjectedRadius) {\n        return;\n    }\n    scale1 *= supportScale;\n    scale2 *= supportScale;\n\n    #if GSL_STOCHASTIC\n    \n    \n    \n    uint seed = texelFetch(stochasticSeeds, texCoord, 0).r;\n    uint hash = hashU32(seed);\n    uvec2 offset = uvec2(hash, hash >> 5u) - uvec2(viewportOrigin);\n    uint phase = ((hash >> 10u) + stochasticSample) & 31u;\n    vStochasticOffset = (offset.x & 31u) | ((offset.y & 31u) << 5u) | (phase << 10u);\n    #endif\n\n    \n    if (encodeLinear) {\n        rgba.rgb = srgbToLinear(rgba.rgb);\n    }\n    \n    vec3 rgb = min(rgba.rgb, vec3(65504.0));\n    vSplat = uvec4(\n        packHalf2x16(rgb.rg),\n        packHalf2x16(vec2(rgb.b, kernelPower)),\n        floatBitsToUint(alpha),\n        floatBitsToUint(supportRadius * supportRadius)\n    );\n\n    \n    vec2 pixelOffset = position.x * eigenVec1 * scale1 + position.y * eigenVec2 * scale2;\n    vec2 ndcOffset = (2.0 / scaledRenderSize) * pixelOffset;\n\n    \n    vec3 ndcCenter = clipCenter.xyz / clipCenter.w;\n    vec3 ndc = vec3(ndcCenter.xy + ndcOffset, ndcCenter.z);\n\n    gl_Position = vec4(ndc.xy * clipCenter.w, clipCenter.zw);\n    #include <logdepthbuf_vertex>\n}";
+var splatVertex_default = "precision highp float;\nprecision highp int;\nprecision highp usampler2DArray;\n\n#include <splatDefines>\n\nflat out uvec4 vSplat;\nout vec2 vSplatUv;\n#if GSL_STOCHASTIC\n\nflat out uint vStochasticOffset;\n#endif\n\nuniform vec2 renderSize;\nuniform vec4 renderToViewQuat;\nuniform vec3 renderToViewPos;\n\nuniform float renderToViewScale;\nuniform float maxStdDev;\nuniform float minPixelRadius;\nuniform float minAlpha;\nuniform float blurAmount;\nuniform float preBlurAmount;\nuniform float clipXY;\nuniform float focalAdjustment;\nuniform bool encodeLinear;\nuniform uint splatCount;\n\nuniform usampler2D ordering;\nuniform usampler2DArray splats;\nuniform usampler2DArray splats2;\n\n#if GSL_STOCHASTIC\nuniform bool stochasticOrdering;\nuniform uint stochasticSample;\nuniform vec2 viewportOrigin;\nuniform usampler2DArray stochasticSeeds;\n#endif\n\nbool isPerspectiveMatrix( mat4 m ) {\n    return m[ 2 ][ 3 ] == -1.0;\n}\n\n#include <logdepthbuf_pars_vertex>\n\nuint hashU32(uint value) {\n    value ^= value >> 16u;\n    value *= 0x7feb352du;\n    value ^= value >> 15u;\n    value *= 0x846ca68bu;\n    value ^= value >> 16u;\n    return value;\n}\n\nfloat gaussianSupportRadius(float alpha, float maximumRadius) {\n    if (minAlpha <= 0.0) return maximumRadius;\n    float radiusSquared = 2.0 * log(alpha / minAlpha);\n    return min(maximumRadius, sqrt(max(0.0, radiusSquared)));\n}\n\nfloat wideSupportRadius(float alpha, float power, float maximumRadius) {\n    if (minAlpha <= 0.0) return maximumRadius;\n    \n    \n    float radiusSquared = 2.0 * log(alpha * power / minAlpha);\n    return min(maximumRadius, sqrt(max(0.0, radiusSquared)));\n}\n\nvoid main() {\n    \n    gl_Position = vec4(0.0, 0.0, 2.0, 1.0);\n\n    uint index = uint(gl_InstanceID) * uint(SPLATS_PER_INSTANCE) + uint(position.z);\n    if (index >= splatCount) return;\n\n    uint splatIndex;\n    #if GSL_STOCHASTIC\n    if (!stochasticOrdering) {\n        \n        splatIndex = index;\n    } else\n    #endif\n    {\n        ivec2 orderingCoord = ivec2(int((index >> 2u) & 4095u), int(index >> 14u));\n        splatIndex = texelFetch(ordering, orderingCoord, 0)[index & 3u];\n    }\n    if (splatIndex == 0xffffffffu) {\n        \n        return;\n    }\n\n    ivec3 texCoord = splatTexCoord(int(splatIndex));\n    uvec4 splat1 = texelFetch(splats, texCoord, 0);\n    vec2 alphaShapeAmount = decodeSplatAlphaShapeAmount(splat1);\n    float alpha = alphaShapeAmount.x;\n    if ((alpha == 0.0) || (alpha < minAlpha)) {\n        return;\n    }\n    vec3 center = decodeSplatCenter(splat1);\n    \n    vec3 viewCenter = renderToViewScale * quatVec(renderToViewQuat, center) + renderToViewPos;\n\n    \n    if (isPerspectiveMatrix(projectionMatrix) && viewCenter.z >= 0.0) {\n        return;\n    }\n\n    \n    vec4 clipCenter = projectionMatrix * vec4(viewCenter, 1.0);\n\n    \n    if (abs(clipCenter.z) >= clipCenter.w) {\n        return;\n    }\n\n    \n    float clip = clipXY * clipCenter.w;\n    if (abs(clipCenter.x) > clip || abs(clipCenter.y) > clip) {\n        return;\n    }\n\n    \n    \n    vec3 lnScales;\n    vec4 quaternion, rgba;\n    uvec4 splat2 = texelFetch(splats2, texCoord, 0);\n    decodeSplatAttributesLnScale(splat2, alpha, lnScales, quaternion, rgba);\n    vec3 scales = exp(lnScales);\n    if (all(equal(scales, vec3(0.0)))) {\n        return;\n    }\n\n    \n    rgba.rgb = max(rgba.rgb, vec3(0.0));\n\n    \n    \n    float kernelShape = 1.0 + 4.0 * min(alphaShapeAmount.y, 1.0);\n    \n    \n    float kernelPower = 0.0;\n    if (kernelShape > 1.0) {\n        kernelPower = exp(\n            (kernelShape * kernelShape - 1.0) / 2.718281828459045\n        );\n    }\n\n    \n    float maximumSupportRadius = maxStdDev\n        + 0.7 * max(kernelShape - 1.0, 0.0);\n    float supportRadius = maximumSupportRadius;\n\n    scales *= renderToViewScale;\n\n    \n    vec4 viewQuaternion = quatQuat(renderToViewQuat, quaternion);\n\n    \n    mat3 RS = scaleQuaternionToMatrix(scales, viewQuaternion);\n\n    \n    vec2 scaledRenderSize = renderSize * focalAdjustment;\n    vec2 focal = 0.5 * scaledRenderSize * vec2(projectionMatrix[0][0], projectionMatrix[1][1]);\n\n    vec3 j0;\n    vec3 j1;\n    if (isOrthographic) {\n        j0 = vec3(focal.x, 0.0, 0.0);\n        j1 = vec3(0.0, focal.y, 0.0);\n    } else {\n        float invZ = 1.0 / viewCenter.z;\n        vec2 J1 = focal * invZ;\n        vec2 J2 = -(J1 * viewCenter.xy) * invZ;\n        j0 = vec3(J1.x, 0.0, J2.x);\n        j1 = vec3(0.0, J1.y, J2.y);\n    }\n\n    \n    \n    vec3 p0 = transpose(RS) * j0;\n    vec3 p1 = transpose(RS) * j1;\n    float a = dot(p0, p0);\n    float b = dot(p0, p1);\n    float d = dot(p1, p1);\n\n    \n    a += preBlurAmount;\n    d += preBlurAmount;\n\n    float detOrig = a * d - b * b;\n    \n    a += blurAmount;\n    d += blurAmount;\n    float det = a * d - b * b;\n    if (det <= 0.0) return;\n\n    \n    float blurAdjust = sqrt(max(0.0, detOrig / det));\n    alpha *= blurAdjust;\n    if (!(alpha > 0.0) || alpha < minAlpha) {\n        return;\n    }\n\n    \n    if (kernelPower == 0.0) {\n        supportRadius = gaussianSupportRadius(alpha, supportRadius);\n    } else {\n        supportRadius = wideSupportRadius(alpha, kernelPower, supportRadius);\n    }\n    vSplatUv = position.xy * supportRadius;\n\n    \n    float eigenAvg = 0.5 * (a + d);\n    float eigenDelta = length(vec2(0.5 * (a - d), b));\n    float eigen1 = eigenAvg + eigenDelta;\n    \n    float eigen2 = max(eigenAvg - eigenDelta, 1e-4);\n\n    vec2 eigenVec1 = (abs(b) > 0.001)\n        ? normalize(vec2(b, eigen1 - a))\n        : ((a >= d) ? vec2(1.0, 0.0) : vec2(0.0, 1.0));\n    vec2 eigenVec2 = vec2(eigenVec1.y, -eigenVec1.x);\n\n    \n    \n    float maxProjectedRadius = min(renderSize.x, renderSize.y) * focalAdjustment;\n    float scale1 = min(maxProjectedRadius, maximumSupportRadius * sqrt(eigen1));\n    float scale2 = min(maxProjectedRadius, maximumSupportRadius * sqrt(eigen2));\n    float supportScale = (maximumSupportRadius > 0.0)\n        ? supportRadius / maximumSupportRadius\n        : 0.0;\n    \n    \n    float cullScale = (kernelPower == 0.0) ? supportScale : 1.0;\n    \n    float minProjectedRadius = minPixelRadius * focalAdjustment;\n    if (scale1 * cullScale < minProjectedRadius && scale2 * cullScale < minProjectedRadius) {\n        return;\n    }\n    scale1 *= supportScale;\n    scale2 *= supportScale;\n\n    #if GSL_STOCHASTIC\n    \n    \n    \n    uint seed = texelFetch(stochasticSeeds, texCoord, 0).r;\n    uint hash = hashU32(seed);\n    uvec2 offset = uvec2(hash, hash >> 5u) - uvec2(viewportOrigin);\n    uint phase = ((hash >> 10u) + stochasticSample) & 31u;\n    vStochasticOffset = (offset.x & 31u) | ((offset.y & 31u) << 5u) | (phase << 10u);\n    #endif\n\n    \n    if (encodeLinear) {\n        rgba.rgb = srgbToLinear(rgba.rgb);\n    }\n    \n    vec3 rgb = min(rgba.rgb, vec3(65504.0));\n    vSplat = uvec4(\n        packHalf2x16(rgb.rg),\n        packHalf2x16(vec2(rgb.b, kernelPower)),\n        floatBitsToUint(alpha),\n        floatBitsToUint(supportRadius * supportRadius)\n    );\n\n    \n    vec2 pixelOffset = position.x * eigenVec1 * scale1 + position.y * eigenVec2 * scale2;\n    vec2 ndcOffset = (2.0 / scaledRenderSize) * pixelOffset;\n\n    \n    vec3 ndcCenter = clipCenter.xyz / clipCenter.w;\n    vec3 ndc = vec3(ndcCenter.xy + ndcOffset, ndcCenter.z);\n\n    gl_Position = vec4(ndc.xy * clipCenter.w, clipCenter.zw);\n    #include <logdepthbuf_vertex>\n}";
 let shaders = null;
 function getShaders() {
   if (!shaders) {
@@ -3357,7 +3358,8 @@ const _SplatAccumulator = class _SplatAccumulator {
     timer,
     camera,
     layerCamera = camera,
-    previous
+    previous,
+    frameCallbacks = true
   }) {
     const previousMapping = previous.mapping;
     const previousVersion = previous.version;
@@ -3386,12 +3388,13 @@ const _SplatAccumulator = class _SplatAccumulator {
       }
       if (!ancestor) globalEdits.add(node);
     });
+    const frameContext = {
+      time: this.time,
+      deltaTime: this.deltaTime,
+      globalEdits: Array.from(globalEdits)
+    };
     for (const mesh of allMeshes) {
-      mesh.frameUpdate({
-        time: this.time,
-        deltaTime: this.deltaTime,
-        globalEdits: Array.from(globalEdits)
-      });
+      mesh.frameUpdate(frameContext, frameCallbacks);
     }
     const visibleMeshes = [];
     scene.traverseVisible((node) => {
@@ -3583,7 +3586,6 @@ function createProjectionProgram(uniforms, view) {
   } = view;
   const maxStdDev = uniformBinding(uniforms, "maxStdDev", "float");
   const minPixelRadius = uniformBinding(uniforms, "minPixelRadius", "float");
-  const maxPixelRadius = uniformBinding(uniforms, "maxPixelRadius", "float");
   const minAlpha = uniformBinding(uniforms, "minAlpha", "float");
   const preBlurAmount = uniformBinding(uniforms, "preBlurAmount", "float");
   const blurAmount = uniformBinding(uniforms, "blurAmount", "float");
@@ -3698,7 +3700,7 @@ function createProjectionProgram(uniforms, view) {
               supportRadius.div(maximumSupportRadius),
               0
             );
-            const maxProjectedRadius = maxPixelRadius.mul(focalAdjustment);
+            const maxProjectedRadius = renderSize.x.min(renderSize.y).mul(focalAdjustment);
             const fullScale1 = maxProjectedRadius.min(
               maximumSupportRadius.mul(eigen1.sqrt())
             );
@@ -5381,7 +5383,6 @@ class ProjectedSplats {
       sortMode,
       uniforms.maxStdDev.value,
       uniforms.minPixelRadius.value,
-      uniforms.maxPixelRadius.value,
       uniforms.minAlpha.value,
       uniforms.preBlurAmount.value,
       uniforms.blurAmount.value,
@@ -5523,13 +5524,13 @@ function createSplatBackend(renderer, uniforms, options) {
   }
   return usesNativeWebGPU(renderer) ? new WebGPUSplatBackend(renderer, uniforms, options) : new WebGLFallbackSplatBackend(renderer, uniforms, options);
 }
-function configureSplatOutput(renderer, target, uniforms) {
+function configureSplatOutput(renderer, target, uniforms, encodeLinear) {
   let blendSpace = THREE.ColorManagement.workingColorSpace;
   if (!isWebGPURenderer(renderer)) {
     if (target === null) blendSpace = renderer.outputColorSpace;
     else if (isXRRenderTarget(target)) blendSpace = target.texture.colorSpace;
   }
-  uniforms.encodeLinear.value = blendSpace !== THREE.SRGBColorSpace;
+  uniforms.encodeLinear.value = encodeLinear ?? blendSpace !== THREE.SRGBColorSpace;
 }
 const renderToViewScaleTmp = new THREE.Vector3();
 const renderToViewMatrixTmp = new THREE.Matrix4();
@@ -5571,6 +5572,7 @@ class GaussianSplatRenderer extends THREE.Mesh {
     const geometry = new SplatGeometry();
     const material = backend.selectMaterial(stochastic);
     super(geometry, material);
+    this.frameCallbacks = true;
     this.renderSize = new THREE.Vector2();
     this.stochasticSample = 0;
     this.lastFrame = -1;
@@ -5605,6 +5607,7 @@ class GaussianSplatRenderer extends THREE.Mesh {
     this._depthTest = options.depthTest ?? true;
     this._depthWrite = options.depthWrite ?? false;
     this._premultipliedAlpha = premultipliedAlpha;
+    this._encodeLinear = options.encodeLinear;
     this._transparent = options.transparent ?? true;
     this._stochastic = stochastic;
     this.autoAdvanceStochasticSample = options.autoAdvanceStochasticSample ?? true;
@@ -5618,7 +5621,6 @@ class GaussianSplatRenderer extends THREE.Mesh {
     this.preUpdate = options.preUpdate ?? true;
     this.maxStdDev = options.maxStdDev ?? Math.sqrt(8);
     this.minPixelRadius = options.minPixelRadius ?? 1;
-    this.maxPixelRadius = options.maxPixelRadius ?? 256;
     this.minAlpha = options.minAlpha ?? DEFAULT_MIN_ALPHA;
     this.preBlurAmount = options.preBlurAmount ?? 0.3;
     this.blurAmount = options.blurAmount ?? 0;
@@ -5840,7 +5842,6 @@ class GaussianSplatRenderer extends THREE.Mesh {
     this.uniforms.renderToViewScale.value = (renderToViewScaleTmp.x + renderToViewScaleTmp.y + renderToViewScaleTmp.z) / 3;
     this.uniforms.maxStdDev.value = this.maxStdDev;
     this.uniforms.minPixelRadius.value = this.minPixelRadius;
-    this.uniforms.maxPixelRadius.value = this.maxPixelRadius;
     this.uniforms.minAlpha.value = this.minAlpha;
     this.uniforms.preBlurAmount.value = this.preBlurAmount;
     this.uniforms.blurAmount.value = this.blurAmount;
@@ -5848,7 +5849,12 @@ class GaussianSplatRenderer extends THREE.Mesh {
     this.uniforms.focalAdjustment.value = this.focalAdjustment;
     this.uniforms.stochastic.value = this.stochasticFrame;
     this.uniforms.stochasticSample.value = this.stochasticSample >>> 0;
-    configureSplatOutput(renderer, currentRenderTarget, this.uniforms);
+    configureSplatOutput(
+      renderer,
+      currentRenderTarget,
+      this.uniforms,
+      this._encodeLinear
+    );
     if (this.backend.kind === "webgpu") {
       if (this.backend.sortError) throw this.backend.sortError;
       if (this.backend.precompile) {
@@ -5930,7 +5936,8 @@ class GaussianSplatRenderer extends THREE.Mesh {
         timer: this.timer,
         camera,
         layerCamera: request.camera,
-        previous: this.current
+        previous: this.current,
+        frameCallbacks: this.frameCallbacks
       });
       this.display = this.current;
       this.activeSplats = this.current.numSplats;
@@ -5997,7 +6004,8 @@ class GaussianSplatRenderer extends THREE.Mesh {
         timer: this.timer,
         camera,
         layerCamera: updateCamera,
-        previous: this.current
+        previous: this.current,
+        frameCallbacks: this.frameCallbacks
       });
     } catch (error) {
       this.releaseAccumulator(next);
@@ -6175,6 +6183,15 @@ class GaussianSplatRenderer extends THREE.Mesh {
       this.sorting = false;
     }
   }
+  /** Decode sRGB before blending; undefined follows the active blend space. */
+  get encodeLinear() {
+    return this._encodeLinear;
+  }
+  set encodeLinear(value) {
+    if (value === this._encodeLinear) return;
+    this._encodeLinear = value;
+    this.setDirty();
+  }
   get premultipliedAlpha() {
     return this._premultipliedAlpha;
   }
@@ -6423,23 +6440,18 @@ class TAAPass extends Pass {
     this.edgeDepthDiff = 1e-3;
     this.maxMotionLength = 128;
     this.useSubpixelCorrection = true;
-    this.accumulateInOutputSpace = true;
     this._source = Object.assign(makeTarget("TAAPass.scene"), {
-      isXRRenderTarget: false
+      isXRRenderTarget: true
     });
     this._history = [
       makeTarget("TAAPass.history0"),
       makeTarget("TAAPass.history1")
     ];
-    this._size = new Vector2();
     this._clearColor = new Color();
     this._state = createTAAState(
       (value) => ({ value }),
       [this._source, ...this._history]
     );
-    this._workingColorSpace = ColorManagement.workingColorSpace;
-    this._toneMapping = NoToneMapping;
-    this._toneMappingExposure = 1;
     this._uniforms = {
       source: { value: this._source.texture },
       sourceDepth: { value: this._source.depthTexture },
@@ -6460,15 +6472,23 @@ class TAAPass extends Pass {
     });
     this._copyMaterial = new ShaderMaterial({
       name: "TAAPass.copy",
-      uniforms: { source: { value: null } },
+      uniforms: { source: { value: null }, decode: { value: false } },
       vertexShader,
+      // Inverts OutputPass's transfer, so the two round-trip at any alpha.
       fragmentShader: (
         /* glsl */
         `
         uniform sampler2D source;
+        uniform bool decode;
         in vec2 vUv;
         out vec4 fragColor;
-        void main() { fragColor = texture(source, vUv); }
+        void main() {
+          fragColor = texture(source, vUv);
+          if (decode) {
+            vec4 color = vec4(max(fragColor.rgb, 0.0), 1.0);
+            fragColor.rgb = sRGBTransferEOTF(color).rgb;
+          }
+        }
       `
       ),
       glslVersion: GLSL3,
@@ -6495,33 +6515,23 @@ class TAAPass extends Pass {
   reset() {
     this._state.reset();
   }
-  /** Render the scene and TAA to the canvas, a target, or the composer's buffer. */
-  render(renderer, writeBuffer = null) {
+  /** Render the scene and resolve TAA into the composer's working-space buffer. */
+  render(renderer, writeBuffer) {
     const { camera, _state: state, _uniforms: uniforms } = this;
-    if (writeBuffer) {
-      this.setSize(writeBuffer.width, writeBuffer.height);
-    } else {
-      renderer.getDrawingBufferSize(this._size);
-      this.setSize(this._size.x, this._size.y);
-    }
-    const workingColorSpace = ColorManagement.workingColorSpace;
-    const colorSpace = this.accumulateInOutputSpace ? renderer.outputColorSpace : workingColorSpace;
-    const toneMapping = this.accumulateInOutputSpace ? renderer.toneMapping : NoToneMapping;
-    const exposure = toneMapping === NoToneMapping ? 1 : renderer.toneMappingExposure;
-    if (this._source.texture.colorSpace !== colorSpace || this._source.isXRRenderTarget !== this.accumulateInOutputSpace || this._workingColorSpace !== workingColorSpace || this._toneMapping !== toneMapping || this._toneMappingExposure !== exposure) {
+    this.setSize(writeBuffer.width, writeBuffer.height);
+    const colorSpace = renderer.outputColorSpace;
+    if (this._source.texture.colorSpace !== colorSpace) {
       this._source.texture.colorSpace = colorSpace;
-      this._source.isXRRenderTarget = this.accumulateInOutputSpace;
-      this._workingColorSpace = workingColorSpace;
-      this._toneMapping = toneMapping;
-      this._toneMappingExposure = exposure;
       this.reset();
     }
     const previousTarget = renderer.getRenderTarget();
     const autoClear = renderer.autoClear;
     const xrEnabled = renderer.xr.enabled;
+    const toneMapping = renderer.toneMapping;
     try {
       renderer.xr.enabled = false;
       renderer.autoClear = false;
+      renderer.toneMapping = NoToneMapping;
       const reversedDepth = camera.reversedDepth;
       state.beginCapture(camera);
       try {
@@ -6551,6 +6561,7 @@ class TAAPass extends Pass {
       this._quad.material = this._resolveMaterial;
       this._quad.render(renderer);
       this._copyMaterial.uniforms.source.value = output.texture;
+      this._copyMaterial.uniforms.decode.value = !this.renderToScreen && ColorManagement.getTransfer(colorSpace) === SRGBTransfer;
       renderer.setRenderTarget(this.renderToScreen ? null : writeBuffer);
       this._quad.material = this._copyMaterial;
       this._quad.render(renderer);
@@ -6559,6 +6570,7 @@ class TAAPass extends Pass {
       renderer.setRenderTarget(previousTarget);
       renderer.autoClear = autoClear;
       renderer.xr.enabled = xrEnabled;
+      renderer.toneMapping = toneMapping;
     }
   }
   dispose() {
@@ -6859,6 +6871,643 @@ class TAANode extends TempNode {
     this.material.dispose();
   }
 }
+class WebGLCapture {
+  constructor(renderer) {
+    this.renderer = renderer;
+    this.depthTexture = new THREE.DepthTexture(
+      1,
+      1,
+      THREE.UnsignedIntType
+    );
+    this.target = Object.assign(
+      new THREE.WebGLRenderTarget(1, 1, {
+        type: THREE.UnsignedByteType,
+        internalFormat: "RGBA8",
+        generateMipmaps: false,
+        depthTexture: this.depthTexture
+      }),
+      // Output/XR semantics enable per-material display conversion before blending.
+      // Plain RGBA8 stores those output-space values without an sRGB attachment.
+      { isXRRenderTarget: true }
+    );
+    this.camera = new THREE.OrthographicCamera(-1, 1, 1, -1, 0, 1);
+    this.material = new THREE.ShaderMaterial({
+      uniforms: {
+        colorBuffer: { value: this.target.texture },
+        depthBuffer: { value: this.target.depthTexture },
+        decodeSRGB: { value: true },
+        encodeSRGB: { value: false }
+      },
+      vertexShader: `
+      varying vec2 vUv;
+      void main() {
+        vUv = uv;
+        gl_Position = vec4(position.xy, 0.0, 1.0);
+      }
+    `,
+      fragmentShader: `
+      uniform sampler2D colorBuffer;
+      uniform sampler2D depthBuffer;
+      uniform bool decodeSRGB;
+      uniform bool encodeSRGB;
+      varying vec2 vUv;
+      void main() {
+        vec4 color = texture2D(colorBuffer, vUv);
+        color.rgb = color.a > 0.0 ? color.rgb / color.a : vec3(0.0);
+        if (decodeSRGB) color = sRGBTransferEOTF(color);
+        if (encodeSRGB) color = sRGBTransferOETF(color);
+        color.rgb *= color.a;
+        gl_FragColor = color;
+        gl_FragDepth = texture2D(depthBuffer, vUv).r;
+      }
+    `,
+      blending: THREE.NoBlending,
+      depthFunc: THREE.AlwaysDepth,
+      toneMapped: false
+    });
+    this.quad = new THREE.Mesh(
+      new THREE.PlaneGeometry(2, 2),
+      this.material
+    );
+    this.quad.frustumCulled = false;
+  }
+  render(scene, camera) {
+    const { renderer, target, material } = this;
+    const output = renderer.getRenderTarget();
+    if (!output) throw new Error("WebGL capture requires a render target");
+    const face = renderer.getActiveCubeFace();
+    const mip = renderer.getActiveMipmapLevel();
+    const type = output.texture.type === THREE.HalfFloatType || output.texture.type === THREE.FloatType ? output.texture.type : THREE.UnsignedByteType;
+    if (target.texture.type !== type || target.depthBuffer !== output.depthBuffer || target.stencilBuffer !== output.stencilBuffer || target.samples !== output.samples) {
+      target.dispose();
+      target.texture.type = type;
+      target.texture.internalFormat = type === THREE.UnsignedByteType ? "RGBA8" : null;
+      target.depthBuffer = output.depthBuffer;
+      target.stencilBuffer = output.stencilBuffer;
+      this.depthTexture.format = output.stencilBuffer ? THREE.DepthStencilFormat : THREE.DepthFormat;
+      this.depthTexture.type = output.stencilBuffer ? THREE.UnsignedInt248Type : THREE.UnsignedIntType;
+      target.samples = output.samples;
+    }
+    target.setSize(output.width, output.height);
+    target.texture.colorSpace = renderer.outputColorSpace;
+    material.uniforms.decodeSRGB.value = target.texture.colorSpace === THREE.SRGBColorSpace;
+    material.uniforms.encodeSRGB.value = output.texture.colorSpace === THREE.SRGBColorSpace && output.texture.type !== THREE.UnsignedByteType;
+    material.depthTest = output.depthBuffer;
+    material.depthWrite = output.depthBuffer;
+    try {
+      renderer.setRenderTarget(target);
+      renderer.render(scene, camera);
+      renderer.setRenderTarget(output, face, mip);
+      material.depthFunc = renderer.state.buffers.depth.getReversed() ? THREE.NeverDepth : THREE.AlwaysDepth;
+      renderer.render(this.quad, this.camera);
+    } finally {
+      renderer.setRenderTarget(output, face, mip);
+    }
+  }
+  dispose() {
+    this.target.dispose();
+    this.quad.geometry.dispose();
+    this.material.dispose();
+  }
+}
+class WebGPUCapture {
+  constructor(renderer) {
+    this.renderer = renderer;
+    this.depthTexture = new THREE.DepthTexture(1, 1, THREE.FloatType);
+    this.target = new THREE.RenderTarget(1, 1, {
+      generateMipmaps: false,
+      depthTexture: this.depthTexture
+    });
+    this.material = new NodeMaterial();
+    this.quad = new QuadMesh(this.material);
+    this.workingColorSpace = "";
+    this.outputColorSpace = "";
+    this.storageColorSpace = "";
+    this.toneMapping = null;
+    this.material.blending = THREE.NoBlending;
+    this.material.toneMapped = false;
+    this.material.depthNode = N.texture(this.depthTexture).load(
+      N.ivec2(N.screenCoordinate.xy)
+    ).r;
+  }
+  render(scene, camera) {
+    const { renderer, target, material } = this;
+    const output = renderer.getRenderTarget();
+    if (!output) throw new Error("WebGPU capture requires a render target");
+    const face = renderer.getActiveCubeFace();
+    const mip = renderer.getActiveMipmapLevel();
+    const workingColorSpace = THREE.ColorManagement.workingColorSpace;
+    const native = usesNativeWebGPU(renderer);
+    const depthFormat = output.stencilBuffer ? THREE.DepthStencilFormat : THREE.DepthFormat;
+    let depthType = !native && output.samples > 0 ? THREE.UnsignedIntType : THREE.FloatType;
+    if (output.stencilBuffer) {
+      const float = output.depthTexture ? output.depthTexture.type === THREE.FloatType : renderer.reversedDepthBuffer;
+      depthType = native && float && renderer.hasFeature("depth32float-stencil8") ? THREE.FloatType : THREE.UnsignedInt248Type;
+    }
+    const type = output.texture.type === THREE.HalfFloatType || output.texture.type === THREE.FloatType ? output.texture.type : renderer.outputColorSpace !== workingColorSpace || renderer.toneMapping !== THREE.NoToneMapping ? renderer.getOutputBufferType() : THREE.UnsignedByteType;
+    if (target.texture.type !== type || target.depthBuffer !== output.depthBuffer || target.stencilBuffer !== output.stencilBuffer || this.depthTexture.type !== depthType || this.depthTexture.format !== depthFormat || target.samples !== output.samples) {
+      target.dispose();
+      target.texture.type = type;
+      this.depthTexture.type = depthType;
+      this.depthTexture.format = depthFormat;
+      target.depthBuffer = output.depthBuffer;
+      target.stencilBuffer = output.stencilBuffer;
+      target.depthTexture = output.depthBuffer ? this.depthTexture : null;
+      if (target.samples !== output.samples) material.needsUpdate = true;
+      target.samples = output.samples;
+    }
+    target.setSize(output.width, output.height);
+    const storageColorSpace = output.texture.type === THREE.UnsignedByteType && output.texture.colorSpace === THREE.SRGBColorSpace ? THREE.LinearSRGBColorSpace : output.texture.colorSpace || THREE.LinearSRGBColorSpace;
+    if (this.workingColorSpace !== workingColorSpace || this.outputColorSpace !== renderer.outputColorSpace || this.storageColorSpace !== storageColorSpace || this.toneMapping !== renderer.toneMapping) {
+      const color = N.texture(target.texture).load(
+        N.ivec2(N.screenCoordinate.xy)
+      );
+      const outputColor = N.renderOutput(
+        color,
+        renderer.toneMapping,
+        renderer.outputColorSpace
+      );
+      material.fragmentNode = N.premultiplyAlpha(
+        N.convertColorSpace(
+          N.unpremultiplyAlpha(outputColor),
+          renderer.outputColorSpace,
+          storageColorSpace
+        )
+      );
+      material.needsUpdate = true;
+      this.workingColorSpace = workingColorSpace;
+      this.outputColorSpace = renderer.outputColorSpace;
+      this.storageColorSpace = storageColorSpace;
+      this.toneMapping = renderer.toneMapping;
+    }
+    material.depthTest = output.depthBuffer;
+    material.depthWrite = output.depthBuffer;
+    material.depthFunc = renderer.reversedDepthBuffer ? THREE.NeverDepth : THREE.AlwaysDepth;
+    try {
+      renderer.setRenderTarget(target);
+      renderer.render(scene, camera);
+      renderer.setRenderTarget(output, face, mip);
+      this.quad.render(renderer);
+    } finally {
+      renderer.setRenderTarget(output, face, mip);
+    }
+  }
+  dispose() {
+    this.target.dispose();
+    this.material.dispose();
+  }
+}
+async function readPixels(renderer, target, pixels, face = 0) {
+  if (target.texture.format !== THREE.RGBAFormat || target.texture.type !== THREE.UnsignedByteType) {
+    throw new Error(
+      "Splat capture readback requires an RGBA UnsignedByte target"
+    );
+  }
+  const { width, height } = target;
+  if (!isWebGPURenderer(renderer)) {
+    await renderer.readRenderTargetPixelsAsync(
+      target,
+      0,
+      0,
+      width,
+      height,
+      pixels,
+      face
+    );
+    return;
+  }
+  const readback = await renderer.readRenderTargetPixelsAsync(
+    target,
+    0,
+    0,
+    width,
+    height,
+    0,
+    face
+  );
+  const source = new Uint8Array(
+    readback.buffer,
+    readback.byteOffset,
+    readback.byteLength
+  );
+  if (!usesNativeWebGPU(renderer)) {
+    pixels.set(source);
+    return;
+  }
+  const rowBytes = width * 4;
+  const rowStride = Math.ceil(rowBytes / 256) * 256;
+  for (let y = 0; y < height; y++) {
+    const start = (height - y - 1) * rowStride;
+    pixels.set(source.subarray(start, start + rowBytes), y * rowBytes);
+  }
+}
+function downsamplePixels(source, width, height, superXY, output) {
+  const subWidth = width / superXY;
+  const subHeight = height / superXY;
+  const samples = superXY * superXY;
+  for (let y = 0; y < subHeight; y++) {
+    for (let x = 0; x < subWidth; x++) {
+      const outputIndex = (y * subWidth + x) * 4;
+      for (let channel = 0; channel < 4; channel++) {
+        let sum = 0;
+        for (let sy = 0; sy < superXY; sy++) {
+          const row = (y * superXY + sy) * width;
+          for (let sx = 0; sx < superXY; sx++) {
+            sum += source[(row + x * superXY + sx) * 4 + channel];
+          }
+        }
+        output[outputIndex + channel] = Math.round(sum / samples);
+      }
+    }
+  }
+}
+function withCaptureState(renderer, draw) {
+  const target = renderer.getRenderTarget();
+  const cubeFace = renderer.getActiveCubeFace();
+  const mipmapLevel = renderer.getActiveMipmapLevel();
+  const xrEnabled = renderer.xr.enabled;
+  const autoClear = renderer.autoClear;
+  const nodeRenderer = isWebGPURenderer(renderer) ? renderer : null;
+  const mrt = (nodeRenderer == null ? void 0 : nodeRenderer.getMRT()) ?? null;
+  renderer.xr.enabled = false;
+  renderer.autoClear = true;
+  nodeRenderer == null ? void 0 : nodeRenderer.setMRT(null);
+  try {
+    return draw();
+  } finally {
+    renderer.xr.enabled = xrEnabled;
+    renderer.autoClear = autoClear;
+    nodeRenderer == null ? void 0 : nodeRenderer.setMRT(mrt);
+    setRendererRenderTarget(renderer, target, cubeFace, mipmapLevel);
+  }
+}
+function captureSceneView(scene, hideObjects) {
+  if (hideObjects.length === 0) return scene;
+  const hidden = new Set(hideObjects);
+  const view = new THREE.Scene();
+  view.matrixWorldAutoUpdate = scene.matrixWorldAutoUpdate;
+  view.updateMatrixWorld = (force) => scene.updateMatrixWorld(force);
+  const filter = (callback) => (object) => {
+    if (!(object instanceof SplatEdit)) {
+      let ancestor = object;
+      while (ancestor) {
+        if (hidden.has(ancestor)) return;
+        ancestor = ancestor.parent;
+      }
+    }
+    callback(object);
+  };
+  view.traverse = (callback) => scene.traverse(filter(callback));
+  view.traverseVisible = (callback) => scene.traverseVisible(filter(callback));
+  return view;
+}
+class SplatCapture {
+  constructor({ splatRenderer, target }) {
+    this.disposed = false;
+    this.pending = Promise.resolve();
+    this.cubeRenders = /* @__PURE__ */ new Map();
+    this.lastCube = null;
+    this.pmrem = null;
+    this.splatRenderer = splatRenderer;
+    this.capturePass = isWebGPURenderer(this.renderer) ? new WebGPUCapture(this.renderer) : new WebGLCapture(this.renderer);
+    this.superXY = (target == null ? void 0 : target.superXY) ?? 1;
+    if (!Number.isInteger(this.superXY) || this.superXY < 1 || this.superXY > 4) {
+      throw new Error("Splat capture superXY must be an integer from 1 to 4");
+    }
+    if (target) this.initializeTarget(target);
+    this.captureRenderer = new GaussianSplatRenderer({
+      renderer: this.renderer,
+      timer: splatRenderer.timer,
+      autoUpdate: false,
+      stochastic: false
+    });
+    this.captureRenderer.frameCallbacks = false;
+  }
+  initializeTarget(target) {
+    const {
+      width,
+      height,
+      doubleBuffer,
+      superXY: _superXY,
+      ...options
+    } = target;
+    if (!Number.isInteger(width) || !Number.isInteger(height) || width < 1 || height < 1 || width * this.superXY > 8192 || height * this.superXY > 8192) {
+      throw new Error(
+        "Splat capture dimensions must be positive integers up to 8192 / superXY"
+      );
+    }
+    const targetOptions = {
+      format: THREE.RGBAFormat,
+      type: THREE.UnsignedByteType,
+      colorSpace: THREE.SRGBColorSpace,
+      ...options,
+      // Three.js attaches stencil only together with depth.
+      stencilBuffer: options.depthBuffer !== false && this.stencilBuffer
+    };
+    const superWidth = width * this.superXY;
+    const superHeight = height * this.superXY;
+    this.target = isWebGPURenderer(this.renderer) ? new THREE.RenderTarget(superWidth, superHeight, targetOptions) : new THREE.WebGLRenderTarget(superWidth, superHeight, targetOptions);
+    if (doubleBuffer) {
+      this.backTarget = this.target.clone();
+    }
+  }
+  get renderer() {
+    return this.splatRenderer.renderer;
+  }
+  get stencilBuffer() {
+    var _a2;
+    const { renderer } = this;
+    return isWebGPURenderer(renderer) ? renderer.stencil : ((_a2 = renderer.getContextAttributes()) == null ? void 0 : _a2.stencil) === true;
+  }
+  assertActive() {
+    if (this.disposed) throw new Error("Splat capture is disposed");
+  }
+  enqueue(task) {
+    const result = this.pending.then(task);
+    this.pending = result.catch(() => {
+    });
+    return result;
+  }
+  async renderCapture({ scene, camera }, draw, radial = false, hideObjects = []) {
+    this.assertActive();
+    const { splatRenderer: source, captureRenderer } = this;
+    Object.assign(captureRenderer, {
+      maxStdDev: source.maxStdDev,
+      minPixelRadius: source.minPixelRadius,
+      minAlpha: source.minAlpha,
+      preBlurAmount: source.preBlurAmount,
+      blurAmount: source.blurAmount,
+      clipXY: source.clipXY,
+      focalAdjustment: source.focalAdjustment,
+      fastSort: source.fastSort,
+      premultipliedAlpha: source.premultipliedAlpha,
+      transparent: source.transparent,
+      depthTest: source.depthTest,
+      depthWrite: source.depthWrite,
+      encodeLinear: source.encodeLinear,
+      sortRadial: radial || source.sortRadial
+    });
+    const sourceMaterial = source.material;
+    const captureMaterial = captureRenderer.material;
+    captureMaterial.stencilWrite = sourceMaterial.stencilWrite;
+    captureMaterial.stencilWriteMask = sourceMaterial.stencilWriteMask;
+    captureMaterial.stencilFunc = sourceMaterial.stencilFunc;
+    captureMaterial.stencilRef = sourceMaterial.stencilRef;
+    captureMaterial.stencilFuncMask = sourceMaterial.stencilFuncMask;
+    captureMaterial.stencilFail = sourceMaterial.stencilFail;
+    captureMaterial.stencilZFail = sourceMaterial.stencilZFail;
+    captureMaterial.stencilZPass = sourceMaterial.stencilZPass;
+    captureRenderer.layers.mask = camera.layers.mask;
+    const view = { scene: captureSceneView(scene, hideObjects), camera };
+    await captureRenderer.update(view);
+    if (captureRenderer.display.mapping.some(
+      ({ node, version }) => node.version !== version
+    )) {
+      await captureRenderer.update(view);
+    }
+    this.assertActive();
+    const layers = /* @__PURE__ */ new Map();
+    scene.traverse((object) => {
+      if (object instanceof GaussianSplatRenderer) {
+        layers.set(object.layers, object.layers.mask);
+      }
+    });
+    const visibility = new Map(
+      hideObjects.map((object) => [object, object.visible])
+    );
+    try {
+      for (const layer of layers.keys()) layer.mask = 0;
+      for (const object of visibility.keys()) object.visible = false;
+      scene.add(captureRenderer);
+      withCaptureState(this.renderer, draw);
+    } finally {
+      scene.remove(captureRenderer);
+      for (const [layer, mask] of layers) layer.mask = mask;
+      for (const [object, visible] of visibility) object.visible = visible;
+    }
+  }
+  /** Snapshots the camera now; the capture may wait for earlier ones. */
+  targetCapture({ scene, camera }) {
+    this.assertActive();
+    camera.updateWorldMatrix(true, false);
+    const Camera = camera.constructor;
+    const captureCamera = new Camera().copy(camera, false);
+    captureCamera.matrixAutoUpdate = false;
+    captureCamera.matrix.copy(camera.matrixWorld);
+    return async () => {
+      this.assertActive();
+      const target = this.backTarget ?? this.target;
+      if (!target)
+        throw new Error("Initialize SplatCapture with target options");
+      const stencilBuffer = target.depthBuffer && this.stencilBuffer;
+      if (target.stencilBuffer !== stencilBuffer) {
+        target.dispose();
+        target.stencilBuffer = stencilBuffer;
+      }
+      await this.renderCapture({ scene, camera: captureCamera }, () => {
+        setRendererRenderTarget(this.renderer, target);
+        this.capturePass.render(scene, captureCamera);
+      });
+      if (target !== this.target) {
+        [this.target, this.backTarget] = [this.backTarget, this.target];
+      }
+      return target;
+    };
+  }
+  async renderTarget(view) {
+    return this.enqueue(this.targetCapture(view));
+  }
+  /** Reuses the returned buffer; copy it if a later read must not overwrite it. */
+  async readTarget() {
+    var _a2, _b;
+    this.assertActive();
+    const target = this.target;
+    if (!target) throw new Error("Initialize SplatCapture with target options");
+    const { width, height } = target;
+    if (width % this.superXY !== 0 || height % this.superXY !== 0) {
+      throw new Error(
+        "Splat capture target dimensions must be divisible by superXY"
+      );
+    }
+    const byteSize = width * height * 4;
+    if (((_a2 = this.superPixels) == null ? void 0 : _a2.length) !== byteSize) {
+      this.superPixels = new Uint8Array(byteSize);
+    }
+    const pixels = this.superPixels;
+    await readPixels(this.renderer, target, pixels);
+    this.assertActive();
+    if (this.superXY === 1) return pixels;
+    const subSize = byteSize / (this.superXY * this.superXY);
+    if (((_b = this.targetPixels) == null ? void 0 : _b.length) !== subSize) {
+      this.targetPixels = new Uint8Array(subSize);
+    }
+    downsamplePixels(pixels, width, height, this.superXY, this.targetPixels);
+    return this.targetPixels;
+  }
+  async renderReadTarget(view) {
+    const capture = this.targetCapture(view);
+    return this.enqueue(async () => {
+      await capture();
+      return this.readTarget();
+    });
+  }
+  renderCube(scene, camera) {
+    const { renderer } = this;
+    camera.updateMatrixWorld();
+    if (camera.coordinateSystem !== renderer.coordinateSystem) {
+      camera.coordinateSystem = renderer.coordinateSystem;
+      camera.updateCoordinateSystem();
+    }
+    const target = camera.renderTarget;
+    const generateMipmaps = target.texture.generateMipmaps;
+    target.texture.generateMipmaps = false;
+    try {
+      for (let face = 0; face < 6; face++) {
+        if (face === 5) target.texture.generateMipmaps = generateMipmaps;
+        setRendererRenderTarget(
+          renderer,
+          target,
+          face,
+          camera.activeMipmapLevel
+        );
+        this.capturePass.render(scene, camera.children[face]);
+      }
+      target.texture.needsPMREMUpdate = true;
+    } finally {
+      target.texture.generateMipmaps = generateMipmaps;
+    }
+  }
+  /** Validates and snapshots the center now; the capture may wait for earlier ones. */
+  cubeCapture({
+    scene,
+    worldCenter,
+    size: size2 = 256,
+    near = 0.1,
+    far = 1e3,
+    hideObjects = [],
+    filter = false
+  }) {
+    this.assertActive();
+    if (!Number.isInteger(size2) || size2 < 1 || size2 > 8192) {
+      throw new Error(
+        "Splat capture cube size must be a positive integer up to 8192"
+      );
+    }
+    if (!(near > 0 && far > near && Number.isFinite(far))) {
+      throw new Error("Splat capture cube requires 0 < near < far < Infinity");
+    }
+    const center = worldCenter.clone();
+    return async () => {
+      this.assertActive();
+      const stencilBuffer = this.stencilBuffer;
+      let cubeRender = this.cubeRenders.get(filter);
+      if (!cubeRender || cubeRender.target.width !== size2 || cubeRender.target.stencilBuffer !== stencilBuffer || cubeRender.near !== near || cubeRender.far !== far) {
+        cubeRender == null ? void 0 : cubeRender.target.dispose();
+        if (this.lastCube === cubeRender) this.lastCube = null;
+        const Target = isWebGPURenderer(this.renderer) ? CubeRenderTarget : THREE.WebGLCubeRenderTarget;
+        const target2 = new Target(size2, {
+          format: THREE.RGBAFormat,
+          type: THREE.UnsignedByteType,
+          stencilBuffer,
+          generateMipmaps: filter,
+          minFilter: filter ? THREE.LinearMipmapLinearFilter : THREE.LinearFilter,
+          colorSpace: filter ? THREE.LinearSRGBColorSpace : THREE.SRGBColorSpace
+        });
+        const camera2 = new THREE.CubeCamera(near, far, target2);
+        cubeRender = { target: target2, camera: camera2, near, far };
+        this.cubeRenders.set(filter, cubeRender);
+      }
+      const { target, camera } = cubeRender;
+      camera.position.copy(center);
+      const updateCamera = new THREE.PerspectiveCamera(90, 1, near, far);
+      updateCamera.position.copy(center);
+      await this.renderCapture(
+        { scene, camera: updateCamera },
+        () => this.renderCube(scene, camera),
+        true,
+        hideObjects
+      );
+      this.lastCube = cubeRender;
+      return target.texture;
+    };
+  }
+  async renderCubeMap(options) {
+    return this.enqueue(this.cubeCapture(options));
+  }
+  /** Faces of the latest cube capture, in the WebGL layout on every backend. */
+  async readCubeTargets() {
+    return this.enqueue(async () => {
+      this.assertActive();
+      if (!this.lastCube)
+        throw new Error("Render a cube map before reading its faces");
+      const { target } = this.lastCube;
+      const native = usesNativeWebGPU(this.renderer);
+      const faces = [];
+      for (let face = 0; face < 6; face++) {
+        const pixels = new Uint8Array(target.width * target.height * 4);
+        const source = native && face < 2 ? 1 - face : face;
+        await readPixels(this.renderer, target, pixels, source);
+        if (native) new Uint32Array(pixels.buffer).reverse();
+        faces.push(pixels);
+      }
+      this.assertActive();
+      return faces;
+    });
+  }
+  /** The caller owns the result; texture.dispose() also releases its render target. */
+  async renderEnvMap(options) {
+    const capture = this.cubeCapture({ ...options, filter: true });
+    return this.enqueue(async () => {
+      const cube = await capture();
+      this.assertActive();
+      this.pmrem ?? (this.pmrem = isWebGPURenderer(this.renderer) ? new PMREMGenerator(this.renderer) : new THREE.PMREMGenerator(this.renderer));
+      const pmrem = this.pmrem;
+      const target = withCaptureState(
+        this.renderer,
+        () => pmrem.fromCubemap(cube)
+      );
+      const disposeTarget = () => {
+        target.texture.removeEventListener("dispose", disposeTarget);
+        target.dispose();
+      };
+      target.texture.addEventListener("dispose", disposeTarget);
+      return target.texture;
+    });
+  }
+  recurseSetEnvMap(root, envMap) {
+    root.traverse((node) => {
+      var _a2;
+      if (!(node instanceof THREE.Mesh)) return;
+      const materials = Array.isArray(node.material) ? node.material : [node.material];
+      for (const material of materials) {
+        if (material instanceof THREE.MeshStandardMaterial) {
+          if (((_a2 = material.envMap) == null ? void 0 : _a2.mapping) !== envMap.mapping) {
+            material.needsUpdate = true;
+          }
+          material.envMap = envMap;
+        }
+      }
+    });
+  }
+  dispose() {
+    var _a2, _b, _c;
+    if (this.disposed) return;
+    this.disposed = true;
+    this.captureRenderer.dispose();
+    this.capturePass.dispose();
+    (_a2 = this.target) == null ? void 0 : _a2.dispose();
+    (_b = this.backTarget) == null ? void 0 : _b.dispose();
+    for (const { target } of this.cubeRenders.values()) target.dispose();
+    (_c = this.pmrem) == null ? void 0 : _c.dispose();
+    this.target = void 0;
+    this.backTarget = void 0;
+    this.superPixels = void 0;
+    this.targetPixels = void 0;
+    this.cubeRenders.clear();
+    this.lastCube = null;
+    this.pmrem = null;
+  }
+}
 function getAssetBaseUrl(url) {
   if (!url) return void 0;
   try {
@@ -11432,7 +12081,7 @@ export {
   GaussianSplatRenderer,
   RadStreamScheduler,
   SogStreamScheduler,
-  SplatAccumulator,
+  SplatCapture,
   SplatEdit,
   SplatEditRgbaBlendMode,
   SplatEditSdf,