@driftengine/core 4.4.2 → 4.5.0

package/src/render/shaders/generated/globalMedium.wgsl.ts

@@ -5,7 +5,7 @@
  * the next generation, and `npm run wgsl:check` fails the build when this is stale.
  */
 
-export const MEDIUM_FRAG_WGSL = "struct Uniforms {\n    uDepthToWorld: mat4x4<f32>,\n    uCameraPos: vec3<f32>,\n    uSunDir: vec3<f32>,\n    uSunColor: vec3<f32>,\n    uAmbient: vec3<f32>,\n    uDensity: f32,\n    uAlbedo: f32,\n    uAnisotropy: f32,\n    uMaxDistance: f32,\n    uSteps: i32,\n    uSunShadow: f32,\n    uLightViewProj: mat4x4<f32>,\n    uPeeledShadowEnabled: i32,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\n@group(0) @binding(34) \nvar uStaticShadowMap_t: texture_2d<f32>;\n@group(0) @binding(35) \nvar uStaticShadowMap_s: sampler;\n@group(0) @binding(36) \nvar uPeeledShadowMap_t: texture_2d<f32>;\n@group(0) @binding(37) \nvar uPeeledShadowMap_s: sampler;\n@group(0) @binding(38) \nvar uDynamicShadowMap_t: texture_2d<f32>;\n@group(0) @binding(39) \nvar uDynamicShadowMap_s: sampler;\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: vec4<f32>;\nvar<private> gl_FragCoord_1: vec4<f32>;\n\nfn occlusion_u0028_f1_u003b_f1_u003b(stored: ptr<function, f32>, compare: ptr<function, f32>) -> f32 {\n    let _e52 = (*compare);\n    let _e53 = (*stored);\n    return smoothstep(-0.0025f, 0.0025f, (_e52 - _e53));\n}\n\nfn sunReach_u0028_vf3_u003b(worldPos: ptr<function, vec3<f32>>) -> f32 {\n    var lightPos: vec4<f32>;\n    var p: vec3<f32>;\n    var fromCentre: vec2<f32>;\n    var edgeFade: f32;\n    var compare_1: f32;\n    var blocked: f32;\n    var param: f32;\n    var param_1: f32;\n    var param_2: f32;\n    var param_3: f32;\n    var param_4: f32;\n    var param_5: f32;\n    var phi_99_: bool;\n    var phi_106_: bool;\n    var phi_114_: bool;\n    var phi_121_: bool;\n\n    let _e64 = unnamed.uLightViewProj;\n    let _e65 = (*worldPos);\n    lightPos = (_e64 * vec4<f32>(_e65.x, _e65.y, _e65.z, 1f));\n    let _e72 = lightPos[3u];\n    if (_e72 <= 0f) {\n        return 1f;\n    }\n    let _e74 = lightPos;\n    let _e77 = lightPos[3u];\n    p = (((_e74.xyz / vec3(_e77)) * 0.5f) + vec3(0.5f));\n    let _e84 = p[2u];\n    let _e85 = (_e84 > 1f);\n    phi_99_ = _e85;\n    if !(_e85) {\n        let _e88 = p[0u];\n        phi_99_ = (_e88 < 0f);\n    }\n    let _e91 = phi_99_;\n    phi_106_ = _e91;\n    if !(_e91) {\n        let _e94 = p[0u];\n        phi_106_ = (_e94 > 1f);\n    }\n    let _e97 = phi_106_;\n    phi_114_ = _e97;\n    if !(_e97) {\n        let _e100 = p[1u];\n        phi_114_ = (_e100 < 0f);\n    }\n    let _e103 = phi_114_;\n    phi_121_ = _e103;\n    if !(_e103) {\n        let _e106 = p[1u];\n        phi_121_ = (_e106 > 1f);\n    }\n    let _e109 = phi_121_;\n    if _e109 {\n        return 1f;\n    }\n    let _e110 = p;\n    fromCentre = (abs((_e110.xy - vec2(0.5f))) * 2f);\n    let _e117 = fromCentre[0u];\n    let _e119 = fromCentre[1u];\n    edgeFade = (1f - smoothstep(0.72f, 0.98f, max(_e117, _e119)));\n    let _e124 = p[2u];\n    let _e127 = edgeFade;\n    edgeFade = (_e127 * (1f - smoothstep(0.9f, 1f, _e124)));\n    let _e129 = edgeFade;\n    if (_e129 <= 0f) {\n        return 1f;\n    }\n    let _e132 = p[2u];\n    compare_1 = (_e132 - 0.0015f);\n    let _e134 = p;\n    let _e136 = textureSampleLevel(uStaticShadowMap_t, uStaticShadowMap_s, _e134.xy, 0f);\n    param = _e136.x;\n    let _e138 = compare_1;\n    param_1 = _e138;\n    let _e139 = occlusion_u0028_f1_u003b_f1_u003b((&param), (&param_1));\n    blocked = _e139;\n    let _e141 = unnamed.uPeeledShadowEnabled;\n    if (_e141 != 0i) {\n        let _e143 = blocked;\n        let _e144 = p;\n        let _e146 = textureSampleLevel(uPeeledShadowMap_t, uPeeledShadowMap_s, _e144.xy, 0f);\n        param_2 = _e146.x;\n        let _e148 = compare_1;\n        param_3 = _e148;\n        let _e149 = occlusion_u0028_f1_u003b_f1_u003b((&param_2), (&param_3));\n        blocked = max(_e143, _e149);\n    }\n    let _e151 = blocked;\n    let _e152 = p;\n    let _e154 = textureSampleLevel(uDynamicShadowMap_t, uDynamicShadowMap_s, _e152.xy, 0f);\n    param_4 = _e154.x;\n    let _e156 = compare_1;\n    param_5 = _e156;\n    let _e157 = occlusion_u0028_f1_u003b_f1_u003b((&param_4), (&param_5));\n    blocked = max(_e151, _e157);\n    let _e159 = blocked;\n    let _e162 = unnamed.uSunShadow;\n    let _e163 = edgeFade;\n    return mix(1f, (1f - _e159), (_e162 * _e163));\n}\n\nfn phase_u0028_f1_u003b_f1_u003b(cosTheta: ptr<function, f32>, g: ptr<function, f32>) -> f32 {\n    var g2_: f32;\n    var d: f32;\n\n    let _e54 = (*g);\n    let _e55 = (*g);\n    g2_ = (_e54 * _e55);\n    let _e57 = g2_;\n    let _e59 = (*g);\n    let _e61 = (*cosTheta);\n    d = max(((1f + _e57) - ((2f * _e59) * _e61)), 0.0001f);\n    let _e65 = g2_;\n    let _e67 = d;\n    let _e69 = d;\n    return ((1f - _e65) / ((12.566371f * _e67) * sqrt(_e69)));\n}\n\nfn hash21_u0028_vf2_u003b(p_1: ptr<function, vec2<f32>>) -> f32 {\n    let _e51 = (*p_1);\n    return fract((sin(dot(_e51, vec2<f32>(127.1f, 311.7f))) * 43758.547f));\n}\n\nfn main_1() {\n    var ndc: vec2<f32>;\n    var probe: vec4<f32>;\n    var dir: vec3<f32>;\n    var stored_1: f32;\n    var far: f32;\n    var hit: vec4<f32>;\n    var steps: i32;\n    var dither: f32;\n    var param_6: vec2<f32>;\n    var scatter: f32;\n    var param_7: f32;\n    var param_8: f32;\n    var sunLit: vec3<f32>;\n    var skyLit: vec3<f32>;\n    var inscatter: vec3<f32>;\n    var transmittance: f32;\n    var previous: f32;\n    var i: i32;\n    var u: f32;\n    var next: f32;\n    var segment: f32;\n    var travelled: f32;\n    var segmentTransmittance: f32;\n    var scattered: f32;\n    var lit: f32;\n    var param_9: vec3<f32>;\n\n    let _e76 = vUv_1;\n    ndc = ((_e76 * 2f) - vec2(1f));\n    let _e81 = unnamed.uDepthToWorld;\n    let _e82 = ndc;\n    probe = (_e81 * vec4<f32>(_e82.x, _e82.y, 0.5f, 1f));\n    let _e87 = probe;\n    let _e90 = probe[3u];\n    let _e94 = unnamed.uCameraPos;\n    dir = normalize(((_e87.xyz / vec3(_e90)) - _e94));\n    let _e97 = vUv_1;\n    let _e98 = textureSampleLevel(uDepth_t, uDepth_s, _e97, 0f);\n    stored_1 = _e98.x;\n    let _e101 = unnamed.uMaxDistance;\n    far = _e101;\n    let _e102 = stored_1;\n    if !((_e102 <= 0f)) {\n        let _e106 = unnamed.uDepthToWorld;\n        let _e107 = ndc;\n        let _e108 = stored_1;\n        hit = (_e106 * vec4<f32>(_e107.x, _e107.y, _e108, 1f));\n        let _e114 = hit[3u];\n        if (_e114 > 0.000001f) {\n            let _e116 = far;\n            let _e117 = hit;\n            let _e120 = hit[3u];\n            let _e124 = unnamed.uCameraPos;\n            let _e126 = dir;\n            far = min(_e116, dot(((_e117.xyz / vec3(_e120)) - _e124), _e126));\n        }\n    }\n    let _e129 = far;\n    if (_e129 <= 0f) {\n        fragColor = vec4<f32>(0f, 0f, 0f, 1f);\n        return;\n    }\n    let _e132 = unnamed.uSteps;\n    steps = clamp(_e132, 1i, 64i);\n    let _e134 = gl_FragCoord_1;\n    param_6 = _e134.xy;\n    let _e136 = hash21_u0028_vf2_u003b((&param_6));\n    dither = (_e136 - 0.5f);\n    let _e139 = unnamed.uAlbedo;\n    let _e140 = dir;\n    let _e142 = unnamed.uSunDir;\n    param_7 = dot(_e140, _e142);\n    let _e145 = unnamed.uAnisotropy;\n    param_8 = _e145;\n    let _e146 = phase_u0028_f1_u003b_f1_u003b((&param_7), (&param_8));\n    scatter = (_e139 * _e146);\n    let _e149 = unnamed.uSunColor;\n    let _e150 = scatter;\n    sunLit = (_e149 * _e150);\n    let _e153 = unnamed.uAmbient;\n    let _e155 = unnamed.uAlbedo;\n    skyLit = ((_e153 * _e155) * 0.07957747f);\n    inscatter = vec3<f32>(0f, 0f, 0f);\n    transmittance = 1f;\n    previous = 0f;\n    i = 0i;\n    loop {\n        let _e158 = i;\n        if (_e158 < 64i) {\n            let _e160 = i;\n            let _e161 = steps;\n            if (_e160 >= _e161) {\n                break;\n            }\n            let _e163 = i;\n            let _e166 = steps;\n            u = (f32((_e163 + 1i)) / f32(_e166));\n            let _e169 = far;\n            let _e170 = u;\n            next = (_e169 * pow(_e170, 2f));\n            let _e173 = next;\n            let _e174 = previous;\n            segment = (_e173 - _e174);\n            let _e176 = previous;\n            let _e177 = next;\n            travelled = (0.5f * (_e176 + _e177));\n            let _e180 = next;\n            previous = _e180;\n            let _e182 = unnamed.uDensity;\n            let _e184 = segment;\n            segmentTransmittance = exp((-(_e182) * _e184));\n            let _e187 = segmentTransmittance;\n            scattered = (1f - _e187);\n            lit = 1f;\n            let _e190 = unnamed.uSunShadow;\n            if (_e190 > 0f) {\n                let _e193 = unnamed.uCameraPos;\n                let _e194 = dir;\n                let _e195 = travelled;\n                let _e196 = dither;\n                let _e197 = segment;\n                param_9 = (_e193 + (_e194 * (_e195 + (_e196 * _e197))));\n                let _e202 = sunReach_u0028_vf3_u003b((&param_9));\n                lit = _e202;\n            }\n            let _e203 = transmittance;\n            let _e204 = scattered;\n            let _e206 = sunLit;\n            let _e207 = lit;\n            let _e209 = skyLit;\n            let _e212 = inscatter;\n            inscatter = (_e212 + (((_e206 * _e207) + _e209) * (_e203 * _e204)));\n            let _e214 = segmentTransmittance;\n            let _e215 = transmittance;\n            transmittance = (_e215 * _e214);\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e217 = i;\n            i = (_e217 + 1i);\n        }\n    }\n    let _e219 = inscatter;\n    let _e220 = (_e219 * 12.566371f);\n    let _e221 = transmittance;\n    fragColor = vec4<f32>(_e220.x, _e220.y, _e220.z, _e221);\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>, @builtin(position) gl_FragCoord: vec4<f32>) -> @location(0) vec4<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 MEDIUM_FRAG_WGSL = "struct Uniforms {\n    uDepthToWorld: mat4x4<f32>,\n    uCameraPos: vec3<f32>,\n    uSunDir: vec3<f32>,\n    uSunColor: vec3<f32>,\n    uAmbient: vec3<f32>,\n    uDensity: f32,\n    uAlbedo: f32,\n    uAnisotropy: f32,\n    uMaxDistance: f32,\n    uSteps: i32,\n    uSunShadow: f32,\n    uLightViewProj: mat4x4<f32>,\n    uPeeledShadowEnabled: i32,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\n@group(0) @binding(34) \nvar uSunShadows_t: texture_2d_array<f32>;\n@group(0) @binding(35) \nvar uSunShadows_s: sampler;\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: vec4<f32>;\nvar<private> gl_FragCoord_1: vec4<f32>;\n\nfn occlusion_u0028_f1_u003b_f1_u003b(stored: ptr<function, f32>, compare: ptr<function, f32>) -> f32 {\n    let _e48 = (*compare);\n    let _e49 = (*stored);\n    return smoothstep(-0.0025f, 0.0025f, (_e48 - _e49));\n}\n\nfn sunReach_u0028_vf3_u003b(worldPos: ptr<function, vec3<f32>>) -> f32 {\n    var lightPos: vec4<f32>;\n    var p: vec3<f32>;\n    var fromCentre: vec2<f32>;\n    var edgeFade: f32;\n    var compare_1: f32;\n    var blocked: f32;\n    var param: f32;\n    var param_1: f32;\n    var param_2: f32;\n    var param_3: f32;\n    var param_4: f32;\n    var param_5: f32;\n    var phi_99_: bool;\n    var phi_106_: bool;\n    var phi_114_: bool;\n    var phi_121_: bool;\n\n    let _e60 = unnamed.uLightViewProj;\n    let _e61 = (*worldPos);\n    lightPos = (_e60 * vec4<f32>(_e61.x, _e61.y, _e61.z, 1f));\n    let _e68 = lightPos[3u];\n    if (_e68 <= 0f) {\n        return 1f;\n    }\n    let _e70 = lightPos;\n    let _e73 = lightPos[3u];\n    p = (((_e70.xyz / vec3(_e73)) * 0.5f) + vec3(0.5f));\n    let _e80 = p[2u];\n    let _e81 = (_e80 > 1f);\n    phi_99_ = _e81;\n    if !(_e81) {\n        let _e84 = p[0u];\n        phi_99_ = (_e84 < 0f);\n    }\n    let _e87 = phi_99_;\n    phi_106_ = _e87;\n    if !(_e87) {\n        let _e90 = p[0u];\n        phi_106_ = (_e90 > 1f);\n    }\n    let _e93 = phi_106_;\n    phi_114_ = _e93;\n    if !(_e93) {\n        let _e96 = p[1u];\n        phi_114_ = (_e96 < 0f);\n    }\n    let _e99 = phi_114_;\n    phi_121_ = _e99;\n    if !(_e99) {\n        let _e102 = p[1u];\n        phi_121_ = (_e102 > 1f);\n    }\n    let _e105 = phi_121_;\n    if _e105 {\n        return 1f;\n    }\n    let _e106 = p;\n    fromCentre = (abs((_e106.xy - vec2(0.5f))) * 2f);\n    let _e113 = fromCentre[0u];\n    let _e115 = fromCentre[1u];\n    edgeFade = (1f - smoothstep(0.72f, 0.98f, max(_e113, _e115)));\n    let _e120 = p[2u];\n    let _e123 = edgeFade;\n    edgeFade = (_e123 * (1f - smoothstep(0.9f, 1f, _e120)));\n    let _e125 = edgeFade;\n    if (_e125 <= 0f) {\n        return 1f;\n    }\n    let _e128 = p[2u];\n    compare_1 = (_e128 - 0.0015f);\n    let _e130 = p;\n    let _e131 = _e130.xy;\n    let _e134 = vec3<f32>(_e131.x, _e131.y, 0f);\n    let _e140 = textureSampleLevel(uSunShadows_t, uSunShadows_s, vec2<f32>(_e134.x, _e134.y), i32(_e134.z), 0f);\n    param = _e140.x;\n    let _e142 = compare_1;\n    param_1 = _e142;\n    let _e143 = occlusion_u0028_f1_u003b_f1_u003b((&param), (&param_1));\n    blocked = _e143;\n    let _e145 = unnamed.uPeeledShadowEnabled;\n    if (_e145 != 0i) {\n        let _e147 = blocked;\n        let _e148 = p;\n        let _e149 = _e148.xy;\n        let _e152 = vec3<f32>(_e149.x, _e149.y, 2f);\n        let _e158 = textureSampleLevel(uSunShadows_t, uSunShadows_s, vec2<f32>(_e152.x, _e152.y), i32(_e152.z), 0f);\n        param_2 = _e158.x;\n        let _e160 = compare_1;\n        param_3 = _e160;\n        let _e161 = occlusion_u0028_f1_u003b_f1_u003b((&param_2), (&param_3));\n        blocked = max(_e147, _e161);\n    }\n    let _e163 = blocked;\n    let _e164 = p;\n    let _e165 = _e164.xy;\n    let _e168 = vec3<f32>(_e165.x, _e165.y, 1f);\n    let _e174 = textureSampleLevel(uSunShadows_t, uSunShadows_s, vec2<f32>(_e168.x, _e168.y), i32(_e168.z), 0f);\n    param_4 = _e174.x;\n    let _e176 = compare_1;\n    param_5 = _e176;\n    let _e177 = occlusion_u0028_f1_u003b_f1_u003b((&param_4), (&param_5));\n    blocked = max(_e163, _e177);\n    let _e179 = blocked;\n    let _e182 = unnamed.uSunShadow;\n    let _e183 = edgeFade;\n    return mix(1f, (1f - _e179), (_e182 * _e183));\n}\n\nfn phase_u0028_f1_u003b_f1_u003b(cosTheta: ptr<function, f32>, g: ptr<function, f32>) -> f32 {\n    var g2_: f32;\n    var d: f32;\n\n    let _e50 = (*g);\n    let _e51 = (*g);\n    g2_ = (_e50 * _e51);\n    let _e53 = g2_;\n    let _e55 = (*g);\n    let _e57 = (*cosTheta);\n    d = max(((1f + _e53) - ((2f * _e55) * _e57)), 0.0001f);\n    let _e61 = g2_;\n    let _e63 = d;\n    let _e65 = d;\n    return ((1f - _e61) / ((12.566371f * _e63) * sqrt(_e65)));\n}\n\nfn hash21_u0028_vf2_u003b(p_1: ptr<function, vec2<f32>>) -> f32 {\n    let _e47 = (*p_1);\n    return fract((sin(dot(_e47, vec2<f32>(127.1f, 311.7f))) * 43758.547f));\n}\n\nfn main_1() {\n    var ndc: vec2<f32>;\n    var probe: vec4<f32>;\n    var dir: vec3<f32>;\n    var stored_1: f32;\n    var far: f32;\n    var hit: vec4<f32>;\n    var steps: i32;\n    var dither: f32;\n    var param_6: vec2<f32>;\n    var scatter: f32;\n    var param_7: f32;\n    var param_8: f32;\n    var sunLit: vec3<f32>;\n    var skyLit: vec3<f32>;\n    var inscatter: vec3<f32>;\n    var transmittance: f32;\n    var previous: f32;\n    var i: i32;\n    var u: f32;\n    var next: f32;\n    var segment: f32;\n    var travelled: f32;\n    var segmentTransmittance: f32;\n    var scattered: f32;\n    var lit: f32;\n    var param_9: vec3<f32>;\n\n    let _e72 = vUv_1;\n    ndc = ((_e72 * 2f) - vec2(1f));\n    let _e77 = unnamed.uDepthToWorld;\n    let _e78 = ndc;\n    probe = (_e77 * vec4<f32>(_e78.x, _e78.y, 0.5f, 1f));\n    let _e83 = probe;\n    let _e86 = probe[3u];\n    let _e90 = unnamed.uCameraPos;\n    dir = normalize(((_e83.xyz / vec3(_e86)) - _e90));\n    let _e93 = vUv_1;\n    let _e94 = textureSampleLevel(uDepth_t, uDepth_s, _e93, 0f);\n    stored_1 = _e94.x;\n    let _e97 = unnamed.uMaxDistance;\n    far = _e97;\n    let _e98 = stored_1;\n    if !((_e98 <= 0f)) {\n        let _e102 = unnamed.uDepthToWorld;\n        let _e103 = ndc;\n        let _e104 = stored_1;\n        hit = (_e102 * vec4<f32>(_e103.x, _e103.y, _e104, 1f));\n        let _e110 = hit[3u];\n        if (_e110 > 0.000001f) {\n            let _e112 = far;\n            let _e113 = hit;\n            let _e116 = hit[3u];\n            let _e120 = unnamed.uCameraPos;\n            let _e122 = dir;\n            far = min(_e112, dot(((_e113.xyz / vec3(_e116)) - _e120), _e122));\n        }\n    }\n    let _e125 = far;\n    if (_e125 <= 0f) {\n        fragColor = vec4<f32>(0f, 0f, 0f, 1f);\n        return;\n    }\n    let _e128 = unnamed.uSteps;\n    steps = clamp(_e128, 1i, 64i);\n    let _e130 = gl_FragCoord_1;\n    param_6 = _e130.xy;\n    let _e132 = hash21_u0028_vf2_u003b((&param_6));\n    dither = (_e132 - 0.5f);\n    let _e135 = unnamed.uAlbedo;\n    let _e136 = dir;\n    let _e138 = unnamed.uSunDir;\n    param_7 = dot(_e136, _e138);\n    let _e141 = unnamed.uAnisotropy;\n    param_8 = _e141;\n    let _e142 = phase_u0028_f1_u003b_f1_u003b((&param_7), (&param_8));\n    scatter = (_e135 * _e142);\n    let _e145 = unnamed.uSunColor;\n    let _e146 = scatter;\n    sunLit = (_e145 * _e146);\n    let _e149 = unnamed.uAmbient;\n    let _e151 = unnamed.uAlbedo;\n    skyLit = ((_e149 * _e151) * 0.07957747f);\n    inscatter = vec3<f32>(0f, 0f, 0f);\n    transmittance = 1f;\n    previous = 0f;\n    i = 0i;\n    loop {\n        let _e154 = i;\n        if (_e154 < 64i) {\n            let _e156 = i;\n            let _e157 = steps;\n            if (_e156 >= _e157) {\n                break;\n            }\n            let _e159 = i;\n            let _e162 = steps;\n            u = (f32((_e159 + 1i)) / f32(_e162));\n            let _e165 = far;\n            let _e166 = u;\n            next = (_e165 * pow(_e166, 2f));\n            let _e169 = next;\n            let _e170 = previous;\n            segment = (_e169 - _e170);\n            let _e172 = previous;\n            let _e173 = next;\n            travelled = (0.5f * (_e172 + _e173));\n            let _e176 = next;\n            previous = _e176;\n            let _e178 = unnamed.uDensity;\n            let _e180 = segment;\n            segmentTransmittance = exp((-(_e178) * _e180));\n            let _e183 = segmentTransmittance;\n            scattered = (1f - _e183);\n            lit = 1f;\n            let _e186 = unnamed.uSunShadow;\n            if (_e186 > 0f) {\n                let _e189 = unnamed.uCameraPos;\n                let _e190 = dir;\n                let _e191 = travelled;\n                let _e192 = dither;\n                let _e193 = segment;\n                param_9 = (_e189 + (_e190 * (_e191 + (_e192 * _e193))));\n                let _e198 = sunReach_u0028_vf3_u003b((&param_9));\n                lit = _e198;\n            }\n            let _e199 = transmittance;\n            let _e200 = scattered;\n            let _e202 = sunLit;\n            let _e203 = lit;\n            let _e205 = skyLit;\n            let _e208 = inscatter;\n            inscatter = (_e208 + (((_e202 * _e203) + _e205) * (_e199 * _e200)));\n            let _e210 = segmentTransmittance;\n            let _e211 = transmittance;\n            transmittance = (_e211 * _e210);\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e213 = i;\n            i = (_e213 + 1i);\n        }\n    }\n    let _e215 = inscatter;\n    let _e216 = (_e215 * 12.566371f);\n    let _e217 = transmittance;\n    fragColor = vec4<f32>(_e216.x, _e216.y, _e216.z, _e217);\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>, @builtin(position) gl_FragCoord: vec4<f32>) -> @location(0) vec4<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 MEDIUM_UPSAMPLE_FRAG_WGSL = "struct Uniforms {\n    uMediumTexel: 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 uMedium_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uMedium_s: sampler;\nvar<private> fragColor: vec4<f32>;\n\nfn viewDistance_u0028_f1_u003b(stored: ptr<function, f32>) -> f32 {\n    var ndc: f32;\n\n    let _e27 = (*stored);\n    ndc = (1f - (_e27 * 2f));\n    let _e32 = unnamed.uDepthToViewZ[0u];\n    let _e33 = ndc;\n    let _e37 = unnamed.uDepthToViewZ[1u];\n    let _e41 = unnamed.uDepthToViewZ[2u];\n    let _e42 = ndc;\n    let _e46 = unnamed.uDepthToViewZ[3u];\n    return abs((((_e32 * _e33) + _e37) / ((_e41 * _e42) + _e46)));\n}\n\nfn main_1() {\n    var here: f32;\n    var param: f32;\n    var coord: vec2<f32>;\n    var base: vec2<f32>;\n    var f: vec2<f32>;\n    var total: vec4<f32>;\n    var weight: f32;\n    var nearest: vec4<f32>;\n    var nearestGap: f32;\n    var i: i32;\n    var offset: vec2<f32>;\n    var uv: vec2<f32>;\n    var bilinear: f32;\n    var there: f32;\n    var param_1: f32;\n    var gap: f32;\n    var sampled: vec4<f32>;\n    var depthWeight: f32;\n    var local: vec4<f32>;\n\n    let _e44 = vUv_1;\n    let _e45 = textureSampleLevel(uDepth_t, uDepth_s, _e44, 0f);\n    param = _e45.x;\n    let _e47 = viewDistance_u0028_f1_u003b((&param));\n    here = _e47;\n    let _e48 = vUv_1;\n    let _e50 = unnamed.uMediumTexel;\n    coord = ((_e48 / _e50) - vec2(0.5f));\n    let _e54 = coord;\n    base = floor(_e54);\n    let _e56 = coord;\n    let _e57 = base;\n    f = (_e56 - _e57);\n    total = vec4<f32>(0f, 0f, 0f, 0f);\n    weight = 0f;\n    nearest = vec4<f32>(0f, 0f, 0f, 1f);\n    nearestGap = 1000000000000000000000000000000f;\n    i = 0i;\n    loop {\n        let _e59 = i;\n        if (_e59 < 4i) {\n            let _e61 = i;\n            let _e64 = i;\n            offset = vec2<f32>(f32((_e61 & 1i)), f32(((_e64 >> bitcast<u32>(1i)) & 1i)));\n            let _e70 = base;\n            let _e71 = offset;\n            let _e76 = unnamed.uMediumTexel;\n            uv = (((_e70 + _e71) + vec2(0.5f)) * _e76);\n            let _e79 = f[0u];\n            let _e82 = f[0u];\n            let _e84 = offset[0u];\n            let _e87 = f[1u];\n            let _e90 = f[1u];\n            let _e92 = offset[1u];\n            bilinear = (mix((1f - _e79), _e82, _e84) * mix((1f - _e87), _e90, _e92));\n            let _e95 = uv;\n            let _e96 = textureSampleLevel(uDepth_t, uDepth_s, _e95, 0f);\n            param_1 = _e96.x;\n            let _e98 = viewDistance_u0028_f1_u003b((&param_1));\n            there = _e98;\n            let _e99 = there;\n            let _e100 = here;\n            let _e103 = there;\n            let _e104 = here;\n            gap = (abs((_e99 - _e100)) / max(min(_e103, _e104), 0.001f));\n            let _e108 = uv;\n            let _e109 = textureSampleLevel(uMedium_t, uMedium_s, _e108, 0f);\n            sampled = _e109;\n            let _e110 = gap;\n            let _e111 = nearestGap;\n            if (_e110 < _e111) {\n                let _e113 = gap;\n                nearestGap = _e113;\n                let _e114 = sampled;\n                nearest = _e114;\n            }\n            let _e115 = gap;\n            depthWeight = (1f - smoothstep(0.04f, 0.05f, _e115));\n            let _e118 = sampled;\n            let _e119 = bilinear;\n            let _e121 = depthWeight;\n            let _e123 = total;\n            total = (_e123 + ((_e118 * _e119) * _e121));\n            let _e125 = bilinear;\n            let _e126 = depthWeight;\n            let _e128 = weight;\n            weight = (_e128 + (_e125 * _e126));\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e130 = i;\n            i = (_e130 + 1i);\n        }\n    }\n    let _e132 = weight;\n    if (_e132 > 0.0001f) {\n        let _e134 = total;\n        let _e135 = weight;\n        local = (_e134 / vec4(_e135));\n    } else {\n        let _e138 = nearest;\n        local = _e138;\n    }\n    let _e139 = local;\n    fragColor = _e139;\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>) -> @location(0) vec4<f32> {\n    vUv_1 = vUv;\n    main_1();\n    let _e3 = fragColor;\n    return _e3;\n}\n";
 
@@ -91,20 +91,10 @@ export const GLOBALMEDIUM_BINDINGS = {
         "sampler": 33,
         "type": "sampler2D"
       },
-      "uStaticShadowMap": {
+      "uSunShadows": {
         "texture": 34,
         "sampler": 35,
-        "type": "sampler2D"
-      },
-      "uPeeledShadowMap": {
-        "texture": 36,
-        "sampler": 37,
-        "type": "sampler2D"
-      },
-      "uDynamicShadowMap": {
-        "texture": 38,
-        "sampler": 39,
-        "type": "sampler2D"
+        "type": "sampler2DArray"
       }
     }
   },

