gaussian-splat-lite 1.1.2 → 1.1.3

package/CHANGELOG.md

@@ -7,6 +7,13 @@ and this project follows [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [1.1.3] - 2026-09-23
+
+### Changed
+
+- Optimized manual sorted rendering across WebGL, WebGPU, and WebGL fallback by removing unused stochastic and depth branches from the color fragment shader. Auto and stochastic modes retain uniform-based switching; custom GLSL shaders are unchanged.
+- Native WebGPU reuses projection, visibility compaction, and sort results when source data, views, and projection settings are unchanged.
+
 ## [1.1.2] - 2026-09-21
 
 ### Added
@@ -388,7 +395,8 @@ and this project follows [Semantic Versioning](https://semver.org/).
 
 - Initial public release of the Three.js Gaussian Splatting renderer.
 
-[Unreleased]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v1.1.2...HEAD
+[Unreleased]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v1.1.3...HEAD
+[1.1.3]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v1.1.2...v1.1.3
 [1.1.2]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v1.1.1...v1.1.2
 [1.1.1]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v1.1.0...v1.1.1
 [1.1.0]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v1.0.4...v1.1.0

package/dist/gaussian-splat-lite.cjs

@@ -24456,7 +24456,7 @@ class FullScreenQuad {
   }
 }
 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\n#include <splatDefines>\n\nuniform float near;\nuniform float far;\n#ifndef GSL_COLOR_IN_VERTEX\nuniform bool encodeLinear;\n#endif\nuniform float time;\nuniform float minAlpha;\nuniform bool stochastic;\nuniform vec4 stochasticTemporalSample;\nuniform bool stochasticResolve;\nuniform bool depthOnly;\nuniform highp usampler2D stochasticNoise;\nuniform vec2 viewportOrigin;\n\nout vec4 fragColor;\n\nin vec4 vRgba;\nin vec2 vSplatUv;\nflat in uint vStochasticHash;\nflat in float vSupportRadiusSquared;\nflat in float vKernelPower;\n\n#include <logdepthbuf_pars_fragment>\n\nvoid main() {\n    vec4 rgba = vRgba;\n\n    float z2 = dot(vSplatUv, vSplatUv);\n    if (z2 > vSupportRadiusSquared) {\n        discard;\n    }\n\n    float kernelAlpha = exp(-0.5 * z2);\n    if (vKernelPower != 0.0) {\n        kernelAlpha = 1.0 - pow(1.0 - kernelAlpha, vKernelPower);\n    }\n    rgba.a *= kernelAlpha;\n\n    if (rgba.a < minAlpha) {\n        discard;\n    }\n    if (stochastic || depthOnly) {\n        \n        uvec2 pixel = uvec2(gl_FragCoord.xy - viewportOrigin);\n        uvec2 offset = uvec2(vStochasticHash, vStochasticHash >> 5u);\n        if (stochastic && !depthOnly) offset += uvec2(stochasticTemporalSample.zw);\n        ivec2 coord = ivec2((pixel + offset) & uvec2(31u));\n        float randomValue = (float(texelFetch(stochasticNoise, coord, 0).r) + 0.5) / 1024.0;\n        if (randomValue >= rgba.a) {\n            discard;\n        }\n\n        if (depthOnly) {\n            fragColor = vec4(0.0);\n            #include <logdepthbuf_fragment>\n            return;\n        }\n    }\n    #ifndef GSL_COLOR_IN_VERTEX\n    if (encodeLinear) {\n        rgba.rgb = srgbToLinear(rgba.rgb);\n    }\n    #endif\n\n    if (stochastic) {\n        \n        \n        fragColor = vec4(rgba.rgb, stochasticResolve ? 2.0 : 1.0);\n        #include <logdepthbuf_fragment>\n        return;\n    }\n\n    #ifdef 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 splatFragment_default = "precision highp float;\nprecision highp int;\n\n#include <splatDefines>\n\nuniform float near;\nuniform float far;\n#ifndef GSL_COLOR_IN_VERTEX\nuniform bool encodeLinear;\n#endif\nuniform float time;\nuniform float minAlpha;\nuniform bool stochastic;\nuniform vec4 stochasticTemporalSample;\nuniform bool stochasticResolve;\nuniform bool depthOnly;\nuniform highp usampler2D stochasticNoise;\nuniform vec2 viewportOrigin;\n\nout vec4 fragColor;\n\nin vec4 vRgba;\nin vec2 vSplatUv;\nflat in uint vStochasticHash;\nflat in float vSupportRadiusSquared;\nflat in float vKernelPower;\n\n#include <logdepthbuf_pars_fragment>\n\nvoid main() {\n    vec4 rgba = vRgba;\n\n    float z2 = dot(vSplatUv, vSplatUv);\n    if (z2 > vSupportRadiusSquared) {\n        discard;\n    }\n\n    float kernelAlpha = exp(-0.5 * z2);\n    if (vKernelPower != 0.0) {\n        kernelAlpha = 1.0 - pow(1.0 - kernelAlpha, vKernelPower);\n    }\n    rgba.a *= kernelAlpha;\n\n    if (rgba.a < minAlpha) {\n        discard;\n    }\n    #if !GSL_SORTED_FRAGMENT\n    if (stochastic || depthOnly) {\n        \n        uvec2 pixel = uvec2(gl_FragCoord.xy - viewportOrigin);\n        uvec2 offset = uvec2(vStochasticHash, vStochasticHash >> 5u);\n        if (stochastic && !depthOnly) offset += uvec2(stochasticTemporalSample.zw);\n        ivec2 coord = ivec2((pixel + offset) & uvec2(31u));\n        float randomValue = (float(texelFetch(stochasticNoise, coord, 0).r) + 0.5) / 1024.0;\n        if (randomValue >= rgba.a) {\n            discard;\n        }\n\n        if (depthOnly) {\n            fragColor = vec4(0.0);\n            #include <logdepthbuf_fragment>\n            return;\n        }\n    }\n    #ifndef GSL_COLOR_IN_VERTEX\n    if (encodeLinear) {\n        rgba.rgb = srgbToLinear(rgba.rgb);\n    }\n    #endif\n\n    if (stochastic) {\n        \n        \n        fragColor = vec4(rgba.rgb, stochasticResolve ? 2.0 : 1.0);\n        #include <logdepthbuf_fragment>\n        return;\n    }\n    #endif\n\n    #ifdef 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\nout vec4 vRgba;\nout vec2 vSplatUv;\nflat out uint vStochasticHash;\nflat out float vSupportRadiusSquared;\nflat out float vKernelPower;\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 time;\nuniform float deltaTime;\nuniform float minAlpha;\nuniform float blurAmount;\nuniform float preBlurAmount;\nuniform float clipXY;\nuniform float focalAdjustment;\nuniform bool stochastic;\nuniform vec4 stochasticTemporalSample;\n#ifdef GSL_COLOR_IN_VERTEX\nuniform bool encodeLinear;\n#endif\nuniform bool depthOnly;\n\nuniform usampler2D ordering;\nuniform usampler2DArray splats;\nuniform usampler2DArray splats2;\nuniform usampler2DArray stochasticSeeds;\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 splatIndex;\n    if (stochastic || depthOnly) {\n        \n        splatIndex = uint(gl_InstanceID);\n    } else {\n        ivec2 orderingCoord = ivec2((gl_InstanceID >> 2) & 4095, gl_InstanceID >> 14);\n        splatIndex = texelFetch(ordering, orderingCoord, 0)[gl_InstanceID & 3];\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 (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    vKernelPower = kernelPower;\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    vRgba = vec4(rgba.rgb, alpha);\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    vRgba.a = alpha;\n\n    \n    if (kernelPower == 0.0) {\n        supportRadius = gaussianSupportRadius(alpha, supportRadius);\n    } else {\n        supportRadius = wideSupportRadius(alpha, kernelPower, supportRadius);\n    }\n    vSupportRadiusSquared = supportRadius * supportRadius;\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    \n    \n    vStochasticHash = 0u;\n    if (stochastic || depthOnly) {\n        vStochasticHash = hashU32(texelFetch(stochasticSeeds, texCoord, 0).r);\n    }\n\n    \n    #ifdef GSL_COLOR_IN_VERTEX\n    if (encodeLinear && !depthOnly) {\n        vRgba.rgb = srgbToLinear(vRgba.rgb);\n    }\n    #endif\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    if (stochastic && !depthOnly) {\n        gl_Position.xy += stochasticTemporalSample.xy * gl_Position.w;\n    }\n\n    #include <logdepthbuf_vertex>\n}";
 let shaders = null;
 function getShaders() {
@@ -25605,6 +25605,7 @@ const stochasticHash = N.Fn(([input]) => {
   return value;
 });
 function createSplatFragment({
+  sorted,
   minAlpha,
   stochastic,
   stochasticResolve,
@@ -25634,6 +25635,7 @@ function createSplatFragment({
     });
     rgba.a.mulAssign(kernelAlpha);
     rgba.a.lessThan(minAlpha).discard();
+    if (sorted) return rgba;
     N.If(stochastic.or(depthOnly), () => {
       const pixel = N.uvec2(N.screenCoordinate.xy.sub(vViewportOrigin));
       const offset = N.uvec2(
@@ -25678,7 +25680,9 @@ function createSplatNodeMaterial({
   premultipliedAlpha,
   transparent,
   depthTest,
-  depthWrite
+  depthWrite,
+  sorted = false,
+  vertexNode: sharedVertexNode
 }) {
   const orderingNode = providedOrderingNode ?? createDefaultOrderingNode();
   const splats = textureBinding(uniforms, "splats", true);
@@ -25713,6 +25717,7 @@ function createSplatNodeMaterial({
     vViewportOrigin,
     fragmentNode
   } = createSplatFragment({
+    sorted,
     minAlpha,
     stochastic,
     stochasticResolve,
@@ -25721,7 +25726,7 @@ function createSplatNodeMaterial({
     depthOnly,
     premultipliedAlpha: premultipliedAlphaNode
   });
-  const vertexNode = N.Fn((builder) => {
+  function buildVertex(builder) {
     const camera = materialCamera(builder);
     const clipPosition = N.vec4(0, 0, 2, 1).toVar();
     vRgba.assign(N.vec4(0));
@@ -25805,34 +25810,51 @@ function createSplatNodeMaterial({
       clipPosition.xy.addAssign(temporalSample.xy.mul(clipPosition.w));
     });
     return clipPosition;
-  })();
-  const material = new NodeMaterial();
-  material.vertexNode = vertexNode;
-  material.colorNode = fragmentNode;
-  material.premultipliedAlpha = premultipliedAlpha;
-  material.transparent = transparent;
-  material.depthTest = depthTest;
-  material.depthWrite = depthWrite;
-  material.side = THREE__namespace.FrontSide;
-  material.allowOverride = false;
-  material.fog = false;
-  material.toneMapped = false;
-  return Object.assign(material, { uniforms, orderingNode });
+  }
+  const vertexNode = sharedVertexNode ?? N.Fn(buildVertex)();
+  return Object.assign(new NodeMaterial(), {
+    uniforms,
+    orderingNode,
+    vertexNode,
+    colorNode: fragmentNode,
+    premultipliedAlpha,
+    transparent,
+    depthTest,
+    depthWrite,
+    side: THREE__namespace.FrontSide,
+    allowOverride: false,
+    fog: false,
+    toneMapped: false
+  });
 }
 class NodeSplatBackend {
   constructor(renderer, uniforms, options, orderingNode, vertexData) {
     this.renderer = renderer;
-    this.material = createSplatNodeMaterial({
+    this.sortedMaterial = createSplatNodeMaterial({
       uniforms,
       ...options,
       orderingNode,
-      vertexData
+      vertexData,
+      sorted: true
+    });
+    this.uniformMaterial = createSplatNodeMaterial({
+      uniforms,
+      ...options,
+      orderingNode: this.sortedMaterial.orderingNode,
+      vertexNode: this.sortedMaterial.vertexNode
     });
   }
+  selectMaterial(useUniform) {
+    return useUniform ? this.uniformMaterial : this.sortedMaterial;
+  }
+  dispose() {
+    this.sortedMaterial.dispose();
+    this.uniformMaterial.dispose();
+  }
   createDepthMaterial(uniforms) {
     return createSplatNodeMaterial({
       uniforms,
-      orderingNode: this.material.orderingNode,
+      orderingNode: this.sortedMaterial.orderingNode,
       premultipliedAlpha: false,
       transparent: false,
       depthTest: true,
@@ -25922,7 +25944,7 @@ class WebGLFallbackSplatBackend extends NodeSplatBackend {
     return this.ordering.data;
   }
   setCPUOrdering(update) {
-    this.material.orderingNode.value = this.ordering.update(
+    this.sortedMaterial.orderingNode.value = this.ordering.update(
       update,
       (texture2, rows) => {
         this.renderer.initTexture(texture2);
@@ -25936,6 +25958,7 @@ class WebGLFallbackSplatBackend extends NodeSplatBackend {
     );
   }
   dispose() {
+    super.dispose();
     this.ordering.dispose();
   }
   bindOrdering(material, _uniforms) {
@@ -25947,6 +25970,7 @@ function createWebGLSplatMaterial(uniforms, options) {
   const defines2 = {};
   if (options.vertexShader === void 0 && options.fragmentShader === void 0) {
     defines2.GSL_COLOR_IN_VERTEX = 1;
+    defines2.GSL_SORTED_FRAGMENT = 0;
   }
   return new THREE__namespace.ShaderMaterial({
     ...options,
@@ -25968,6 +25992,16 @@ class WebGLSplatBackend {
     const extension = renderer.getContext().getExtension("WEBGL_provoking_vertex");
     extension == null ? void 0 : extension.provokingVertexWEBGL(extension.FIRST_VERTEX_CONVENTION_WEBGL);
   }
+  selectMaterial(useUniform) {
+    const { material } = this;
+    const currentSorted = material.defines.GSL_SORTED_FRAGMENT;
+    const sorted = Number(!useUniform);
+    if (currentSorted !== void 0 && currentSorted !== sorted) {
+      material.defines.GSL_SORTED_FRAGMENT = sorted;
+      material.needsUpdate = true;
+    }
+    return material;
+  }
   createDepthMaterial(uniforms) {
     return createWebGLSplatMaterial(uniforms, {
       premultipliedAlpha: false,
@@ -26012,6 +26046,7 @@ class WebGLSplatBackend {
   }
   dispose() {
     this.ordering.dispose();
+    this.material.dispose();
   }
 }
 function makeTexture$1(channels = 4) {
@@ -26693,6 +26728,7 @@ class ProjectedSplats {
     this.capacity = 0;
     this.viewCapacity = 0;
     this.disposed = false;
+    this.projectedInputs = [];
     const computeRenderer = renderer;
     this.limits = computeRenderer.backend.device.limits;
     this.state = {
@@ -26951,6 +26987,7 @@ class ProjectedSplats {
     this.state.viewStride.value = capacity;
   }
   render(accumulator, camera, geometry, radial, fastSort, shrink = false) {
+    var _a2, _b;
     if (this.error) throw this.error;
     if (this.compiledSlots === 0 || this.disposed) {
       geometry.instanceCount = 0;
@@ -26966,6 +27003,40 @@ class ProjectedSplats {
     this.cache.ensureOrder(multiView, shrink);
     geometry.setIndirect(this.indirect);
     geometry.setSplatCount(Math.max(1, accumulator.numSplats));
+    const { uniforms } = this;
+    const inputs = [
+      accumulator,
+      accumulator.version,
+      ...accumulator.viewOrigin.toArray(),
+      multiView,
+      cameras.length,
+      radial,
+      fastSort,
+      uniforms.stochastic.value,
+      uniforms.maxStdDev.value,
+      uniforms.minPixelRadius.value,
+      uniforms.maxPixelRadius.value,
+      uniforms.minAlpha.value,
+      uniforms.preBlurAmount.value,
+      uniforms.blurAmount.value,
+      uniforms.clipXY.value,
+      uniforms.focalAdjustment.value
+    ];
+    for (const { node } of accumulator.mapping) inputs.push(node.layers.mask);
+    for (const view of cameras) {
+      inputs.push(
+        ...view.matrixWorld.elements,
+        ...view.projectionMatrix.elements,
+        view.near,
+        view.far,
+        view.layers.mask,
+        ((_a2 = view.viewport) == null ? void 0 : _a2.z) ?? uniforms.renderSize.value.x,
+        ((_b = view.viewport) == null ? void 0 : _b.w) ?? uniforms.renderSize.value.y
+      );
+    }
+    if (!shrink && inputs.length === this.projectedInputs.length && inputs.every((value, index2) => value === this.projectedInputs[index2]))
+      return;
+    this.projectedInputs = [];
     for (let eye = 0; eye < cameras.length; eye++) {
       const view = cameras[eye];
       this.state.viewIndex.value = eye;
@@ -27008,10 +27079,12 @@ class ProjectedSplats {
       }
       this.renderer.compute(pending);
     }
+    this.projectedInputs = inputs;
   }
   dispose() {
     if (this.disposed) return;
     this.disposed = true;
+    this.projectedInputs = [];
     void this.compilation.then(() => this.disposeResources());
   }
   disposeResources() {
@@ -27061,6 +27134,7 @@ class WebGPUSplatBackend extends NodeSplatBackend {
   bindOrdering(_material, _uniforms) {
   }
   dispose() {
+    super.dispose();
     this.projection.dispose();
   }
 }
@@ -27173,7 +27247,7 @@ class GaussianSplatRenderer extends THREE__namespace.Mesh {
     const geometry = new SplatGeometry(
       backend.kind === "webgpu" ? WEBGPU_SPLATS_PER_INSTANCE : 1
     );
-    const material = backend.material;
+    const material = backend.selectMaterial(autoStochastic || stochastic);
     super(geometry, material);
     this.renderSize = new THREE__namespace.Vector2();
     this.lastFrame = -1;
@@ -27207,7 +27281,6 @@ class GaussianSplatRenderer extends THREE__namespace.Mesh {
     this.renderer = options.renderer;
     this.backend = backend;
     this.capture = new SplatCapture(this, backend, () => this.beginCapture());
-    this.material = material;
     this.uniforms = uniforms;
     this.depthPass = new SplatDepthPass(
       this,
@@ -27224,8 +27297,7 @@ class GaussianSplatRenderer extends THREE__namespace.Mesh {
     this._stochastic = stochastic;
     this._renderDepth = renderDepth;
     this.stochasticPhase = stochastic ? "forced" : null;
-    this.applyRenderOrder();
-    this.applyMaterialState(this.stochasticFrame);
+    this.refreshRenderConfiguration();
     this.frustumCulled = false;
     this.onDirty = options.onDirty;
     this.dirty = true;
@@ -27290,7 +27362,6 @@ class GaussianSplatRenderer extends THREE__namespace.Mesh {
     this.maxSplats = 0;
     this.activeSplats = 0;
     this.geometry.dispose();
-    this.material.dispose();
   }
   /** Native WebGPU sorts on the GPU before drawing; WebGL sorts in a worker. */
   get synchronousSort() {
@@ -27393,25 +27464,27 @@ class GaussianSplatRenderer extends THREE__namespace.Mesh {
     }
   }
   applyMaterialState(stochasticActive) {
+    const { material } = this;
     const managedAsOpaque = this.usesManagedRenderState;
     const transparent = managedAsOpaque ? false : this._transparent;
     const blending = stochasticActive ? THREE__namespace.NoBlending : managedAsOpaque && this._transparent ? THREE__namespace.CustomBlending : this.sortedBlending;
-    const wasOpaque = isOpaqueMaterial(this.material);
-    this.material.transparent = transparent;
-    this.material.blending = blending;
+    const wasOpaque = isOpaqueMaterial(material);
+    material.transparent = transparent;
+    material.blending = blending;
     if (managedAsOpaque && this._transparent) {
-      this.material.blendEquation = THREE__namespace.AddEquation;
-      this.material.blendSrc = this._premultipliedAlpha ? THREE__namespace.OneFactor : THREE__namespace.SrcAlphaFactor;
-      this.material.blendDst = THREE__namespace.OneMinusSrcAlphaFactor;
-      this.material.blendEquationAlpha = THREE__namespace.AddEquation;
-      this.material.blendSrcAlpha = THREE__namespace.OneFactor;
-      this.material.blendDstAlpha = THREE__namespace.OneMinusSrcAlphaFactor;
-    }
-    this.material.depthTest = stochasticActive ? true : this._depthTest;
-    this.material.depthWrite = stochasticActive ? true : this._depthWrite;
+      material.blendEquation = THREE__namespace.AddEquation;
+      material.blendSrc = this._premultipliedAlpha ? THREE__namespace.OneFactor : THREE__namespace.SrcAlphaFactor;
+      material.blendDst = THREE__namespace.OneMinusSrcAlphaFactor;
+      material.blendEquationAlpha = THREE__namespace.AddEquation;
+      material.blendSrcAlpha = THREE__namespace.OneFactor;
+      material.blendDstAlpha = THREE__namespace.OneMinusSrcAlphaFactor;
+    }
+    material.depthTest = stochasticActive ? true : this._depthTest;
+    material.depthWrite = stochasticActive ? true : this._depthWrite;
     this.depthPass.updateVisibility();
-    if (wasOpaque !== isOpaqueMaterial(this.material)) {
-      this.material.needsUpdate = true;
+    if (material.premultipliedAlpha !== this._premultipliedAlpha || wasOpaque !== isOpaqueMaterial(material)) {
+      material.premultipliedAlpha = this._premultipliedAlpha;
+      material.needsUpdate = true;
     }
   }
   onBeforeRender(renderer, scene, camera) {
@@ -27459,7 +27532,7 @@ class GaussianSplatRenderer extends THREE__namespace.Mesh {
         gaussianSplatRenderer.updateTimeoutId = setTimeout(() => {
           gaussianSplatRenderer.updateTimeoutId = -1;
           gaussianSplatRenderer.updateInternal(updateRequest);
-        }, 1);
+        }, 0);
       }
     }
     const typedCamera = camera;
@@ -27527,6 +27600,13 @@ class GaussianSplatRenderer extends THREE__namespace.Mesh {
       gaussianSplatRenderer.requestMotionFollowup = false;
       gaussianSplatRenderer.setDirty();
     }
+    if (!this.stochasticModeEnabled && !this.stochasticFrame) {
+      const material = this.backend.selectMaterial(false);
+      if (this.material !== material) {
+        this.material = material;
+        this.applyMaterialState(false);
+      }
+    }
   }
   clearSplats() {
     this.activeSplats = 0;
@@ -27896,6 +27976,10 @@ class GaussianSplatRenderer extends THREE__namespace.Mesh {
       );
     }
   }
+  refreshRenderConfiguration() {
+    this.applyRenderOrder();
+    this.applyMaterialState(this.stochasticFrame);
+  }
   refreshStochasticConfiguration() {
     this.requestMotionFollowup = false;
     if (this._stochastic) {
@@ -27909,8 +27993,10 @@ class GaussianSplatRenderer extends THREE__namespace.Mesh {
       this.stochasticPhase = null;
       this.stochasticWasForced = false;
     }
-    this.applyRenderOrder();
-    this.applyMaterialState(this.stochasticFrame);
+    this.material = this.backend.selectMaterial(
+      this.stochasticModeEnabled || this.stochasticFrame
+    );
+    this.refreshRenderConfiguration();
     this.setDirty();
   }
   get premultipliedAlpha() {
@@ -27921,9 +28007,7 @@ class GaussianSplatRenderer extends THREE__namespace.Mesh {
     if (this._premultipliedAlpha !== nextValue) {
       this._premultipliedAlpha = nextValue;
       this.uniforms.premultipliedAlpha.value = nextValue;
-      this.material.premultipliedAlpha = nextValue;
       this.applyMaterialState(this.stochasticFrame);
-      this.material.needsUpdate = true;
     }
   }
   get transparent() {
@@ -27988,8 +28072,7 @@ class GaussianSplatRenderer extends THREE__namespace.Mesh {
     if (nextValue === this._renderDepth) return;
     this.assertBuiltInSplatShaders(nextValue);
     this._renderDepth = nextValue;
-    this.applyRenderOrder();
-    this.applyMaterialState(this.stochasticFrame);
+    this.refreshRenderConfiguration();
     this.setDirty();
   }
   get depthTest() {
@@ -28004,8 +28087,7 @@ class GaussianSplatRenderer extends THREE__namespace.Mesh {
   }
   set depthWrite(value) {
     this._depthWrite = Boolean(value);
-    this.applyRenderOrder();
-    this.applyMaterialState(this.stochasticFrame);
+    this.refreshRenderConfiguration();
   }
 }
 function isOpaqueMaterial(material) {