@driftengine/core 3.61.0

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

@@ -0,0 +1,201 @@
+/*
+ * Generated from ../scatter.ts by `npm run wgsl`. Do not edit.
+ *
+ * The GLSL beside this file is the source of truth. A hand edit here is discarded by
+ * the next generation, and `npm run wgsl:check` fails the build when this is stale.
+ */
+export const SCATTER_DEPTH_VERT_WGSL = "struct Uniforms {\n    uLightViewProj: mat4x4<f32>,\n    uWindDirection: vec2<f32>,\n    uWindSpeed: f32,\n    uWindGust: f32,\n    uWindTime: f32,\n    uWindSpatialPhase: vec2<f32>,\n    uTrample: array<vec4<f32>, 8>,\n    uTrampleRadius: f32,\n    uTrampleDepth: f32,\n}\n\nstruct gl_PerVertex {\n    @builtin(position) gl_Position: vec4<f32>,\n    gl_PointSize: f32,\n}\n\nstruct VertexOutput {\n    @location(0) member: vec4<f32>,\n    @builtin(position) gl_Position: vec4<f32>,\n}\n\n@group(0) @binding(0) \nvar<uniform> unnamed: Uniforms;\nvar<private> aPosition_1: vec3<f32>;\nvar<private> aInstancePos_1: vec3<f32>;\nvar<private> aScaleYaw_1: vec2<f32>;\nvar<private> aWindResponse_1: vec3<f32>;\nvar<private> vLightPosition: vec4<f32>;\nvar<private> unnamed_1: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f);\n\nfn scatterOffset_u0028_vf3_u003b_vf3_u003b_vf2_u003b_vf3_u003b_vf2_u003b(position: ptr<function, vec3<f32>>, instancePos: ptr<function, vec3<f32>>, scaleYaw: ptr<function, vec2<f32>>, windResponse: ptr<function, vec3<f32>>, yawTrig: ptr<function, vec2<f32>>) -> vec3<f32> {\n    var s: f32;\n    var c: f32;\n    var local: vec3<f32>;\n    var rotated: vec3<f32>;\n    var phase: f32;\n    var rooted: f32;\n    var bend: f32;\n    var pressed: f32;\n    var away: vec2<f32>;\n    var i: i32;\n    var p: vec4<f32>;\n    var offset: vec3<f32>;\n    var dist: f32;\n    var fade: f32;\n    var strength: f32;\n    var local_1: vec2<f32>;\n    var take: f32;\n\n    let _e49 = (*yawTrig)[0u];\n    s = _e49;\n    let _e51 = (*yawTrig)[1u];\n    c = _e51;\n    let _e52 = (*position);\n    let _e54 = (*scaleYaw)[0u];\n    local = (_e52 * _e54);\n    let _e57 = local[0u];\n    let _e58 = c;\n    let _e61 = local[2u];\n    let _e62 = s;\n    let _e66 = local[1u];\n    let _e68 = local[0u];\n    let _e70 = s;\n    let _e73 = local[2u];\n    let _e74 = c;\n    rotated = vec3<f32>(((_e57 * _e58) + (_e61 * _e62)), _e66, ((-(_e68) * _e70) + (_e73 * _e74)));\n    let _e78 = (*instancePos);\n    let _e81 = unnamed.uWindSpatialPhase;\n    let _e84 = unnamed.uWindTime;\n    let _e87 = (*windResponse)[2u];\n    phase = ((dot(_e78.xz, _e81) + _e84) + _e87);\n    let _e90 = rotated[1u];\n    let _e92 = (*windResponse)[0u];\n    rooted = clamp((_e90 * _e92), 0f, 1f);\n    let _e96 = unnamed.uWindSpeed;\n    let _e98 = unnamed.uWindGust;\n    let _e100 = (*windResponse)[1u];\n    let _e103 = phase;\n    let _e106 = rooted;\n    let _e108 = rooted;\n    bend = ((((_e96 + (_e98 * _e100)) * sin(_e103)) * _e106) * _e108);\n    let _e111 = unnamed.uWindDirection;\n    let _e112 = bend;\n    let _e114 = rotated;\n    let _e116 = (_e114.xz + (_e111 * _e112));\n    let _e117 = rotated;\n    rotated = vec3<f32>(_e116.x, _e117.y, _e116.y);\n    pressed = 0f;\n    away = vec2<f32>(0f, 0f);\n    i = 0i;\n    loop {\n        let _e122 = i;\n        if (_e122 < 8i) {\n            let _e124 = i;\n            let _e127 = unnamed.uTrample[_e124];\n            p = _e127;\n            let _e129 = p[3u];\n            if (_e129 <= 0f) {\n                continue;\n            }\n            let _e131 = (*instancePos);\n            let _e132 = p;\n            offset = (_e131 - _e132.xyz);\n            let _e135 = offset;\n            dist = length(_e135);\n            let _e137 = dist;\n            let _e139 = unnamed.uTrampleRadius;\n            if (_e137 >= _e139) {\n                continue;\n            }\n            let _e141 = dist;\n            let _e143 = unnamed.uTrampleRadius;\n            fade = (1f - (_e141 / _e143));\n            let _e147 = p[3u];\n            let _e148 = fade;\n            let _e150 = fade;\n            strength = ((_e147 * _e148) * _e150);\n            let _e152 = strength;\n            let _e153 = pressed;\n            if (_e152 <= _e153) {\n                continue;\n            }\n            let _e155 = strength;\n            pressed = _e155;\n            let _e156 = dist;\n            if (_e156 > 0.0001f) {\n                let _e158 = offset;\n                let _e160 = dist;\n                local_1 = (_e158.xz / vec2(_e160));\n            } else {\n                local_1 = vec2<f32>(0f, 0f);\n            }\n            let _e163 = local_1;\n            away = _e163;\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e164 = i;\n            i = (_e164 + 1i);\n        }\n    }\n    let _e166 = pressed;\n    if (_e166 > 0f) {\n        let _e168 = pressed;\n        let _e170 = unnamed.uTrampleDepth;\n        take = (_e168 * _e170);\n        let _e172 = take;\n        let _e175 = rotated[1u];\n        rotated[1u] = (_e175 * (1f - _e172));\n        let _e178 = away;\n        let _e179 = take;\n        let _e182 = rotated[1u];\n        let _e185 = rotated;\n        let _e187 = (_e185.xz + (((_e178 * _e179) * _e182) * 1.4f));\n        let _e188 = rotated;\n        rotated = vec3<f32>(_e187.x, _e188.y, _e187.y);\n    }\n    let _e193 = rotated;\n    return _e193;\n}\n\nfn scatterYaw_u0028_f1_u003b(yaw: ptr<function, f32>) -> vec2<f32> {\n    let _e27 = (*yaw);\n    let _e29 = (*yaw);\n    return vec2<f32>(sin(_e27), cos(_e29));\n}\n\nfn main_1() {\n    var rotated_1: vec3<f32>;\n    var param: f32;\n    var param_1: vec3<f32>;\n    var param_2: vec3<f32>;\n    var param_3: vec2<f32>;\n    var param_4: vec3<f32>;\n    var param_5: vec2<f32>;\n\n    let _e34 = aScaleYaw_1[1u];\n    param = _e34;\n    let _e35 = scatterYaw_u0028_f1_u003b((&param));\n    let _e36 = aPosition_1;\n    param_1 = _e36;\n    let _e37 = aInstancePos_1;\n    param_2 = _e37;\n    let _e38 = aScaleYaw_1;\n    param_3 = _e38;\n    let _e39 = aWindResponse_1;\n    param_4 = _e39;\n    param_5 = _e35;\n    let _e40 = scatterOffset_u0028_vf3_u003b_vf3_u003b_vf2_u003b_vf3_u003b_vf2_u003b((&param_1), (&param_2), (&param_3), (&param_4), (&param_5));\n    rotated_1 = _e40;\n    let _e42 = unnamed.uLightViewProj;\n    let _e43 = aInstancePos_1;\n    let _e44 = rotated_1;\n    let _e45 = (_e43 + _e44);\n    vLightPosition = (_e42 * vec4<f32>(_e45.x, _e45.y, _e45.z, 1f));\n    let _e51 = vLightPosition;\n    unnamed_1.gl_Position = _e51;\n    return;\n}\n\n@vertex \nfn main(@location(0) aPosition: vec3<f32>, @location(3) aInstancePos: vec3<f32>, @location(4) aScaleYaw: vec2<f32>, @location(6) aWindResponse: vec3<f32>) -> VertexOutput {\n    aPosition_1 = aPosition;\n    aInstancePos_1 = aInstancePos;\n    aScaleYaw_1 = aScaleYaw;\n    aWindResponse_1 = aWindResponse;\n    main_1();\n    let _e12 = unnamed_1.gl_Position.y;\n    unnamed_1.gl_Position.y = -(_e12);\n    let _e14 = vLightPosition;\n    let _e15 = unnamed_1.gl_Position;\n    return VertexOutput(_e14, _e15);\n}\n";
+export const SCATTER_FRAG_WGSL = "struct Uniforms {\n    uDirectionalDir: vec3<f32>,\n    uDirectionalColor: vec3<f32>,\n    uAmbient: vec3<f32>,\n    uCameraPos: vec3<f32>,\n    uFogColor: vec3<f32>,\n    uFogDensity: f32,\n    uFogHeightFalloff: f32,\n    uFogEyeY: f32,\n    uUnderwaterColor: vec3<f32>,\n    uUnderwaterFogDensity: f32,\n    uUnderwaterFactor: f32,\n    uFogMode: i32,\n    uFogNear: f32,\n    uFogFar: f32,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vNormal_1: vec3<f32>;\nvar<private> vColor_1: vec3<f32>;\nvar<private> vWorldPos_1: vec3<f32>;\nvar<private> outColor: vec4<f32>;\n\nfn mediumColor_u0028_() -> vec3<f32> {\n    let _e25 = unnamed.uFogColor;\n    let _e27 = unnamed.uUnderwaterColor;\n    let _e29 = unnamed.uUnderwaterFactor;\n    return mix(_e25, _e27, vec3(_e29));\n}\n\nfn mediumFog_u0028_f1_u003b_f1_u003b(dist: ptr<function, f32>, pointY: ptr<function, f32>) -> f32 {\n    var span: f32;\n    var ramp: f32;\n    var wetLinear: f32;\n    var t: f32;\n    var denom: f32;\n    var air: f32;\n    var wet: f32;\n\n    let _e34 = unnamed.uFogMode;\n    if (_e34 == 1i) {\n        let _e37 = unnamed.uFogFar;\n        let _e39 = unnamed.uFogNear;\n        span = max((_e37 - _e39), 0.0001f);\n        let _e42 = (*dist);\n        let _e44 = unnamed.uFogNear;\n        let _e46 = span;\n        ramp = clamp(((_e42 - _e44) / _e46), 0f, 1f);\n        let _e50 = unnamed.uUnderwaterFactor;\n        if (_e50 <= 0f) {\n            let _e52 = ramp;\n            return _e52;\n        }\n        let _e54 = unnamed.uUnderwaterFogDensity;\n        let _e55 = (*dist);\n        wetLinear = (_e54 * _e55);\n        let _e57 = ramp;\n        let _e58 = wetLinear;\n        let _e60 = wetLinear;\n        let _e66 = unnamed.uUnderwaterFactor;\n        return mix(_e57, (1f - exp2(((-(_e58) * _e60) * 1.442695f))), _e66);\n    }\n    let _e68 = (*pointY);\n    let _e70 = unnamed.uFogEyeY;\n    let _e73 = unnamed.uFogHeightFalloff;\n    t = ((_e68 - _e70) * _e73);\n    let _e75 = t;\n    let _e78 = t;\n    denom = select(_e78, 0.0001f, (abs(_e75) < 0.0001f));\n    let _e81 = unnamed.uFogDensity;\n    let _e83 = (*dist);\n    let _e85 = denom;\n    let _e90 = denom;\n    air = (1f - exp((((-(_e81) * _e83) * (1f - exp(-(_e85)))) / _e90)));\n    let _e95 = unnamed.uUnderwaterFactor;\n    if (_e95 <= 0f) {\n        let _e97 = air;\n        return _e97;\n    }\n    let _e99 = unnamed.uUnderwaterFogDensity;\n    let _e100 = (*dist);\n    wet = (_e99 * _e100);\n    let _e102 = air;\n    let _e103 = wet;\n    let _e105 = wet;\n    let _e111 = unnamed.uUnderwaterFactor;\n    return mix(_e102, (1f - exp2(((-(_e103) * _e105) * 1.442695f))), _e111);\n}\n\nfn main_1() {\n    var n: vec3<f32>;\n    var ndl: f32;\n    var lit: vec3<f32>;\n    var fog: f32;\n    var param: f32;\n    var param_1: f32;\n\n    let _e30 = vNormal_1;\n    n = normalize(_e30);\n    let _e32 = n;\n    let _e34 = unnamed.uDirectionalDir;\n    ndl = abs(dot(_e32, _e34));\n    let _e37 = vColor_1;\n    let _e39 = unnamed.uAmbient;\n    let _e41 = unnamed.uDirectionalColor;\n    let _e42 = ndl;\n    lit = (_e37 * (_e39 + (_e41 * _e42)));\n    let _e46 = vWorldPos_1;\n    let _e48 = unnamed.uCameraPos;\n    param = distance(_e46, _e48);\n    let _e51 = vWorldPos_1[1u];\n    param_1 = _e51;\n    let _e52 = mediumFog_u0028_f1_u003b_f1_u003b((&param), (&param_1));\n    fog = _e52;\n    let _e53 = lit;\n    let _e54 = mediumColor_u0028_();\n    let _e55 = fog;\n    let _e57 = mix(_e53, _e54, vec3(_e55));\n    outColor = vec4<f32>(_e57.x, _e57.y, _e57.z, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(1) vNormal: vec3<f32>, @location(0) vColor: vec3<f32>, @location(2) vWorldPos: vec3<f32>) -> @location(0) vec4<f32> {\n    vNormal_1 = vNormal;\n    vColor_1 = vColor;\n    vWorldPos_1 = vWorldPos;\n    main_1();\n    let _e7 = outColor;\n    return _e7;\n}\n";
+export const SCATTER_VERT_WGSL = "struct Uniforms {\n    uViewProj: mat4x4<f32>,\n    uWindDirection: vec2<f32>,\n    uWindSpeed: f32,\n    uWindGust: f32,\n    uWindTime: f32,\n    uWindSpatialPhase: vec2<f32>,\n    uTrample: array<vec4<f32>, 8>,\n    uTrampleRadius: f32,\n    uTrampleDepth: f32,\n}\n\nstruct gl_PerVertex {\n    @builtin(position) gl_Position: vec4<f32>,\n    gl_PointSize: f32,\n}\n\nstruct VertexOutput {\n    @location(0) member: vec3<f32>,\n    @location(1) member_1: vec3<f32>,\n    @location(2) member_2: vec3<f32>,\n    @builtin(position) gl_Position: vec4<f32>,\n}\n\n@group(0) @binding(0) \nvar<uniform> unnamed: Uniforms;\nvar<private> aScaleYaw_1: vec2<f32>;\nvar<private> aPosition_1: vec3<f32>;\nvar<private> aInstancePos_1: vec3<f32>;\nvar<private> aWindResponse_1: vec3<f32>;\nvar<private> vColor: vec3<f32>;\nvar<private> aColor_1: vec3<f32>;\nvar<private> aTint_1: vec3<f32>;\nvar<private> vNormal: vec3<f32>;\nvar<private> aNormal_1: vec3<f32>;\nvar<private> vWorldPos: vec3<f32>;\nvar<private> unnamed_1: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f);\n\nfn scatterOffset_u0028_vf3_u003b_vf3_u003b_vf2_u003b_vf3_u003b_vf2_u003b(position: ptr<function, vec3<f32>>, instancePos: ptr<function, vec3<f32>>, scaleYaw: ptr<function, vec2<f32>>, windResponse: ptr<function, vec3<f32>>, yawTrig: ptr<function, vec2<f32>>) -> vec3<f32> {\n    var s: f32;\n    var c: f32;\n    var local: vec3<f32>;\n    var rotated: vec3<f32>;\n    var phase: f32;\n    var rooted: f32;\n    var bend: f32;\n    var pressed: f32;\n    var away: vec2<f32>;\n    var i: i32;\n    var p: vec4<f32>;\n    var offset: vec3<f32>;\n    var dist: f32;\n    var fade: f32;\n    var strength: f32;\n    var local_1: vec2<f32>;\n    var take: f32;\n\n    let _e54 = (*yawTrig)[0u];\n    s = _e54;\n    let _e56 = (*yawTrig)[1u];\n    c = _e56;\n    let _e57 = (*position);\n    let _e59 = (*scaleYaw)[0u];\n    local = (_e57 * _e59);\n    let _e62 = local[0u];\n    let _e63 = c;\n    let _e66 = local[2u];\n    let _e67 = s;\n    let _e71 = local[1u];\n    let _e73 = local[0u];\n    let _e75 = s;\n    let _e78 = local[2u];\n    let _e79 = c;\n    rotated = vec3<f32>(((_e62 * _e63) + (_e66 * _e67)), _e71, ((-(_e73) * _e75) + (_e78 * _e79)));\n    let _e83 = (*instancePos);\n    let _e86 = unnamed.uWindSpatialPhase;\n    let _e89 = unnamed.uWindTime;\n    let _e92 = (*windResponse)[2u];\n    phase = ((dot(_e83.xz, _e86) + _e89) + _e92);\n    let _e95 = rotated[1u];\n    let _e97 = (*windResponse)[0u];\n    rooted = clamp((_e95 * _e97), 0f, 1f);\n    let _e101 = unnamed.uWindSpeed;\n    let _e103 = unnamed.uWindGust;\n    let _e105 = (*windResponse)[1u];\n    let _e108 = phase;\n    let _e111 = rooted;\n    let _e113 = rooted;\n    bend = ((((_e101 + (_e103 * _e105)) * sin(_e108)) * _e111) * _e113);\n    let _e116 = unnamed.uWindDirection;\n    let _e117 = bend;\n    let _e119 = rotated;\n    let _e121 = (_e119.xz + (_e116 * _e117));\n    let _e122 = rotated;\n    rotated = vec3<f32>(_e121.x, _e122.y, _e121.y);\n    pressed = 0f;\n    away = vec2<f32>(0f, 0f);\n    i = 0i;\n    loop {\n        let _e127 = i;\n        if (_e127 < 8i) {\n            let _e129 = i;\n            let _e132 = unnamed.uTrample[_e129];\n            p = _e132;\n            let _e134 = p[3u];\n            if (_e134 <= 0f) {\n                continue;\n            }\n            let _e136 = (*instancePos);\n            let _e137 = p;\n            offset = (_e136 - _e137.xyz);\n            let _e140 = offset;\n            dist = length(_e140);\n            let _e142 = dist;\n            let _e144 = unnamed.uTrampleRadius;\n            if (_e142 >= _e144) {\n                continue;\n            }\n            let _e146 = dist;\n            let _e148 = unnamed.uTrampleRadius;\n            fade = (1f - (_e146 / _e148));\n            let _e152 = p[3u];\n            let _e153 = fade;\n            let _e155 = fade;\n            strength = ((_e152 * _e153) * _e155);\n            let _e157 = strength;\n            let _e158 = pressed;\n            if (_e157 <= _e158) {\n                continue;\n            }\n            let _e160 = strength;\n            pressed = _e160;\n            let _e161 = dist;\n            if (_e161 > 0.0001f) {\n                let _e163 = offset;\n                let _e165 = dist;\n                local_1 = (_e163.xz / vec2(_e165));\n            } else {\n                local_1 = vec2<f32>(0f, 0f);\n            }\n            let _e168 = local_1;\n            away = _e168;\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e169 = i;\n            i = (_e169 + 1i);\n        }\n    }\n    let _e171 = pressed;\n    if (_e171 > 0f) {\n        let _e173 = pressed;\n        let _e175 = unnamed.uTrampleDepth;\n        take = (_e173 * _e175);\n        let _e177 = take;\n        let _e180 = rotated[1u];\n        rotated[1u] = (_e180 * (1f - _e177));\n        let _e183 = away;\n        let _e184 = take;\n        let _e187 = rotated[1u];\n        let _e190 = rotated;\n        let _e192 = (_e190.xz + (((_e183 * _e184) * _e187) * 1.4f));\n        let _e193 = rotated;\n        rotated = vec3<f32>(_e192.x, _e193.y, _e192.y);\n    }\n    let _e198 = rotated;\n    return _e198;\n}\n\nfn scatterYaw_u0028_f1_u003b(yaw: ptr<function, f32>) -> vec2<f32> {\n    let _e32 = (*yaw);\n    let _e34 = (*yaw);\n    return vec2<f32>(sin(_e32), cos(_e34));\n}\n\nfn main_1() {\n    var yawTrig_1: vec2<f32>;\n    var param: f32;\n    var rotated_1: vec3<f32>;\n    var param_1: vec3<f32>;\n    var param_2: vec3<f32>;\n    var param_3: vec2<f32>;\n    var param_4: vec3<f32>;\n    var param_5: vec2<f32>;\n    var world: vec3<f32>;\n    var s_1: f32;\n    var c_1: f32;\n\n    let _e43 = aScaleYaw_1[1u];\n    param = _e43;\n    let _e44 = scatterYaw_u0028_f1_u003b((&param));\n    yawTrig_1 = _e44;\n    let _e45 = aPosition_1;\n    param_1 = _e45;\n    let _e46 = aInstancePos_1;\n    param_2 = _e46;\n    let _e47 = aScaleYaw_1;\n    param_3 = _e47;\n    let _e48 = aWindResponse_1;\n    param_4 = _e48;\n    let _e49 = yawTrig_1;\n    param_5 = _e49;\n    let _e50 = scatterOffset_u0028_vf3_u003b_vf3_u003b_vf2_u003b_vf3_u003b_vf2_u003b((&param_1), (&param_2), (&param_3), (&param_4), (&param_5));\n    rotated_1 = _e50;\n    let _e51 = aInstancePos_1;\n    let _e52 = rotated_1;\n    world = (_e51 + _e52);\n    let _e55 = yawTrig_1[0u];\n    s_1 = _e55;\n    let _e57 = yawTrig_1[1u];\n    c_1 = _e57;\n    let _e58 = aColor_1;\n    let _e59 = aTint_1;\n    vColor = (_e58 * _e59);\n    let _e62 = aNormal_1[0u];\n    let _e63 = c_1;\n    let _e66 = aNormal_1[2u];\n    let _e67 = s_1;\n    let _e71 = aNormal_1[1u];\n    let _e73 = aNormal_1[0u];\n    let _e75 = s_1;\n    let _e78 = aNormal_1[2u];\n    let _e79 = c_1;\n    vNormal = vec3<f32>(((_e62 * _e63) + (_e66 * _e67)), _e71, ((-(_e73) * _e75) + (_e78 * _e79)));\n    let _e83 = world;\n    vWorldPos = _e83;\n    let _e85 = unnamed.uViewProj;\n    let _e86 = world;\n    unnamed_1.gl_Position = (_e85 * vec4<f32>(_e86.x, _e86.y, _e86.z, 1f));\n    return;\n}\n\n@vertex \nfn main(@location(4) aScaleYaw: vec2<f32>, @location(0) aPosition: vec3<f32>, @location(3) aInstancePos: vec3<f32>, @location(6) aWindResponse: vec3<f32>, @location(2) aColor: vec3<f32>, @location(5) aTint: vec3<f32>, @location(1) aNormal: vec3<f32>) -> VertexOutput {\n    aScaleYaw_1 = aScaleYaw;\n    aPosition_1 = aPosition;\n    aInstancePos_1 = aInstancePos;\n    aWindResponse_1 = aWindResponse;\n    aColor_1 = aColor;\n    aTint_1 = aTint;\n    aNormal_1 = aNormal;\n    main_1();\n    let _e20 = unnamed_1.gl_Position.y;\n    unnamed_1.gl_Position.y = -(_e20);\n    let _e22 = vColor;\n    let _e23 = vNormal;\n    let _e24 = vWorldPos;\n    let _e25 = unnamed_1.gl_Position;\n    return VertexOutput(_e22, _e23, _e24, _e25);\n}\n";
+/**
+ * What the transform assigned, so the renderer binds the same numbers.
+ *
+ * A permuted shader has one entry per variant, keyed as `FLAT_FRAG_WGSL` is.
+ */
+export const SCATTER_BINDINGS = {
+    "SCATTER_DEPTH_VERT": {
+        "uniforms": 0,
+        "uniformSize": 240,
+        "fields": {
+            "uLightViewProj": {
+                "offset": 0,
+                "size": 64,
+                "type": "mat4"
+            },
+            "uWindDirection": {
+                "offset": 64,
+                "size": 8,
+                "type": "vec2"
+            },
+            "uWindSpeed": {
+                "offset": 72,
+                "size": 4,
+                "type": "float"
+            },
+            "uWindGust": {
+                "offset": 76,
+                "size": 4,
+                "type": "float"
+            },
+            "uWindTime": {
+                "offset": 80,
+                "size": 4,
+                "type": "float"
+            },
+            "uWindSpatialPhase": {
+                "offset": 88,
+                "size": 8,
+                "type": "vec2"
+            },
+            "uTrample": {
+                "offset": 96,
+                "size": 128,
+                "type": "vec4",
+                "length": 8,
+                "stride": 16
+            },
+            "uTrampleRadius": {
+                "offset": 224,
+                "size": 4,
+                "type": "float"
+            },
+            "uTrampleDepth": {
+                "offset": 228,
+                "size": 4,
+                "type": "float"
+            }
+        },
+        "textures": {}
+    },
+    "SCATTER_FRAG": {
+        "uniforms": 1,
+        "uniformSize": 128,
+        "fields": {
+            "uDirectionalDir": {
+                "offset": 0,
+                "size": 12,
+                "type": "vec3"
+            },
+            "uDirectionalColor": {
+                "offset": 16,
+                "size": 12,
+                "type": "vec3"
+            },
+            "uAmbient": {
+                "offset": 32,
+                "size": 12,
+                "type": "vec3"
+            },
+            "uCameraPos": {
+                "offset": 48,
+                "size": 12,
+                "type": "vec3"
+            },
+            "uFogColor": {
+                "offset": 64,
+                "size": 12,
+                "type": "vec3"
+            },
+            "uFogDensity": {
+                "offset": 76,
+                "size": 4,
+                "type": "float"
+            },
+            "uFogHeightFalloff": {
+                "offset": 80,
+                "size": 4,
+                "type": "float"
+            },
+            "uFogEyeY": {
+                "offset": 84,
+                "size": 4,
+                "type": "float"
+            },
+            "uUnderwaterColor": {
+                "offset": 96,
+                "size": 12,
+                "type": "vec3"
+            },
+            "uUnderwaterFogDensity": {
+                "offset": 108,
+                "size": 4,
+                "type": "float"
+            },
+            "uUnderwaterFactor": {
+                "offset": 112,
+                "size": 4,
+                "type": "float"
+            },
+            "uFogMode": {
+                "offset": 116,
+                "size": 4,
+                "type": "int"
+            },
+            "uFogNear": {
+                "offset": 120,
+                "size": 4,
+                "type": "float"
+            },
+            "uFogFar": {
+                "offset": 124,
+                "size": 4,
+                "type": "float"
+            }
+        },
+        "textures": {}
+    },
+    "SCATTER_VERT": {
+        "uniforms": 0,
+        "uniformSize": 240,
+        "fields": {
+            "uViewProj": {
+                "offset": 0,
+                "size": 64,
+                "type": "mat4"
+            },
+            "uWindDirection": {
+                "offset": 64,
+                "size": 8,
+                "type": "vec2"
+            },
+            "uWindSpeed": {
+                "offset": 72,
+                "size": 4,
+                "type": "float"
+            },
+            "uWindGust": {
+                "offset": 76,
+                "size": 4,
+                "type": "float"
+            },
+            "uWindTime": {
+                "offset": 80,
+                "size": 4,
+                "type": "float"
+            },
+            "uWindSpatialPhase": {
+                "offset": 88,
+                "size": 8,
+                "type": "vec2"
+            },
+            "uTrample": {
+                "offset": 96,
+                "size": 128,
+                "type": "vec4",
+                "length": 8,
+                "stride": 16
+            },
+            "uTrampleRadius": {
+                "offset": 224,
+                "size": 4,
+                "type": "float"
+            },
+            "uTrampleDepth": {
+                "offset": 228,
+                "size": 4,
+                "type": "float"
+            }
+        },
+        "textures": {}
+    }
+};

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