package/src/render/shaders/generated/lightVolume.wgsl.ts

@@ -10,7 +10,7 @@ export const LIGHT_VOLUME_VERT_WGSL = "struct Uniforms {\n    uViewProj: mat4x4<
 /** One entry per permutation, keyed by the flags that are on. See `variantKey`. */
 export const LIGHT_VOLUME_FRAG_WGSL: Readonly<Record<string, string>> = {
   "none": "struct Uniforms {\n    uCameraPos: vec3<f32>,\n    uStrength: f32,\n    uLength: f32,\n    uSpread: f32,\n    uDust: f32,\n    uDustScale: f32,\n    uDustOffset: vec3<f32>,\n    uNear: f32,\n    uCameraLocal: vec3<f32>,\n    uModelWorld: mat4x4<f32>,\n    uSamples: i32,\n    uSceneDepthEnabled: i32,\n    uInvViewport: vec2<f32>,\n    uDepthToLocal: mat4x4<f32>,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vLocal_1: vec3<f32>;\nvar<private> gl_FragCoord_1: vec4<f32>;\n@group(0) @binding(32) \nvar uSceneDepth_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uSceneDepth_s: sampler;\nvar<private> fragColor: vec4<f32>;\nvar<private> vColor_1: vec3<f32>;\nvar<private> vEnergy_1: f32;\nvar<private> vNormal_1: vec3<f32>;\nvar<private> vWorldPos_1: vec3<f32>;\n\nfn hash31_u0028_vf3_u003b(p: ptr<function, vec3<f32>>) -> f32 {\n    let _e77 = (*p);\n    return fract((sin(dot(_e77, vec3<f32>(127.1f, 311.7f, 74.7f))) * 43758.547f));\n}\n\nfn volumeNoise_u0028_vf3_u003b(p_1: ptr<function, vec3<f32>>) -> f32 {\n    var i: vec3<f32>;\n    var f: vec3<f32>;\n    var u: vec3<f32>;\n    var x00_: f32;\n    var param: vec3<f32>;\n    var param_1: vec3<f32>;\n    var x10_: f32;\n    var param_2: vec3<f32>;\n    var param_3: vec3<f32>;\n    var x01_: f32;\n    var param_4: vec3<f32>;\n    var param_5: vec3<f32>;\n    var x11_: f32;\n    var param_6: vec3<f32>;\n    var param_7: vec3<f32>;\n\n    let _e92 = (*p_1);\n    i = floor(_e92);\n    let _e94 = (*p_1);\n    f = fract(_e94);\n    let _e96 = f;\n    let _e97 = f;\n    let _e99 = f;\n    u = ((_e96 * _e97) * (vec3(3f) - (_e99 * 2f)));\n    let _e104 = i;\n    param = (_e104 + vec3<f32>(0f, 0f, 0f));\n    let _e106 = hash31_u0028_vf3_u003b((&param));\n    let _e107 = i;\n    param_1 = (_e107 + vec3<f32>(1f, 0f, 0f));\n    let _e109 = hash31_u0028_vf3_u003b((&param_1));\n    let _e111 = u[0u];\n    x00_ = mix(_e106, _e109, _e111);\n    let _e113 = i;\n    param_2 = (_e113 + vec3<f32>(0f, 1f, 0f));\n    let _e115 = hash31_u0028_vf3_u003b((&param_2));\n    let _e116 = i;\n    param_3 = (_e116 + vec3<f32>(1f, 1f, 0f));\n    let _e118 = hash31_u0028_vf3_u003b((&param_3));\n    let _e120 = u[0u];\n    x10_ = mix(_e115, _e118, _e120);\n    let _e122 = i;\n    param_4 = (_e122 + vec3<f32>(0f, 0f, 1f));\n    let _e124 = hash31_u0028_vf3_u003b((&param_4));\n    let _e125 = i;\n    param_5 = (_e125 + vec3<f32>(1f, 0f, 1f));\n    let _e127 = hash31_u0028_vf3_u003b((&param_5));\n    let _e129 = u[0u];\n    x01_ = mix(_e124, _e127, _e129);\n    let _e131 = i;\n    param_6 = (_e131 + vec3<f32>(0f, 1f, 1f));\n    let _e133 = hash31_u0028_vf3_u003b((&param_6));\n    let _e134 = i;\n    param_7 = (_e134 + vec3<f32>(1f, 1f, 1f));\n    let _e136 = hash31_u0028_vf3_u003b((&param_7));\n    let _e138 = u[0u];\n    x11_ = mix(_e133, _e136, _e138);\n    let _e140 = x00_;\n    let _e141 = x10_;\n    let _e143 = u[1u];\n    let _e145 = x01_;\n    let _e146 = x11_;\n    let _e148 = u[1u];\n    let _e151 = u[2u];\n    return mix(mix(_e140, _e141, _e143), mix(_e145, _e146, _e148), _e151);\n}\n\nfn dustField_u0028_vf3_u003b(p_2: ptr<function, vec3<f32>>) -> f32 {\n    var param_8: vec3<f32>;\n    var param_9: vec3<f32>;\n\n    let _e79 = (*p_2);\n    param_8 = _e79;\n    let _e80 = volumeNoise_u0028_vf3_u003b((&param_8));\n    let _e82 = (*p_2);\n    param_9 = ((_e82 * 2.17f) + vec3(19.3f));\n    let _e86 = volumeNoise_u0028_vf3_u003b((&param_9));\n    return ((_e80 * 0.65f) + (_e86 * 0.35f));\n}\n\nfn densityAt_u0028_vf3_u003b_f1_u003b(local: ptr<function, vec3<f32>>, near: ptr<function, f32>) -> f32 {\n    var drawn: f32;\n    var along: f32;\n    var openness: f32;\n    var across: f32;\n\n    let _e83 = unnamed.uLength;\n    let _e84 = (*near);\n    drawn = max((_e83 - _e84), 0.0001f);\n    let _e88 = (*local)[2u];\n    let _e89 = (*near);\n    let _e91 = drawn;\n    along = clamp(((_e88 - _e89) / _e91), 0f, 1f);\n    let _e94 = (*local);\n    let _e98 = (*local)[2u];\n    openness = (length(_e94.xy) / max(_e98, 0.001f));\n    let _e101 = openness;\n    let _e103 = unnamed.uSpread;\n    across = clamp((_e101 / max(_e103, 0.0001f)), 0f, 1f);\n    let _e107 = along;\n    let _e110 = across;\n    return (pow((1f - _e107), 1.3f) * pow((1f - _e110), 2f));\n}\n\nfn main_1() {\n    var origin: vec3<f32>;\n    var toFragment: vec3<f32>;\n    var span: f32;\n    var dir: vec3<f32>;\n    var local_1: vec3<f32>;\n    var near_1: f32;\n    var enter: f32;\n    var leave: f32;\n    var toNear: f32;\n    var toFar: f32;\n    var reach: f32;\n    var ca: f32;\n    var cb: f32;\n    var cc: f32;\n    var disc: f32;\n    var root: f32;\n    var uv: vec2<f32>;\n    var stored: f32;\n    var hit: vec4<f32>;\n    var samples: i32;\n    var step_: f32;\n    var cell: i32;\n    var shadowOffset: f32;\n    var indexable: array<f32, 16>;\n    var param_10: vec3<f32>;\n    var total: f32;\n    var i_1: i32;\n    var travelled: f32;\n    var local_2: vec3<f32>;\n    var density: f32;\n    var param_11: vec3<f32>;\n    var param_12: f32;\n    var world: vec3<f32>;\n    var param_13: vec3<f32>;\n    var reference: f32;\n    var lit: f32;\n    var phi_282_: bool;\n\n    let _e113 = unnamed.uCameraLocal;\n    origin = _e113;\n    let _e114 = vLocal_1;\n    let _e115 = origin;\n    toFragment = (_e114 - _e115);\n    let _e117 = toFragment;\n    span = length(_e117);\n    let _e119 = span;\n    if (_e119 > 0.00001f) {\n        let _e121 = toFragment;\n        let _e122 = span;\n        local_1 = (_e121 / vec3(_e122));\n    } else {\n        local_1 = vec3<f32>(0f, 0f, 1f);\n    }\n    let _e125 = local_1;\n    dir = _e125;\n    let _e127 = unnamed.uNear;\n    let _e129 = unnamed.uLength;\n    near_1 = min(_e127, _e129);\n    enter = 0f;\n    let _e132 = unnamed.uLength;\n    leave = (_e132 * 2f);\n    let _e135 = dir[2u];\n    if (abs(_e135) > 0.00001f) {\n        let _e138 = near_1;\n        let _e140 = origin[2u];\n        let _e143 = dir[2u];\n        toNear = ((_e138 - _e140) / _e143);\n        let _e146 = unnamed.uLength;\n        let _e148 = origin[2u];\n        let _e151 = dir[2u];\n        toFar = ((_e146 - _e148) / _e151);\n        let _e153 = toNear;\n        let _e154 = toFar;\n        enter = min(_e153, _e154);\n        let _e156 = toNear;\n        let _e157 = toFar;\n        leave = max(_e156, _e157);\n    } else {\n        let _e160 = origin[2u];\n        let _e161 = near_1;\n        let _e162 = (_e160 < _e161);\n        phi_282_ = _e162;\n        if !(_e162) {\n            let _e165 = origin[2u];\n            let _e167 = unnamed.uLength;\n            phi_282_ = (_e165 > _e167);\n        }\n        let _e170 = phi_282_;\n        if _e170 {\n            discard;\n        }\n    }\n    let _e172 = unnamed.uSpread;\n    let _e174 = unnamed.uLength;\n    reach = ((_e172 * _e174) * 1.05f);\n    let _e177 = dir;\n    let _e179 = dir;\n    ca = dot(_e177.xy, _e179.xy);\n    let _e182 = origin;\n    let _e184 = dir;\n    cb = (2f * dot(_e182.xy, _e184.xy));\n    let _e188 = origin;\n    let _e190 = origin;\n    let _e193 = reach;\n    let _e194 = reach;\n    cc = (dot(_e188.xy, _e190.xy) - (_e193 * _e194));\n    let _e197 = ca;\n    if (_e197 > 0.00000001f) {\n        let _e199 = cb;\n        let _e200 = cb;\n        let _e202 = ca;\n        let _e204 = cc;\n        disc = ((_e199 * _e200) - ((4f * _e202) * _e204));\n        let _e207 = disc;\n        if (_e207 <= 0f) {\n            discard;\n        }\n        let _e209 = disc;\n        root = sqrt(_e209);\n        let _e211 = enter;\n        let _e212 = cb;\n        let _e214 = root;\n        let _e216 = ca;\n        enter = max(_e211, ((-(_e212) - _e214) / (2f * _e216)));\n        let _e220 = leave;\n        let _e221 = cb;\n        let _e223 = root;\n        let _e225 = ca;\n        leave = min(_e220, ((-(_e221) + _e223) / (2f * _e225)));\n    } else {\n        let _e229 = cc;\n        if (_e229 > 0f) {\n            discard;\n        }\n    }\n    let _e231 = enter;\n    enter = max(_e231, 0f);\n    let _e233 = leave;\n    let _e234 = enter;\n    let _e236 = unnamed.uLength;\n    leave = min(_e233, (_e234 + (_e236 * 2f)));\n    let _e241 = unnamed.uSceneDepthEnabled;\n    if (_e241 != 0i) {\n        let _e243 = gl_FragCoord_1;\n        let _e246 = unnamed.uInvViewport;\n        uv = (_e243.xy * _e246);\n        let _e248 = uv;\n        let _e249 = textureSampleLevel(uSceneDepth_t, uSceneDepth_s, _e248, 0f);\n        stored = _e249.x;\n        let _e252 = unnamed.uDepthToLocal;\n        let _e253 = uv;\n        let _e256 = ((_e253 * 2f) - vec2(1f));\n        let _e257 = stored;\n        hit = (_e252 * vec4<f32>(_e256.x, _e256.y, _e257, 1f));\n        let _e263 = hit[3u];\n        if (_e263 > 0.000001f) {\n            let _e265 = leave;\n            let _e266 = hit;\n            let _e269 = hit[3u];\n            let _e272 = origin;\n            let _e274 = dir;\n            leave = min(_e265, dot(((_e266.xyz / vec3(_e269)) - _e272), _e274));\n        }\n    }\n    let _e277 = leave;\n    let _e278 = enter;\n    if (_e277 <= _e278) {\n        discard;\n    }\n    let _e281 = unnamed.uSamples;\n    samples = clamp(_e281, 2i, 64i);\n    let _e283 = leave;\n    let _e284 = enter;\n    let _e286 = samples;\n    step_ = ((_e283 - _e284) / f32(_e286));\n    let _e290 = gl_FragCoord_1[1u];\n    let _e298 = gl_FragCoord_1[0u];\n    cell = ((i32((_e290 - (floor((_e290 / 4f)) * 4f))) * 4i) + i32((_e298 - (floor((_e298 / 4f)) * 4f))));\n    let _e305 = cell;\n    indexable = array<f32, 16>(0f, 8f, 2f, 10f, 12f, 4f, 14f, 6f, 3f, 11f, 1f, 9f, 15f, 7f, 13f, 5f);\n    let _e307 = indexable[_e305];\n    let _e308 = gl_FragCoord_1;\n    let _e309 = _e308.xy;\n    param_10 = vec3<f32>(_e309.x, _e309.y, 3.7f);\n    let _e313 = hash31_u0028_vf3_u003b((&param_10));\n    let _e317 = step_;\n    shadowOffset = ((((_e307 + _e313) / 16f) - 0.5f) * _e317);\n    total = 0f;\n    i_1 = 0i;\n    loop {\n        let _e319 = i_1;\n        if (_e319 < 64i) {\n            let _e321 = i_1;\n            let _e322 = samples;\n            if (_e321 >= _e322) {\n                break;\n            }\n            let _e324 = enter;\n            let _e325 = i_1;\n            let _e328 = step_;\n            travelled = (_e324 + ((f32(_e325) + 0.5f) * _e328));\n            let _e331 = origin;\n            let _e332 = dir;\n            let _e333 = travelled;\n            local_2 = (_e331 + (_e332 * _e333));\n            let _e336 = local_2;\n            param_11 = _e336;\n            let _e337 = near_1;\n            param_12 = _e337;\n            let _e338 = densityAt_u0028_vf3_u003b_f1_u003b((&param_11), (&param_12));\n            density = _e338;\n            let _e339 = density;\n            if (_e339 <= 0f) {\n                continue;\n            }\n            let _e342 = unnamed.uModelWorld;\n            let _e343 = local_2;\n            world = (_e342 * vec4<f32>(_e343.x, _e343.y, _e343.z, 1f)).xyz;\n            let _e351 = unnamed.uDust;\n            if (_e351 > 0f) {\n                let _e353 = world;\n                let _e355 = unnamed.uDustOffset;\n                let _e358 = unnamed.uDustScale;\n                param_13 = ((_e353 + _e355) / vec3(max(_e358, 0.001f)));\n                let _e362 = dustField_u0028_vf3_u003b((&param_13));\n                let _e364 = unnamed.uDust;\n                let _e366 = density;\n                density = (_e366 * mix(1f, _e362, _e364));\n            }\n            let _e368 = density;\n            let _e369 = total;\n            total = (_e369 + _e368);\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e371 = i_1;\n            i_1 = (_e371 + 1i);\n        }\n    }\n    let _e374 = unnamed.uSpread;\n    let _e376 = unnamed.uLength;\n    reference = max((_e374 * _e376), 0.0001f);\n    let _e379 = total;\n    let _e381 = step_;\n    let _e383 = reference;\n    lit = (1f - exp((((-(_e379) * _e381) / _e383) * 3f)));\n    let _e388 = vColor_1;\n    let _e389 = vEnergy_1;\n    let _e390 = lit;\n    let _e393 = unnamed.uStrength;\n    let _e395 = (_e388 * ((_e389 * _e390) * _e393));\n    fragColor = vec4<f32>(_e395.x, _e395.y, _e395.z, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(4) vLocal: vec3<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(0) vColor: vec3<f32>, @location(1) vEnergy: f32, @location(2) vNormal: vec3<f32>, @location(3) vWorldPos: vec3<f32>) -> @location(0) vec4<f32> {\n    vLocal_1 = vLocal;\n    gl_FragCoord_1 = gl_FragCoord;\n    vColor_1 = vColor;\n    vEnergy_1 = vEnergy;\n    vNormal_1 = vNormal;\n    vWorldPos_1 = vWorldPos;\n    main_1();\n    let _e13 = fragColor;\n    return _e13;\n}\n",
-  "directionalShadows": "struct Uniforms {\n    uCameraPos: vec3<f32>,\n    uStrength: f32,\n    uLength: f32,\n    uSpread: f32,\n    uDust: f32,\n    uDustScale: f32,\n    uDustOffset: vec3<f32>,\n    uSunShadow: f32,\n    uLightViewProj: mat4x4<f32>,\n    uShadowMapSize: f32,\n    uPeeledShadowEnabled: i32,\n    uNear: f32,\n    uCameraLocal: vec3<f32>,\n    uModelWorld: mat4x4<f32>,\n    uSamples: i32,\n    uSceneDepthEnabled: i32,\n    uInvViewport: vec2<f32>,\n    uDepthToLocal: mat4x4<f32>,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\n@group(0) @binding(32) \nvar uStaticShadowMap_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uStaticShadowMap_s: sampler;\n@group(0) @binding(34) \nvar uPeeledShadowMap_t: texture_2d<f32>;\n@group(0) @binding(35) \nvar uPeeledShadowMap_s: sampler;\n@group(0) @binding(36) \nvar uDynamicShadowMap_t: texture_2d<f32>;\n@group(0) @binding(37) \nvar uDynamicShadowMap_s: sampler;\nvar<private> vLocal_1: vec3<f32>;\nvar<private> gl_FragCoord_1: vec4<f32>;\n@group(0) @binding(38) \nvar uSceneDepth_t: texture_2d<f32>;\n@group(0) @binding(39) \nvar uSceneDepth_s: sampler;\nvar<private> fragColor: vec4<f32>;\nvar<private> vColor_1: vec3<f32>;\nvar<private> vEnergy_1: f32;\nvar<private> vNormal_1: vec3<f32>;\nvar<private> vWorldPos_1: vec3<f32>;\n\nfn occlusion_u0028_f1_u003b_f1_u003b(stored: ptr<function, f32>, compare: ptr<function, f32>) -> f32 {\n    let _e91 = (*compare);\n    let _e92 = (*stored);\n    return smoothstep(-0.0025f, 0.0025f, (_e91 - _e92));\n}\n\nfn sunReach_u0028_vf3_u003b(worldPos: ptr<function, vec3<f32>>) -> f32 {\n    var lightPos: vec4<f32>;\n    var p: vec3<f32>;\n    var fromCentre: vec2<f32>;\n    var edgeFade: f32;\n    var compare_1: f32;\n    var blocked: f32;\n    var param: f32;\n    var param_1: f32;\n    var param_2: f32;\n    var param_3: f32;\n    var param_4: f32;\n    var param_5: f32;\n    var phi_212_: bool;\n    var phi_219_: bool;\n    var phi_226_: bool;\n    var phi_233_: bool;\n\n    let _e103 = unnamed.uLightViewProj;\n    let _e104 = (*worldPos);\n    lightPos = (_e103 * vec4<f32>(_e104.x, _e104.y, _e104.z, 1f));\n    let _e111 = lightPos[3u];\n    if (_e111 <= 0f) {\n        return 1f;\n    }\n    let _e113 = lightPos;\n    let _e116 = lightPos[3u];\n    p = (((_e113.xyz / vec3(_e116)) * 0.5f) + vec3(0.5f));\n    let _e123 = p[2u];\n    let _e124 = (_e123 > 1f);\n    phi_212_ = _e124;\n    if !(_e124) {\n        let _e127 = p[0u];\n        phi_212_ = (_e127 < 0f);\n    }\n    let _e130 = phi_212_;\n    phi_219_ = _e130;\n    if !(_e130) {\n        let _e133 = p[0u];\n        phi_219_ = (_e133 > 1f);\n    }\n    let _e136 = phi_219_;\n    phi_226_ = _e136;\n    if !(_e136) {\n        let _e139 = p[1u];\n        phi_226_ = (_e139 < 0f);\n    }\n    let _e142 = phi_226_;\n    phi_233_ = _e142;\n    if !(_e142) {\n        let _e145 = p[1u];\n        phi_233_ = (_e145 > 1f);\n    }\n    let _e148 = phi_233_;\n    if _e148 {\n        return 1f;\n    }\n    let _e149 = p;\n    fromCentre = (abs((_e149.xy - vec2(0.5f))) * 2f);\n    let _e156 = fromCentre[0u];\n    let _e158 = fromCentre[1u];\n    edgeFade = (1f - smoothstep(0.72f, 0.98f, max(_e156, _e158)));\n    let _e163 = p[2u];\n    let _e166 = edgeFade;\n    edgeFade = (_e166 * (1f - smoothstep(0.9f, 1f, _e163)));\n    let _e168 = edgeFade;\n    if (_e168 <= 0f) {\n        return 1f;\n    }\n    let _e171 = p[2u];\n    compare_1 = (_e171 - 0.0015f);\n    let _e173 = p;\n    let _e175 = textureSampleLevel(uStaticShadowMap_t, uStaticShadowMap_s, _e173.xy, 0f);\n    param = _e175.x;\n    let _e177 = compare_1;\n    param_1 = _e177;\n    let _e178 = occlusion_u0028_f1_u003b_f1_u003b((&param), (&param_1));\n    blocked = _e178;\n    let _e180 = unnamed.uPeeledShadowEnabled;\n    if (_e180 != 0i) {\n        let _e182 = blocked;\n        let _e183 = p;\n        let _e185 = textureSampleLevel(uPeeledShadowMap_t, uPeeledShadowMap_s, _e183.xy, 0f);\n        param_2 = _e185.x;\n        let _e187 = compare_1;\n        param_3 = _e187;\n        let _e188 = occlusion_u0028_f1_u003b_f1_u003b((&param_2), (&param_3));\n        blocked = max(_e182, _e188);\n    }\n    let _e190 = blocked;\n    let _e191 = p;\n    let _e193 = textureSampleLevel(uDynamicShadowMap_t, uDynamicShadowMap_s, _e191.xy, 0f);\n    param_4 = _e193.x;\n    let _e195 = compare_1;\n    param_5 = _e195;\n    let _e196 = occlusion_u0028_f1_u003b_f1_u003b((&param_4), (&param_5));\n    blocked = max(_e190, _e196);\n    let _e198 = blocked;\n    let _e201 = unnamed.uSunShadow;\n    let _e202 = edgeFade;\n    return mix(1f, (1f - _e198), (_e201 * _e202));\n}\n\nfn hash31_u0028_vf3_u003b(p_1: ptr<function, vec3<f32>>) -> f32 {\n    let _e90 = (*p_1);\n    return fract((sin(dot(_e90, vec3<f32>(127.1f, 311.7f, 74.7f))) * 43758.547f));\n}\n\nfn volumeNoise_u0028_vf3_u003b(p_2: ptr<function, vec3<f32>>) -> f32 {\n    var i: vec3<f32>;\n    var f: vec3<f32>;\n    var u: vec3<f32>;\n    var x00_: f32;\n    var param_6: vec3<f32>;\n    var param_7: vec3<f32>;\n    var x10_: f32;\n    var param_8: vec3<f32>;\n    var param_9: vec3<f32>;\n    var x01_: f32;\n    var param_10: vec3<f32>;\n    var param_11: vec3<f32>;\n    var x11_: f32;\n    var param_12: vec3<f32>;\n    var param_13: vec3<f32>;\n\n    let _e105 = (*p_2);\n    i = floor(_e105);\n    let _e107 = (*p_2);\n    f = fract(_e107);\n    let _e109 = f;\n    let _e110 = f;\n    let _e112 = f;\n    u = ((_e109 * _e110) * (vec3(3f) - (_e112 * 2f)));\n    let _e117 = i;\n    param_6 = (_e117 + vec3<f32>(0f, 0f, 0f));\n    let _e119 = hash31_u0028_vf3_u003b((&param_6));\n    let _e120 = i;\n    param_7 = (_e120 + vec3<f32>(1f, 0f, 0f));\n    let _e122 = hash31_u0028_vf3_u003b((&param_7));\n    let _e124 = u[0u];\n    x00_ = mix(_e119, _e122, _e124);\n    let _e126 = i;\n    param_8 = (_e126 + vec3<f32>(0f, 1f, 0f));\n    let _e128 = hash31_u0028_vf3_u003b((&param_8));\n    let _e129 = i;\n    param_9 = (_e129 + vec3<f32>(1f, 1f, 0f));\n    let _e131 = hash31_u0028_vf3_u003b((&param_9));\n    let _e133 = u[0u];\n    x10_ = mix(_e128, _e131, _e133);\n    let _e135 = i;\n    param_10 = (_e135 + vec3<f32>(0f, 0f, 1f));\n    let _e137 = hash31_u0028_vf3_u003b((&param_10));\n    let _e138 = i;\n    param_11 = (_e138 + vec3<f32>(1f, 0f, 1f));\n    let _e140 = hash31_u0028_vf3_u003b((&param_11));\n    let _e142 = u[0u];\n    x01_ = mix(_e137, _e140, _e142);\n    let _e144 = i;\n    param_12 = (_e144 + vec3<f32>(0f, 1f, 1f));\n    let _e146 = hash31_u0028_vf3_u003b((&param_12));\n    let _e147 = i;\n    param_13 = (_e147 + vec3<f32>(1f, 1f, 1f));\n    let _e149 = hash31_u0028_vf3_u003b((&param_13));\n    let _e151 = u[0u];\n    x11_ = mix(_e146, _e149, _e151);\n    let _e153 = x00_;\n    let _e154 = x10_;\n    let _e156 = u[1u];\n    let _e158 = x01_;\n    let _e159 = x11_;\n    let _e161 = u[1u];\n    let _e164 = u[2u];\n    return mix(mix(_e153, _e154, _e156), mix(_e158, _e159, _e161), _e164);\n}\n\nfn dustField_u0028_vf3_u003b(p_3: ptr<function, vec3<f32>>) -> f32 {\n    var param_14: vec3<f32>;\n    var param_15: vec3<f32>;\n\n    let _e92 = (*p_3);\n    param_14 = _e92;\n    let _e93 = volumeNoise_u0028_vf3_u003b((&param_14));\n    let _e95 = (*p_3);\n    param_15 = ((_e95 * 2.17f) + vec3(19.3f));\n    let _e99 = volumeNoise_u0028_vf3_u003b((&param_15));\n    return ((_e93 * 0.65f) + (_e99 * 0.35f));\n}\n\nfn densityAt_u0028_vf3_u003b_f1_u003b(local: ptr<function, vec3<f32>>, near: ptr<function, f32>) -> f32 {\n    var drawn: f32;\n    var along: f32;\n    var openness: f32;\n    var across: f32;\n\n    let _e96 = unnamed.uLength;\n    let _e97 = (*near);\n    drawn = max((_e96 - _e97), 0.0001f);\n    let _e101 = (*local)[2u];\n    let _e102 = (*near);\n    let _e104 = drawn;\n    along = clamp(((_e101 - _e102) / _e104), 0f, 1f);\n    let _e107 = (*local);\n    let _e111 = (*local)[2u];\n    openness = (length(_e107.xy) / max(_e111, 0.001f));\n    let _e114 = openness;\n    let _e116 = unnamed.uSpread;\n    across = clamp((_e114 / max(_e116, 0.0001f)), 0f, 1f);\n    let _e120 = along;\n    let _e123 = across;\n    return (pow((1f - _e120), 1.3f) * pow((1f - _e123), 2f));\n}\n\nfn main_1() {\n    var origin: vec3<f32>;\n    var toFragment: vec3<f32>;\n    var span: f32;\n    var dir: vec3<f32>;\n    var local_1: vec3<f32>;\n    var near_1: f32;\n    var enter: f32;\n    var leave: f32;\n    var toNear: f32;\n    var toFar: f32;\n    var reach: f32;\n    var ca: f32;\n    var cb: f32;\n    var cc: f32;\n    var disc: f32;\n    var root: f32;\n    var uv: vec2<f32>;\n    var stored_1: f32;\n    var hit: vec4<f32>;\n    var samples: i32;\n    var step_: f32;\n    var cell: i32;\n    var shadowOffset: f32;\n    var indexable: array<f32, 16>;\n    var param_16: vec3<f32>;\n    var total: f32;\n    var i_1: i32;\n    var travelled: f32;\n    var local_2: vec3<f32>;\n    var density: f32;\n    var param_17: vec3<f32>;\n    var param_18: f32;\n    var world: vec3<f32>;\n    var param_19: vec3<f32>;\n    var dithered: vec3<f32>;\n    var param_20: vec3<f32>;\n    var reference: f32;\n    var lit: f32;\n    var phi_464_: bool;\n\n    let _e128 = unnamed.uCameraLocal;\n    origin = _e128;\n    let _e129 = vLocal_1;\n    let _e130 = origin;\n    toFragment = (_e129 - _e130);\n    let _e132 = toFragment;\n    span = length(_e132);\n    let _e134 = span;\n    if (_e134 > 0.00001f) {\n        let _e136 = toFragment;\n        let _e137 = span;\n        local_1 = (_e136 / vec3(_e137));\n    } else {\n        local_1 = vec3<f32>(0f, 0f, 1f);\n    }\n    let _e140 = local_1;\n    dir = _e140;\n    let _e142 = unnamed.uNear;\n    let _e144 = unnamed.uLength;\n    near_1 = min(_e142, _e144);\n    enter = 0f;\n    let _e147 = unnamed.uLength;\n    leave = (_e147 * 2f);\n    let _e150 = dir[2u];\n    if (abs(_e150) > 0.00001f) {\n        let _e153 = near_1;\n        let _e155 = origin[2u];\n        let _e158 = dir[2u];\n        toNear = ((_e153 - _e155) / _e158);\n        let _e161 = unnamed.uLength;\n        let _e163 = origin[2u];\n        let _e166 = dir[2u];\n        toFar = ((_e161 - _e163) / _e166);\n        let _e168 = toNear;\n        let _e169 = toFar;\n        enter = min(_e168, _e169);\n        let _e171 = toNear;\n        let _e172 = toFar;\n        leave = max(_e171, _e172);\n    } else {\n        let _e175 = origin[2u];\n        let _e176 = near_1;\n        let _e177 = (_e175 < _e176);\n        phi_464_ = _e177;\n        if !(_e177) {\n            let _e180 = origin[2u];\n            let _e182 = unnamed.uLength;\n            phi_464_ = (_e180 > _e182);\n        }\n        let _e185 = phi_464_;\n        if _e185 {\n            discard;\n        }\n    }\n    let _e187 = unnamed.uSpread;\n    let _e189 = unnamed.uLength;\n    reach = ((_e187 * _e189) * 1.05f);\n    let _e192 = dir;\n    let _e194 = dir;\n    ca = dot(_e192.xy, _e194.xy);\n    let _e197 = origin;\n    let _e199 = dir;\n    cb = (2f * dot(_e197.xy, _e199.xy));\n    let _e203 = origin;\n    let _e205 = origin;\n    let _e208 = reach;\n    let _e209 = reach;\n    cc = (dot(_e203.xy, _e205.xy) - (_e208 * _e209));\n    let _e212 = ca;\n    if (_e212 > 0.00000001f) {\n        let _e214 = cb;\n        let _e215 = cb;\n        let _e217 = ca;\n        let _e219 = cc;\n        disc = ((_e214 * _e215) - ((4f * _e217) * _e219));\n        let _e222 = disc;\n        if (_e222 <= 0f) {\n            discard;\n        }\n        let _e224 = disc;\n        root = sqrt(_e224);\n        let _e226 = enter;\n        let _e227 = cb;\n        let _e229 = root;\n        let _e231 = ca;\n        enter = max(_e226, ((-(_e227) - _e229) / (2f * _e231)));\n        let _e235 = leave;\n        let _e236 = cb;\n        let _e238 = root;\n        let _e240 = ca;\n        leave = min(_e235, ((-(_e236) + _e238) / (2f * _e240)));\n    } else {\n        let _e244 = cc;\n        if (_e244 > 0f) {\n            discard;\n        }\n    }\n    let _e246 = enter;\n    enter = max(_e246, 0f);\n    let _e248 = leave;\n    let _e249 = enter;\n    let _e251 = unnamed.uLength;\n    leave = min(_e248, (_e249 + (_e251 * 2f)));\n    let _e256 = unnamed.uSceneDepthEnabled;\n    if (_e256 != 0i) {\n        let _e258 = gl_FragCoord_1;\n        let _e261 = unnamed.uInvViewport;\n        uv = (_e258.xy * _e261);\n        let _e263 = uv;\n        let _e264 = textureSampleLevel(uSceneDepth_t, uSceneDepth_s, _e263, 0f);\n        stored_1 = _e264.x;\n        let _e267 = unnamed.uDepthToLocal;\n        let _e268 = uv;\n        let _e271 = ((_e268 * 2f) - vec2(1f));\n        let _e272 = stored_1;\n        hit = (_e267 * vec4<f32>(_e271.x, _e271.y, _e272, 1f));\n        let _e278 = hit[3u];\n        if (_e278 > 0.000001f) {\n            let _e280 = leave;\n            let _e281 = hit;\n            let _e284 = hit[3u];\n            let _e287 = origin;\n            let _e289 = dir;\n            leave = min(_e280, dot(((_e281.xyz / vec3(_e284)) - _e287), _e289));\n        }\n    }\n    let _e292 = leave;\n    let _e293 = enter;\n    if (_e292 <= _e293) {\n        discard;\n    }\n    let _e296 = unnamed.uSamples;\n    samples = clamp(_e296, 2i, 64i);\n    let _e298 = leave;\n    let _e299 = enter;\n    let _e301 = samples;\n    step_ = ((_e298 - _e299) / f32(_e301));\n    let _e305 = gl_FragCoord_1[1u];\n    let _e313 = gl_FragCoord_1[0u];\n    cell = ((i32((_e305 - (floor((_e305 / 4f)) * 4f))) * 4i) + i32((_e313 - (floor((_e313 / 4f)) * 4f))));\n    let _e320 = cell;\n    indexable = array<f32, 16>(0f, 8f, 2f, 10f, 12f, 4f, 14f, 6f, 3f, 11f, 1f, 9f, 15f, 7f, 13f, 5f);\n    let _e322 = indexable[_e320];\n    let _e323 = gl_FragCoord_1;\n    let _e324 = _e323.xy;\n    param_16 = vec3<f32>(_e324.x, _e324.y, 3.7f);\n    let _e328 = hash31_u0028_vf3_u003b((&param_16));\n    let _e332 = step_;\n    shadowOffset = ((((_e322 + _e328) / 16f) - 0.5f) * _e332);\n    total = 0f;\n    i_1 = 0i;\n    loop {\n        let _e334 = i_1;\n        if (_e334 < 64i) {\n            let _e336 = i_1;\n            let _e337 = samples;\n            if (_e336 >= _e337) {\n                break;\n            }\n            let _e339 = enter;\n            let _e340 = i_1;\n            let _e343 = step_;\n            travelled = (_e339 + ((f32(_e340) + 0.5f) * _e343));\n            let _e346 = origin;\n            let _e347 = dir;\n            let _e348 = travelled;\n            local_2 = (_e346 + (_e347 * _e348));\n            let _e351 = local_2;\n            param_17 = _e351;\n            let _e352 = near_1;\n            param_18 = _e352;\n            let _e353 = densityAt_u0028_vf3_u003b_f1_u003b((&param_17), (&param_18));\n            density = _e353;\n            let _e354 = density;\n            if (_e354 <= 0f) {\n                continue;\n            }\n            let _e357 = unnamed.uModelWorld;\n            let _e358 = local_2;\n            world = (_e357 * vec4<f32>(_e358.x, _e358.y, _e358.z, 1f)).xyz;\n            let _e366 = unnamed.uDust;\n            if (_e366 > 0f) {\n                let _e368 = world;\n                let _e370 = unnamed.uDustOffset;\n                let _e373 = unnamed.uDustScale;\n                param_19 = ((_e368 + _e370) / vec3(max(_e373, 0.001f)));\n                let _e377 = dustField_u0028_vf3_u003b((&param_19));\n                let _e379 = unnamed.uDust;\n                let _e381 = density;\n                density = (_e381 * mix(1f, _e377, _e379));\n            }\n            let _e384 = unnamed.uSunShadow;\n            if (_e384 > 0f) {\n                let _e387 = unnamed.uModelWorld;\n                let _e388 = origin;\n                let _e389 = dir;\n                let _e390 = travelled;\n                let _e391 = shadowOffset;\n                let _e394 = (_e388 + (_e389 * (_e390 + _e391)));\n                dithered = (_e387 * vec4<f32>(_e394.x, _e394.y, _e394.z, 1f)).xyz;\n                let _e401 = dithered;\n                param_20 = _e401;\n                let _e402 = sunReach_u0028_vf3_u003b((&param_20));\n                let _e403 = density;\n                density = (_e403 * _e402);\n            }\n            let _e405 = density;\n            let _e406 = total;\n            total = (_e406 + _e405);\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e408 = i_1;\n            i_1 = (_e408 + 1i);\n        }\n    }\n    let _e411 = unnamed.uSpread;\n    let _e413 = unnamed.uLength;\n    reference = max((_e411 * _e413), 0.0001f);\n    let _e416 = total;\n    let _e418 = step_;\n    let _e420 = reference;\n    lit = (1f - exp((((-(_e416) * _e418) / _e420) * 3f)));\n    let _e425 = vColor_1;\n    let _e426 = vEnergy_1;\n    let _e427 = lit;\n    let _e430 = unnamed.uStrength;\n    let _e432 = (_e425 * ((_e426 * _e427) * _e430));\n    fragColor = vec4<f32>(_e432.x, _e432.y, _e432.z, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(4) vLocal: vec3<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(0) vColor: vec3<f32>, @location(1) vEnergy: f32, @location(2) vNormal: vec3<f32>, @location(3) vWorldPos: vec3<f32>) -> @location(0) vec4<f32> {\n    vLocal_1 = vLocal;\n    gl_FragCoord_1 = gl_FragCoord;\n    vColor_1 = vColor;\n    vEnergy_1 = vEnergy;\n    vNormal_1 = vNormal;\n    vWorldPos_1 = vWorldPos;\n    main_1();\n    let _e13 = fragColor;\n    return _e13;\n}\n",
+  "directionalShadows": "struct Uniforms {\n    uCameraPos: vec3<f32>,\n    uStrength: f32,\n    uLength: f32,\n    uSpread: f32,\n    uDust: f32,\n    uDustScale: f32,\n    uDustOffset: vec3<f32>,\n    uSunShadow: f32,\n    uLightViewProj: mat4x4<f32>,\n    uShadowMapSize: f32,\n    uPeeledShadowEnabled: i32,\n    uNear: f32,\n    uCameraLocal: vec3<f32>,\n    uModelWorld: mat4x4<f32>,\n    uSamples: i32,\n    uSceneDepthEnabled: i32,\n    uInvViewport: vec2<f32>,\n    uDepthToLocal: mat4x4<f32>,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\n@group(0) @binding(32) \nvar uSunShadows_t: texture_2d_array<f32>;\n@group(0) @binding(33) \nvar uSunShadows_s: sampler;\nvar<private> vLocal_1: vec3<f32>;\nvar<private> gl_FragCoord_1: vec4<f32>;\n@group(0) @binding(34) \nvar uSceneDepth_t: texture_2d<f32>;\n@group(0) @binding(35) \nvar uSceneDepth_s: sampler;\nvar<private> fragColor: vec4<f32>;\nvar<private> vColor_1: vec3<f32>;\nvar<private> vEnergy_1: f32;\nvar<private> vNormal_1: vec3<f32>;\nvar<private> vWorldPos_1: vec3<f32>;\n\nfn occlusion_u0028_f1_u003b_f1_u003b(stored: ptr<function, f32>, compare: ptr<function, f32>) -> f32 {\n    let _e87 = (*compare);\n    let _e88 = (*stored);\n    return smoothstep(-0.0025f, 0.0025f, (_e87 - _e88));\n}\n\nfn sunReach_u0028_vf3_u003b(worldPos: ptr<function, vec3<f32>>) -> f32 {\n    var lightPos: vec4<f32>;\n    var p: vec3<f32>;\n    var fromCentre: vec2<f32>;\n    var edgeFade: f32;\n    var compare_1: f32;\n    var blocked: f32;\n    var param: f32;\n    var param_1: f32;\n    var param_2: f32;\n    var param_3: f32;\n    var param_4: f32;\n    var param_5: f32;\n    var phi_212_: bool;\n    var phi_219_: bool;\n    var phi_226_: bool;\n    var phi_233_: bool;\n\n    let _e99 = unnamed.uLightViewProj;\n    let _e100 = (*worldPos);\n    lightPos = (_e99 * vec4<f32>(_e100.x, _e100.y, _e100.z, 1f));\n    let _e107 = lightPos[3u];\n    if (_e107 <= 0f) {\n        return 1f;\n    }\n    let _e109 = lightPos;\n    let _e112 = lightPos[3u];\n    p = (((_e109.xyz / vec3(_e112)) * 0.5f) + vec3(0.5f));\n    let _e119 = p[2u];\n    let _e120 = (_e119 > 1f);\n    phi_212_ = _e120;\n    if !(_e120) {\n        let _e123 = p[0u];\n        phi_212_ = (_e123 < 0f);\n    }\n    let _e126 = phi_212_;\n    phi_219_ = _e126;\n    if !(_e126) {\n        let _e129 = p[0u];\n        phi_219_ = (_e129 > 1f);\n    }\n    let _e132 = phi_219_;\n    phi_226_ = _e132;\n    if !(_e132) {\n        let _e135 = p[1u];\n        phi_226_ = (_e135 < 0f);\n    }\n    let _e138 = phi_226_;\n    phi_233_ = _e138;\n    if !(_e138) {\n        let _e141 = p[1u];\n        phi_233_ = (_e141 > 1f);\n    }\n    let _e144 = phi_233_;\n    if _e144 {\n        return 1f;\n    }\n    let _e145 = p;\n    fromCentre = (abs((_e145.xy - vec2(0.5f))) * 2f);\n    let _e152 = fromCentre[0u];\n    let _e154 = fromCentre[1u];\n    edgeFade = (1f - smoothstep(0.72f, 0.98f, max(_e152, _e154)));\n    let _e159 = p[2u];\n    let _e162 = edgeFade;\n    edgeFade = (_e162 * (1f - smoothstep(0.9f, 1f, _e159)));\n    let _e164 = edgeFade;\n    if (_e164 <= 0f) {\n        return 1f;\n    }\n    let _e167 = p[2u];\n    compare_1 = (_e167 - 0.0015f);\n    let _e169 = p;\n    let _e170 = _e169.xy;\n    let _e173 = vec3<f32>(_e170.x, _e170.y, 0f);\n    let _e179 = textureSampleLevel(uSunShadows_t, uSunShadows_s, vec2<f32>(_e173.x, _e173.y), i32(_e173.z), 0f);\n    param = _e179.x;\n    let _e181 = compare_1;\n    param_1 = _e181;\n    let _e182 = occlusion_u0028_f1_u003b_f1_u003b((&param), (&param_1));\n    blocked = _e182;\n    let _e184 = unnamed.uPeeledShadowEnabled;\n    if (_e184 != 0i) {\n        let _e186 = blocked;\n        let _e187 = p;\n        let _e188 = _e187.xy;\n        let _e191 = vec3<f32>(_e188.x, _e188.y, 2f);\n        let _e197 = textureSampleLevel(uSunShadows_t, uSunShadows_s, vec2<f32>(_e191.x, _e191.y), i32(_e191.z), 0f);\n        param_2 = _e197.x;\n        let _e199 = compare_1;\n        param_3 = _e199;\n        let _e200 = occlusion_u0028_f1_u003b_f1_u003b((&param_2), (&param_3));\n        blocked = max(_e186, _e200);\n    }\n    let _e202 = blocked;\n    let _e203 = p;\n    let _e204 = _e203.xy;\n    let _e207 = vec3<f32>(_e204.x, _e204.y, 1f);\n    let _e213 = textureSampleLevel(uSunShadows_t, uSunShadows_s, vec2<f32>(_e207.x, _e207.y), i32(_e207.z), 0f);\n    param_4 = _e213.x;\n    let _e215 = compare_1;\n    param_5 = _e215;\n    let _e216 = occlusion_u0028_f1_u003b_f1_u003b((&param_4), (&param_5));\n    blocked = max(_e202, _e216);\n    let _e218 = blocked;\n    let _e221 = unnamed.uSunShadow;\n    let _e222 = edgeFade;\n    return mix(1f, (1f - _e218), (_e221 * _e222));\n}\n\nfn hash31_u0028_vf3_u003b(p_1: ptr<function, vec3<f32>>) -> f32 {\n    let _e86 = (*p_1);\n    return fract((sin(dot(_e86, vec3<f32>(127.1f, 311.7f, 74.7f))) * 43758.547f));\n}\n\nfn volumeNoise_u0028_vf3_u003b(p_2: ptr<function, vec3<f32>>) -> f32 {\n    var i: vec3<f32>;\n    var f: vec3<f32>;\n    var u: vec3<f32>;\n    var x00_: f32;\n    var param_6: vec3<f32>;\n    var param_7: vec3<f32>;\n    var x10_: f32;\n    var param_8: vec3<f32>;\n    var param_9: vec3<f32>;\n    var x01_: f32;\n    var param_10: vec3<f32>;\n    var param_11: vec3<f32>;\n    var x11_: f32;\n    var param_12: vec3<f32>;\n    var param_13: vec3<f32>;\n\n    let _e101 = (*p_2);\n    i = floor(_e101);\n    let _e103 = (*p_2);\n    f = fract(_e103);\n    let _e105 = f;\n    let _e106 = f;\n    let _e108 = f;\n    u = ((_e105 * _e106) * (vec3(3f) - (_e108 * 2f)));\n    let _e113 = i;\n    param_6 = (_e113 + vec3<f32>(0f, 0f, 0f));\n    let _e115 = hash31_u0028_vf3_u003b((&param_6));\n    let _e116 = i;\n    param_7 = (_e116 + vec3<f32>(1f, 0f, 0f));\n    let _e118 = hash31_u0028_vf3_u003b((&param_7));\n    let _e120 = u[0u];\n    x00_ = mix(_e115, _e118, _e120);\n    let _e122 = i;\n    param_8 = (_e122 + vec3<f32>(0f, 1f, 0f));\n    let _e124 = hash31_u0028_vf3_u003b((&param_8));\n    let _e125 = i;\n    param_9 = (_e125 + vec3<f32>(1f, 1f, 0f));\n    let _e127 = hash31_u0028_vf3_u003b((&param_9));\n    let _e129 = u[0u];\n    x10_ = mix(_e124, _e127, _e129);\n    let _e131 = i;\n    param_10 = (_e131 + vec3<f32>(0f, 0f, 1f));\n    let _e133 = hash31_u0028_vf3_u003b((&param_10));\n    let _e134 = i;\n    param_11 = (_e134 + vec3<f32>(1f, 0f, 1f));\n    let _e136 = hash31_u0028_vf3_u003b((&param_11));\n    let _e138 = u[0u];\n    x01_ = mix(_e133, _e136, _e138);\n    let _e140 = i;\n    param_12 = (_e140 + vec3<f32>(0f, 1f, 1f));\n    let _e142 = hash31_u0028_vf3_u003b((&param_12));\n    let _e143 = i;\n    param_13 = (_e143 + vec3<f32>(1f, 1f, 1f));\n    let _e145 = hash31_u0028_vf3_u003b((&param_13));\n    let _e147 = u[0u];\n    x11_ = mix(_e142, _e145, _e147);\n    let _e149 = x00_;\n    let _e150 = x10_;\n    let _e152 = u[1u];\n    let _e154 = x01_;\n    let _e155 = x11_;\n    let _e157 = u[1u];\n    let _e160 = u[2u];\n    return mix(mix(_e149, _e150, _e152), mix(_e154, _e155, _e157), _e160);\n}\n\nfn dustField_u0028_vf3_u003b(p_3: ptr<function, vec3<f32>>) -> f32 {\n    var param_14: vec3<f32>;\n    var param_15: vec3<f32>;\n\n    let _e88 = (*p_3);\n    param_14 = _e88;\n    let _e89 = volumeNoise_u0028_vf3_u003b((&param_14));\n    let _e91 = (*p_3);\n    param_15 = ((_e91 * 2.17f) + vec3(19.3f));\n    let _e95 = volumeNoise_u0028_vf3_u003b((&param_15));\n    return ((_e89 * 0.65f) + (_e95 * 0.35f));\n}\n\nfn densityAt_u0028_vf3_u003b_f1_u003b(local: ptr<function, vec3<f32>>, near: ptr<function, f32>) -> f32 {\n    var drawn: f32;\n    var along: f32;\n    var openness: f32;\n    var across: f32;\n\n    let _e92 = unnamed.uLength;\n    let _e93 = (*near);\n    drawn = max((_e92 - _e93), 0.0001f);\n    let _e97 = (*local)[2u];\n    let _e98 = (*near);\n    let _e100 = drawn;\n    along = clamp(((_e97 - _e98) / _e100), 0f, 1f);\n    let _e103 = (*local);\n    let _e107 = (*local)[2u];\n    openness = (length(_e103.xy) / max(_e107, 0.001f));\n    let _e110 = openness;\n    let _e112 = unnamed.uSpread;\n    across = clamp((_e110 / max(_e112, 0.0001f)), 0f, 1f);\n    let _e116 = along;\n    let _e119 = across;\n    return (pow((1f - _e116), 1.3f) * pow((1f - _e119), 2f));\n}\n\nfn main_1() {\n    var origin: vec3<f32>;\n    var toFragment: vec3<f32>;\n    var span: f32;\n    var dir: vec3<f32>;\n    var local_1: vec3<f32>;\n    var near_1: f32;\n    var enter: f32;\n    var leave: f32;\n    var toNear: f32;\n    var toFar: f32;\n    var reach: f32;\n    var ca: f32;\n    var cb: f32;\n    var cc: f32;\n    var disc: f32;\n    var root: f32;\n    var uv: vec2<f32>;\n    var stored_1: f32;\n    var hit: vec4<f32>;\n    var samples: i32;\n    var step_: f32;\n    var cell: i32;\n    var shadowOffset: f32;\n    var indexable: array<f32, 16>;\n    var param_16: vec3<f32>;\n    var total: f32;\n    var i_1: i32;\n    var travelled: f32;\n    var local_2: vec3<f32>;\n    var density: f32;\n    var param_17: vec3<f32>;\n    var param_18: f32;\n    var world: vec3<f32>;\n    var param_19: vec3<f32>;\n    var dithered: vec3<f32>;\n    var param_20: vec3<f32>;\n    var reference: f32;\n    var lit: f32;\n    var phi_469_: bool;\n\n    let _e124 = unnamed.uCameraLocal;\n    origin = _e124;\n    let _e125 = vLocal_1;\n    let _e126 = origin;\n    toFragment = (_e125 - _e126);\n    let _e128 = toFragment;\n    span = length(_e128);\n    let _e130 = span;\n    if (_e130 > 0.00001f) {\n        let _e132 = toFragment;\n        let _e133 = span;\n        local_1 = (_e132 / vec3(_e133));\n    } else {\n        local_1 = vec3<f32>(0f, 0f, 1f);\n    }\n    let _e136 = local_1;\n    dir = _e136;\n    let _e138 = unnamed.uNear;\n    let _e140 = unnamed.uLength;\n    near_1 = min(_e138, _e140);\n    enter = 0f;\n    let _e143 = unnamed.uLength;\n    leave = (_e143 * 2f);\n    let _e146 = dir[2u];\n    if (abs(_e146) > 0.00001f) {\n        let _e149 = near_1;\n        let _e151 = origin[2u];\n        let _e154 = dir[2u];\n        toNear = ((_e149 - _e151) / _e154);\n        let _e157 = unnamed.uLength;\n        let _e159 = origin[2u];\n        let _e162 = dir[2u];\n        toFar = ((_e157 - _e159) / _e162);\n        let _e164 = toNear;\n        let _e165 = toFar;\n        enter = min(_e164, _e165);\n        let _e167 = toNear;\n        let _e168 = toFar;\n        leave = max(_e167, _e168);\n    } else {\n        let _e171 = origin[2u];\n        let _e172 = near_1;\n        let _e173 = (_e171 < _e172);\n        phi_469_ = _e173;\n        if !(_e173) {\n            let _e176 = origin[2u];\n            let _e178 = unnamed.uLength;\n            phi_469_ = (_e176 > _e178);\n        }\n        let _e181 = phi_469_;\n        if _e181 {\n            discard;\n        }\n    }\n    let _e183 = unnamed.uSpread;\n    let _e185 = unnamed.uLength;\n    reach = ((_e183 * _e185) * 1.05f);\n    let _e188 = dir;\n    let _e190 = dir;\n    ca = dot(_e188.xy, _e190.xy);\n    let _e193 = origin;\n    let _e195 = dir;\n    cb = (2f * dot(_e193.xy, _e195.xy));\n    let _e199 = origin;\n    let _e201 = origin;\n    let _e204 = reach;\n    let _e205 = reach;\n    cc = (dot(_e199.xy, _e201.xy) - (_e204 * _e205));\n    let _e208 = ca;\n    if (_e208 > 0.00000001f) {\n        let _e210 = cb;\n        let _e211 = cb;\n        let _e213 = ca;\n        let _e215 = cc;\n        disc = ((_e210 * _e211) - ((4f * _e213) * _e215));\n        let _e218 = disc;\n        if (_e218 <= 0f) {\n            discard;\n        }\n        let _e220 = disc;\n        root = sqrt(_e220);\n        let _e222 = enter;\n        let _e223 = cb;\n        let _e225 = root;\n        let _e227 = ca;\n        enter = max(_e222, ((-(_e223) - _e225) / (2f * _e227)));\n        let _e231 = leave;\n        let _e232 = cb;\n        let _e234 = root;\n        let _e236 = ca;\n        leave = min(_e231, ((-(_e232) + _e234) / (2f * _e236)));\n    } else {\n        let _e240 = cc;\n        if (_e240 > 0f) {\n            discard;\n        }\n    }\n    let _e242 = enter;\n    enter = max(_e242, 0f);\n    let _e244 = leave;\n    let _e245 = enter;\n    let _e247 = unnamed.uLength;\n    leave = min(_e244, (_e245 + (_e247 * 2f)));\n    let _e252 = unnamed.uSceneDepthEnabled;\n    if (_e252 != 0i) {\n        let _e254 = gl_FragCoord_1;\n        let _e257 = unnamed.uInvViewport;\n        uv = (_e254.xy * _e257);\n        let _e259 = uv;\n        let _e260 = textureSampleLevel(uSceneDepth_t, uSceneDepth_s, _e259, 0f);\n        stored_1 = _e260.x;\n        let _e263 = unnamed.uDepthToLocal;\n        let _e264 = uv;\n        let _e267 = ((_e264 * 2f) - vec2(1f));\n        let _e268 = stored_1;\n        hit = (_e263 * vec4<f32>(_e267.x, _e267.y, _e268, 1f));\n        let _e274 = hit[3u];\n        if (_e274 > 0.000001f) {\n            let _e276 = leave;\n            let _e277 = hit;\n            let _e280 = hit[3u];\n            let _e283 = origin;\n            let _e285 = dir;\n            leave = min(_e276, dot(((_e277.xyz / vec3(_e280)) - _e283), _e285));\n        }\n    }\n    let _e288 = leave;\n    let _e289 = enter;\n    if (_e288 <= _e289) {\n        discard;\n    }\n    let _e292 = unnamed.uSamples;\n    samples = clamp(_e292, 2i, 64i);\n    let _e294 = leave;\n    let _e295 = enter;\n    let _e297 = samples;\n    step_ = ((_e294 - _e295) / f32(_e297));\n    let _e301 = gl_FragCoord_1[1u];\n    let _e309 = gl_FragCoord_1[0u];\n    cell = ((i32((_e301 - (floor((_e301 / 4f)) * 4f))) * 4i) + i32((_e309 - (floor((_e309 / 4f)) * 4f))));\n    let _e316 = cell;\n    indexable = array<f32, 16>(0f, 8f, 2f, 10f, 12f, 4f, 14f, 6f, 3f, 11f, 1f, 9f, 15f, 7f, 13f, 5f);\n    let _e318 = indexable[_e316];\n    let _e319 = gl_FragCoord_1;\n    let _e320 = _e319.xy;\n    param_16 = vec3<f32>(_e320.x, _e320.y, 3.7f);\n    let _e324 = hash31_u0028_vf3_u003b((&param_16));\n    let _e328 = step_;\n    shadowOffset = ((((_e318 + _e324) / 16f) - 0.5f) * _e328);\n    total = 0f;\n    i_1 = 0i;\n    loop {\n        let _e330 = i_1;\n        if (_e330 < 64i) {\n            let _e332 = i_1;\n            let _e333 = samples;\n            if (_e332 >= _e333) {\n                break;\n            }\n            let _e335 = enter;\n            let _e336 = i_1;\n            let _e339 = step_;\n            travelled = (_e335 + ((f32(_e336) + 0.5f) * _e339));\n            let _e342 = origin;\n            let _e343 = dir;\n            let _e344 = travelled;\n            local_2 = (_e342 + (_e343 * _e344));\n            let _e347 = local_2;\n            param_17 = _e347;\n            let _e348 = near_1;\n            param_18 = _e348;\n            let _e349 = densityAt_u0028_vf3_u003b_f1_u003b((&param_17), (&param_18));\n            density = _e349;\n            let _e350 = density;\n            if (_e350 <= 0f) {\n                continue;\n            }\n            let _e353 = unnamed.uModelWorld;\n            let _e354 = local_2;\n            world = (_e353 * vec4<f32>(_e354.x, _e354.y, _e354.z, 1f)).xyz;\n            let _e362 = unnamed.uDust;\n            if (_e362 > 0f) {\n                let _e364 = world;\n                let _e366 = unnamed.uDustOffset;\n                let _e369 = unnamed.uDustScale;\n                param_19 = ((_e364 + _e366) / vec3(max(_e369, 0.001f)));\n                let _e373 = dustField_u0028_vf3_u003b((&param_19));\n                let _e375 = unnamed.uDust;\n                let _e377 = density;\n                density = (_e377 * mix(1f, _e373, _e375));\n            }\n            let _e380 = unnamed.uSunShadow;\n            if (_e380 > 0f) {\n                let _e383 = unnamed.uModelWorld;\n                let _e384 = origin;\n                let _e385 = dir;\n                let _e386 = travelled;\n                let _e387 = shadowOffset;\n                let _e390 = (_e384 + (_e385 * (_e386 + _e387)));\n                dithered = (_e383 * vec4<f32>(_e390.x, _e390.y, _e390.z, 1f)).xyz;\n                let _e397 = dithered;\n                param_20 = _e397;\n                let _e398 = sunReach_u0028_vf3_u003b((&param_20));\n                let _e399 = density;\n                density = (_e399 * _e398);\n            }\n            let _e401 = density;\n            let _e402 = total;\n            total = (_e402 + _e401);\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e404 = i_1;\n            i_1 = (_e404 + 1i);\n        }\n    }\n    let _e407 = unnamed.uSpread;\n    let _e409 = unnamed.uLength;\n    reference = max((_e407 * _e409), 0.0001f);\n    let _e412 = total;\n    let _e414 = step_;\n    let _e416 = reference;\n    lit = (1f - exp((((-(_e412) * _e414) / _e416) * 3f)));\n    let _e421 = vColor_1;\n    let _e422 = vEnergy_1;\n    let _e423 = lit;\n    let _e426 = unnamed.uStrength;\n    let _e428 = (_e421 * ((_e422 * _e423) * _e426));\n    fragColor = vec4<f32>(_e428.x, _e428.y, _e428.z, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(4) vLocal: vec3<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(0) vColor: vec3<f32>, @location(1) vEnergy: f32, @location(2) vNormal: vec3<f32>, @location(3) vWorldPos: vec3<f32>) -> @location(0) vec4<f32> {\n    vLocal_1 = vLocal;\n    gl_FragCoord_1 = gl_FragCoord;\n    vColor_1 = vColor;\n    vEnergy_1 = vEnergy;\n    vNormal_1 = vNormal;\n    vWorldPos_1 = vWorldPos;\n    main_1();\n    let _e13 = fragColor;\n    return _e13;\n}\n",
 };
 
 /**
@@ -216,25 +216,15 @@ export const LIGHTVOLUME_BINDINGS = {
         }
       },
       "textures": {
-        "uStaticShadowMap": {
+        "uSunShadows": {
           "texture": 32,
           "sampler": 33,
-          "type": "sampler2D"
+          "type": "sampler2DArray"
         },
-        "uPeeledShadowMap": {
+        "uSceneDepth": {
           "texture": 34,
           "sampler": 35,
           "type": "sampler2D"
-        },
-        "uDynamicShadowMap": {
-          "texture": 36,
-          "sampler": 37,
-          "type": "sampler2D"
-        },
-        "uSceneDepth": {
-          "texture": 38,
-          "sampler": 39,
-          "type": "sampler2D"
         }
       }
     }

package/src/render/shaders/generated/octahedralResolve.wgsl.ts

@@ -7,6 +7,8 @@
 
 export const OCTAHEDRAL_RESOLVE_FRAG_WGSL = "struct Uniforms {\n    uFaceRotation: mat3x3<f32>,\n    uFaceIndex: i32,\n    uFar: f32,\n    uNear: f32,\n    uEdge: f32,\n}\n\nvar<private> gl_FragCoord_1: vec4<f32>;\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\n@group(0) @binding(32) \nvar uFace_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uFace_s: sampler;\nvar<private> gl_FragDepth: f32 = 0f;\n\nfn octDecode_u0028_vf2_u003b(uv: ptr<function, vec2<f32>>) -> vec3<f32> {\n    var f: vec2<f32>;\n    var n: vec3<f32>;\n    var t: f32;\n    var local: f32;\n    var local_1: f32;\n\n    let _e25 = (*uv);\n    f = ((_e25 * 2f) - vec2(1f));\n    let _e30 = f[0u];\n    let _e32 = f[1u];\n    let _e34 = f[0u];\n    let _e38 = f[1u];\n    n = vec3<f32>(_e30, _e32, ((1f - abs(_e34)) - abs(_e38)));\n    let _e43 = n[2u];\n    t = max(-(_e43), 0f);\n    let _e47 = n[0u];\n    if (_e47 >= 0f) {\n        let _e49 = t;\n        local = -(_e49);\n    } else {\n        let _e51 = t;\n        local = _e51;\n    }\n    let _e52 = local;\n    let _e54 = n[0u];\n    n[0u] = (_e54 + _e52);\n    let _e58 = n[1u];\n    if (_e58 >= 0f) {\n        let _e60 = t;\n        local_1 = -(_e60);\n    } else {\n        let _e62 = t;\n        local_1 = _e62;\n    }\n    let _e63 = local_1;\n    let _e65 = n[1u];\n    n[1u] = (_e65 + _e63);\n    let _e68 = n;\n    return normalize(_e68);\n}\n\nfn main_1() {\n    var d: vec3<f32>;\n    var param: vec2<f32>;\n    var a: vec3<f32>;\n    var face: i32;\n    var v: vec3<f32>;\n    var forward: f32;\n    var faceUv: vec2<f32>;\n    var stored: f32;\n    var ndc: f32;\n    var faceLocalZ: f32;\n    var phi_116_: bool;\n\n    let _e29 = gl_FragCoord_1;\n    let _e32 = unnamed.uEdge;\n    param = (_e29.xy / vec2(_e32));\n    let _e35 = octDecode_u0028_vf2_u003b((&param));\n    d = _e35;\n    let _e36 = d;\n    a = abs(_e36);\n    let _e39 = a[0u];\n    let _e41 = a[1u];\n    let _e42 = (_e39 >= _e41);\n    phi_116_ = _e42;\n    if _e42 {\n        let _e44 = a[0u];\n        let _e46 = a[2u];\n        phi_116_ = (_e44 >= _e46);\n    }\n    let _e49 = phi_116_;\n    if _e49 {\n        let _e51 = d[0u];\n        face = select(1i, 0i, (_e51 >= 0f));\n    } else {\n        let _e55 = a[1u];\n        let _e57 = a[2u];\n        if (_e55 >= _e57) {\n            let _e60 = d[1u];\n            face = select(3i, 2i, (_e60 >= 0f));\n        } else {\n            let _e64 = d[2u];\n            face = select(5i, 4i, (_e64 >= 0f));\n        }\n    }\n    let _e67 = face;\n    let _e69 = unnamed.uFaceIndex;\n    if (_e67 != _e69) {\n        discard;\n    }\n    let _e72 = unnamed.uFaceRotation;\n    let _e73 = d;\n    v = (_e72 * _e73);\n    let _e76 = v[2u];\n    forward = -(_e76);\n    let _e78 = v;\n    let _e80 = forward;\n    faceUv = (((_e78.xy / vec2(_e80)) * 0.5f) + vec2(0.5f));\n    let _e86 = faceUv;\n    let _e87 = textureSampleLevel(uFace_t, uFace_s, _e86, 0f);\n    stored = _e87.x;\n    let _e89 = stored;\n    if (_e89 >= 0.9999f) {\n        gl_FragDepth = 1f;\n        return;\n    }\n    let _e91 = stored;\n    ndc = ((_e91 * 2f) - 1f);\n    let _e95 = unnamed.uFar;\n    let _e98 = unnamed.uNear;\n    let _e101 = unnamed.uFar;\n    let _e103 = unnamed.uNear;\n    let _e105 = ndc;\n    let _e107 = unnamed.uFar;\n    let _e109 = unnamed.uNear;\n    faceLocalZ = (((2f * _e95) * _e98) / ((_e101 + _e103) - (_e105 * (_e107 - _e109))));\n    let _e114 = faceLocalZ;\n    let _e115 = forward;\n    let _e118 = unnamed.uFar;\n    gl_FragDepth = clamp(((_e114 / _e115) / _e118), 0f, 1f);\n    return;\n}\n\n@fragment \nfn main(@builtin(position) gl_FragCoord: vec4<f32>) -> @builtin(frag_depth) f32 {\n    gl_FragCoord_1 = gl_FragCoord;\n    main_1();\n    let _e3 = gl_FragDepth;\n    return _e3;\n}\n";
 
+export const OCTAHEDRAL_RESOLVE_TINT_FRAG_WGSL = "struct Uniforms {\n    uFaceRotation: mat3x3<f32>,\n    uFaceIndex: i32,\n    uEdge: f32,\n}\n\nvar<private> gl_FragCoord_1: vec4<f32>;\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> outTint: vec4<f32>;\n@group(0) @binding(32) \nvar uFace_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uFace_s: sampler;\n\nfn octDecode_u0028_vf2_u003b(uv: ptr<function, vec2<f32>>) -> vec3<f32> {\n    var f: vec2<f32>;\n    var n: vec3<f32>;\n    var t: f32;\n    var local: f32;\n    var local_1: f32;\n\n    let _e24 = (*uv);\n    f = ((_e24 * 2f) - vec2(1f));\n    let _e29 = f[0u];\n    let _e31 = f[1u];\n    let _e33 = f[0u];\n    let _e37 = f[1u];\n    n = vec3<f32>(_e29, _e31, ((1f - abs(_e33)) - abs(_e37)));\n    let _e42 = n[2u];\n    t = max(-(_e42), 0f);\n    let _e46 = n[0u];\n    if (_e46 >= 0f) {\n        let _e48 = t;\n        local = -(_e48);\n    } else {\n        let _e50 = t;\n        local = _e50;\n    }\n    let _e51 = local;\n    let _e53 = n[0u];\n    n[0u] = (_e53 + _e51);\n    let _e57 = n[1u];\n    if (_e57 >= 0f) {\n        let _e59 = t;\n        local_1 = -(_e59);\n    } else {\n        let _e61 = t;\n        local_1 = _e61;\n    }\n    let _e62 = local_1;\n    let _e64 = n[1u];\n    n[1u] = (_e64 + _e62);\n    let _e67 = n;\n    return normalize(_e67);\n}\n\nfn main_1() {\n    var d: vec3<f32>;\n    var param: vec2<f32>;\n    var a: vec3<f32>;\n    var face: i32;\n    var v: vec3<f32>;\n    var forward: f32;\n    var faceUv: vec2<f32>;\n    var phi_116_: bool;\n\n    let _e25 = gl_FragCoord_1;\n    let _e28 = unnamed.uEdge;\n    param = (_e25.xy / vec2(_e28));\n    let _e31 = octDecode_u0028_vf2_u003b((&param));\n    d = _e31;\n    let _e32 = d;\n    a = abs(_e32);\n    let _e35 = a[0u];\n    let _e37 = a[1u];\n    let _e38 = (_e35 >= _e37);\n    phi_116_ = _e38;\n    if _e38 {\n        let _e40 = a[0u];\n        let _e42 = a[2u];\n        phi_116_ = (_e40 >= _e42);\n    }\n    let _e45 = phi_116_;\n    if _e45 {\n        let _e47 = d[0u];\n        face = select(1i, 0i, (_e47 >= 0f));\n    } else {\n        let _e51 = a[1u];\n        let _e53 = a[2u];\n        if (_e51 >= _e53) {\n            let _e56 = d[1u];\n            face = select(3i, 2i, (_e56 >= 0f));\n        } else {\n            let _e60 = d[2u];\n            face = select(5i, 4i, (_e60 >= 0f));\n        }\n    }\n    let _e63 = face;\n    let _e65 = unnamed.uFaceIndex;\n    if (_e63 != _e65) {\n        discard;\n    }\n    let _e68 = unnamed.uFaceRotation;\n    let _e69 = d;\n    v = (_e68 * _e69);\n    let _e72 = v[2u];\n    forward = -(_e72);\n    let _e74 = v;\n    let _e76 = forward;\n    faceUv = (((_e74.xy / vec2(_e76)) * 0.5f) + vec2(0.5f));\n    let _e82 = faceUv;\n    let _e83 = textureSampleLevel(uFace_t, uFace_s, _e82, 0f);\n    outTint = _e83;\n    return;\n}\n\n@fragment \nfn main(@builtin(position) gl_FragCoord: vec4<f32>) -> @location(0) vec4<f32> {\n    gl_FragCoord_1 = gl_FragCoord;\n    main_1();\n    let _e3 = outTint;\n    return _e3;\n}\n";
+
 export const OCTAHEDRAL_RESOLVE_VERT_WGSL = "struct gl_PerVertex {\n    @builtin(position) gl_Position: vec4<f32>,\n    gl_PointSize: f32,\n}\n\nvar<private> gl_VertexIndex_1: i32;\nvar<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f);\n\nfn main_1() {\n    var p: vec2<f32>;\n\n    let _e9 = gl_VertexIndex_1;\n    let _e14 = gl_VertexIndex_1;\n    p = vec2<f32>(f32(((_e9 << bitcast<u32>(1i)) & 2i)), f32((_e14 & 2i)));\n    let _e18 = p;\n    let _e21 = ((_e18 * 2f) - vec2(1f));\n    unnamed.gl_Position = vec4<f32>(_e21.x, _e21.y, 0f, 1f);\n    return;\n}\n\n@vertex \nfn main(@builtin(vertex_index) gl_VertexIndex: u32) -> @builtin(position) vec4<f32> {\n    gl_VertexIndex_1 = i32(gl_VertexIndex);\n    main_1();\n    let _e6 = unnamed.gl_Position.y;\n    unnamed.gl_Position.y = -(_e6);\n    let _e8 = unnamed.gl_Position;\n    return _e8;\n}\n";
 
 /**
@@ -53,6 +55,34 @@ export const OCTAHEDRALRESOLVE_BINDINGS = {
       }
     }
   },
+  "OCTAHEDRAL_RESOLVE_TINT_FRAG": {
+    "uniforms": 1,
+    "uniformSize": 64,
+    "fields": {
+      "uFaceRotation": {
+        "offset": 0,
+        "size": 48,
+        "type": "mat3"
+      },
+      "uFaceIndex": {
+        "offset": 48,
+        "size": 4,
+        "type": "int"
+      },
+      "uEdge": {
+        "offset": 52,
+        "size": 4,
+        "type": "float"
+      }
+    },
+    "textures": {
+      "uFace": {
+        "texture": 32,
+        "sampler": 33,
+        "type": "sampler2D"
+      }
+    }
+  },
   "OCTAHEDRAL_RESOLVE_VERT": {
     "uniforms": null,
     "textures": {}

package/src/render/shaders/globalMedium.ts

@@ -1,3 +1,4 @@
+import { SUN_DYNAMIC_LAYER, SUN_PEELED_LAYER, SUN_STATIC_LAYER } from '../shadowMap.ts';
 import { glslIsFarDepth, glslSceneDepthToNdc } from '../depthConvention.ts';
 import { MAX_GLOBAL_MEDIUM_STEPS } from '../globalMedium.ts';
 
@@ -79,9 +80,8 @@ uniform int uSteps;
 /** How much of the medium the sun's own shadow map removes, 0 to 1. At 0 nothing is sampled. */
 uniform float uSunShadow;
 uniform mat4 uLightViewProj;
