gaussian-splat-lite 1.1.6 → 1.1.8

package/CHANGELOG.md

@@ -7,6 +7,29 @@ and this project follows [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [1.1.8] - 2026-09-29
+
+### Fixed
+
+- Fixed TAA output color conversion and tone mapping on WebGPU and WebGL fallback when required by the renderer settings.
+
+### Changed
+
+- TAA now reconstructs positions in view space on all backends, reducing small-near-plane numerical error and preserving logarithmic depth precision. History acceptance and accumulation rules are unchanged.
+- TAA selects the nearest sample directly from logarithmic depth, and its node backends match Three.js's minimum near plane when decoding it.
+- Packed per-Splat color and kernel varyings from 24 to 16 bytes across WebGL, WebGPU, and WebGL fallback. RGB and kernel power use half precision; source alpha and squared support radius retain float32 precision. RGB is capped at 65504, and kernel-power rounding can slightly change wide-kernel coverage.
+- Moved fragment support-radius rejection before unpacking kernel data and deferred color assembly until after alpha and coverage rejection on all backends.
+
+### Security
+
+- Updated the development dependency `fast-uri` to 3.1.7 to resolve high-severity security advisories.
+
+## [1.1.7] - 2026-09-27
+
+### Fixed
+
+- Removed the constant directional drift of stochastic noise under TAA by reordering temporal blue-noise offsets across all rendering backends.
+
 ## [1.1.6] - 2026-09-27
 
 ### Changed
@@ -420,7 +443,9 @@ 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.6...HEAD
+[Unreleased]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v1.1.8...HEAD
+[1.1.8]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v1.1.7...v1.1.8
+[1.1.7]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v1.1.6...v1.1.7
 [1.1.6]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v1.1.5...v1.1.6
 [1.1.5]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v1.1.4...v1.1.5
 [1.1.4]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v1.1.3...v1.1.4

package/README.md

@@ -8,16 +8,22 @@
 
 **Three.js Gaussian Splatting · WebGPU · Depth Rendering · Streaming**
 
+Gaussian Splatting renderer for **Three.js**, with **WebGPU/WebGL2**, **depth rendering**, and **large-scene streaming**. Load PLY/SPZ/SOG/RAD models, combine them with regular 3D objects, and explore large scenes as detail loads around the camera.
+
+<div align="center">
+
 **[Try Live Demo](https://gaussian-splat-lite.vercel.app/)**
 
+</div>
+
 <p align="center">
-  <img src="./Gaussian-Splat-Lite.svg" alt="Gaussian Splat Lite" width="1000">
+  <a href="https://gaussian-splat-lite.vercel.app/">
+    <img src="./.github/assets/default-demo.gif" alt="Gaussian Splat Lite — default example with a seamless 90-degree camera orbit" width="800">
+  </a>
 </p>
 
 </div>
 
-Gaussian Splatting renderer for **Three.js**, with **WebGPU/WebGL2**, **depth rendering**, and **large-scene streaming**. Load PLY/SPZ/SOG/RAD models, combine them with regular 3D objects, and explore large scenes as detail loads around the camera.
-
 ## Features
 
 | Focus | What you get |
@@ -184,6 +190,8 @@ See [Contributing](CONTRIBUTING.md#validation) for validation commands. `npm run
 
 The overall architecture of Gaussian Splat Lite draws on [Spark](https://github.com/sparkjsdev/spark) and [SuperSplat](https://github.com/playcanvas/supersplat).
 
+Example model adapted from [shehabmekky](https://superspl.at/scene/c1e6297e) ([CC BY 4.0](https://creativecommons.org/licenses/by/4.0/)).
+
 ## License
 
 Licensed under [Apache 2.0](LICENSE). See [NOTICE](NOTICE) and [third-party licenses](THIRD_PARTY_LICENSES.md) for attribution.

package/dist/gaussian-splat-lite.cjs

@@ -24455,8 +24455,8 @@ 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\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    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 minAlpha;\nuniform float blurAmount;\nuniform float preBlurAmount;\nuniform float clipXY;\nuniform float focalAdjustment;\nuniform bool stochastic;\nuniform bool stochasticOrdering;\nuniform vec4 stochasticTemporalSample;\nuniform bool encodeLinear;\nuniform bool depthOnly;\nuniform uint splatCount;\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 index = uint(gl_InstanceID) * uint(SPLATS_PER_INSTANCE) + uint(position.z);\n    if (index >= splatCount) return;\n\n    uint splatIndex;\n    if ((stochastic && !stochasticOrdering) || depthOnly) {\n        \n        splatIndex = index;\n    } else {\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 (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    if (encodeLinear && !depthOnly) {\n        vRgba.rgb = srgbToLinear(vRgba.rgb);\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    if (stochastic && !depthOnly) {\n        gl_Position.xy += stochasticTemporalSample.xy * gl_Position.w;\n    }\n\n    #include <logdepthbuf_vertex>\n}";
+var splatFragment_default = "precision highp float;\nprecision highp int;\n\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\nflat in uvec4 vSplat;\nin vec2 vSplatUv;\nflat in uint vStochasticHash;\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_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 >= alpha) {\n            discard;\n        }\n\n        if (depthOnly) {\n            fragColor = vec4(0.0);\n            #include <logdepthbuf_fragment>\n            return;\n        }\n    }\n    #endif\n\n    \n    vec4 rgba = vec4(unpackHalf2x16(vSplat.x), blueKernelPower.x, alpha);\n    #if !GSL_SORTED_FRAGMENT\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\nflat out uvec4 vSplat;\nout vec2 vSplatUv;\nflat out uint vStochasticHash;\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 stochastic;\nuniform bool stochasticOrdering;\nuniform vec4 stochasticTemporalSample;\nuniform bool encodeLinear;\nuniform bool depthOnly;\nuniform uint splatCount;\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 index = uint(gl_InstanceID) * uint(SPLATS_PER_INSTANCE) + uint(position.z);\n    if (index >= splatCount) return;\n\n    uint splatIndex;\n    if ((stochastic && !stochasticOrdering) || depthOnly) {\n        \n        splatIndex = index;\n    } else {\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 (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    \n    \n    vStochasticHash = 0u;\n    if (stochastic || depthOnly) {\n        vStochasticHash = hashU32(texelFetch(stochasticSeeds, texCoord, 0).r);\n    }\n\n    \n    if (encodeLinear && !depthOnly) {\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    if (stochastic && !depthOnly) {\n        gl_Position.xy += stochasticTemporalSample.xy * gl_Position.w;\n    }\n\n    #include <logdepthbuf_vertex>\n}";
 let shaders = null;
 function getShaders() {
   if (!shaders) {
@@ -25613,47 +25613,50 @@ function createSplatFragment({
   depthOnly,
   premultipliedAlpha
 }) {
-  const vRgba = N.varyingProperty("vec4", "gslRgba");
+  const vSplat = N.varyingProperty("uvec4", "gslSplat");
   const vSplatUv = N.varyingProperty("vec2", "gslSplatUv");
   const vStochasticHash = N.varyingProperty("uint", "gslStochasticHash");
-  const vSupportRadiusSquared = N.varyingProperty(
-    "float",
-    "gslSupportRadiusSquared"
-  );
-  const vKernelPower = N.varyingProperty("float", "gslKernelPower");
   const vViewportOrigin = N.varyingProperty("vec2", "gslViewportOrigin");
   const fragmentNode = N.Fn(() => {
-    const rgba = vRgba.toVar();
     const z2 = vSplatUv.dot(vSplatUv);
-    z2.greaterThan(vSupportRadiusSquared).discard();
+    z2.greaterThan(N.uintBitsToFloat(vSplat.w)).discard();
+    const blueKernelPower = N.unpackHalf2x16(vSplat.y);
+    const kernelPower = blueKernelPower.y;
     const kernelAlpha = z2.mul(-0.5).exp().toVar();
-    N.If(vKernelPower.notEqual(0), () => {
+    N.If(kernelPower.notEqual(0), () => {
       kernelAlpha.assign(
-        N.float(1).sub(N.float(1).sub(kernelAlpha).pow(vKernelPower))
+        N.float(1).sub(N.float(1).sub(kernelAlpha).pow(kernelPower))
       );
     });
-    rgba.a.mulAssign(kernelAlpha);
-    rgba.a.lessThan(minAlpha).discard();
+    const alpha = N.uintBitsToFloat(vSplat.z).mul(kernelAlpha).toVar();
+    alpha.lessThan(minAlpha).discard();
+    if (!sorted) {
+      N.If(stochastic.or(depthOnly), () => {
+        const pixel = N.uvec2(N.screenCoordinate.xy.sub(vViewportOrigin));
+        const offset = N.uvec2(
+          vStochasticHash,
+          vStochasticHash.shiftRight(5)
+        ).add(
+          N.select(
+            stochastic.and(depthOnly.not()),
+            N.uvec2(temporalSample.zw),
+            N.uvec2(0)
+          )
+        );
+        const coord = N.ivec2(
+          pixel.x.add(offset.x).bitAnd(31),
+          pixel.y.add(offset.y).bitAnd(31)
+        );
+        const randomValue = N.float(load2D(stochasticNoise, coord).r).add(0.5).div(1024);
+        randomValue.greaterThanEqual(alpha).discard();
+      });
+    }
+    const rgba = N.vec4(
+      N.unpackHalf2x16(vSplat.x),
+      blueKernelPower.x,
+      alpha
+    ).toVar();
     if (sorted) return rgba;
-    N.If(stochastic.or(depthOnly), () => {
-      const pixel = N.uvec2(N.screenCoordinate.xy.sub(vViewportOrigin));
-      const offset = N.uvec2(
-        vStochasticHash,
-        vStochasticHash.shiftRight(5)
-      ).add(
-        N.select(
-          stochastic.and(depthOnly.not()),
-          N.uvec2(temporalSample.zw),
-          N.uvec2(0)
-        )
-      );
-      const coord = N.ivec2(
-        pixel.x.add(offset.x).bitAnd(31),
-        pixel.y.add(offset.y).bitAnd(31)
-      );
-      const randomValue = N.float(load2D(stochasticNoise, coord).r).add(0.5).div(1024);
-      randomValue.greaterThanEqual(rgba.a).discard();
-    });
     N.If(stochastic.and(depthOnly.not()), () => {
       N.If(premultipliedAlpha.and(stochasticResolve), () => {
         rgba.rgb.mulAssign(0.5);
@@ -25663,15 +25666,22 @@ function createSplatFragment({
     return rgba;
   })();
   return {
-    vRgba,
+    vSplat,
     vSplatUv,
     vStochasticHash,
-    vSupportRadiusSquared,
-    vKernelPower,
     vViewportOrigin,
     fragmentNode
   };
 }
+function packSplatVarying(rgba, supportRadiusSquared, kernelPower) {
+  const rgb = rgba.rgb.min(65504);
+  return N.uvec4(
+    N.packHalf2x16(rgb.xy),
+    N.packHalf2x16(N.vec2(rgb.z, kernelPower)),
+    N.floatBitsToUint(rgba.a),
+    N.floatBitsToUint(supportRadiusSquared)
+  );
+}
 function createSplatNodeMaterial({
   uniforms,
   orderingNode: providedOrderingNode,
@@ -25707,15 +25717,7 @@ function createSplatNodeMaterial({
     "bool"
   );
   const depthOnly = uniformBinding(uniforms, "depthOnly", "bool");
-  const {
-    vRgba,
-    vSplatUv,
-    vStochasticHash,
-    vSupportRadiusSquared,
-    vKernelPower,
-    vViewportOrigin,
-    fragmentNode
-  } = createSplatFragment({
+  const { vSplat, vSplatUv, vStochasticHash, vViewportOrigin, fragmentNode } = createSplatFragment({
     sorted,
     minAlpha,
     stochastic,
@@ -25728,24 +25730,22 @@ function createSplatNodeMaterial({
   function buildVertex(builder) {
     const camera = materialCamera(builder);
     const clipPosition = N.vec4(0, 0, 2, 1).toVar();
-    vRgba.assign(N.vec4(0));
+    vSplat.assign(N.uvec4(0));
     vSplatUv.assign(N.vec2(0));
     vStochasticHash.assign(N.uint(0));
-    vSupportRadiusSquared.assign(0);
-    vKernelPower.assign(0);
     const assignVertexData = (data) => {
       const rgba = data.rgba.toVar();
       N.If(encodeLinear.and(depthOnly.not()), () => {
         rgba.rgb.assign(N.sRGBTransferEOTF(rgba.rgb));
       });
       clipPosition.assign(data.clipPosition);
-      vRgba.assign(rgba);
+      vSplat.assign(
+        packSplatVarying(rgba, data.supportRadiusSquared, data.kernelPower)
+      );
       vSplatUv.assign(data.splatUv);
       N.If(stochastic.or(depthOnly), () => {
         vStochasticHash.assign(stochasticHash(data.stochasticSeed));
       });
-      vSupportRadiusSquared.assign(data.supportRadiusSquared);
-      vKernelPower.assign(data.kernelPower);
       vViewportOrigin.assign(data.viewportOrigin);
     };
     if (vertexData) {
@@ -29261,15 +29261,14 @@ function createTAAPresentation(renderer, views) {
     const depth2 = N.textureLoad(uniforms.depth.value).onObjectUpdate(
       () => uniforms.depth.value
     );
-    material.fragmentNode = load2D(color2, coord);
     material.depthNode = load2D(depth2, coord).r;
     material.vertexNode = N.vec4(N.positionGeometry.xy, 0, 1);
     const output2 = N.renderOutput(
-      N.output,
+      load2D(color2, coord),
       THREE__namespace.NoToneMapping,
       THREE__namespace.NoColorSpace
     );
-    material.outputNode = output2;
+    material.fragmentNode = output2;
     configureOutput = (tone, space) => {
       if (output2.getToneMapping() !== tone || output2.outputColorSpace !== space) {
         output2.setToneMapping(tone);
@@ -29367,9 +29366,9 @@ function createNodeTAAPipeline(renderer, scene, camera, sample2, renderSize, isS
     () => history[1 - index2].textures[1]
   );
   const targets = [sourceTarget, ...history];
-  const currentVP = new THREE__namespace.Matrix4();
-  const previousVP = N.uniform(new THREE__namespace.Matrix4());
-  const inverseVP = N.uniform(new THREE__namespace.Matrix4());
+  const previousVP = new THREE__namespace.Matrix4();
+  const projectionMatrix = N.uniform(camera.projectionMatrix);
+  const viewToPreviousClip = N.uniform(new THREE__namespace.Matrix4());
   const jitter = N.uniform(sample2);
   const size = N.uniform(renderSize);
   const useHistory = N.uniform(false, "bool");
@@ -29377,16 +29376,12 @@ function createNodeTAAPipeline(renderer, scene, camera, sample2, renderSize, isS
   const sampleCount = N.property("float", "taaHistorySamples");
   const logDepth = N.uniform(new THREE__namespace.Vector2());
   const depthProjection = N.uniform(new THREE__namespace.Vector2());
+  const logarithmic = logDepth.x.greaterThan(0);
   const reversed = renderer.reversedDepthBuffer;
   const zeroToOne = reversed || renderer.coordinateSystem === THREE__namespace.WebGPUCoordinateSystem;
-  const hardwareDepth = N.Fn(([encoded]) => {
-    const value = encoded.toVar();
-    N.If(logDepth.x.greaterThan(0), () => {
-      const viewZ = logDepth.x.negate().mul(encoded.mul(logDepth.y).exp2());
-      value.assign(depthProjection.x.add(depthProjection.y.div(viewZ)));
-    });
-    return value;
-  });
+  const logarithmicViewZ = N.Fn(
+    ([encoded]) => logDepth.x.negate().mul(encoded.mul(logDepth.y).exp2())
+  );
   const pixel = N.ivec2(N.screenCoordinate.xy);
   const material = new NodeMaterial();
   material.vertexNode = N.vec4(N.positionGeometry.xy, 0, 1);
@@ -29400,7 +29395,8 @@ function createNodeTAAPipeline(renderer, scene, camera, sample2, renderSize, isS
       const marked = N.bool(false).toVar();
       const low = current.toVar();
       const high = current.toVar();
-      const closest = N.float(reversed ? 0 : 1).toVar();
+      const reverseSelection = reversed ? logarithmic.not() : N.bool(false);
+      const closest = N.select(reverseSelection, 0, 1).toVar();
       const closestPixel = pixel.toVar();
       for (let y = -1; y <= 1; y++) {
         for (let x = -1; x <= 1; x++) {
@@ -29411,11 +29407,18 @@ function createNodeTAAPipeline(renderer, scene, camera, sample2, renderSize, isS
           const bounded = x !== 0 || y !== 0 ? color2.max(0) : color2;
           low.assign(low.min(bounded));
           high.assign(high.max(bounded));
-          const z = hardwareDepth(load2D(depth2, p).r).toVar();
-          N.If(reversed ? z.greaterThan(closest) : z.lessThan(closest), () => {
-            closest.assign(z);
-            closestPixel.assign(p);
-          });
+          const z = load2D(depth2, p).r.toVar();
+          N.If(
+            N.select(
+              reverseSelection,
+              z.greaterThan(closest),
+              z.lessThan(closest)
+            ),
+            () => {
+              closest.assign(z);
+              closestPixel.assign(p);
+            }
+          );
         }
       }
       N.If(marked, () => {
@@ -29425,10 +29428,20 @@ function createNodeTAAPipeline(renderer, scene, camera, sample2, renderSize, isS
         N.If(load2D(source, closestPixel).a.greaterThan(1), () => {
           ndc.subAssign(jitter.xy);
         });
-        const world = inverseVP.mul(
-          N.vec4(ndc, zeroToOne ? closest : closest.mul(2).sub(1), 1)
-        );
-        const projected = previousVP.mul(world).toVar();
+        const p = projectionMatrix;
+        const pz = p.element(2);
+        const pw = p.element(3);
+        const z = zeroToOne ? closest : closest.mul(2).sub(1);
+        const orientation = reversed ? -1 : 1;
+        const viewZ = pw.z.sub(z.mul(pw.w)).mul(orientation).toVar();
+        const viewW = z.mul(pz.w).sub(pz.z).mul(orientation).toVar();
+        N.If(logarithmic, () => {
+          viewZ.assign(logarithmicViewZ(closest));
+          viewW.assign(1);
+        });
+        const clipW = pz.w.mul(viewZ).add(pw.w.mul(viewW));
+        const viewXY = ndc.mul(clipW).sub(pz.xy.mul(viewZ)).sub(pw.xy.mul(viewW)).div(N.vec2(p.element(0).x, p.element(1).y));
+        const projected = viewToPreviousClip.mul(N.vec4(viewXY, viewZ, viewW)).toVar();
         N.If(projected.w.greaterThan(0), () => {
           const previous = projected.xyz.div(projected.w);
           const previousUV = uv2.add(previous.xy.sub(ndc).mul(N.vec2(0.5, -0.5))).toVar();
@@ -29446,19 +29459,26 @@ function createNodeTAAPipeline(renderer, scene, camera, sample2, renderSize, isS
               const validWeight = N.float(0).toVar();
               for (let y = 0; y < 2; y++) {
                 for (let x = 0; x < 2; x++) {
-                  const p = base.add(N.ivec2(x, y));
+                  const p2 = base.add(N.ivec2(x, y));
                   const weight = (x === 0 ? N.float(1).sub(fraction.x) : fraction.x).mul(y === 0 ? N.float(1).sub(fraction.y) : fraction.y);
                   N.If(
-                    weight.greaterThan(0).and(p.x.greaterThanEqual(0)).and(p.y.greaterThanEqual(0)).and(p.x.lessThan(N.int(size.x))).and(p.y.lessThan(N.int(size.y))),
+                    weight.greaterThan(0).and(p2.x.greaterThanEqual(0)).and(p2.y.greaterThanEqual(0)).and(p2.x.lessThan(N.int(size.x))).and(p2.y.lessThan(N.int(size.y))),
                     () => {
-                      const oldDepth = hardwareDepth(load2D(historyDepth, p).r);
+                      const oldDepth = load2D(historyDepth, p2).r.toVar();
+                      N.If(logarithmic, () => {
+                        oldDepth.assign(
+                          depthProjection.x.add(
+                            depthProjection.y.div(logarithmicViewZ(oldDepth))
+                          )
+                        );
+                      });
                       const disocclusion = reversed ? oldDepth.sub(expectedDepth) : expectedDepth.sub(oldDepth);
                       N.If(disocclusion.lessThanEqual(5e-4), () => {
                         historySum.addAssign(
-                          load2D(historyColor, p).mul(weight)
+                          load2D(historyColor, p2).mul(weight)
                         );
                         sampleSum.addAssign(
-                          load2D(historySamples, p).r.mul(weight)
+                          load2D(historySamples, p2).r.mul(weight)
                         );
                         validWeight.addAssign(weight);
                       });
@@ -29532,17 +29552,14 @@ function createNodeTAAPipeline(renderer, scene, camera, sample2, renderSize, isS
         renderer.autoClearStencil
       );
       renderer.render(scene, camera);
-      currentVP.multiplyMatrices(
-        camera.projectionMatrix,
-        camera.matrixWorldInverse
-      );
-      inverseVP.value.copy(currentVP).invert();
+      viewToPreviousClip.value.multiplyMatrices(previousVP, camera.matrixWorld);
       stochasticFrame.value = isStochastic();
       useHistory.value = stochasticFrame.value && valid;
       const perspective = camera;
+      const near = Math.max(perspective.near, 1e-6);
       logDepth.value.set(
-        renderer.logarithmicDepthBuffer && perspective.isPerspectiveCamera ? perspective.near : 0,
-        Math.log2(perspective.far / perspective.near)
+        renderer.logarithmicDepthBuffer && perspective.isPerspectiveCamera ? near : 0,
+        Math.log2(perspective.far / near)
       );
       const projection = camera.projectionMatrix.elements;
       const scale = zeroToOne ? 1 : 0.5;
@@ -29552,7 +29569,10 @@ function createNodeTAAPipeline(renderer, scene, camera, sample2, renderSize, isS
       );
       renderer.setRenderTarget(history[index2]);
       renderer.render(mesh, fullscreenCamera);
-      previousVP.value.copy(currentVP);
+      previousVP.multiplyMatrices(
+        camera.projectionMatrix,
+        camera.matrixWorldInverse
+      );
       index2 = 1 - index2;
       valid = true;
     },
@@ -29583,8 +29603,8 @@ uniform sampler2D historyDepth;
 uniform sampler2D historySamples;
 uniform vec2 renderSize;
 uniform vec4 sampleOffset;
-uniform mat4 inverseVP;
-uniform mat4 previousVP;
+uniform mat4 projection;
+uniform mat4 viewToPreviousClip;
 uniform bool valid;
 uniform bool stochasticFrame;
 uniform bool reversed;
@@ -29593,13 +29613,10 @@ uniform vec2 depthProjection;
 layout(location = 0) out vec4 fragColor;
 layout(location = 1) out float fragSamples;
 
-float hardwareDepth(float encoded) {
-    if (logDepth.x == 0.0) return encoded;
-    float viewZ = -exp2(encoded * logDepth.y) + 1.0;
-    return depthProjection.x + depthProjection.y / viewZ;
+float logarithmicViewZ(float encoded) {
+    return -exp2(encoded * logDepth.y) + 1.0;
 }
 
-float clipZ(float depth) { return reversed ? depth : depth * 2.0 - 1.0; }
 ivec2 bounded(ivec2 p) { return clamp(p, ivec2(0), ivec2(renderSize) - 1); }
 vec4 colorAt(ivec2 p) {
     vec4 color = texelFetch(source, bounded(p), 0);
@@ -29618,7 +29635,10 @@ void main() {
     bool marked = false;
     vec4 low = current;
     vec4 high = current;
-    float closest = reversed ? 0.0 : 1.0;
+    // Log depth increases with distance; compare it before any conversion.
+    bool logarithmic = logDepth.x > 0.0;
+    bool reverseSelection = reversed && !logarithmic;
+    float closest = reverseSelection ? 0.0 : 1.0;
     ivec2 closestPixel = pixel;
     // Match the node backend's top-left traversal when depths are equal.
     for (int y = 1; y >= -1; --y) {
@@ -29630,8 +29650,8 @@ void main() {
             if (x != 0 || y != 0) color = max(color, vec4(0.0));
             low = min(low, color);
             high = max(high, color);
-            float z = hardwareDepth(texelFetch(sourceDepth, p, 0).r);
-            if (reversed ? z > closest : z < closest) {
+            float z = texelFetch(sourceDepth, p, 0).r;
+            if (reverseSelection ? z > closest : z < closest) {
                 closest = z;
                 closestPixel = p;
             }
@@ -29642,8 +29662,21 @@ void main() {
     vec2 closestUV = (vec2(closestPixel) + 0.5) / renderSize;
     vec2 ndc = closestUV * 2.0 - 1.0;
     if (texelFetch(source, closestPixel, 0).a > 1.0) ndc -= sampleOffset.xy;
-    vec4 world = inverseVP * vec4(ndc, clipZ(closest), 1.0);
-    vec4 projected = previousVP * world;
+    // Reconstruct homogeneous view coordinates without inverse VP cancellation.
+    float z = reversed ? closest : closest * 2.0 - 1.0;
+    // Keep W positive in both depth modes; W = 0 represents a point at infinity.
+    float orientation = reversed ? -1.0 : 1.0;
+    float viewZ = (projection[3][2] - z * projection[3][3]) * orientation;
+    float viewW = (z * projection[2][3] - projection[2][2]) * orientation;
+    if (logarithmic) {
+        // Decode log depth directly to retain its precision.
+        viewZ = logarithmicViewZ(closest);
+        viewW = 1.0;
+    }
+    float clipW = projection[2][3] * viewZ + projection[3][3] * viewW;
+    vec2 viewXY = (ndc * clipW - projection[2].xy * viewZ
+        - projection[3].xy * viewW) / vec2(projection[0][0], projection[1][1]);
+    vec4 projected = viewToPreviousClip * vec4(viewXY, viewZ, viewW);
     if (projected.w <= 0.0) return;
     vec3 previous = projected.xyz / projected.w;
     vec2 previousUV = uv + (previous.xy - ndc) * 0.5;
@@ -29663,7 +29696,8 @@ void main() {
             float weight = (x == 0 ? 1.0 - fraction.x : fraction.x)
                 * (y == 0 ? 1.0 - fraction.y : fraction.y);
             if (weight > 0.0 && all(greaterThanEqual(p, ivec2(0))) && all(lessThan(p, ivec2(renderSize)))) {
-                float oldDepth = hardwareDepth(texelFetch(historyDepth, p, 0).r);
+                float oldDepth = texelFetch(historyDepth, p, 0).r;
+                if (logarithmic) oldDepth = depthProjection.x + depthProjection.y / logarithmicViewZ(oldDepth);
                 float disocclusion = reversed ? oldDepth - expectedDepth : expectedDepth - oldDepth;
                 if (disocclusion <= 0.0005) {
                     historySum += texelFetch(history, p, 0) * weight;
@@ -29710,8 +29744,7 @@ function createWebGLTAAPipeline(renderer, scene, camera, sample2, renderSize, is
     target.textures.push(samples);
   });
   const targets = [source, ...history];
-  const currentVP = new THREE__namespace.Matrix4();
-  const previousVP = { value: new THREE__namespace.Matrix4() };
+  const previousVP = new THREE__namespace.Matrix4();
   const reversed = renderer.capabilities.reversedDepthBuffer;
   const uniforms = {
     source: { value: source.texture },
@@ -29721,8 +29754,8 @@ function createWebGLTAAPipeline(renderer, scene, camera, sample2, renderSize, is
     historySamples: { value: history[0].textures[1] },
     renderSize: { value: renderSize },
     sampleOffset: { value: sample2 },
-    inverseVP: { value: new THREE__namespace.Matrix4() },
-    previousVP,
+    projection: { value: camera.projectionMatrix },
+    viewToPreviousClip: { value: new THREE__namespace.Matrix4() },
     valid: { value: false },
     stochasticFrame: { value: false },
     reversed: { value: reversed },
@@ -29776,16 +29809,15 @@ function createWebGLTAAPipeline(renderer, scene, camera, sample2, renderSize, is
         renderer.autoClearStencil
       );
       renderer.render(scene, camera);
-      currentVP.multiplyMatrices(
-        camera.projectionMatrix,
-        camera.matrixWorldInverse
-      );
       const input = history[1 - index2];
       const output2 = history[index2];
       uniforms.history.value = input.texture;
       uniforms.historyDepth.value = input.depthTexture;
       uniforms.historySamples.value = input.textures[1];
-      uniforms.inverseVP.value.copy(currentVP).invert();
+      uniforms.viewToPreviousClip.value.multiplyMatrices(
+        previousVP,
+        camera.matrixWorld
+      );
       const stochastic = isStochastic();
       uniforms.valid.value = stochastic && valid;
       uniforms.stochasticFrame.value = stochastic;
@@ -29802,7 +29834,10 @@ function createWebGLTAAPipeline(renderer, scene, camera, sample2, renderSize, is
       );
       renderer.setRenderTarget(output2);
       renderer.render(mesh, fullscreenCamera);
-      previousVP.value.copy(currentVP);
+      previousVP.multiplyMatrices(
+        camera.projectionMatrix,
+        camera.matrixWorldInverse
+      );
       index2 = 1 - index2;
       valid = true;
     },
@@ -29814,7 +29849,8 @@ function createWebGLTAAPipeline(renderer, scene, camera, sample2, renderSize, is
     }
   };
 }
-const SAMPLES = 8;
+const NOISE_PHASES = [0, 4, 1, 6, 2, 7, 3, 5];
+const SAMPLES = NOISE_PHASES.length;
 function halton(index2, base) {
   let result = 0;
   let fraction = 1;
@@ -29991,6 +30027,7 @@ class StochasticTAAPass {
     const xrEnabled = renderer.xr.enabled;
     const autoClear = renderer.autoClear;
     const index2 = this.frame % SAMPLES;
+    const noisePhase = NOISE_PHASES[index2];
     try {
       renderer.xr.enabled = false;
       for (const view of this.views) {
@@ -29998,8 +30035,8 @@ class StochasticTAAPass {
         sample2.set(
           2 * (halton(index2 + 1, 2) - 0.5) / size.x,
           2 * (halton(index2 + 1, 3) - 0.5) / size.y,
-          index2 * 17 % 32,
-          index2 * 29 % 32
+          noisePhase * 17 % 32,
+          noisePhase * 29 % 32
         );
         if (!stochastic) sample2.set(0, 0, 0, 0);
         this.splatRenderer[stochasticTemporalSample](sample2);