@@ -0,0 +1,69 @@
+export declare const SDF_TEXT_FRAG_WGSL = "struct Uniforms {\n    uColor: vec3<f32>,\n    uOpacity: f32,\n    uDistanceRange: f32,\n    uAtlasSize: vec2<f32>,\n    uOutputTransform: i32,\n    uOutputExposure: f32,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\n@group(0) @binding(32) \nvar uAtlas_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uAtlas_s: sampler;\nvar<private> vUv_1: vec2<f32>;\nvar<private> outColor: vec4<f32>;\n\nfn linearToSrgb_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var low: vec3<f32>;\n    var high: vec3<f32>;\n\n    let _e60 = (*c);\n    low = (_e60 * 12.92f);\n    let _e62 = (*c);\n    high = ((pow(max(_e62, vec3<f32>(0f, 0f, 0f)), vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3(0.055f));\n    let _e68 = high;\n    let _e69 = low;\n    let _e70 = (*c);\n    return mix(_e68, _e69, step(_e70, vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f)));\n}\n\nfn rrtAndOdtFit_u0028_vf3_u003b(v: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var a: vec3<f32>;\n    var b: vec3<f32>;\n\n    let _e60 = (*v);\n    let _e61 = (*v);\n    a = ((_e60 * (_e61 + vec3(0.0245786f))) - vec3(0.000090537f));\n    let _e67 = (*v);\n    let _e68 = (*v);\n    b = ((_e67 * ((_e68 * 0.983729f) + vec3(0.432951f))) + vec3(0.238081f));\n    let _e75 = a;\n    let _e76 = b;\n    return (_e75 / _e76);\n}\n\nfn acesFilmic_u0028_vf3_u003b(x: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var param: vec3<f32>;\n\n    let _e60 = unnamed.uOutputExposure;\n    let _e61 = (*x);\n    (*x) = (_e61 * _e60);\n    let _e63 = (*x);\n    param = (mat3x3<f32>(vec3<f32>(0.59719f, 0.076f, 0.0284f), vec3<f32>(0.35458f, 0.90834f, 0.13383f), vec3<f32>(0.04823f, 0.01566f, 0.83777f)) * _e63);\n    let _e65 = rrtAndOdtFit_u0028_vf3_u003b((&param));\n    return clamp((mat3x3<f32>(vec3<f32>(1.60475f, -0.10208f, -0.00327f), vec3<f32>(-0.53108f, 1.10813f, -0.07276f), vec3<f32>(-0.07367f, -0.00605f, 1.07602f)) * _e65), vec3(0f), vec3(1f));\n}\n\nfn applyOutputTransform_u0028_vf3_u003b(c_1: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var param_1: vec3<f32>;\n    var param_2: vec3<f32>;\n\n    let _e61 = unnamed.uOutputTransform;\n    if (_e61 == 0i) {\n        let _e63 = (*c_1);\n        return _e63;\n    }\n    let _e65 = unnamed.uOutputTransform;\n    if (_e65 == 2i) {\n        let _e67 = (*c_1);\n        param_1 = _e67;\n        let _e68 = acesFilmic_u0028_vf3_u003b((&param_1));\n        (*c_1) = _e68;\n    }\n    let _e69 = (*c_1);\n    param_2 = _e69;\n    let _e70 = linearToSrgb_u0028_vf3_u003b((&param_2));\n    return _e70;\n}\n\nfn median_u0028_vf3_u003b(rgb: ptr<function, vec3<f32>>) -> f32 {\n    let _e59 = (*rgb)[0u];\n    let _e61 = (*rgb)[1u];\n    let _e64 = (*rgb)[0u];\n    let _e66 = (*rgb)[1u];\n    let _e69 = (*rgb)[2u];\n    return max(min(_e59, _e61), min(max(_e64, _e66), _e69));\n}\n\nfn main_1() {\n    var sampled: vec3<f32>;\n    var distance_: f32;\n    var param_3: vec3<f32>;\n    var texelsPerPixel: vec2<f32>;\n    var pixelRange: f32;\n    var coverage: f32;\n    var param_4: vec3<f32>;\n\n    let _e64 = vUv_1;\n    let _e65 = textureSampleLevel(uAtlas_t, uAtlas_s, _e64, 0f);\n    sampled = _e65.xyz;\n    let _e67 = sampled;\n    param_3 = _e67;\n    let _e68 = median_u0028_vf3_u003b((&param_3));\n    distance_ = (_e68 - 0.5f);\n    let _e70 = vUv_1;\n    let _e71 = fwidth(_e70);\n    let _e73 = unnamed.uAtlasSize;\n    texelsPerPixel = (_e71 * _e73);\n    let _e76 = texelsPerPixel[0u];\n    let _e78 = texelsPerPixel[1u];\n    pixelRange = max((0.5f * (_e76 + _e78)), 0.0001f);\n    let _e82 = distance_;\n    let _e84 = unnamed.uDistanceRange;\n    let _e86 = pixelRange;\n    coverage = clamp((((_e82 * _e84) / _e86) + 0.5f), 0f, 1f);\n    let _e91 = unnamed.uColor;\n    param_4 = _e91;\n    let _e92 = applyOutputTransform_u0028_vf3_u003b((&param_4));\n    let _e93 = coverage;\n    let _e95 = unnamed.uOpacity;\n    outColor = vec4<f32>(_e92.x, _e92.y, _e92.z, (_e93 * _e95));\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 = outColor;\n    return _e3;\n}\n";
+export declare const SDF_TEXT_VERT_WGSL = "struct gl_PerVertex {\n    @builtin(position) gl_Position: vec4<f32>,\n    gl_PointSize: f32,\n}\n\nstruct Uniforms {\n    uViewProj: mat4x4<f32>,\n    uModel: mat4x4<f32>,\n}\n\nstruct VertexOutput {\n    @location(0) member: vec2<f32>,\n    @builtin(position) gl_Position: vec4<f32>,\n}\n\nvar<private> vUv: vec2<f32>;\nvar<private> aUv_1: vec2<f32>;\nvar<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f);\n@group(0) @binding(0) \nvar<uniform> unnamed_1: Uniforms;\nvar<private> aPosition_1: vec3<f32>;\n\nfn main_1() {\n    let _e8 = aUv_1;\n    vUv = _e8;\n    let _e10 = unnamed_1.uViewProj;\n    let _e12 = unnamed_1.uModel;\n    let _e14 = aPosition_1;\n    unnamed.gl_Position = ((_e10 * _e12) * vec4<f32>(_e14.x, _e14.y, _e14.z, 1f));\n    return;\n}\n\n@vertex \nfn main(@location(1) aUv: vec2<f32>, @location(0) aPosition: vec3<f32>) -> VertexOutput {\n    aUv_1 = aUv;\n    aPosition_1 = aPosition;\n    main_1();\n    let _e8 = unnamed.gl_Position.y;\n    unnamed.gl_Position.y = -(_e8);\n    let _e10 = vUv;\n    let _e11 = unnamed.gl_Position;\n    return VertexOutput(_e10, _e11);\n}\n";
+/**
+ * What the transform assigned, so the renderer binds the same numbers.
+ *
+ * A permuted shader has one entry per variant, keyed as `FLAT_FRAG_WGSL` is.
+ */
+export declare const SDFTEXT_BINDINGS: {
+    readonly SDF_TEXT_FRAG: {
+        readonly uniforms: 1;
+        readonly uniformSize: 48;
+        readonly fields: {
+            readonly uColor: {
+                readonly offset: 0;
+                readonly size: 12;
+                readonly type: "vec3";
+            };
+            readonly uOpacity: {
+                readonly offset: 12;
+                readonly size: 4;
+                readonly type: "float";
+            };
+            readonly uDistanceRange: {
+                readonly offset: 16;
+                readonly size: 4;
+                readonly type: "float";
+            };
+            readonly uAtlasSize: {
+                readonly offset: 24;
+                readonly size: 8;
+                readonly type: "vec2";
+            };
+            readonly uOutputTransform: {
+                readonly offset: 32;
+                readonly size: 4;
+                readonly type: "int";
+            };
+            readonly uOutputExposure: {
+                readonly offset: 36;
+                readonly size: 4;
+                readonly type: "float";
+            };
+        };
+        readonly textures: {
+            readonly uAtlas: {
+                readonly texture: 32;
+                readonly sampler: 33;
+                readonly type: "sampler2D";
+            };
+        };
+    };
+    readonly SDF_TEXT_VERT: {
+        readonly uniforms: 0;
+        readonly uniformSize: 128;
+        readonly fields: {
+            readonly uViewProj: {
+                readonly offset: 0;
+                readonly size: 64;
+                readonly type: "mat4";
+            };
+            readonly uModel: {
+                readonly offset: 64;
+                readonly size: 64;
+                readonly type: "mat4";
+            };
+        };
+        readonly textures: {};
+    };
+};

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