-uniform sampler2D uStaticShadowMap;
-uniform sampler2D uPeeledShadowMap;
-uniform sampler2D uDynamicShadowMap;
+/* The sun's static, moving and peeled maps, as layers of one array: see shadowMap.ts. */
+uniform highp sampler2DArray uSunShadows;
 uniform int uPeeledShadowEnabled;
 
 out vec4 fragColor;
@@ -150,11 +150,11 @@ float sunReach(vec3 worldPos) {
   if (edgeFade <= 0.0) return 1.0;
 
   float compare = p.z - SHADOW_BIAS;
-  float blocked = occlusion(textureLod(uStaticShadowMap, p.xy, 0.0).r, compare);
+  float blocked = occlusion(textureLod(uSunShadows, vec3(p.xy, ${SUN_STATIC_LAYER}.0), 0.0).r, compare);
   if (uPeeledShadowEnabled != 0) {
-    blocked = max(blocked, occlusion(textureLod(uPeeledShadowMap, p.xy, 0.0).r, compare));
+    blocked = max(blocked, occlusion(textureLod(uSunShadows, vec3(p.xy, ${SUN_PEELED_LAYER}.0), 0.0).r, compare));
   }
-  blocked = max(blocked, occlusion(textureLod(uDynamicShadowMap, p.xy, 0.0).r, compare));
+  blocked = max(blocked, occlusion(textureLod(uSunShadows, vec3(p.xy, ${SUN_DYNAMIC_LAYER}.0), 0.0).r, compare));
   return mix(1.0, 1.0 - blocked, uSunShadow * edgeFade);
 }
 

