@driftengine/core 4.3.0 → 4.4.1

package/dist/render/shaders/flat/main.js

@@ -36,8 +36,13 @@ export const MAIN_GLSL = `void main() {
   if (uAlbedoEnabled != 0) {
     vec4 texel = texture(uAlbedo, vUv);
     // Discarded before anything else is computed: a thrown-away fragment should not pay
-    // for the lighting it will never contribute to.
-    if (texel.a < uAlbedoCutout) discard;
+    // for the lighting it will never contribute to. The test credits alpha for the mip level
+    // it samples, so a needle averaged thin down the chain is not lost; see cutoutCoverage.ts.
+    // Behind a branch on a uniform, so a material with no cutoff pays nothing for it.
+    if (uAlbedoCutout > 0.0) {
+      float tested = cutoutAlpha(texel.a, vUv * vec2(textureSize(uAlbedo, 0)));
+      if (tested < uAlbedoCutout) discard;
+    }
     albedo *= texel.rgb;
     coverage = texel.a;
   }
@@ -80,6 +85,15 @@ export const MAIN_GLSL = `void main() {
 
   if (uLightingEnabled != 0) {
     vec3 n = normalize(vNormal);
+    /*
+     * **Which face of a two-sided surface this is, from the normal and not from the rasteriser.**
+     * The rasteriser's own facing flag would say it exactly, and it is one more input to the stage: the flat
+     * shader already carries sixteen, WebGPU's ceiling, and the seventeenth made every pipeline
+     * invalid and every mesh draw nothing. A face whose own normal points away from the eye is the
+     * back of the sheet; what that gives up is a sliver at a curved silhouette, where a front face's
+     * interpolated normal already leans away and is lit as the back.
+     */
+    bool backFace = uDoubleSided != 0 && dot(n, uCameraPos - vWorldPos) < 0.0;
     /*
      * The authored normal, before either relief perturbs it.
      *
@@ -259,6 +273,15 @@ export const MAIN_GLSL = `void main() {
       );
     }
 
+    /*
+     * **The back face of a two-sided surface is lit as its front**, which is glTF's rule for
+     * \`doubleSided\`: the whole shading normal turned toward the viewer, after the map and the
+     * relief have perturbed it, as three.js turns its normal, tangent and bitangent together.
+     * Turning only the interpolated normal would leave a normal map's tilt pointing the wrong way
+     * across the fold of every curtain.
+     */
+    if (backFace) n = -n;
+
     /*
      * One dot product, used twice: ndl is the lit side and its negative is the night side below.
      * Shared rather than issued twice because it is the same number and one is cheaper, and not
@@ -272,8 +295,23 @@ export const MAIN_GLSL = `void main() {
      * term below needs it too. The sun and the moon are the only sources whose shadow
      * used to stop at a glowing surface.
      */
+    /*
+     * **The surface's own n·l, before any map tilted it: the side of the surface the sun is on.**
+     *
+     * A normal map says which way each texel faces within its surface; it cannot put a texel on the
+     * other side of that surface from the sun. Read from the mapped normal alone, the texels of a
+     * column's face turned from a high sun that leaned into the light were lit as though the column
+     * were not in the way: a field of white specks over stone in shade. So the shadow's band is
+     * chosen by this, and the sun is taken away as it reaches zero, over the last two hundredths of
+     * n·l, where an unmapped surface's own Lambert term is already under 0.02. Over a tenth it moved
+     * every smooth column's terminator in the published scenes. What it gives up is the bump-lit
+     * relief of a surface barely facing the sun, where the light was already grazing.
+     */
+    vec3 surfaceN = normalize(vNormal);
+    if (backFace) surfaceN = -surfaceN;
+    float surfaceNdl = dot(surfaceN, uDirectionalDir);
 #if DIRECTIONAL_SHADOWS
-    float sunShade = shadowFactor(ndl);
+    float sunShade = shadowFactor(max(surfaceNdl, 0.0));
 #else
     float sunShade = 1.0;
 #endif
@@ -297,7 +335,13 @@ export const MAIN_GLSL = `void main() {
      * that shipped before it.
      */
     sunShade *= vSkyDirect;
-    float direct = ndl * sunShade;
+    /*
+     * And the sun gone from a surface turned from it, whatever its map says. See \`surfaceNdl\`.
+     * Its own factor rather than folded into sunShade, which the emissive share reads as the sun's
+     * shadow: a lamp's pane turned from the moon is not in shadow, it is only unlit.
+     */
+    float sunFacing = smoothstep(0.0, 0.02, surfaceNdl);
+    float direct = ndl * sunShade * sunFacing;
 
     /*
      * Hemispheric: sky above, ground below, mixed by which way the surface looks. An
@@ -327,6 +371,7 @@ export const MAIN_GLSL = `void main() {
      * set, which is the guarantee that option was added to give.
      */
     vec3 irradiance = gridIrradiance(n, vWorldPos);
+    irradiance = mix(irradiance, ambient, probeGridOutside(surfaceN, vWorldPos));
     ambient = mix(ambient, irradiance, uProbeGridAmbient * uEnvironmentEnabled);
 #endif
     /*
@@ -405,7 +450,7 @@ export const MAIN_GLSL = `void main() {
      * before: \`sunSpec\` is \`vec3(vSpecular)\` at metal 0 and \`vSpecular\` defaults to 0.
      */
     vec3 sunHighlight =
-      uDirectionalColor * specularLobe(max(dot(n, halfway), 0.0), surfaceRoughness) * sunSpec * sunShade;
+      uDirectionalColor * specularLobe(max(dot(n, halfway), 0.0), surfaceRoughness) * sunSpec * sunShade * sunFacing;
     /*
      * The dielectric's share goes in here, where it has always gone, so the environment blend
      * below dims it by exactly the reflectance it always dimmed it by. The metal's share is added
@@ -812,6 +857,7 @@ export const MAIN_GLSL = `void main() {
      */
     vec3 lampOpen = vec3(0.0);
     vec3 lampShadowed = vec3(0.0);
+    float driftShare = driftLightShare(vWorldPos);
 
     /*
      * Which froxel this fragment is in.
@@ -911,7 +957,7 @@ export const MAIN_GLSL = `void main() {
       cookie = uintBitsToFloat(rec4.w);
       } else {
       i = slot;
-      if (i >= uLightCount) break;
+      if (i >= uLightCount || i >= MAX_LIGHTS) break;
       lightPos = uLightPos[i];
       lightRadius = uLightRadius[i];
       lightColor = uLightColor[i];
@@ -924,6 +970,9 @@ export const MAIN_GLSL = `void main() {
       iesAxis = uLightIesAxis[i];
       cookie = uLightCookie[i];
       }
+      /* A DriftLight field's own light carries a negative weight, and is shaded exactly only for the
+         share of this pixel the field does not stand in for. See \`driftLight.ts\`. */
+      if (lightWeight < 0.0) lightWeight = -lightWeight * (1.0 - driftShare);
       /*
        * **The cone, and a point light's is one that admits every direction.**
        *
@@ -986,6 +1035,8 @@ export const MAIN_GLSL = `void main() {
        * grazing the angle is. Without it the cubemap's face seams show as a
        * diagonal cross and the whole plane bands.
        */
+      /* How present this light's shadow is. See \`POINT_SHADOW_MIN_WEIGHT\`. */
+      float shadowWeight = clamp(falloff * 2.0, 0.0, 1.0);
 #if POINT_SHADOWS
       float grazing = 1.0 - ndl;
       float normalOffset = (0.06 + dist * 0.05) * grazing * grazing + 0.02;
@@ -1024,7 +1075,7 @@ export const MAIN_GLSL = `void main() {
        */
       int shadowRead = clamp(shadowSlot, 0, MAX_LIGHTS - 1);
       int layer = shadowSlot >= 0 && shadowSlot < MAX_LIGHTS ? uPointShadowLayer[shadowRead] : -1;
-      if (layer >= 0) {
+      if (layer >= 0 && shadowWeight > POINT_SHADOW_MIN_WEIGHT) {
         occl = mix(
           1.0,
           pointShadow(
@@ -1053,7 +1104,7 @@ export const MAIN_GLSL = `void main() {
       float liveWeight = 0.0;
       int liveLayer =
         shadowSlot >= 0 && shadowSlot < MAX_LIGHTS ? uLivePointShadowLayer[shadowRead] : -1;
-      if (liveLayer >= 0) {
+      if (liveLayer >= 0 && shadowWeight > POINT_SHADOW_MIN_WEIGHT) {
         liveOccl = pointShadow(
           uPointShadows,
           float(liveLayer),
@@ -1073,7 +1124,7 @@ export const MAIN_GLSL = `void main() {
       // Blend occlusion out as the light fades, so a shadow can never be more
       // present than the light casting it — and slot changes at the edge of
       // range become invisible rather than a pop.
-      float shaded = mix(1.0, occl, clamp(falloff * 2.0, 0.0, 1.0));
+      float shaded = mix(1.0, occl, shadowWeight);
       /*
        * The cone multiplies the distance falloff rather than replacing it, which is what makes a
        * spot a point light with a direction rather than a second kind of light. It is exactly 1
@@ -1493,6 +1544,14 @@ export const MAIN_GLSL = `void main() {
     );
 #endif
     lit += lampOpenFloor * lampShade;
+    /*
+     * DriftLight: every fixed light past the frame's choice, summed and occluded, for the share of
+     * this pixel the exact lights above no longer cover. Diffuse only, and so no metal term: see
+     * \`driftLight.ts\`.
+     */
+    if (driftShare > 0.0) {
+      lit += albedo * driftLightIrradiance(vWorldPos, n) * (driftShare * uDriftLight.w) * (1.0 - metal);
+    }
 
     /*
      * Self-illuminated geometry, dimmed where a lamp's shadow crosses it.

package/dist/render/shaders/flat/preamble.js

@@ -26,6 +26,12 @@ import { FOG_GLSL } from '../fog.js';
 export function preambleGlsl({ maxLights, maxAreaLights }) {
     return `#version 300 es
 precision highp float;
+/*
+ * highp int as well: a clustered light is decoded with uintBitsToFloat from texels that arrive as
+ * uvec4, and its texel index passes 32767 in a big world. The fragment default for int and uint is
+ * mediump, which a sixteen-bit driver truncates, and every clustered light then lights nothing.
+ */
+precision highp int;
 
 in vec3 vNormal;
 in vec3 vColor;
@@ -128,6 +134,12 @@ uniform int uAlbedoEnabled;
  */
 uniform float uAlbedoCutout;
 
+/**
+ * 1 for a surface seen from both faces: glTF's doubleSided, a curtain or a leaf card. Its draw culls
+ * nothing, and a back face is lit as a front, with the shading normal turned toward the viewer.
+ */
+uniform int uDoubleSided;
+
 /**
  * A normal map, in the surface's own space.
  *
@@ -538,6 +550,12 @@ uniform vec3 uProbeGridCounts;
  * exactly as it did before any probe existed.
  */
 uniform float uProbeGridAmbient;
+/**
+ * Which sets of layers the shading reads, and how far between them: the last whole sweep's layer
+ * offset, the newest whole sweep's, and the blend from the first toward the second. \`(0, 0, 0)\`
+ * for a grid that does not crossfade. See \`probeSweeps.ts\`.
+ */
+uniform vec3 uProbeGridSets;
 #endif
 /** A world-space box that lights up regardless of time of day (run finished). */
 uniform vec3 uHighlightMin;
@@ -625,12 +643,12 @@ uvec4 clusterTexel(int texel) {
  * both numbers sit beside the budgets they come from.
  */
 /*
- * **Both arms have the same bound, and that equality is deliberate.** There is one loop, so a
- * larger clustered cap would raise the bound for the fixed path too, and a scene that never asks
- * for froxels would carry a loop of 28 where it carries 16 today. \`MAX_LIGHTS_PER_CLUSTER\` is
- * pinned equal to \`MAX_LIGHTS\` for that reason; a test in \`textureUnitBudget.test.ts\` asserts it.
+ * **The bound is the froxel's cap, and the fixed arm leaves long before it.** The two were equal
+ * until a candlelit interior needed more than sixteen lights in a froxel; see
+ * \`MAX_LIGHTS_PER_CLUSTER\`. The fixed arm breaks at \`uLightCount\` and at \`MAX_LIGHTS\`, so it
+ * iterates exactly what it did and never indexes its uniform arrays past their end.
  */
-#define LIGHT_LOOP_MAX MAX_LIGHTS
+#define LIGHT_LOOP_MAX MAX_LIGHTS_PER_CLUSTER
 uniform int uLightCount;
 /** 0 keeps the radius-shaped falloff; 1 is physical inverse-square with a soft cutoff. */
 uniform int uLightFalloff;

package/dist/render/shaders/flat/probeGrid.js

@@ -66,10 +66,19 @@ void probeCell(vec3 worldPos, out vec3 base, out vec3 frac) {
   frac *= step(vec3(1.5), uProbeGridCounts);
 }
 
-/** One probe's diffuse light: the cosine convolution, at its own level, in one fetch. */
+/**
+ * One probe's diffuse light: the cosine convolution, at its own level, in one fetch, or two where a
+ * crossfading grid is between sweeps. See \`probeSweeps.ts\`: the last whole sweep blended toward
+ * the newest, so a grid re-baked a probe a frame changes a little every frame rather than a probe's
+ * worth at once. The second fetch is behind a branch on a uniform, so a grid that is not blending
+ * pays for one.
+ */
 vec3 probeIrradiance(vec3 dir, float layer) {
   float level = uEnvironmentIrradianceLevel;
-  return textureLod(uEnvironment, probeCoord(dir, level, layer), level).rgb;
+  vec3 last = textureLod(uEnvironment, probeCoord(dir, level, layer + uProbeGridSets.x), level).rgb;
+  if (uProbeGridSets.z <= 0.0) return last;
+  vec3 newest = textureLod(uEnvironment, probeCoord(dir, level, layer + uProbeGridSets.y), level).rgb;
+  return mix(last, newest, uProbeGridSets.z);
 }
 
 /**
@@ -78,8 +87,12 @@ vec3 probeIrradiance(vec3 dir, float layer) {
  * textureLod rather than texture throughout, per the 2026-08-07 rule and for a second reason on
  * top of it: the level is wanted here, and the fetches sit inside a loop that no compiler can
  * prove uniform.
+ *
+ * **From the newest whole sweep alone**, where a crossfading grid holds two: a reflection is a
+ * picture of the room, and the blend that smooths the diffuse light would be two pictures at once.
  */
-vec3 probeRadiance(vec3 dir, float lod, float layer) {
+vec3 probeRadiance(vec3 dir, float lod, float layerIndex) {
+  float layer = layerIndex + uProbeGridSets.y;
   float lo = clamp(floor(lod), 0.0, uEnvironmentMaxLod);
   float hi = min(lo + 1.0, uEnvironmentMaxLod);
   vec3 coarse = textureLod(uEnvironment, probeCoord(dir, hi, layer), hi).rgb;
@@ -122,6 +135,36 @@ float probeVisible(vec3 fromProbe, float distanceM, float layer) {
   return pow(chebyshev, ${glslFloat(PROBE_VISIBILITY_SHARPNESS)});
 }
 
+/**
+ * How far a surface outside the grid faces away from it, 0 to 1: how much of its diffuse light the
+ * grid cannot know.
+ *
+ * **Outside the box the grid clamps to its edge probes**, which is right for a floor below the
+ * lowest layer or a vault above the highest, where the surface faces back into the grid and sees
+ * what those probes see. It is wrong for a face turned away: a building's outer wall read its edge
+ * probe's light in the direction of that wall's normal, which from inside the courtyard is the
+ * shaded back of the same wall, and drew black under a noon sun. So a surface takes the open sky's
+ * hemisphere as it leaves the box facing out, from a metre past it to two and a half, and keeps the
+ * grid facing in. What it gives up is the grid's bounce on the outside of a model whose grid does
+ * not reach it, which the grid never had.
+ *
+ * **The normal is the surface's own, never a mapped one.** Read from the mapped normal, the back of a
+ * gallery floor a metre past the grid's last row took the sky on every texel its map tilted toward
+ * the wall: white glints over paving in shade. Which side of the grid a surface faces is a fact
+ * about the surface.
+ */
+float probeGridOutside(vec3 n, vec3 worldPos) {
+  vec3 top = max(uProbeGridCounts - 1.0, vec3(0.0));
+  vec3 local = (worldPos - uProbeGridOrigin) * uProbeGridInvSpacing;
+  /* Only along an axis the grid spans: a grid one probe wide on an axis has no side there, and a
+     single probe, which lights a whole scene from one place, has none at all. */
+  vec3 beyond = (local - clamp(local, vec3(0.0), top)) / max(uProbeGridInvSpacing, vec3(1e-6));
+  beyond *= step(vec3(1.5), uProbeGridCounts);
+  float distanceM = length(beyond);
+  if (distanceM <= 0.0) return 0.0;
+  return smoothstep(1.0, 2.5, distanceM) * smoothstep(0.0, 0.5, dot(n, beyond / distanceM));
+}
+
 /**
  * The grid's diffuse light at a point, trilinear over the eight probes around it.
  *

package/dist/render/shaders/generated/ambientOcclusion.wgsl.d.ts

@@ -1,5 +1,5 @@
-export declare const AO_BLUR_FRAG_WGSL = "struct Uniforms {\n    uStep: vec2<f32>,\n    uDepthToViewZ: vec4<f32>,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\n@group(0) @binding(34) \nvar uDepth_t: texture_2d<f32>;\n@group(0) @binding(35) \nvar uDepth_s: sampler;\nvar<private> vUv_1: vec2<f32>;\n@group(0) @binding(32) \nvar uAo_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uAo_s: sampler;\nvar<private> fragColor: f32;\n\nfn viewZ_u0028_f1_u003b(depth: ptr<function, f32>) -> f32 {\n    var ndc: f32;\n\n    let _e22 = (*depth);\n    ndc = (1f - (_e22 * 2f));\n    let _e27 = unnamed.uDepthToViewZ[0u];\n    let _e28 = ndc;\n    let _e32 = unnamed.uDepthToViewZ[1u];\n    let _e36 = unnamed.uDepthToViewZ[2u];\n    let _e37 = ndc;\n    let _e41 = unnamed.uDepthToViewZ[3u];\n    return (((_e27 * _e28) + _e32) / ((_e36 * _e37) + _e41));\n}\n\nfn main_1() {\n    var centre: f32;\n    var param: f32;\n    var tolerance: f32;\n    var sum: f32;\n    var weight: f32;\n    var i: i32;\n    var uv: vec2<f32>;\n    var z: f32;\n    var param_1: f32;\n    var w: f32;\n    var local: f32;\n\n    let _e31 = vUv_1;\n    let _e32 = textureSampleLevel(uDepth_t, uDepth_s, _e31, 0f);\n    param = _e32.x;\n    let _e34 = viewZ_u0028_f1_u003b((&param));\n    centre = _e34;\n    let _e35 = centre;\n    tolerance = ((0.02f * abs(_e35)) + 0.0001f);\n    sum = 0f;\n    weight = 0f;\n    i = -3i;\n    loop {\n        let _e39 = i;\n        if (_e39 <= 4i) {\n            let _e41 = vUv_1;\n            let _e43 = unnamed.uStep;\n            let _e44 = i;\n            uv = (_e41 + (_e43 * f32(_e44)));\n            let _e48 = uv;\n            let _e49 = textureSampleLevel(uDepth_t, uDepth_s, _e48, 0f);\n            param_1 = _e49.x;\n            let _e51 = viewZ_u0028_f1_u003b((&param_1));\n            z = _e51;\n            let _e52 = z;\n            let _e53 = centre;\n            let _e56 = tolerance;\n            w = max(0f, (1f - (abs((_e52 - _e53)) / _e56)));\n            let _e60 = uv;\n            let _e61 = textureSampleLevel(uAo_t, uAo_s, _e60, 0f);\n            let _e63 = w;\n            let _e65 = sum;\n            sum = (_e65 + (_e61.x * _e63));\n            let _e67 = w;\n            let _e68 = weight;\n            weight = (_e68 + _e67);\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e70 = i;\n            i = (_e70 + 1i);\n        }\n    }\n    let _e72 = weight;\n    if (_e72 > 0f) {\n        let _e74 = sum;\n        let _e75 = weight;\n        local = (_e74 / _e75);\n    } else {\n        let _e77 = vUv_1;\n        let _e78 = textureSampleLevel(uAo_t, uAo_s, _e77, 0f);\n        local = _e78.x;\n    }\n    let _e80 = local;\n    fragColor = _e80;\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>) -> @location(0) f32 {\n    vUv_1 = vUv;\n    main_1();\n    let _e3 = fragColor;\n    return _e3;\n}\n";
-export declare const AO_FRAG_WGSL = "struct Uniforms {\n    uProjScale: vec2<f32>,\n    uInvProjection: mat4x4<f32>,\n    uRadius: f32,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vUv_1: vec2<f32>;\n@group(0) @binding(32) \nvar uDepth_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uDepth_s: sampler;\nvar<private> fragColor: f32;\nvar<private> gl_FragCoord_1: vec4<f32>;\n\nfn viewPosition_u0028_vf2_u003b_f1_u003b(uv: ptr<function, vec2<f32>>, depth: ptr<function, f32>) -> vec3<f32> {\n    var clip: vec4<f32>;\n    var view: vec4<f32>;\n\n    let _e33 = (*uv);\n    let _e36 = ((_e33 * 2f) - vec2(1f));\n    let _e37 = (*depth);\n    clip = vec4<f32>(_e36.x, _e36.y, (1f - (_e37 * 2f)), 1f);\n    let _e44 = unnamed.uInvProjection;\n    let _e45 = clip;\n    view = (_e44 * _e45);\n    let _e47 = view;\n    let _e50 = view[3u];\n    return (_e47.xyz / vec3(_e50));\n}\n\nfn main_1() {\n    var stepX: vec2<f32>;\n    var stepY: vec2<f32>;\n    var depth_1: f32;\n    var p: vec3<f32>;\n    var param: vec2<f32>;\n    var param_1: f32;\n    var dpdx_: vec3<f32>;\n    var dpdy_: vec3<f32>;\n    var right: vec3<f32>;\n    var param_2: vec2<f32>;\n    var param_3: f32;\n    var left: vec3<f32>;\n    var param_4: vec2<f32>;\n    var param_5: f32;\n    var down: vec3<f32>;\n    var param_6: vec2<f32>;\n    var param_7: f32;\n    var up: vec3<f32>;\n    var param_8: vec2<f32>;\n    var param_9: f32;\n    var here: f32;\n    var edgeFloor: f32;\n    var rightGap: f32;\n    var leftGap: f32;\n    var downGap: f32;\n    var upGap: f32;\n    var n: vec3<f32>;\n    var reach: vec2<f32>;\n    var tile: f32;\n    var turn: f32;\n    var sum: f32;\n    var i: i32;\n    var t: f32;\n    var angle: f32;\n    var uv_1: vec2<f32>;\n    var sampled: f32;\n    var v: vec3<f32>;\n    var param_10: vec2<f32>;\n    var param_11: f32;\n    var vv: f32;\n\n    let _e69 = vUv_1;\n    let _e70 = dpdx(_e69);\n    stepX = _e70;\n    let _e71 = vUv_1;\n    let _e72 = dpdy(_e71);\n    stepY = _e72;\n    let _e73 = vUv_1;\n    let _e74 = textureSampleLevel(uDepth_t, uDepth_s, _e73, 0f);\n    depth_1 = _e74.x;\n    let _e76 = vUv_1;\n    param = _e76;\n    let _e77 = depth_1;\n    param_1 = _e77;\n    let _e78 = viewPosition_u0028_vf2_u003b_f1_u003b((&param), (&param_1));\n    p = _e78;\n    let _e79 = p;\n    let _e80 = dpdx(_e79);\n    dpdx_ = _e80;\n    let _e81 = p;\n    let _e82 = dpdy(_e81);\n    dpdy_ = _e82;\n    let _e83 = depth_1;\n    if (_e83 <= 0f) {\n        fragColor = 1f;\n        return;\n    }\n    let _e85 = vUv_1;\n    let _e86 = stepX;\n    let _e88 = vUv_1;\n    let _e89 = stepX;\n    let _e91 = textureSampleLevel(uDepth_t, uDepth_s, (_e88 + _e89), 0f);\n    param_2 = (_e85 + _e86);\n    param_3 = _e91.x;\n    let _e93 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_2), (&param_3));\n    right = _e93;\n    let _e94 = vUv_1;\n    let _e95 = stepX;\n    let _e97 = vUv_1;\n    let _e98 = stepX;\n    let _e100 = textureSampleLevel(uDepth_t, uDepth_s, (_e97 - _e98), 0f);\n    param_4 = (_e94 - _e95);\n    param_5 = _e100.x;\n    let _e102 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_4), (&param_5));\n    left = _e102;\n    let _e103 = vUv_1;\n    let _e104 = stepY;\n    let _e106 = vUv_1;\n    let _e107 = stepY;\n    let _e109 = textureSampleLevel(uDepth_t, uDepth_s, (_e106 + _e107), 0f);\n    param_6 = (_e103 + _e104);\n    param_7 = _e109.x;\n    let _e111 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_6), (&param_7));\n    down = _e111;\n    let _e112 = vUv_1;\n    let _e113 = stepY;\n    let _e115 = vUv_1;\n    let _e116 = stepY;\n    let _e118 = textureSampleLevel(uDepth_t, uDepth_s, (_e115 - _e116), 0f);\n    param_8 = (_e112 - _e113);\n    param_9 = _e118.x;\n    let _e120 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_8), (&param_9));\n    up = _e120;\n    let _e122 = p[2u];\n    here = -(_e122);\n    let _e124 = here;\n    edgeFloor = (0.05f * _e124);\n    let _e127 = right[2u];\n    let _e129 = here;\n    rightGap = abs((-(_e127) - _e129));\n    let _e133 = left[2u];\n    let _e135 = here;\n    leftGap = abs((-(_e133) - _e135));\n    let _e139 = down[2u];\n    let _e141 = here;\n    downGap = abs((-(_e139) - _e141));\n    let _e145 = up[2u];\n    let _e147 = here;\n    upGap = abs((-(_e145) - _e147));\n    let _e150 = rightGap;\n    let _e151 = leftGap;\n    let _e153 = edgeFloor;\n    if (_e150 > ((_e151 * 8f) + _e153)) {\n        let _e156 = p;\n        let _e157 = left;\n        dpdx_ = (_e156 - _e157);\n    } else {\n        let _e159 = leftGap;\n        let _e160 = rightGap;\n        let _e162 = edgeFloor;\n        if (_e159 > ((_e160 * 8f) + _e162)) {\n            let _e165 = right;\n            let _e166 = p;\n            dpdx_ = (_e165 - _e166);\n        }\n    }\n    let _e168 = downGap;\n    let _e169 = upGap;\n    let _e171 = edgeFloor;\n    if (_e168 > ((_e169 * 8f) + _e171)) {\n        let _e174 = p;\n        let _e175 = up;\n        dpdy_ = (_e174 - _e175);\n    } else {\n        let _e177 = upGap;\n        let _e178 = downGap;\n        let _e180 = edgeFloor;\n        if (_e177 > ((_e178 * 8f) + _e180)) {\n            let _e183 = down;\n            let _e184 = p;\n            dpdy_ = (_e183 - _e184);\n        }\n    }\n    let _e186 = dpdx_;\n    let _e187 = dpdy_;\n    n = normalize(cross(_e186, _e187));\n    let _e190 = n;\n    let _e191 = p;\n    if (dot(_e190, _e191) > 0f) {\n        let _e194 = n;\n        n = -(_e194);\n    }\n    let _e197 = unnamed.uRadius;\n    let _e199 = unnamed.uProjScale;\n    let _e203 = p[2u];\n    reach = min((((_e199 * _e197) * 0.5f) / vec2(max(-(_e203), 0.001f))), vec2<f32>(0.06f, 0.06f));\n    let _e210 = gl_FragCoord_1[0u];\n    let _e216 = gl_FragCoord_1[1u];\n    tile = ((_e210 - (floor((_e210 / 4f)) * 4f)) + (4f * (_e216 - (floor((_e216 / 4f)) * 4f))));\n    let _e223 = tile;\n    turn = (_e223 * 0.3926991f);\n    sum = 0f;\n    i = 0i;\n    loop {\n        let _e225 = i;\n        if (_e225 < 12i) {\n            let _e227 = i;\n            t = ((f32(_e227) + 0.5f) / 12f);\n            let _e231 = turn;\n            let _e232 = i;\n            angle = (_e231 + (f32(_e232) * 2.3999631f));\n            let _e236 = vUv_1;\n            let _e237 = angle;\n            let _e239 = angle;\n            let _e242 = t;\n            let _e245 = reach;\n            uv_1 = (_e236 + ((vec2<f32>(cos(_e237), sin(_e239)) * sqrt(_e242)) * _e245));\n            let _e248 = uv_1;\n            let _e249 = textureSampleLevel(uDepth_t, uDepth_s, _e248, 0f);\n            sampled = _e249.x;\n            let _e251 = sampled;\n            if (_e251 <= 0f) {\n                continue;\n            }\n            let _e253 = uv_1;\n            param_10 = _e253;\n            let _e254 = sampled;\n            param_11 = _e254;\n            let _e255 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_10), (&param_11));\n            let _e256 = p;\n            v = (_e255 - _e256);\n            let _e258 = v;\n            let _e259 = v;\n            vv = dot(_e258, _e259);\n            let _e261 = vv;\n            let _e263 = unnamed.uRadius;\n            let _e265 = unnamed.uRadius;\n            if (_e261 > (_e263 * _e265)) {\n                continue;\n            }\n            let _e268 = v;\n            let _e269 = n;\n            let _e272 = p[2u];\n            let _e277 = vv;\n            let _e280 = sum;\n            sum = (_e280 + (max(0f, (dot(_e268, _e269) - (0.004f * -(_e272)))) / (_e277 + 0.01f)));\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e282 = i;\n            i = (_e282 + 1i);\n        }\n    }\n    let _e285 = unnamed.uRadius;\n    let _e287 = sum;\n    fragColor = clamp((1f - (((2f * _e285) * _e287) / 12f)), 0f, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>, @builtin(position) gl_FragCoord: vec4<f32>) -> @location(0) f32 {\n    vUv_1 = vUv;\n    gl_FragCoord_1 = gl_FragCoord;\n    main_1();\n    let _e5 = fragColor;\n    return _e5;\n}\n";
+export declare const AO_BLUR_FRAG_WGSL = "struct Uniforms {\n    uStep: vec2<f32>,\n    uDepthToViewZ: vec4<f32>,\n    uAoScale: f32,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\n@group(0) @binding(34) \nvar uDepth_t: texture_2d<f32>;\n@group(0) @binding(35) \nvar uDepth_s: sampler;\nvar<private> vUv_1: vec2<f32>;\n@group(0) @binding(32) \nvar uAo_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uAo_s: sampler;\nvar<private> fragColor: f32;\n\nfn viewZ_u0028_f1_u003b(depth: ptr<function, f32>) -> f32 {\n    var ndc: f32;\n\n    let _e22 = (*depth);\n    ndc = (1f - (_e22 * 2f));\n    let _e27 = unnamed.uDepthToViewZ[0u];\n    let _e28 = ndc;\n    let _e32 = unnamed.uDepthToViewZ[1u];\n    let _e36 = unnamed.uDepthToViewZ[2u];\n    let _e37 = ndc;\n    let _e41 = unnamed.uDepthToViewZ[3u];\n    return (((_e27 * _e28) + _e32) / ((_e36 * _e37) + _e41));\n}\n\nfn main_1() {\n    var depth_1: f32;\n    var own: f32;\n    var centre: f32;\n    var param: f32;\n    var inverse: f32;\n    var stepAfter: f32;\n    var param_1: f32;\n    var stepBefore: f32;\n    var param_2: f32;\n    var slope: f32;\n    var sum: f32;\n    var weight: f32;\n    var i: i32;\n    var uv: vec2<f32>;\n    var z: f32;\n    var param_3: f32;\n    var w: f32;\n    var blurred: f32;\n    var local: f32;\n\n    let _e39 = vUv_1;\n    let _e40 = textureSampleLevel(uDepth_t, uDepth_s, _e39, 0f);\n    depth_1 = _e40.x;\n    let _e42 = vUv_1;\n    let _e43 = textureSampleLevel(uAo_t, uAo_s, _e42, 0f);\n    own = _e43.x;\n    let _e45 = depth_1;\n    if (_e45 <= 0f) {\n        let _e47 = own;\n        let _e49 = unnamed.uAoScale;\n        fragColor = min((_e47 * _e49), 1f);\n        return;\n    }\n    let _e52 = depth_1;\n    param = _e52;\n    let _e53 = viewZ_u0028_f1_u003b((&param));\n    centre = _e53;\n    let _e54 = centre;\n    inverse = (1f / _e54);\n    let _e56 = vUv_1;\n    let _e58 = unnamed.uStep;\n    let _e60 = textureSampleLevel(uDepth_t, uDepth_s, (_e56 + _e58), 0f);\n    param_1 = _e60.x;\n    let _e62 = viewZ_u0028_f1_u003b((&param_1));\n    let _e64 = inverse;\n    stepAfter = ((1f / _e62) - _e64);\n    let _e66 = inverse;\n    let _e67 = vUv_1;\n    let _e69 = unnamed.uStep;\n    let _e71 = textureSampleLevel(uDepth_t, uDepth_s, (_e67 - _e69), 0f);\n    param_2 = _e71.x;\n    let _e73 = viewZ_u0028_f1_u003b((&param_2));\n    stepBefore = (_e66 - (1f / _e73));\n    let _e76 = stepAfter;\n    let _e78 = stepBefore;\n    let _e81 = stepAfter;\n    let _e82 = stepBefore;\n    slope = select(_e82, _e81, (abs(_e76) < abs(_e78)));\n    sum = 0f;\n    weight = 0f;\n    i = -3i;\n    loop {\n        let _e84 = i;\n        if (_e84 <= 4i) {\n            let _e86 = vUv_1;\n            let _e88 = unnamed.uStep;\n            let _e89 = i;\n            uv = (_e86 + (_e88 * f32(_e89)));\n            let _e93 = uv;\n            let _e94 = textureSampleLevel(uDepth_t, uDepth_s, _e93, 0f);\n            param_3 = _e94.x;\n            let _e96 = viewZ_u0028_f1_u003b((&param_3));\n            z = _e96;\n            let _e97 = z;\n            let _e98 = inverse;\n            let _e99 = slope;\n            let _e100 = i;\n            w = max(0f, (1f - (abs(((_e97 * (_e98 + (_e99 * f32(_e100)))) - 1f)) / 0.02f)));\n            let _e110 = uv;\n            let _e111 = textureSampleLevel(uAo_t, uAo_s, _e110, 0f);\n            let _e113 = w;\n            let _e115 = sum;\n            sum = (_e115 + (_e111.x * _e113));\n            let _e117 = w;\n            let _e118 = weight;\n            weight = (_e118 + _e117);\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e120 = i;\n            i = (_e120 + 1i);\n        }\n    }\n    let _e122 = weight;\n    if (_e122 > 0f) {\n        let _e124 = sum;\n        let _e125 = weight;\n        local = (_e124 / _e125);\n    } else {\n        let _e127 = own;\n        local = _e127;\n    }\n    let _e128 = local;\n    blurred = _e128;\n    let _e129 = blurred;\n    let _e131 = unnamed.uAoScale;\n    fragColor = min((_e129 * _e131), 1f);\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>) -> @location(0) f32 {\n    vUv_1 = vUv;\n    main_1();\n    let _e3 = fragColor;\n    return _e3;\n}\n";
+export declare const AO_FRAG_WGSL = "struct Uniforms {\n    uProjScale: vec2<f32>,\n    uInvProjection: mat4x4<f32>,\n    uRadius: f32,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vUv_1: vec2<f32>;\n@group(0) @binding(32) \nvar uDepth_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uDepth_s: sampler;\nvar<private> fragColor: f32;\nvar<private> gl_FragCoord_1: vec4<f32>;\n\nfn gtaoArc_u0028_f1_u003b_f1_u003b_f1_u003b(h0_: ptr<function, f32>, h1_: ptr<function, f32>, normal: ptr<function, f32>) -> f32 {\n    var c: f32;\n    var s2_: f32;\n\n    let _e40 = (*normal);\n    c = cos(_e40);\n    let _e42 = (*normal);\n    s2_ = (2f * sin(_e42));\n    let _e45 = (*h0_);\n    let _e47 = (*normal);\n    let _e51 = c;\n    let _e53 = (*h0_);\n    let _e54 = s2_;\n    let _e58 = (*h1_);\n    let _e60 = (*normal);\n    let _e64 = c;\n    let _e66 = (*h1_);\n    let _e67 = s2_;\n    return ((0.25f * ((-(cos(((2f * _e45) - _e47))) + _e51) + (_e53 * _e54))) + (0.25f * ((-(cos(((2f * _e58) - _e60))) + _e64) + (_e66 * _e67))));\n}\n\nfn viewPosition_u0028_vf2_u003b_f1_u003b(uv: ptr<function, vec2<f32>>, depth: ptr<function, f32>) -> vec3<f32> {\n    var clip: vec4<f32>;\n    var view: vec4<f32>;\n\n    let _e39 = (*uv);\n    let _e42 = ((_e39 * 2f) - vec2(1f));\n    let _e43 = (*depth);\n    clip = vec4<f32>(_e42.x, _e42.y, (1f - (_e43 * 2f)), 1f);\n    let _e50 = unnamed.uInvProjection;\n    let _e51 = clip;\n    view = (_e50 * _e51);\n    let _e53 = view;\n    let _e56 = view[3u];\n    return (_e53.xyz / vec3(_e56));\n}\n\nfn main_1() {\n    var stepX: vec2<f32>;\n    var stepY: vec2<f32>;\n    var depth_1: f32;\n    var p: vec3<f32>;\n    var param: vec2<f32>;\n    var param_1: f32;\n    var dpdx_: vec3<f32>;\n    var dpdy_: vec3<f32>;\n    var right: vec3<f32>;\n    var param_2: vec2<f32>;\n    var param_3: f32;\n    var left: vec3<f32>;\n    var param_4: vec2<f32>;\n    var param_5: f32;\n    var down: vec3<f32>;\n    var param_6: vec2<f32>;\n    var param_7: f32;\n    var up: vec3<f32>;\n    var param_8: vec2<f32>;\n    var param_9: f32;\n    var here: f32;\n    var edgeFloor: f32;\n    var rightGap: f32;\n    var leftGap: f32;\n    var downGap: f32;\n    var upGap: f32;\n    var n: vec3<f32>;\n    var toEye: vec3<f32>;\n    var reach: vec2<f32>;\n    var tile: f32;\n    var turn: f32;\n    var stagger: f32;\n    var pixel: vec2<f32>;\n    var visible: f32;\n    var slice: i32;\n    var angle: f32;\n    var screen: vec2<f32>;\n    var along: vec3<f32>;\n    var param_10: vec2<f32>;\n    var param_11: f32;\n    var across: vec3<f32>;\n    var axis: vec3<f32>;\n    var projected: vec3<f32>;\n    var projectedLength: f32;\n    var normalAngle: f32;\n    var horizon0_: f32;\n    var horizon1_: f32;\n    var k: i32;\n    var t: f32;\n    var stride: vec2<f32>;\n    var side: i32;\n    var uv_1: vec2<f32>;\n    var local: vec2<f32>;\n    var sampled: f32;\n    var v: vec3<f32>;\n    var param_12: vec2<f32>;\n    var param_13: f32;\n    var distance2_: f32;\n    var cosine: f32;\n    var fade: f32;\n    var local_1: f32;\n    var local_2: f32;\n    var h0_1: f32;\n    var h1_1: f32;\n    var param_14: f32;\n    var param_15: f32;\n    var param_16: f32;\n\n    let _e102 = vUv_1;\n    let _e103 = dpdx(_e102);\n    stepX = _e103;\n    let _e104 = vUv_1;\n    let _e105 = dpdy(_e104);\n    stepY = _e105;\n    let _e106 = vUv_1;\n    let _e107 = textureSampleLevel(uDepth_t, uDepth_s, _e106, 0f);\n    depth_1 = _e107.x;\n    let _e109 = vUv_1;\n    param = _e109;\n    let _e110 = depth_1;\n    param_1 = _e110;\n    let _e111 = viewPosition_u0028_vf2_u003b_f1_u003b((&param), (&param_1));\n    p = _e111;\n    let _e112 = p;\n    let _e113 = dpdx(_e112);\n    dpdx_ = _e113;\n    let _e114 = p;\n    let _e115 = dpdy(_e114);\n    dpdy_ = _e115;\n    let _e116 = depth_1;\n    if (_e116 <= 0f) {\n        fragColor = 1f;\n        return;\n    }\n    let _e118 = vUv_1;\n    let _e119 = stepX;\n    let _e121 = vUv_1;\n    let _e122 = stepX;\n    let _e124 = textureSampleLevel(uDepth_t, uDepth_s, (_e121 + _e122), 0f);\n    param_2 = (_e118 + _e119);\n    param_3 = _e124.x;\n    let _e126 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_2), (&param_3));\n    right = _e126;\n    let _e127 = vUv_1;\n    let _e128 = stepX;\n    let _e130 = vUv_1;\n    let _e131 = stepX;\n    let _e133 = textureSampleLevel(uDepth_t, uDepth_s, (_e130 - _e131), 0f);\n    param_4 = (_e127 - _e128);\n    param_5 = _e133.x;\n    let _e135 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_4), (&param_5));\n    left = _e135;\n    let _e136 = vUv_1;\n    let _e137 = stepY;\n    let _e139 = vUv_1;\n    let _e140 = stepY;\n    let _e142 = textureSampleLevel(uDepth_t, uDepth_s, (_e139 + _e140), 0f);\n    param_6 = (_e136 + _e137);\n    param_7 = _e142.x;\n    let _e144 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_6), (&param_7));\n    down = _e144;\n    let _e145 = vUv_1;\n    let _e146 = stepY;\n    let _e148 = vUv_1;\n    let _e149 = stepY;\n    let _e151 = textureSampleLevel(uDepth_t, uDepth_s, (_e148 - _e149), 0f);\n    param_8 = (_e145 - _e146);\n    param_9 = _e151.x;\n    let _e153 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_8), (&param_9));\n    up = _e153;\n    let _e155 = p[2u];\n    here = -(_e155);\n    let _e157 = here;\n    edgeFloor = (0.05f * _e157);\n    let _e160 = right[2u];\n    let _e162 = here;\n    rightGap = abs((-(_e160) - _e162));\n    let _e166 = left[2u];\n    let _e168 = here;\n    leftGap = abs((-(_e166) - _e168));\n    let _e172 = down[2u];\n    let _e174 = here;\n    downGap = abs((-(_e172) - _e174));\n    let _e178 = up[2u];\n    let _e180 = here;\n    upGap = abs((-(_e178) - _e180));\n    let _e183 = rightGap;\n    let _e184 = leftGap;\n    let _e186 = edgeFloor;\n    if (_e183 > ((_e184 * 8f) + _e186)) {\n        let _e189 = p;\n        let _e190 = left;\n        dpdx_ = (_e189 - _e190);\n    } else {\n        let _e192 = leftGap;\n        let _e193 = rightGap;\n        let _e195 = edgeFloor;\n        if (_e192 > ((_e193 * 8f) + _e195)) {\n            let _e198 = right;\n            let _e199 = p;\n            dpdx_ = (_e198 - _e199);\n        }\n    }\n    let _e201 = downGap;\n    let _e202 = upGap;\n    let _e204 = edgeFloor;\n    if (_e201 > ((_e202 * 8f) + _e204)) {\n        let _e207 = p;\n        let _e208 = up;\n        dpdy_ = (_e207 - _e208);\n    } else {\n        let _e210 = upGap;\n        let _e211 = downGap;\n        let _e213 = edgeFloor;\n        if (_e210 > ((_e211 * 8f) + _e213)) {\n            let _e216 = down;\n            let _e217 = p;\n            dpdy_ = (_e216 - _e217);\n        }\n    }\n    let _e219 = dpdx_;\n    let _e220 = dpdy_;\n    n = normalize(cross(_e219, _e220));\n    let _e223 = n;\n    let _e224 = p;\n    if (dot(_e223, _e224) > 0f) {\n        let _e227 = n;\n        n = -(_e227);\n    }\n    let _e229 = p;\n    toEye = normalize(-(_e229));\n    let _e233 = unnamed.uRadius;\n    let _e235 = unnamed.uProjScale;\n    let _e239 = p[2u];\n    reach = min((((_e235 * _e233) * 0.5f) / vec2(max(-(_e239), 0.001f))), vec2<f32>(0.06f, 0.06f));\n    let _e246 = gl_FragCoord_1[0u];\n    let _e252 = gl_FragCoord_1[1u];\n    tile = ((_e246 - (floor((_e246 / 4f)) * 4f)) + (4f * (_e252 - (floor((_e252 / 4f)) * 4f))));\n    let _e259 = tile;\n    turn = (_e259 * 0.098174766f);\n    let _e261 = tile;\n    stagger = fract((_e261 * 0.618034f));\n    let _e264 = stepX;\n    let _e266 = stepY;\n    pixel = vec2<f32>(length(_e264), length(_e266));\n    visible = 0f;\n    slice = 0i;\n    loop {\n        let _e269 = slice;\n        if (_e269 < 2i) {\n            let _e271 = turn;\n            let _e272 = slice;\n            angle = (_e271 + (f32(_e272) * 1.5707964f));\n            let _e276 = angle;\n            let _e279 = pixel[0u];\n            let _e282 = pixel[1u];\n            let _e284 = angle;\n            screen = vec2<f32>(((cos(_e276) * _e279) / _e282), sin(_e284));\n            let _e287 = vUv_1;\n            let _e288 = screen;\n            param_10 = (_e287 + (_e288 * 0.001f));\n            let _e291 = depth_1;\n            param_11 = _e291;\n            let _e292 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_10), (&param_11));\n            let _e293 = p;\n            along = normalize((_e292 - _e293));\n            let _e296 = along;\n            let _e297 = toEye;\n            let _e298 = along;\n            let _e299 = toEye;\n            across = normalize((_e296 - (_e297 * dot(_e298, _e299))));\n            let _e304 = across;\n            let _e305 = toEye;\n            axis = cross(_e304, _e305);\n            let _e307 = n;\n            let _e308 = axis;\n            let _e309 = n;\n            let _e310 = axis;\n            projected = (_e307 - (_e308 * dot(_e309, _e310)));\n            let _e314 = projected;\n            projectedLength = length(_e314);\n            let _e316 = projectedLength;\n            if (_e316 < 0.0001f) {\n                continue;\n            }\n            let _e318 = projected;\n            let _e319 = across;\n            let _e321 = projected;\n            let _e322 = toEye;\n            normalAngle = atan2(dot(_e318, _e319), dot(_e321, _e322));\n            horizon0_ = -1f;\n            horizon1_ = -1f;\n            k = 0i;\n            loop {\n                let _e325 = k;\n                if (_e325 < 6i) {\n                    let _e327 = k;\n                    let _e329 = stagger;\n                    t = ((f32(_e327) + _e329) / 6f);\n                    let _e332 = screen;\n                    let _e334 = reach[1u];\n                    let _e336 = t;\n                    let _e337 = t;\n                    stride = ((_e332 * _e334) * ((_e336 * _e337) + 0.013888889f));\n                    side = 0i;\n                    loop {\n                        let _e341 = side;\n                        if (_e341 < 2i) {\n                            let _e343 = side;\n                            if (_e343 == 0i) {\n                                let _e345 = vUv_1;\n                                let _e346 = stride;\n                                local = (_e345 - _e346);\n                            } else {\n                                let _e348 = vUv_1;\n                                let _e349 = stride;\n                                local = (_e348 + _e349);\n                            }\n                            let _e351 = local;\n                            uv_1 = _e351;\n                            let _e352 = uv_1;\n                            let _e353 = textureSampleLevel(uDepth_t, uDepth_s, _e352, 0f);\n                            sampled = _e353.x;\n                            let _e355 = sampled;\n                            if (_e355 <= 0f) {\n                                continue;\n                            }\n                            let _e357 = uv_1;\n                            param_12 = _e357;\n                            let _e358 = sampled;\n                            param_13 = _e358;\n                            let _e359 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_12), (&param_13));\n                            let _e360 = p;\n                            v = (_e359 - _e360);\n                            let _e362 = v;\n                            let _e363 = v;\n                            distance2_ = dot(_e362, _e363);\n                            let _e365 = distance2_;\n                            if (_e365 < 0.00000001f) {\n                                continue;\n                            }\n                            let _e367 = v;\n                            let _e368 = toEye;\n                            let _e370 = distance2_;\n                            cosine = (dot(_e367, _e368) * inverseSqrt(_e370));\n                            let _e373 = distance2_;\n                            let _e375 = unnamed.uRadius;\n                            let _e377 = unnamed.uRadius;\n                            fade = clamp((1f - (_e373 / (_e375 * _e377))), 0f, 1f);\n                            let _e382 = cosine;\n                            let _e383 = fade;\n                            cosine = mix(-1f, _e382, _e383);\n                            let _e385 = side;\n                            if (_e385 == 0i) {\n                                let _e387 = cosine;\n                                let _e388 = horizon0_;\n                                if (_e387 > _e388) {\n                                    let _e390 = cosine;\n                                    local_1 = _e390;\n                                } else {\n                                    let _e391 = horizon0_;\n                                    let _e392 = cosine;\n                                    local_1 = mix(_e391, _e392, 0.2f);\n                                }\n                                let _e394 = local_1;\n                                horizon0_ = _e394;\n                            } else {\n                                let _e395 = cosine;\n                                let _e396 = horizon1_;\n                                if (_e395 > _e396) {\n                                    let _e398 = cosine;\n                                    local_2 = _e398;\n                                } else {\n                                    let _e399 = horizon1_;\n                                    let _e400 = cosine;\n                                    local_2 = mix(_e399, _e400, 0.2f);\n                                }\n                                let _e402 = local_2;\n                                horizon1_ = _e402;\n                            }\n                            continue;\n                        } else {\n                            break;\n                        }\n                        continuing {\n                            let _e403 = side;\n                            side = (_e403 + 1i);\n                        }\n                    }\n                    continue;\n                } else {\n                    break;\n                }\n                continuing {\n                    let _e405 = k;\n                    k = (_e405 + 1i);\n                }\n            }\n            let _e407 = horizon0_;\n            let _e411 = normalAngle;\n            h0_1 = max(-(acos(clamp(_e407, -1f, 1f))), (_e411 - 1.5707963f));\n            let _e414 = horizon1_;\n            let _e417 = normalAngle;\n            h1_1 = min(acos(clamp(_e414, -1f, 1f)), (_e417 + 1.5707963f));\n            let _e420 = projectedLength;\n            let _e421 = h0_1;\n            param_14 = _e421;\n            let _e422 = h1_1;\n            param_15 = _e422;\n            let _e423 = normalAngle;\n            param_16 = _e423;\n            let _e424 = gtaoArc_u0028_f1_u003b_f1_u003b_f1_u003b((&param_14), (&param_15), (&param_16));\n            let _e426 = visible;\n            visible = (_e426 + (_e420 * _e424));\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e428 = slice;\n            slice = (_e428 + 1i);\n        }\n    }\n    let _e430 = visible;\n    fragColor = clamp(((_e430 / 2f) * 0.5f), 0f, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>, @builtin(position) gl_FragCoord: vec4<f32>) -> @location(0) f32 {\n    vUv_1 = vUv;\n    gl_FragCoord_1 = gl_FragCoord;\n    main_1();\n    let _e5 = fragColor;\n    return _e5;\n}\n";
 /**
  * What the transform assigned, so the renderer binds the same numbers.
  *
@@ -8,7 +8,7 @@ export declare const AO_FRAG_WGSL = "struct Uniforms {\n    uProjScale: vec2<f32
 export declare const AMBIENTOCCLUSION_BINDINGS: {
     readonly AO_BLUR_FRAG: {
         readonly uniforms: 1;
-        readonly uniformSize: 32;
+        readonly uniformSize: 48;
         readonly fields: {
             readonly uStep: {
                 readonly offset: 0;
@@ -20,6 +20,11 @@ export declare const AMBIENTOCCLUSION_BINDINGS: {
                 readonly size: 16;
                 readonly type: "vec4";
             };
+            readonly uAoScale: {
+                readonly offset: 32;
+                readonly size: 4;
+                readonly type: "float";
+            };
         };
         readonly textures: {
             readonly uAo: {

package/dist/render/shaders/generated/ambientOcclusion.wgsl.js

@@ -4,8 +4,8 @@
  * The GLSL beside this file is the source of truth. A hand edit here is discarded by
  * the next generation, and `npm run wgsl:check` fails the build when this is stale.
  */
-export const AO_BLUR_FRAG_WGSL = "struct Uniforms {\n    uStep: vec2<f32>,\n    uDepthToViewZ: vec4<f32>,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\n@group(0) @binding(34) \nvar uDepth_t: texture_2d<f32>;\n@group(0) @binding(35) \nvar uDepth_s: sampler;\nvar<private> vUv_1: vec2<f32>;\n@group(0) @binding(32) \nvar uAo_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uAo_s: sampler;\nvar<private> fragColor: f32;\n\nfn viewZ_u0028_f1_u003b(depth: ptr<function, f32>) -> f32 {\n    var ndc: f32;\n\n    let _e22 = (*depth);\n    ndc = (1f - (_e22 * 2f));\n    let _e27 = unnamed.uDepthToViewZ[0u];\n    let _e28 = ndc;\n    let _e32 = unnamed.uDepthToViewZ[1u];\n    let _e36 = unnamed.uDepthToViewZ[2u];\n    let _e37 = ndc;\n    let _e41 = unnamed.uDepthToViewZ[3u];\n    return (((_e27 * _e28) + _e32) / ((_e36 * _e37) + _e41));\n}\n\nfn main_1() {\n    var centre: f32;\n    var param: f32;\n    var tolerance: f32;\n    var sum: f32;\n    var weight: f32;\n    var i: i32;\n    var uv: vec2<f32>;\n    var z: f32;\n    var param_1: f32;\n    var w: f32;\n    var local: f32;\n\n    let _e31 = vUv_1;\n    let _e32 = textureSampleLevel(uDepth_t, uDepth_s, _e31, 0f);\n    param = _e32.x;\n    let _e34 = viewZ_u0028_f1_u003b((&param));\n    centre = _e34;\n    let _e35 = centre;\n    tolerance = ((0.02f * abs(_e35)) + 0.0001f);\n    sum = 0f;\n    weight = 0f;\n    i = -3i;\n    loop {\n        let _e39 = i;\n        if (_e39 <= 4i) {\n            let _e41 = vUv_1;\n            let _e43 = unnamed.uStep;\n            let _e44 = i;\n            uv = (_e41 + (_e43 * f32(_e44)));\n            let _e48 = uv;\n            let _e49 = textureSampleLevel(uDepth_t, uDepth_s, _e48, 0f);\n            param_1 = _e49.x;\n            let _e51 = viewZ_u0028_f1_u003b((&param_1));\n            z = _e51;\n            let _e52 = z;\n            let _e53 = centre;\n            let _e56 = tolerance;\n            w = max(0f, (1f - (abs((_e52 - _e53)) / _e56)));\n            let _e60 = uv;\n            let _e61 = textureSampleLevel(uAo_t, uAo_s, _e60, 0f);\n            let _e63 = w;\n            let _e65 = sum;\n            sum = (_e65 + (_e61.x * _e63));\n            let _e67 = w;\n            let _e68 = weight;\n            weight = (_e68 + _e67);\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e70 = i;\n            i = (_e70 + 1i);\n        }\n    }\n    let _e72 = weight;\n    if (_e72 > 0f) {\n        let _e74 = sum;\n        let _e75 = weight;\n        local = (_e74 / _e75);\n    } else {\n        let _e77 = vUv_1;\n        let _e78 = textureSampleLevel(uAo_t, uAo_s, _e77, 0f);\n        local = _e78.x;\n    }\n    let _e80 = local;\n    fragColor = _e80;\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>) -> @location(0) f32 {\n    vUv_1 = vUv;\n    main_1();\n    let _e3 = fragColor;\n    return _e3;\n}\n";
-export const AO_FRAG_WGSL = "struct Uniforms {\n    uProjScale: vec2<f32>,\n    uInvProjection: mat4x4<f32>,\n    uRadius: f32,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vUv_1: vec2<f32>;\n@group(0) @binding(32) \nvar uDepth_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uDepth_s: sampler;\nvar<private> fragColor: f32;\nvar<private> gl_FragCoord_1: vec4<f32>;\n\nfn viewPosition_u0028_vf2_u003b_f1_u003b(uv: ptr<function, vec2<f32>>, depth: ptr<function, f32>) -> vec3<f32> {\n    var clip: vec4<f32>;\n    var view: vec4<f32>;\n\n    let _e33 = (*uv);\n    let _e36 = ((_e33 * 2f) - vec2(1f));\n    let _e37 = (*depth);\n    clip = vec4<f32>(_e36.x, _e36.y, (1f - (_e37 * 2f)), 1f);\n    let _e44 = unnamed.uInvProjection;\n    let _e45 = clip;\n    view = (_e44 * _e45);\n    let _e47 = view;\n    let _e50 = view[3u];\n    return (_e47.xyz / vec3(_e50));\n}\n\nfn main_1() {\n    var stepX: vec2<f32>;\n    var stepY: vec2<f32>;\n    var depth_1: f32;\n    var p: vec3<f32>;\n    var param: vec2<f32>;\n    var param_1: f32;\n    var dpdx_: vec3<f32>;\n    var dpdy_: vec3<f32>;\n    var right: vec3<f32>;\n    var param_2: vec2<f32>;\n    var param_3: f32;\n    var left: vec3<f32>;\n    var param_4: vec2<f32>;\n    var param_5: f32;\n    var down: vec3<f32>;\n    var param_6: vec2<f32>;\n    var param_7: f32;\n    var up: vec3<f32>;\n    var param_8: vec2<f32>;\n    var param_9: f32;\n    var here: f32;\n    var edgeFloor: f32;\n    var rightGap: f32;\n    var leftGap: f32;\n    var downGap: f32;\n    var upGap: f32;\n    var n: vec3<f32>;\n    var reach: vec2<f32>;\n    var tile: f32;\n    var turn: f32;\n    var sum: f32;\n    var i: i32;\n    var t: f32;\n    var angle: f32;\n    var uv_1: vec2<f32>;\n    var sampled: f32;\n    var v: vec3<f32>;\n    var param_10: vec2<f32>;\n    var param_11: f32;\n    var vv: f32;\n\n    let _e69 = vUv_1;\n    let _e70 = dpdx(_e69);\n    stepX = _e70;\n    let _e71 = vUv_1;\n    let _e72 = dpdy(_e71);\n    stepY = _e72;\n    let _e73 = vUv_1;\n    let _e74 = textureSampleLevel(uDepth_t, uDepth_s, _e73, 0f);\n    depth_1 = _e74.x;\n    let _e76 = vUv_1;\n    param = _e76;\n    let _e77 = depth_1;\n    param_1 = _e77;\n    let _e78 = viewPosition_u0028_vf2_u003b_f1_u003b((&param), (&param_1));\n    p = _e78;\n    let _e79 = p;\n    let _e80 = dpdx(_e79);\n    dpdx_ = _e80;\n    let _e81 = p;\n    let _e82 = dpdy(_e81);\n    dpdy_ = _e82;\n    let _e83 = depth_1;\n    if (_e83 <= 0f) {\n        fragColor = 1f;\n        return;\n    }\n    let _e85 = vUv_1;\n    let _e86 = stepX;\n    let _e88 = vUv_1;\n    let _e89 = stepX;\n    let _e91 = textureSampleLevel(uDepth_t, uDepth_s, (_e88 + _e89), 0f);\n    param_2 = (_e85 + _e86);\n    param_3 = _e91.x;\n    let _e93 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_2), (&param_3));\n    right = _e93;\n    let _e94 = vUv_1;\n    let _e95 = stepX;\n    let _e97 = vUv_1;\n    let _e98 = stepX;\n    let _e100 = textureSampleLevel(uDepth_t, uDepth_s, (_e97 - _e98), 0f);\n    param_4 = (_e94 - _e95);\n    param_5 = _e100.x;\n    let _e102 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_4), (&param_5));\n    left = _e102;\n    let _e103 = vUv_1;\n    let _e104 = stepY;\n    let _e106 = vUv_1;\n    let _e107 = stepY;\n    let _e109 = textureSampleLevel(uDepth_t, uDepth_s, (_e106 + _e107), 0f);\n    param_6 = (_e103 + _e104);\n    param_7 = _e109.x;\n    let _e111 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_6), (&param_7));\n    down = _e111;\n    let _e112 = vUv_1;\n    let _e113 = stepY;\n    let _e115 = vUv_1;\n    let _e116 = stepY;\n    let _e118 = textureSampleLevel(uDepth_t, uDepth_s, (_e115 - _e116), 0f);\n    param_8 = (_e112 - _e113);\n    param_9 = _e118.x;\n    let _e120 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_8), (&param_9));\n    up = _e120;\n    let _e122 = p[2u];\n    here = -(_e122);\n    let _e124 = here;\n    edgeFloor = (0.05f * _e124);\n    let _e127 = right[2u];\n    let _e129 = here;\n    rightGap = abs((-(_e127) - _e129));\n    let _e133 = left[2u];\n    let _e135 = here;\n    leftGap = abs((-(_e133) - _e135));\n    let _e139 = down[2u];\n    let _e141 = here;\n    downGap = abs((-(_e139) - _e141));\n    let _e145 = up[2u];\n    let _e147 = here;\n    upGap = abs((-(_e145) - _e147));\n    let _e150 = rightGap;\n    let _e151 = leftGap;\n    let _e153 = edgeFloor;\n    if (_e150 > ((_e151 * 8f) + _e153)) {\n        let _e156 = p;\n        let _e157 = left;\n        dpdx_ = (_e156 - _e157);\n    } else {\n        let _e159 = leftGap;\n        let _e160 = rightGap;\n        let _e162 = edgeFloor;\n        if (_e159 > ((_e160 * 8f) + _e162)) {\n            let _e165 = right;\n            let _e166 = p;\n            dpdx_ = (_e165 - _e166);\n        }\n    }\n    let _e168 = downGap;\n    let _e169 = upGap;\n    let _e171 = edgeFloor;\n    if (_e168 > ((_e169 * 8f) + _e171)) {\n        let _e174 = p;\n        let _e175 = up;\n        dpdy_ = (_e174 - _e175);\n    } else {\n        let _e177 = upGap;\n        let _e178 = downGap;\n        let _e180 = edgeFloor;\n        if (_e177 > ((_e178 * 8f) + _e180)) {\n            let _e183 = down;\n            let _e184 = p;\n            dpdy_ = (_e183 - _e184);\n        }\n    }\n    let _e186 = dpdx_;\n    let _e187 = dpdy_;\n    n = normalize(cross(_e186, _e187));\n    let _e190 = n;\n    let _e191 = p;\n    if (dot(_e190, _e191) > 0f) {\n        let _e194 = n;\n        n = -(_e194);\n    }\n    let _e197 = unnamed.uRadius;\n    let _e199 = unnamed.uProjScale;\n    let _e203 = p[2u];\n    reach = min((((_e199 * _e197) * 0.5f) / vec2(max(-(_e203), 0.001f))), vec2<f32>(0.06f, 0.06f));\n    let _e210 = gl_FragCoord_1[0u];\n    let _e216 = gl_FragCoord_1[1u];\n    tile = ((_e210 - (floor((_e210 / 4f)) * 4f)) + (4f * (_e216 - (floor((_e216 / 4f)) * 4f))));\n    let _e223 = tile;\n    turn = (_e223 * 0.3926991f);\n    sum = 0f;\n    i = 0i;\n    loop {\n        let _e225 = i;\n        if (_e225 < 12i) {\n            let _e227 = i;\n            t = ((f32(_e227) + 0.5f) / 12f);\n            let _e231 = turn;\n            let _e232 = i;\n            angle = (_e231 + (f32(_e232) * 2.3999631f));\n            let _e236 = vUv_1;\n            let _e237 = angle;\n            let _e239 = angle;\n            let _e242 = t;\n            let _e245 = reach;\n            uv_1 = (_e236 + ((vec2<f32>(cos(_e237), sin(_e239)) * sqrt(_e242)) * _e245));\n            let _e248 = uv_1;\n            let _e249 = textureSampleLevel(uDepth_t, uDepth_s, _e248, 0f);\n            sampled = _e249.x;\n            let _e251 = sampled;\n            if (_e251 <= 0f) {\n                continue;\n            }\n            let _e253 = uv_1;\n            param_10 = _e253;\n            let _e254 = sampled;\n            param_11 = _e254;\n            let _e255 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_10), (&param_11));\n            let _e256 = p;\n            v = (_e255 - _e256);\n            let _e258 = v;\n            let _e259 = v;\n            vv = dot(_e258, _e259);\n            let _e261 = vv;\n            let _e263 = unnamed.uRadius;\n            let _e265 = unnamed.uRadius;\n            if (_e261 > (_e263 * _e265)) {\n                continue;\n            }\n            let _e268 = v;\n            let _e269 = n;\n            let _e272 = p[2u];\n            let _e277 = vv;\n            let _e280 = sum;\n            sum = (_e280 + (max(0f, (dot(_e268, _e269) - (0.004f * -(_e272)))) / (_e277 + 0.01f)));\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e282 = i;\n            i = (_e282 + 1i);\n        }\n    }\n    let _e285 = unnamed.uRadius;\n    let _e287 = sum;\n    fragColor = clamp((1f - (((2f * _e285) * _e287) / 12f)), 0f, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>, @builtin(position) gl_FragCoord: vec4<f32>) -> @location(0) f32 {\n    vUv_1 = vUv;\n    gl_FragCoord_1 = gl_FragCoord;\n    main_1();\n    let _e5 = fragColor;\n    return _e5;\n}\n";
+export const AO_BLUR_FRAG_WGSL = "struct Uniforms {\n    uStep: vec2<f32>,\n    uDepthToViewZ: vec4<f32>,\n    uAoScale: f32,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\n@group(0) @binding(34) \nvar uDepth_t: texture_2d<f32>;\n@group(0) @binding(35) \nvar uDepth_s: sampler;\nvar<private> vUv_1: vec2<f32>;\n@group(0) @binding(32) \nvar uAo_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uAo_s: sampler;\nvar<private> fragColor: f32;\n\nfn viewZ_u0028_f1_u003b(depth: ptr<function, f32>) -> f32 {\n    var ndc: f32;\n\n    let _e22 = (*depth);\n    ndc = (1f - (_e22 * 2f));\n    let _e27 = unnamed.uDepthToViewZ[0u];\n    let _e28 = ndc;\n    let _e32 = unnamed.uDepthToViewZ[1u];\n    let _e36 = unnamed.uDepthToViewZ[2u];\n    let _e37 = ndc;\n    let _e41 = unnamed.uDepthToViewZ[3u];\n    return (((_e27 * _e28) + _e32) / ((_e36 * _e37) + _e41));\n}\n\nfn main_1() {\n    var depth_1: f32;\n    var own: f32;\n    var centre: f32;\n    var param: f32;\n    var inverse: f32;\n    var stepAfter: f32;\n    var param_1: f32;\n    var stepBefore: f32;\n    var param_2: f32;\n    var slope: f32;\n    var sum: f32;\n    var weight: f32;\n    var i: i32;\n    var uv: vec2<f32>;\n    var z: f32;\n    var param_3: f32;\n    var w: f32;\n    var blurred: f32;\n    var local: f32;\n\n    let _e39 = vUv_1;\n    let _e40 = textureSampleLevel(uDepth_t, uDepth_s, _e39, 0f);\n    depth_1 = _e40.x;\n    let _e42 = vUv_1;\n    let _e43 = textureSampleLevel(uAo_t, uAo_s, _e42, 0f);\n    own = _e43.x;\n    let _e45 = depth_1;\n    if (_e45 <= 0f) {\n        let _e47 = own;\n        let _e49 = unnamed.uAoScale;\n        fragColor = min((_e47 * _e49), 1f);\n        return;\n    }\n    let _e52 = depth_1;\n    param = _e52;\n    let _e53 = viewZ_u0028_f1_u003b((&param));\n    centre = _e53;\n    let _e54 = centre;\n    inverse = (1f / _e54);\n    let _e56 = vUv_1;\n    let _e58 = unnamed.uStep;\n    let _e60 = textureSampleLevel(uDepth_t, uDepth_s, (_e56 + _e58), 0f);\n    param_1 = _e60.x;\n    let _e62 = viewZ_u0028_f1_u003b((&param_1));\n    let _e64 = inverse;\n    stepAfter = ((1f / _e62) - _e64);\n    let _e66 = inverse;\n    let _e67 = vUv_1;\n    let _e69 = unnamed.uStep;\n    let _e71 = textureSampleLevel(uDepth_t, uDepth_s, (_e67 - _e69), 0f);\n    param_2 = _e71.x;\n    let _e73 = viewZ_u0028_f1_u003b((&param_2));\n    stepBefore = (_e66 - (1f / _e73));\n    let _e76 = stepAfter;\n    let _e78 = stepBefore;\n    let _e81 = stepAfter;\n    let _e82 = stepBefore;\n    slope = select(_e82, _e81, (abs(_e76) < abs(_e78)));\n    sum = 0f;\n    weight = 0f;\n    i = -3i;\n    loop {\n        let _e84 = i;\n        if (_e84 <= 4i) {\n            let _e86 = vUv_1;\n            let _e88 = unnamed.uStep;\n            let _e89 = i;\n            uv = (_e86 + (_e88 * f32(_e89)));\n            let _e93 = uv;\n            let _e94 = textureSampleLevel(uDepth_t, uDepth_s, _e93, 0f);\n            param_3 = _e94.x;\n            let _e96 = viewZ_u0028_f1_u003b((&param_3));\n            z = _e96;\n            let _e97 = z;\n            let _e98 = inverse;\n            let _e99 = slope;\n            let _e100 = i;\n            w = max(0f, (1f - (abs(((_e97 * (_e98 + (_e99 * f32(_e100)))) - 1f)) / 0.02f)));\n            let _e110 = uv;\n            let _e111 = textureSampleLevel(uAo_t, uAo_s, _e110, 0f);\n            let _e113 = w;\n            let _e115 = sum;\n            sum = (_e115 + (_e111.x * _e113));\n            let _e117 = w;\n            let _e118 = weight;\n            weight = (_e118 + _e117);\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e120 = i;\n            i = (_e120 + 1i);\n        }\n    }\n    let _e122 = weight;\n    if (_e122 > 0f) {\n        let _e124 = sum;\n        let _e125 = weight;\n        local = (_e124 / _e125);\n    } else {\n        let _e127 = own;\n        local = _e127;\n    }\n    let _e128 = local;\n    blurred = _e128;\n    let _e129 = blurred;\n    let _e131 = unnamed.uAoScale;\n    fragColor = min((_e129 * _e131), 1f);\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>) -> @location(0) f32 {\n    vUv_1 = vUv;\n    main_1();\n    let _e3 = fragColor;\n    return _e3;\n}\n";
+export const AO_FRAG_WGSL = "struct Uniforms {\n    uProjScale: vec2<f32>,\n    uInvProjection: mat4x4<f32>,\n    uRadius: f32,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vUv_1: vec2<f32>;\n@group(0) @binding(32) \nvar uDepth_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uDepth_s: sampler;\nvar<private> fragColor: f32;\nvar<private> gl_FragCoord_1: vec4<f32>;\n\nfn gtaoArc_u0028_f1_u003b_f1_u003b_f1_u003b(h0_: ptr<function, f32>, h1_: ptr<function, f32>, normal: ptr<function, f32>) -> f32 {\n    var c: f32;\n    var s2_: f32;\n\n    let _e40 = (*normal);\n    c = cos(_e40);\n    let _e42 = (*normal);\n    s2_ = (2f * sin(_e42));\n    let _e45 = (*h0_);\n    let _e47 = (*normal);\n    let _e51 = c;\n    let _e53 = (*h0_);\n    let _e54 = s2_;\n    let _e58 = (*h1_);\n    let _e60 = (*normal);\n    let _e64 = c;\n    let _e66 = (*h1_);\n    let _e67 = s2_;\n    return ((0.25f * ((-(cos(((2f * _e45) - _e47))) + _e51) + (_e53 * _e54))) + (0.25f * ((-(cos(((2f * _e58) - _e60))) + _e64) + (_e66 * _e67))));\n}\n\nfn viewPosition_u0028_vf2_u003b_f1_u003b(uv: ptr<function, vec2<f32>>, depth: ptr<function, f32>) -> vec3<f32> {\n    var clip: vec4<f32>;\n    var view: vec4<f32>;\n\n    let _e39 = (*uv);\n    let _e42 = ((_e39 * 2f) - vec2(1f));\n    let _e43 = (*depth);\n    clip = vec4<f32>(_e42.x, _e42.y, (1f - (_e43 * 2f)), 1f);\n    let _e50 = unnamed.uInvProjection;\n    let _e51 = clip;\n    view = (_e50 * _e51);\n    let _e53 = view;\n    let _e56 = view[3u];\n    return (_e53.xyz / vec3(_e56));\n}\n\nfn main_1() {\n    var stepX: vec2<f32>;\n    var stepY: vec2<f32>;\n    var depth_1: f32;\n    var p: vec3<f32>;\n    var param: vec2<f32>;\n    var param_1: f32;\n    var dpdx_: vec3<f32>;\n    var dpdy_: vec3<f32>;\n    var right: vec3<f32>;\n    var param_2: vec2<f32>;\n    var param_3: f32;\n    var left: vec3<f32>;\n    var param_4: vec2<f32>;\n    var param_5: f32;\n    var down: vec3<f32>;\n    var param_6: vec2<f32>;\n    var param_7: f32;\n    var up: vec3<f32>;\n    var param_8: vec2<f32>;\n    var param_9: f32;\n    var here: f32;\n    var edgeFloor: f32;\n    var rightGap: f32;\n    var leftGap: f32;\n    var downGap: f32;\n    var upGap: f32;\n    var n: vec3<f32>;\n    var toEye: vec3<f32>;\n    var reach: vec2<f32>;\n    var tile: f32;\n    var turn: f32;\n    var stagger: f32;\n    var pixel: vec2<f32>;\n    var visible: f32;\n    var slice: i32;\n    var angle: f32;\n    var screen: vec2<f32>;\n    var along: vec3<f32>;\n    var param_10: vec2<f32>;\n    var param_11: f32;\n    var across: vec3<f32>;\n    var axis: vec3<f32>;\n    var projected: vec3<f32>;\n    var projectedLength: f32;\n    var normalAngle: f32;\n    var horizon0_: f32;\n    var horizon1_: f32;\n    var k: i32;\n    var t: f32;\n    var stride: vec2<f32>;\n    var side: i32;\n    var uv_1: vec2<f32>;\n    var local: vec2<f32>;\n    var sampled: f32;\n    var v: vec3<f32>;\n    var param_12: vec2<f32>;\n    var param_13: f32;\n    var distance2_: f32;\n    var cosine: f32;\n    var fade: f32;\n    var local_1: f32;\n    var local_2: f32;\n    var h0_1: f32;\n    var h1_1: f32;\n    var param_14: f32;\n    var param_15: f32;\n    var param_16: f32;\n\n    let _e102 = vUv_1;\n    let _e103 = dpdx(_e102);\n    stepX = _e103;\n    let _e104 = vUv_1;\n    let _e105 = dpdy(_e104);\n    stepY = _e105;\n    let _e106 = vUv_1;\n    let _e107 = textureSampleLevel(uDepth_t, uDepth_s, _e106, 0f);\n    depth_1 = _e107.x;\n    let _e109 = vUv_1;\n    param = _e109;\n    let _e110 = depth_1;\n    param_1 = _e110;\n    let _e111 = viewPosition_u0028_vf2_u003b_f1_u003b((&param), (&param_1));\n    p = _e111;\n    let _e112 = p;\n    let _e113 = dpdx(_e112);\n    dpdx_ = _e113;\n    let _e114 = p;\n    let _e115 = dpdy(_e114);\n    dpdy_ = _e115;\n    let _e116 = depth_1;\n    if (_e116 <= 0f) {\n        fragColor = 1f;\n        return;\n    }\n    let _e118 = vUv_1;\n    let _e119 = stepX;\n    let _e121 = vUv_1;\n    let _e122 = stepX;\n    let _e124 = textureSampleLevel(uDepth_t, uDepth_s, (_e121 + _e122), 0f);\n    param_2 = (_e118 + _e119);\n    param_3 = _e124.x;\n    let _e126 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_2), (&param_3));\n    right = _e126;\n    let _e127 = vUv_1;\n    let _e128 = stepX;\n    let _e130 = vUv_1;\n    let _e131 = stepX;\n    let _e133 = textureSampleLevel(uDepth_t, uDepth_s, (_e130 - _e131), 0f);\n    param_4 = (_e127 - _e128);\n    param_5 = _e133.x;\n    let _e135 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_4), (&param_5));\n    left = _e135;\n    let _e136 = vUv_1;\n    let _e137 = stepY;\n    let _e139 = vUv_1;\n    let _e140 = stepY;\n    let _e142 = textureSampleLevel(uDepth_t, uDepth_s, (_e139 + _e140), 0f);\n    param_6 = (_e136 + _e137);\n    param_7 = _e142.x;\n    let _e144 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_6), (&param_7));\n    down = _e144;\n    let _e145 = vUv_1;\n    let _e146 = stepY;\n    let _e148 = vUv_1;\n    let _e149 = stepY;\n    let _e151 = textureSampleLevel(uDepth_t, uDepth_s, (_e148 - _e149), 0f);\n    param_8 = (_e145 - _e146);\n    param_9 = _e151.x;\n    let _e153 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_8), (&param_9));\n    up = _e153;\n    let _e155 = p[2u];\n    here = -(_e155);\n    let _e157 = here;\n    edgeFloor = (0.05f * _e157);\n    let _e160 = right[2u];\n    let _e162 = here;\n    rightGap = abs((-(_e160) - _e162));\n    let _e166 = left[2u];\n    let _e168 = here;\n    leftGap = abs((-(_e166) - _e168));\n    let _e172 = down[2u];\n    let _e174 = here;\n    downGap = abs((-(_e172) - _e174));\n    let _e178 = up[2u];\n    let _e180 = here;\n    upGap = abs((-(_e178) - _e180));\n    let _e183 = rightGap;\n    let _e184 = leftGap;\n    let _e186 = edgeFloor;\n    if (_e183 > ((_e184 * 8f) + _e186)) {\n        let _e189 = p;\n        let _e190 = left;\n        dpdx_ = (_e189 - _e190);\n    } else {\n        let _e192 = leftGap;\n        let _e193 = rightGap;\n        let _e195 = edgeFloor;\n        if (_e192 > ((_e193 * 8f) + _e195)) {\n            let _e198 = right;\n            let _e199 = p;\n            dpdx_ = (_e198 - _e199);\n        }\n    }\n    let _e201 = downGap;\n    let _e202 = upGap;\n    let _e204 = edgeFloor;\n    if (_e201 > ((_e202 * 8f) + _e204)) {\n        let _e207 = p;\n        let _e208 = up;\n        dpdy_ = (_e207 - _e208);\n    } else {\n        let _e210 = upGap;\n        let _e211 = downGap;\n        let _e213 = edgeFloor;\n        if (_e210 > ((_e211 * 8f) + _e213)) {\n            let _e216 = down;\n            let _e217 = p;\n            dpdy_ = (_e216 - _e217);\n        }\n    }\n    let _e219 = dpdx_;\n    let _e220 = dpdy_;\n    n = normalize(cross(_e219, _e220));\n    let _e223 = n;\n    let _e224 = p;\n    if (dot(_e223, _e224) > 0f) {\n        let _e227 = n;\n        n = -(_e227);\n    }\n    let _e229 = p;\n    toEye = normalize(-(_e229));\n    let _e233 = unnamed.uRadius;\n    let _e235 = unnamed.uProjScale;\n    let _e239 = p[2u];\n    reach = min((((_e235 * _e233) * 0.5f) / vec2(max(-(_e239), 0.001f))), vec2<f32>(0.06f, 0.06f));\n    let _e246 = gl_FragCoord_1[0u];\n    let _e252 = gl_FragCoord_1[1u];\n    tile = ((_e246 - (floor((_e246 / 4f)) * 4f)) + (4f * (_e252 - (floor((_e252 / 4f)) * 4f))));\n    let _e259 = tile;\n    turn = (_e259 * 0.098174766f);\n    let _e261 = tile;\n    stagger = fract((_e261 * 0.618034f));\n    let _e264 = stepX;\n    let _e266 = stepY;\n    pixel = vec2<f32>(length(_e264), length(_e266));\n    visible = 0f;\n    slice = 0i;\n    loop {\n        let _e269 = slice;\n        if (_e269 < 2i) {\n            let _e271 = turn;\n            let _e272 = slice;\n            angle = (_e271 + (f32(_e272) * 1.5707964f));\n            let _e276 = angle;\n            let _e279 = pixel[0u];\n            let _e282 = pixel[1u];\n            let _e284 = angle;\n            screen = vec2<f32>(((cos(_e276) * _e279) / _e282), sin(_e284));\n            let _e287 = vUv_1;\n            let _e288 = screen;\n            param_10 = (_e287 + (_e288 * 0.001f));\n            let _e291 = depth_1;\n            param_11 = _e291;\n            let _e292 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_10), (&param_11));\n            let _e293 = p;\n            along = normalize((_e292 - _e293));\n            let _e296 = along;\n            let _e297 = toEye;\n            let _e298 = along;\n            let _e299 = toEye;\n            across = normalize((_e296 - (_e297 * dot(_e298, _e299))));\n            let _e304 = across;\n            let _e305 = toEye;\n            axis = cross(_e304, _e305);\n            let _e307 = n;\n            let _e308 = axis;\n            let _e309 = n;\n            let _e310 = axis;\n            projected = (_e307 - (_e308 * dot(_e309, _e310)));\n            let _e314 = projected;\n            projectedLength = length(_e314);\n            let _e316 = projectedLength;\n            if (_e316 < 0.0001f) {\n                continue;\n            }\n            let _e318 = projected;\n            let _e319 = across;\n            let _e321 = projected;\n            let _e322 = toEye;\n            normalAngle = atan2(dot(_e318, _e319), dot(_e321, _e322));\n            horizon0_ = -1f;\n            horizon1_ = -1f;\n            k = 0i;\n            loop {\n                let _e325 = k;\n                if (_e325 < 6i) {\n                    let _e327 = k;\n                    let _e329 = stagger;\n                    t = ((f32(_e327) + _e329) / 6f);\n                    let _e332 = screen;\n                    let _e334 = reach[1u];\n                    let _e336 = t;\n                    let _e337 = t;\n                    stride = ((_e332 * _e334) * ((_e336 * _e337) + 0.013888889f));\n                    side = 0i;\n                    loop {\n                        let _e341 = side;\n                        if (_e341 < 2i) {\n                            let _e343 = side;\n                            if (_e343 == 0i) {\n                                let _e345 = vUv_1;\n                                let _e346 = stride;\n                                local = (_e345 - _e346);\n                            } else {\n                                let _e348 = vUv_1;\n                                let _e349 = stride;\n                                local = (_e348 + _e349);\n                            }\n                            let _e351 = local;\n                            uv_1 = _e351;\n                            let _e352 = uv_1;\n                            let _e353 = textureSampleLevel(uDepth_t, uDepth_s, _e352, 0f);\n                            sampled = _e353.x;\n                            let _e355 = sampled;\n                            if (_e355 <= 0f) {\n                                continue;\n                            }\n                            let _e357 = uv_1;\n                            param_12 = _e357;\n                            let _e358 = sampled;\n                            param_13 = _e358;\n                            let _e359 = viewPosition_u0028_vf2_u003b_f1_u003b((&param_12), (&param_13));\n                            let _e360 = p;\n                            v = (_e359 - _e360);\n                            let _e362 = v;\n                            let _e363 = v;\n                            distance2_ = dot(_e362, _e363);\n                            let _e365 = distance2_;\n                            if (_e365 < 0.00000001f) {\n                                continue;\n                            }\n                            let _e367 = v;\n                            let _e368 = toEye;\n                            let _e370 = distance2_;\n                            cosine = (dot(_e367, _e368) * inverseSqrt(_e370));\n                            let _e373 = distance2_;\n                            let _e375 = unnamed.uRadius;\n                            let _e377 = unnamed.uRadius;\n                            fade = clamp((1f - (_e373 / (_e375 * _e377))), 0f, 1f);\n                            let _e382 = cosine;\n                            let _e383 = fade;\n                            cosine = mix(-1f, _e382, _e383);\n                            let _e385 = side;\n                            if (_e385 == 0i) {\n                                let _e387 = cosine;\n                                let _e388 = horizon0_;\n                                if (_e387 > _e388) {\n                                    let _e390 = cosine;\n                                    local_1 = _e390;\n                                } else {\n                                    let _e391 = horizon0_;\n                                    let _e392 = cosine;\n                                    local_1 = mix(_e391, _e392, 0.2f);\n                                }\n                                let _e394 = local_1;\n                                horizon0_ = _e394;\n                            } else {\n                                let _e395 = cosine;\n                                let _e396 = horizon1_;\n                                if (_e395 > _e396) {\n                                    let _e398 = cosine;\n                                    local_2 = _e398;\n                                } else {\n                                    let _e399 = horizon1_;\n                                    let _e400 = cosine;\n                                    local_2 = mix(_e399, _e400, 0.2f);\n                                }\n                                let _e402 = local_2;\n                                horizon1_ = _e402;\n                            }\n                            continue;\n                        } else {\n                            break;\n                        }\n                        continuing {\n                            let _e403 = side;\n                            side = (_e403 + 1i);\n                        }\n                    }\n                    continue;\n                } else {\n                    break;\n                }\n                continuing {\n                    let _e405 = k;\n                    k = (_e405 + 1i);\n                }\n            }\n            let _e407 = horizon0_;\n            let _e411 = normalAngle;\n            h0_1 = max(-(acos(clamp(_e407, -1f, 1f))), (_e411 - 1.5707963f));\n            let _e414 = horizon1_;\n            let _e417 = normalAngle;\n            h1_1 = min(acos(clamp(_e414, -1f, 1f)), (_e417 + 1.5707963f));\n            let _e420 = projectedLength;\n            let _e421 = h0_1;\n            param_14 = _e421;\n            let _e422 = h1_1;\n            param_15 = _e422;\n            let _e423 = normalAngle;\n            param_16 = _e423;\n            let _e424 = gtaoArc_u0028_f1_u003b_f1_u003b_f1_u003b((&param_14), (&param_15), (&param_16));\n            let _e426 = visible;\n            visible = (_e426 + (_e420 * _e424));\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e428 = slice;\n            slice = (_e428 + 1i);\n        }\n    }\n    let _e430 = visible;\n    fragColor = clamp(((_e430 / 2f) * 0.5f), 0f, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>, @builtin(position) gl_FragCoord: vec4<f32>) -> @location(0) f32 {\n    vUv_1 = vUv;\n    gl_FragCoord_1 = gl_FragCoord;\n    main_1();\n    let _e5 = fragColor;\n    return _e5;\n}\n";
 /**
  * What the transform assigned, so the renderer binds the same numbers.
  *
@@ -14,7 +14,7 @@ export const AO_FRAG_WGSL = "struct Uniforms {\n    uProjScale: vec2<f32>,\n
 export const AMBIENTOCCLUSION_BINDINGS = {
     "AO_BLUR_FRAG": {
         "uniforms": 1,
-        "uniformSize": 32,
+        "uniformSize": 48,
         "fields": {
             "uStep": {
                 "offset": 0,
@@ -25,6 +25,11 @@ export const AMBIENTOCCLUSION_BINDINGS = {
                 "offset": 16,
                 "size": 16,
                 "type": "vec4"
+            },
+            "uAoScale": {
+                "offset": 32,
+                "size": 4,
+                "type": "float"
             }
         },
         "textures": {