@@ -0,0 +1,75 @@
+/*
+ * Generated from ../sdfText.ts by `npm run wgsl`. Do not edit.
+ *
+ * The GLSL beside this file is the source of truth. A hand edit here is discarded by
+ * the next generation, and `npm run wgsl:check` fails the build when this is stale.
+ */
+export const SDF_TEXT_FRAG_WGSL = "struct Uniforms {\n    uColor: vec3<f32>,\n    uOpacity: f32,\n    uDistanceRange: f32,\n    uAtlasSize: vec2<f32>,\n    uOutputTransform: i32,\n    uOutputExposure: f32,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\n@group(0) @binding(32) \nvar uAtlas_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uAtlas_s: sampler;\nvar<private> vUv_1: vec2<f32>;\nvar<private> outColor: vec4<f32>;\n\nfn linearToSrgb_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var low: vec3<f32>;\n    var high: vec3<f32>;\n\n    let _e60 = (*c);\n    low = (_e60 * 12.92f);\n    let _e62 = (*c);\n    high = ((pow(max(_e62, vec3<f32>(0f, 0f, 0f)), vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3(0.055f));\n    let _e68 = high;\n    let _e69 = low;\n    let _e70 = (*c);\n    return mix(_e68, _e69, step(_e70, vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f)));\n}\n\nfn rrtAndOdtFit_u0028_vf3_u003b(v: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var a: vec3<f32>;\n    var b: vec3<f32>;\n\n    let _e60 = (*v);\n    let _e61 = (*v);\n    a = ((_e60 * (_e61 + vec3(0.0245786f))) - vec3(0.000090537f));\n    let _e67 = (*v);\n    let _e68 = (*v);\n    b = ((_e67 * ((_e68 * 0.983729f) + vec3(0.432951f))) + vec3(0.238081f));\n    let _e75 = a;\n    let _e76 = b;\n    return (_e75 / _e76);\n}\n\nfn acesFilmic_u0028_vf3_u003b(x: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var param: vec3<f32>;\n\n    let _e60 = unnamed.uOutputExposure;\n    let _e61 = (*x);\n    (*x) = (_e61 * _e60);\n    let _e63 = (*x);\n    param = (mat3x3<f32>(vec3<f32>(0.59719f, 0.076f, 0.0284f), vec3<f32>(0.35458f, 0.90834f, 0.13383f), vec3<f32>(0.04823f, 0.01566f, 0.83777f)) * _e63);\n    let _e65 = rrtAndOdtFit_u0028_vf3_u003b((&param));\n    return clamp((mat3x3<f32>(vec3<f32>(1.60475f, -0.10208f, -0.00327f), vec3<f32>(-0.53108f, 1.10813f, -0.07276f), vec3<f32>(-0.07367f, -0.00605f, 1.07602f)) * _e65), vec3(0f), vec3(1f));\n}\n\nfn applyOutputTransform_u0028_vf3_u003b(c_1: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var param_1: vec3<f32>;\n    var param_2: vec3<f32>;\n\n    let _e61 = unnamed.uOutputTransform;\n    if (_e61 == 0i) {\n        let _e63 = (*c_1);\n        return _e63;\n    }\n    let _e65 = unnamed.uOutputTransform;\n    if (_e65 == 2i) {\n        let _e67 = (*c_1);\n        param_1 = _e67;\n        let _e68 = acesFilmic_u0028_vf3_u003b((&param_1));\n        (*c_1) = _e68;\n    }\n    let _e69 = (*c_1);\n    param_2 = _e69;\n    let _e70 = linearToSrgb_u0028_vf3_u003b((&param_2));\n    return _e70;\n}\n\nfn median_u0028_vf3_u003b(rgb: ptr<function, vec3<f32>>) -> f32 {\n    let _e59 = (*rgb)[0u];\n    let _e61 = (*rgb)[1u];\n    let _e64 = (*rgb)[0u];\n    let _e66 = (*rgb)[1u];\n    let _e69 = (*rgb)[2u];\n    return max(min(_e59, _e61), min(max(_e64, _e66), _e69));\n}\n\nfn main_1() {\n    var sampled: vec3<f32>;\n    var distance_: f32;\n    var param_3: vec3<f32>;\n    var texelsPerPixel: vec2<f32>;\n    var pixelRange: f32;\n    var coverage: f32;\n    var param_4: vec3<f32>;\n\n    let _e64 = vUv_1;\n    let _e65 = textureSampleLevel(uAtlas_t, uAtlas_s, _e64, 0f);\n    sampled = _e65.xyz;\n    let _e67 = sampled;\n    param_3 = _e67;\n    let _e68 = median_u0028_vf3_u003b((&param_3));\n    distance_ = (_e68 - 0.5f);\n    let _e70 = vUv_1;\n    let _e71 = fwidth(_e70);\n    let _e73 = unnamed.uAtlasSize;\n    texelsPerPixel = (_e71 * _e73);\n    let _e76 = texelsPerPixel[0u];\n    let _e78 = texelsPerPixel[1u];\n    pixelRange = max((0.5f * (_e76 + _e78)), 0.0001f);\n    let _e82 = distance_;\n    let _e84 = unnamed.uDistanceRange;\n    let _e86 = pixelRange;\n    coverage = clamp((((_e82 * _e84) / _e86) + 0.5f), 0f, 1f);\n    let _e91 = unnamed.uColor;\n    param_4 = _e91;\n    let _e92 = applyOutputTransform_u0028_vf3_u003b((&param_4));\n    let _e93 = coverage;\n    let _e95 = unnamed.uOpacity;\n    outColor = vec4<f32>(_e92.x, _e92.y, _e92.z, (_e93 * _e95));\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 = outColor;\n    return _e3;\n}\n";
+export const SDF_TEXT_VERT_WGSL = "struct gl_PerVertex {\n    @builtin(position) gl_Position: vec4<f32>,\n    gl_PointSize: f32,\n}\n\nstruct Uniforms {\n    uViewProj: mat4x4<f32>,\n    uModel: mat4x4<f32>,\n}\n\nstruct VertexOutput {\n    @location(0) member: vec2<f32>,\n    @builtin(position) gl_Position: vec4<f32>,\n}\n\nvar<private> vUv: vec2<f32>;\nvar<private> aUv_1: vec2<f32>;\nvar<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f);\n@group(0) @binding(0) \nvar<uniform> unnamed_1: Uniforms;\nvar<private> aPosition_1: vec3<f32>;\n\nfn main_1() {\n    let _e8 = aUv_1;\n    vUv = _e8;\n    let _e10 = unnamed_1.uViewProj;\n    let _e12 = unnamed_1.uModel;\n    let _e14 = aPosition_1;\n    unnamed.gl_Position = ((_e10 * _e12) * vec4<f32>(_e14.x, _e14.y, _e14.z, 1f));\n    return;\n}\n\n@vertex \nfn main(@location(1) aUv: vec2<f32>, @location(0) aPosition: vec3<f32>) -> VertexOutput {\n    aUv_1 = aUv;\n    aPosition_1 = aPosition;\n    main_1();\n    let _e8 = unnamed.gl_Position.y;\n    unnamed.gl_Position.y = -(_e8);\n    let _e10 = vUv;\n    let _e11 = unnamed.gl_Position;\n    return VertexOutput(_e10, _e11);\n}\n";
+/**
+ * What the transform assigned, so the renderer binds the same numbers.
+ *
+ * A permuted shader has one entry per variant, keyed as `FLAT_FRAG_WGSL` is.
+ */
+export const SDFTEXT_BINDINGS = {
+    "SDF_TEXT_FRAG": {
+        "uniforms": 1,
+        "uniformSize": 48,
+        "fields": {
+            "uColor": {
+                "offset": 0,
+                "size": 12,
+                "type": "vec3"
+            },
+            "uOpacity": {
+                "offset": 12,
+                "size": 4,
+                "type": "float"
+            },
+            "uDistanceRange": {
+                "offset": 16,
+                "size": 4,
+                "type": "float"
+            },
+            "uAtlasSize": {
+                "offset": 24,
+                "size": 8,
+                "type": "vec2"
+            },
+            "uOutputTransform": {
+                "offset": 32,
+                "size": 4,
+                "type": "int"
+            },
+            "uOutputExposure": {
+                "offset": 36,
+                "size": 4,
+                "type": "float"
+            }
+        },
+        "textures": {
+            "uAtlas": {
+                "texture": 32,
+                "sampler": 33,
+                "type": "sampler2D"
+            }
+        }
+    },
+    "SDF_TEXT_VERT": {
+        "uniforms": 0,
+        "uniformSize": 128,
+        "fields": {
+            "uViewProj": {
+                "offset": 0,
+                "size": 64,
+                "type": "mat4"
+            },
+            "uModel": {
+                "offset": 64,
+                "size": 64,
+                "type": "mat4"
+            }
+        },
+        "textures": {}
+    }
+};

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