package/src/render/shaders/gpudriven/blendRaster.wgsl.ts

@@ -82,6 +82,28 @@ fn oitResolved(accum: vec4<f32>, reveal: f32) -> vec4<f32> {
 }
 `;
 
+/**
+ * Glass over its own shading, as the forward path draws it: `gpudriven/lit.ts`'s `glassShade`,
+ * which `scripts/gpu-parity.mjs` holds this to. Schlick at 0.04 with the angle unsigned — a pane
+ * passes the same light seen from either side — and floored at the forward path's grazing 0.05.
+ */
+const GLASS_SHADE_WGSL = /* wgsl */ `
+fn glassShade(
+  own: vec3<f32>,
+  seen: vec3<f32>,
+  transmission: f32,
+  frost: f32,
+  tint: vec3<f32>,
+  cosView: f32,
+  sunGlow: vec3<f32>,
+) -> vec3<f32> {
+  let c = clamp(abs(cosView), 0.05, 1.0);
+  let fresnel = 0.04 + 0.96 * pow(1.0 - c, 5.0);
+  let shown = transmission * (1.0 - fresnel);
+  return own + (seen * tint - own) * shown + sunGlow * tint * (frost * transmission);
+}
+`;
+
 export const BLEND_RASTER_WGSL = /* wgsl */ `
 struct BlendVarying {
   @builtin(position) position: vec4<f32>,
@@ -108,6 +130,12 @@ ${FRAME_BLOCK_WGSL}
 @group(0) @binding(9) var environmentMap: texture_2d_array<f32>;
 @group(0) @binding(10) var environmentSampler: sampler;
 ${decodeResourcesWgsl({ group: 0, latents: 11, clampSampler: 12, repeatSampler: 13, nodes: 14, weights: 15 })}
+/**
+ * What the opaque half drew, with a mip chain on a frame whose scene holds glass: a pane shows it,
+ * a frosted one a coarser level of it. Read only by a material whose transmission is not zero.
+ */
+@group(0) @binding(16) var opaqueColour: texture_2d<f32>;
+@group(0) @binding(17) var opaqueSampler: sampler;
 fn decodeLatentSize() -> f32 {
   return frame.size.w;
 }
@@ -126,6 +154,7 @@ ${MESH_TRANSFORM_WGSL}
 ${SHADE_LIGHTING_WGSL}
 ${FOG_WGSL}
 ${OIT_WGSL}
+${GLASS_SHADE_WGSL}
 
 const NO_PROGRAM_HERE: u32 = ${0xffffffff}u;
 
@@ -241,7 +270,25 @@ fn blendFrag(in: BlendVarying) -> BlendTargets {
    * distance — which is the whole reason this pipeline gained a fog.
    */
   let toward = distance(in.world, frame.eye.xyz);
-  let colour = mix(litColour(surface, room), mediumColour(), mediumFog(toward, in.world.y));
+  let fog = mediumFog(toward, in.world.y);
+  var colour = mix(litColour(surface, room), mediumColour(), fog);
+  /*
+   * **Glass shows what is behind it**, as the forward path's glass branch does: the opaque half's
+   * picture at this pixel, at the level frost picks, two short of the chain's end so a fully frosted
+   * pane keeps the large light and dark behind it. The sun glows through from the pane's far side,
+   * after the haze as the forward path adds it. A pane is seen from both sides, so its facing is
+   * the side toward the eye.
+   */
+  let transmission = entry.extra.y;
+  if (transmission > 0.0) {
+    let size = vec2<f32>(textureDimensions(opaqueColour, 0));
+    let levels = max(floor(log2(max(size.x, size.y))) - 2.0, 0.0);
+    let seen = textureSampleLevel(opaqueColour, opaqueSampler, in.position.xy / size, entry.extra.z * levels).xyz;
+    let cosView = dot(surface.normal, toEye);
+    let facing = select(surface.normal, -surface.normal, cosView < 0.0);
+    let sunGlow = frame.lightColour.xyz * max(-dot(facing, frame.lightDir.xyz), 0.0) * (1.0 - fog);
+    colour = glassShade(colour, seen, transmission, entry.extra.z, entry.glassTint.xyz, cosView, sunGlow);
+  }
 
   /*
    * **The distance to the eye, not the clip-space depth**, because that is what oitWeight's falloff
@@ -255,6 +302,20 @@ fn blendFrag(in: BlendVarying) -> BlendTargets {
   out.reveal = vec4<f32>(alpha, 0.0, 0.0, alpha);
   return out;
 }
+
+/*
+ * **What a pane lets through, drawn from the sun into the tint map**: \`blendVert\` again, handed
+ * the light's raster matrix and the glass list, and this for the colour — \`glassShadow.ts\`'s
+ * paneTexel, the forward path's GLASS_TINT_FRAG in this language. Written against a white target
+ * with a multiplying blend and no depth, so every pane on a ray counts in any order.
+ */
+@fragment
+fn glassTintFrag(in: BlendVarying) -> @location(0) vec4<f32> {
+  let entry = materials[min(in.material, ${MATERIAL_SLOTS - 1}u)];
+  let c = clamp(abs(dot(normalize(in.normal), frame.lightDir.xyz)), 0.05, 1.0);
+  let passes = entry.extra.y * (1.0 - (0.04 + 0.96 * pow(1.0 - c, 5.0)));
+  return vec4<f32>(passes * entry.glassTint.xyz, 1.0 - entry.extra.z);
+}
 `;
 
 /**
@@ -341,3 +402,29 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
   results[out + 3u] = resolved.z;
 }
 `;
+
+/**
+ * `glassShade` alone, as a dispatch, so it can be checked against `gpudriven/lit.ts`.
+ *
+ * Sixteen floats a case — own, seen, transmission, frost, tint, the view cosine, the glow, one
+ * spare — and four out, the colour and one spare.
+ */
+export const GLASS_SHADE_PARITY_WGSL = /* wgsl */ `
+@group(0) @binding(0) var<storage, read> cases: array<f32>;
+@group(0) @binding(1) var<storage, read_write> results: array<f32>;
+${GLASS_SHADE_WGSL}
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+  if (id.x * 16u + 15u >= arrayLength(&cases)) { return; }
+  let at = id.x * 16u;
+  let own = vec3<f32>(cases[at], cases[at + 1u], cases[at + 2u]);
+  let seen = vec3<f32>(cases[at + 3u], cases[at + 4u], cases[at + 5u]);
+  let tint = vec3<f32>(cases[at + 8u], cases[at + 9u], cases[at + 10u]);
+  let glow = vec3<f32>(cases[at + 12u], cases[at + 13u], cases[at + 14u]);
+  let shaded = glassShade(own, seen, cases[at + 6u], cases[at + 7u], tint, cases[at + 11u], glow);
+  let out = id.x * 4u;
+  results[out] = shaded.x;
+  results[out + 1u] = shaded.y;
+  results[out + 2u] = shaded.z;
+}
+`;

package/src/render/shaders/gpudriven/cull.wgsl.ts

@@ -104,9 +104,11 @@ struct Params {
   eyeZ: f32,
   /** Non-zero to select the blended clusters, zero to select everything else. */
   wantBlend: f32,
+  /** Non-zero to keep, of those, only glass: what the light's glass pass draws. */
+  wantGlass: f32,
 };
 ${MATERIAL_TABLE_WGSL}
-@group(0) @binding(0) var<storage, read> params: array<f32, 7>;
+@group(0) @binding(0) var<storage, read> params: array<f32, 8>;
 /** Six floats a cluster: centre, radius, own error, parent error. */
 @group(0) @binding(1) var<storage, read> clusters: array<f32>;
 @group(0) @binding(2) var<storage, read_write> selected: array<u32>;
@@ -139,11 +141,18 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
    * neither is drawn twice and neither is dropped. The flag is read through a uniform by an index
    * that is the same for every cluster of a mesh, so the branch is as coherent as this shader gets.
    */
-  let blended = materials[min(materialOf[i], ${MATERIAL_SLOTS - 1}u)].orm.w != 0.0;
+  let material = materials[min(materialOf[i], ${MATERIAL_SLOTS - 1}u)];
+  let blended = material.orm.w != 0.0;
   if (blended != (params[6] != 0.0)) {
     selected[i] = 0u;
     return;
   }
+  /* The light's glass pass: a blended surface that is not glass casts nothing, as on the forward
+     path, so only a material letting light through is kept. */
+  if (params[7] != 0.0 && material.extra.y <= 0.0) {
+    selected[i] = 0u;
+    return;
+  }
   let screenHeight = params[0];
   let fovY = params[1];
   let threshold = params[2];

package/src/render/shaders/gpudriven/materialTable.wgsl.ts

@@ -38,8 +38,10 @@ struct Material {
   maps: vec4<f32>,
   /** Roughness scale, metallic scale, the alpha cutoff, and non-zero where this one blends. */
   orm: vec4<f32>,
-  /** The blended opacity, and three spare. */
+  /** The blended opacity, the glass's transmission and frost, and one spare. */
   extra: vec4<f32>,
+  /** The glass's tint, white where the material is not glass, and one spare. */
+  glassTint: vec4<f32>,
 }
 
 const NO_PROGRAM: u32 = ${DECODE_NO_PROGRAM}u;

package/src/render/shaders/gpudriven/shade.wgsl.ts

@@ -8,6 +8,7 @@ import { MATERIAL_SLOTS, MATERIAL_TABLE_WGSL } from './materialTable.wgsl.ts';
 import { MESH_TRANSFORM_WGSL } from './meshTransform.wgsl.ts';
 import { ENVIRONMENT_WGSL } from './environment.wgsl.ts';
 import { SHADE_SHADOW_WGSL } from './shadow.wgsl.ts';
+import { SUN_GLASS_WGSL } from './sunGlass.wgsl.ts';
 
 /**
  * Rebuilding a pixel's surface from the triangle it recorded, on the device.
@@ -514,6 +515,14 @@ struct Job {
 @group(0) @binding(12) var environmentMap: texture_2d_array<f32>;
 @group(0) @binding(13) var environmentSampler: sampler;
 ${decodeResourcesWgsl({ group: 0, latents: 14, clampSampler: 15, repeatSampler: 16, nodes: 17, weights: 18 })}
+/*
+ * **What the sun keeps through glass: the nearest pane's depth and what the panes let through**,
+ * which the pass draws from the sun after its opaque map. Where no material is glass the depth is
+ * the opaque map again and the tint a single white texel, which sunGlassAt reads as none.
+ */
+@group(0) @binding(19) var glassDepthMap: texture_depth_2d;
+@group(0) @binding(20) var glassTints: texture_2d<f32>;
+@group(0) @binding(21) var glassSampler: sampler;
 
 fn decodeLatentSize() -> f32 {
   return frame.size.w;
@@ -545,6 +554,45 @@ fn shadowDepthAt(u: f32, v: f32) -> f32 {
   return textureLoad(shadowMap, vec2<i32>(x, y), 0);
 }
 ${SHADE_SHADOW_WGSL}
+
+/* sunGlass.wgsl.ts's three reads, as the opaque map is read: nearest by integer coordinate. */
+fn glassDepthAt(u: f32, v: f32) -> f32 {
+  let size = frame.shadow.y;
+  let x = i32(clamp(floor(u * size), 0.0, size - 1.0));
+  let y = i32(clamp(floor(v * size), 0.0, size - 1.0));
+  return textureLoad(glassDepthMap, vec2<i32>(x, y), 0);
+}
+
+fn glassTintTexel(u: f32, v: f32) -> vec4<f32> {
+  let size = f32(textureDimensions(glassTints, 0).x);
+  let x = i32(clamp(floor(u * size), 0.0, size - 1.0));
+  let y = i32(clamp(floor(v * size), 0.0, size - 1.0));
+  return textureLoad(glassTints, vec2<i32>(x, y), 0);
+}
+
+/* The tint over a spread, from the chain: the level whose texel is the spread's width. */
+fn glassTintAround(u: f32, v: f32, radius: f32) -> vec4<f32> {
+  let size = f32(textureDimensions(glassTints, 0).x);
+  return textureSampleLevel(glassTints, glassSampler, vec2<f32>(u, v), log2(max(radius * size, 1.0)));
+}
+${SUN_GLASS_WGSL}
+
+/*
+ * The sun's colour at this receiver after the panes between it and the sun: white where no glass
+ * cast, and faded with the opaque shadow's own strength. The map's scale in metres comes off the
+ * light's matrix, which is orthographic: a compute invocation has no derivatives to take it from.
+ */
+fn sunGlassAt(lightPos: vec3<f32>) -> vec3<f32> {
+  if (textureDimensions(glassTints, 0).x <= 1u || frame.shadow.x <= 0.0) { return vec3<f32>(1.0); }
+  let m = frame.lightViewProj;
+  var settings: SunGlassSettings;
+  settings.mapSize = frame.shadow.y;
+  settings.depthSpan = frame.shadow.z;
+  settings.uvPerMetre = 0.5 * length(vec3<f32>(m[0][0], m[1][0], m[2][0]));
+  settings.taps = frame.shadowLimits.y;
+  let tint = sunGlass(lightPos.x * 0.5 + 0.5, lightPos.y * 0.5 + 0.5, lightPos.z, settings);
+  return mix(vec3<f32>(1.0), tint, frame.shadow.x);
+}
 ${ENVIRONMENT_WGSL}
 ${FOG_WGSL}
 
@@ -737,7 +785,8 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
 
   var room: LitEnvironment;
   room.lightDir = frame.lightDir.xyz;
-  room.lightColour = frame.lightColour.xyz;
+  /* The sun's colour through whatever glass stands between it and here, as flat/main.ts's is. */
+  room.lightColour = frame.lightColour.xyz * sunGlassAt(lightPos);
   room.sky = frame.sky.xyz;
   room.ground = frame.ground.xyz;
   /*