@@ -0,0 +1,100 @@
+export declare const SKY_FRAG_WGSL = "struct Uniforms {\n    uInvViewProj: mat4x4<f32>,\n    uCameraPos: vec3<f32>,\n    uTopColor: vec3<f32>,\n    uHorizonColor: vec3<f32>,\n    uDeepColor: vec3<f32>,\n    uSunDir: vec3<f32>,\n    uSunColor: vec3<f32>,\n    uSunDiscExponent: f32,\n    uMoonDir: vec3<f32>,\n    uMoonColor: vec3<f32>,\n    uMoonAngularRadius: f32,\n    uMoonPhase: f32,\n    uNightFactor: f32,\n    uCloudOffset: vec2<f32>,\n    uUnderwaterColor: vec3<f32>,\n    uUnderwaterFactor: f32,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vNdc_1: vec2<f32>;\nvar<private> outColor: vec4<f32>;\n\nfn hash21_u0028_vf2_u003b(p: ptr<function, vec2<f32>>) -> f32 {\n    let _e105 = (*p);\n    return fract((sin(dot(_e105, vec2<f32>(127.1f, 311.7f))) * 43758.547f));\n}\n\nfn valueNoise_u0028_vf2_u003b(p_1: ptr<function, vec2<f32>>) -> f32 {\n    var i: vec2<f32>;\n    var f: vec2<f32>;\n    var u: vec2<f32>;\n    var a: f32;\n    var param: vec2<f32>;\n    var b: f32;\n    var param_1: vec2<f32>;\n    var c: f32;\n    var param_2: vec2<f32>;\n    var d: f32;\n    var param_3: vec2<f32>;\n\n    let _e116 = (*p_1);\n    i = floor(_e116);\n    let _e118 = (*p_1);\n    f = fract(_e118);\n    let _e120 = f;\n    let _e121 = f;\n    let _e123 = f;\n    u = ((_e120 * _e121) * (vec2(3f) - (_e123 * 2f)));\n    let _e128 = i;\n    param = _e128;\n    let _e129 = hash21_u0028_vf2_u003b((&param));\n    a = _e129;\n    let _e130 = i;\n    param_1 = (_e130 + vec2<f32>(1f, 0f));\n    let _e132 = hash21_u0028_vf2_u003b((&param_1));\n    b = _e132;\n    let _e133 = i;\n    param_2 = (_e133 + vec2<f32>(0f, 1f));\n    let _e135 = hash21_u0028_vf2_u003b((&param_2));\n    c = _e135;\n    let _e136 = i;\n    param_3 = (_e136 + vec2<f32>(1f, 1f));\n    let _e138 = hash21_u0028_vf2_u003b((&param_3));\n    d = _e138;\n    let _e139 = a;\n    let _e140 = b;\n    let _e142 = u[0u];\n    let _e144 = c;\n    let _e145 = d;\n    let _e147 = u[0u];\n    let _e150 = u[1u];\n    return mix(mix(_e139, _e140, _e142), mix(_e144, _e145, _e147), _e150);\n}\n\nfn fbm_u0028_vf2_u003b(p_2: ptr<function, vec2<f32>>) -> f32 {\n    var v: f32;\n    var param_4: vec2<f32>;\n    var param_5: vec2<f32>;\n    var param_6: vec2<f32>;\n\n    let _e109 = (*p_2);\n    param_4 = _e109;\n    let _e110 = valueNoise_u0028_vf2_u003b((&param_4));\n    v = (_e110 * 0.5f);\n    let _e112 = (*p_2);\n    param_5 = (_e112 * 2.03f);\n    let _e114 = valueNoise_u0028_vf2_u003b((&param_5));\n    let _e116 = v;\n    v = (_e116 + (_e114 * 0.3f));\n    let _e118 = (*p_2);\n    param_6 = (_e118 * 4.01f);\n    let _e120 = valueNoise_u0028_vf2_u003b((&param_6));\n    let _e122 = v;\n    v = (_e122 + (_e120 * 0.2f));\n    let _e124 = v;\n    return _e124;\n}\n\nfn main_1() {\n    var world: vec4<f32>;\n    var dir: vec3<f32>;\n    var t: f32;\n    var col: vec3<f32>;\n    var local: vec3<f32>;\n    var aboveHorizon: f32;\n    var sunset: f32;\n    var ember: vec3<f32>;\n    var s: f32;\n    var discColor: vec3<f32>;\n    var sunBearing: vec2<f32>;\n    var viewBearing: vec2<f32>;\n    var toward: f32;\n    var fromHorizon: f32;\n    var local_1: f32;\n    var band: f32;\n    var away: f32;\n    var moonReference: vec3<f32>;\n    var moonRight: vec3<f32>;\n    var moonUp: vec3<f32>;\n    var moonRadius: f32;\n    var moonUv: vec2<f32>;\n    var moonRadiusSq: f32;\n    var moonFacing: f32;\n    var moonDisc: f32;\n    var sphereZ: f32;\n    var surfaceNormal: vec3<f32>;\n    var phaseAngle: f32;\n    var phaseLight: vec3<f32>;\n    var phaseShade: f32;\n    var maria: f32;\n    var param_7: vec2<f32>;\n    var param_8: vec2<f32>;\n    var albedo: f32;\n    var limb: f32;\n    var earthshine: f32;\n    var lunarLight: f32;\n    var phaseIllumination: f32;\n    var moonHalo: f32;\n    var p_3: vec2<f32>;\n    var cell: vec2<f32>;\n    var h: f32;\n    var param_9: vec2<f32>;\n    var jitter: vec2<f32>;\n    var param_10: vec2<f32>;\n    var param_11: vec2<f32>;\n    var d_1: f32;\n    var star: f32;\n    var uv: vec2<f32>;\n    var band_1: f32;\n    var param_12: vec2<f32>;\n    var fade: f32;\n    var cloudCol: vec3<f32>;\n    var waterLight: f32;\n\n    let _e159 = unnamed.uInvViewProj;\n    let _e160 = vNdc_1;\n    world = (_e159 * vec4<f32>(_e160.x, _e160.y, 1f, 1f));\n    let _e165 = world;\n    let _e168 = world[3u];\n    let _e172 = unnamed.uCameraPos;\n    dir = normalize(((_e165.xyz / vec3(_e168)) - _e172));\n    let _e176 = dir[1u];\n    t = _e176;\n    let _e177 = t;\n    if (_e177 >= 0f) {\n        let _e180 = unnamed.uHorizonColor;\n        let _e182 = unnamed.uTopColor;\n        let _e183 = t;\n        local = mix(_e180, _e182, vec3(pow(min(_e183, 1f), 0.55f)));\n    } else {\n        let _e189 = unnamed.uHorizonColor;\n        let _e191 = unnamed.uDeepColor;\n        let _e192 = t;\n        local = mix(_e189, _e191, vec3(min((-(_e192) * 1.8f), 1f)));\n    }\n    let _e198 = local;\n    col = _e198;\n    let _e200 = dir[1u];\n    aboveHorizon = smoothstep(-0.04f, 0.06f, _e200);\n    let _e204 = unnamed.uSunDir[1u];\n    let _e209 = unnamed.uSunDir[1u];\n    sunset = ((1f - smoothstep(-0.03f, 0.3f, _e204)) * smoothstep(-0.35f, -0.05f, _e209));\n    ember = vec3<f32>(1f, 0.36f, 0.13f);\n    let _e212 = dir;\n    let _e214 = unnamed.uSunDir;\n    s = max(dot(_e212, _e214), 0f);\n    let _e218 = unnamed.uSunColor;\n    let _e220 = unnamed.uSunColor;\n    let _e221 = ember;\n    let _e223 = sunset;\n    discColor = mix(_e218, (_e220 * _e221), vec3((_e223 * 0.85f)));\n    let _e227 = discColor;\n    let _e228 = s;\n    let _e230 = unnamed.uSunDiscExponent;\n    let _e233 = s;\n    let _e235 = unnamed.uSunDiscExponent;\n    let _e242 = aboveHorizon;\n    let _e244 = col;\n    col = (_e244 + ((_e227 * ((pow(_e228, _e230) * 1.2f) + (pow(_e233, max((_e235 / 75f), 1f)) * 0.12f))) * _e242));\n    let _e247 = unnamed.uSunDir;\n    sunBearing = normalize((_e247.xz + vec2<f32>(0.00001f, 0.00001f)));\n    let _e251 = dir;\n    viewBearing = normalize((_e251.xz + vec2<f32>(0.00001f, 0.00001f)));\n    let _e255 = viewBearing;\n    let _e256 = sunBearing;\n    toward = max(dot(_e255, _e256), 0f);\n    let _e260 = dir[1u];\n    if (_e260 >= 0f) {\n        let _e263 = dir[1u];\n        local_1 = _e263;\n    } else {\n        let _e265 = dir[1u];\n        local_1 = (-(_e265) * 3f);\n    }\n    let _e268 = local_1;\n    fromHorizon = _e268;\n    let _e269 = fromHorizon;\n    band = pow((1f - min((_e269 * 2.2f), 1f)), 2.6f);\n    let _e274 = ember;\n    let _e275 = sunset;\n    let _e277 = band;\n    let _e279 = toward;\n    let _e284 = col;\n    col = (_e284 + (((_e274 * _e275) * _e277) * (0.18f + (0.75f * pow(_e279, 2.2f)))));\n    let _e286 = viewBearing;\n    let _e287 = sunBearing;\n    away = max(-(dot(_e286, _e287)), 0f);\n    let _e291 = sunset;\n    let _e293 = band;\n    let _e295 = away;\n    let _e298 = col;\n    col = (_e298 + ((((vec3<f32>(0.42f, 0.28f, 0.45f) * _e291) * _e293) * _e295) * 0.22f));\n    let _e302 = unnamed.uMoonDir[1u];\n    moonReference = select(vec3<f32>(1f, 0f, 0f), vec3<f32>(0f, 1f, 0f), vec3((abs(_e302) < 0.98f)));\n    let _e307 = moonReference;\n    let _e309 = unnamed.uMoonDir;\n    moonRight = normalize(cross(_e307, _e309));\n    let _e313 = unnamed.uMoonDir;\n    let _e314 = moonRight;\n    moonUp = cross(_e313, _e314);\n    let _e317 = unnamed.uMoonAngularRadius;\n    moonRadius = clamp(_e317, 0.001f, 0.5f);\n    let _e319 = dir;\n    let _e320 = moonRight;\n    let _e322 = dir;\n    let _e323 = moonUp;\n    let _e326 = moonRadius;\n    moonUv = (vec2<f32>(dot(_e319, _e320), dot(_e322, _e323)) / vec2(_e326));\n    let _e329 = moonUv;\n    let _e330 = moonUv;\n    moonRadiusSq = dot(_e329, _e330);\n    let _e332 = dir;\n    let _e334 = unnamed.uMoonDir;\n    moonFacing = step(0f, dot(_e332, _e334));\n    let _e337 = moonRadiusSq;\n    let _e340 = moonFacing;\n    moonDisc = ((1f - smoothstep(0.9f, 1f, _e337)) * _e340);\n    let _e342 = moonDisc;\n    if (_e342 > 0f) {\n        let _e344 = moonRadiusSq;\n        sphereZ = sqrt(max((1f - _e344), 0f));\n        let _e348 = moonUv;\n        let _e349 = sphereZ;\n        surfaceNormal = normalize(vec3<f32>(_e348.x, _e348.y, _e349));\n        let _e355 = unnamed.uMoonPhase;\n        phaseAngle = (_e355 * 6.2831855f);\n        let _e357 = phaseAngle;\n        let _e359 = phaseAngle;\n        phaseLight = vec3<f32>(sin(_e357), 0f, -(cos(_e359)));\n        let _e363 = surfaceNormal;\n        let _e364 = phaseLight;\n        phaseShade = max(dot(_e363, _e364), 0f);\n        let _e367 = moonUv;\n        param_7 = ((_e367 * 3.2f) + vec2<f32>(4.7f, 9.1f));\n        let _e370 = valueNoise_u0028_vf2_u003b((&param_7));\n        let _e372 = moonUv;\n        param_8 = ((_e372 * 9.3f) - vec2<f32>(7.4f, 2.6f));\n        let _e375 = valueNoise_u0028_vf2_u003b((&param_8));\n        maria = ((_e370 * 0.68f) + (_e375 * 0.32f));\n        let _e378 = maria;\n        albedo = mix(0.56f, 1.02f, _e378);\n        let _e380 = sphereZ;\n        limb = mix(0.72f, 1f, _e380);\n        earthshine = 0.035f;\n        let _e382 = earthshine;\n        let _e383 = earthshine;\n        let _e385 = phaseShade;\n        lunarLight = (_e382 + ((1f - _e383) * _e385));\n        let _e389 = unnamed.uMoonColor;\n        let _e390 = albedo;\n        let _e392 = limb;\n        let _e394 = lunarLight;\n        let _e396 = moonDisc;\n        let _e400 = unnamed.uNightFactor;\n        let _e402 = aboveHorizon;\n        let _e404 = col;\n        col = (_e404 + (((((((_e389 * _e390) * _e392) * _e394) * _e396) * 1.35f) * _e400) * _e402));\n    }\n    let _e407 = unnamed.uMoonPhase;\n    phaseIllumination = (0.5f - (cos((_e407 * 6.2831855f)) * 0.5f));\n    let _e412 = moonUv;\n    let _e416 = moonFacing;\n    moonHalo = ((1f - smoothstep(1f, 3f, length(_e412))) * _e416);\n    let _e419 = unnamed.uMoonColor;\n    let _e420 = moonHalo;\n    let _e423 = phaseIllumination;\n    let _e426 = unnamed.uNightFactor;\n    let _e428 = aboveHorizon;\n    let _e430 = col;\n    col = (_e430 + (((((_e419 * _e420) * 0.08f) * _e423) * _e426) * _e428));\n    let _e433 = dir[1u];\n    if (_e433 > 0f) {\n        let _e436 = unnamed.uNightFactor;\n        if (_e436 > 0f) {\n            let _e438 = dir;\n            let _e441 = dir[1u];\n            p_3 = ((_e438.xz / vec2((1f + _e441))) * 26f);\n            let _e446 = p_3;\n            cell = floor(_e446);\n            let _e448 = cell;\n            param_9 = _e448;\n            let _e449 = hash21_u0028_vf2_u003b((&param_9));\n            h = _e449;\n            let _e450 = h;\n            if (_e450 > 0.93f) {\n                let _e452 = cell;\n                param_10 = (_e452 + vec2(17.3f));\n                let _e455 = hash21_u0028_vf2_u003b((&param_10));\n                let _e456 = cell;\n                param_11 = (_e456 + vec2(41.7f));\n                let _e459 = hash21_u0028_vf2_u003b((&param_11));\n                jitter = vec2<f32>(_e455, _e459);\n                let _e461 = p_3;\n                let _e463 = jitter;\n                d_1 = length((fract(_e461) - _e463));\n                let _e466 = d_1;\n                let _e468 = h;\n                star = (smoothstep(0.1f, 0f, _e466) * (0.4f + (_e468 * 0.6f)));\n                let _e472 = star;\n                let _e475 = unnamed.uNightFactor;\n                let _e478 = dir[1u];\n                let _e481 = col;\n                col = (_e481 + (((vec3<f32>(0.86f, 0.91f, 1f) * _e472) * _e475) * smoothstep(0.03f, 0.3f, _e478)));\n            }\n        }\n        let _e484 = dir[1u];\n        if (_e484 > 0.02f) {\n            let _e486 = dir;\n            let _e489 = dir[1u];\n            let _e495 = unnamed.uCloudOffset;\n            uv = (((_e486.xz / vec2(max(_e489, 0.16f))) * 0.09f) + (_e495 * 0.012f));\n            let _e498 = uv;\n            param_12 = _e498;\n            let _e499 = fbm_u0028_vf2_u003b((&param_12));\n            band_1 = smoothstep(0.46f, 0.6f, _e499);\n            let _e502 = dir[1u];\n            fade = smoothstep(0.02f, 0.3f, _e502);\n            let _e505 = unnamed.uHorizonColor;\n            let _e509 = unnamed.uNightFactor;\n            cloudCol = (mix(_e505, vec3<f32>(1f, 1f, 1f), vec3(0.45f)) * mix(1f, 0.32f, _e509));\n            let _e512 = col;\n            let _e513 = cloudCol;\n            let _e514 = band_1;\n            let _e515 = fade;\n            col = mix(_e512, _e513, vec3(((_e514 * _e515) * 0.8f)));\n        }\n    }\n    let _e521 = dir[1u];\n    waterLight = mix(0.62f, 1.08f, clamp(((_e521 * 0.5f) + 0.5f), 0f, 1f));\n    let _e526 = col;\n    let _e528 = unnamed.uUnderwaterColor;\n    let _e529 = waterLight;\n    let _e532 = unnamed.uUnderwaterFactor;\n    col = mix(_e526, (_e528 * _e529), vec3(_e532));\n    let _e535 = col;\n    outColor = vec4<f32>(_e535.x, _e535.y, _e535.z, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(0) vNdc: vec2<f32>) -> @location(0) vec4<f32> {\n    vNdc_1 = vNdc;\n    main_1();\n    let _e3 = outColor;\n    return _e3;\n}\n";
+export declare const SKY_VERT_WGSL = "struct gl_PerVertex {\n    @builtin(position) gl_Position: vec4<f32>,\n    gl_PointSize: f32,\n}\n\nstruct VertexOutput {\n    @location(0) member: vec2<f32>,\n    @builtin(position) gl_Position: vec4<f32>,\n}\n\nvar<private> vNdc: vec2<f32>;\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 indexable: array<vec2<f32>, 3>;\n\n    let _e14 = gl_VertexIndex_1;\n    indexable = array<vec2<f32>, 3>(vec2<f32>(-1f, -1f), vec2<f32>(3f, -1f), vec2<f32>(-1f, 3f));\n    let _e16 = indexable[_e14];\n    vNdc = _e16;\n    let _e17 = vNdc;\n    unnamed.gl_Position = vec4<f32>(_e17.x, _e17.y, 0f, 1f);\n    return;\n}\n\n@vertex \nfn main(@builtin(vertex_index) gl_VertexIndex: u32) -> VertexOutput {\n    gl_VertexIndex_1 = i32(gl_VertexIndex);\n    main_1();\n    let _e7 = unnamed.gl_Position.y;\n    unnamed.gl_Position.y = -(_e7);\n    let _e9 = vNdc;\n    let _e10 = unnamed.gl_Position;\n    return VertexOutput(_e9, _e10);\n}\n";
+/**
+ * What the transform assigned, so the renderer binds the same numbers.
+ *
+ * A permuted shader has one entry per variant, keyed as `FLAT_FRAG_WGSL` is.
+ */
+export declare const SKY_BINDINGS: {
+    readonly SKY_FRAG: {
+        readonly uniforms: 1;
+        readonly uniformSize: 224;
+        readonly fields: {
+            readonly uInvViewProj: {
+                readonly offset: 0;
+                readonly size: 64;
+                readonly type: "mat4";
+            };
+            readonly uCameraPos: {
+                readonly offset: 64;
+                readonly size: 12;
+                readonly type: "vec3";
+            };
+            readonly uTopColor: {
+                readonly offset: 80;
+                readonly size: 12;
+                readonly type: "vec3";
+            };
+            readonly uHorizonColor: {
+                readonly offset: 96;
+                readonly size: 12;
+                readonly type: "vec3";
+            };
+            readonly uDeepColor: {
+                readonly offset: 112;
+                readonly size: 12;
+                readonly type: "vec3";
+            };
+            readonly uSunDir: {
+                readonly offset: 128;
+                readonly size: 12;
+                readonly type: "vec3";
+            };
+            readonly uSunColor: {
+                readonly offset: 144;
+                readonly size: 12;
+                readonly type: "vec3";
+            };
+            readonly uSunDiscExponent: {
+                readonly offset: 156;
+                readonly size: 4;
+                readonly type: "float";
+            };
+            readonly uMoonDir: {
+                readonly offset: 160;
+                readonly size: 12;
+                readonly type: "vec3";
+            };
+            readonly uMoonColor: {
+                readonly offset: 176;
+                readonly size: 12;
+                readonly type: "vec3";
+            };
+            readonly uMoonAngularRadius: {
+                readonly offset: 188;
+                readonly size: 4;
+                readonly type: "float";
+            };
+            readonly uMoonPhase: {
+                readonly offset: 192;
+                readonly size: 4;
+                readonly type: "float";
+            };
+            readonly uNightFactor: {
+                readonly offset: 196;
+                readonly size: 4;
+                readonly type: "float";
+            };
+            readonly uCloudOffset: {
+                readonly offset: 200;
+                readonly size: 8;
+                readonly type: "vec2";
+            };
+            readonly uUnderwaterColor: {
+                readonly offset: 208;
+                readonly size: 12;
+                readonly type: "vec3";
+            };
+            readonly uUnderwaterFactor: {
+                readonly offset: 220;
+                readonly size: 4;
+                readonly type: "float";
+            };
+        };
+        readonly textures: {};
+    };
+    readonly SKY_VERT: {
+        readonly uniforms: null;
+        readonly textures: {};
+    };
+};