@driftengine/core 3.61.0

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

@@ -0,0 +1,93 @@
+/*
+ * Generated from ../smoke.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 SMOKE_FRAG_WGSL = "struct Uniforms {\n    uTime: 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    uNoiseOctaves: i32,\n    uClipPlane: vec4<f32>,\n    uClipEnabled: i32,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vWorldPos_1: vec3<f32>;\nvar<private> vSeed_1: f32;\nvar<private> vUv_1: vec2<f32>;\nvar<private> vDistance_1: f32;\nvar<private> outColor: vec4<f32>;\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 _e76 = unnamed.uFogMode;\n    if (_e76 == 1i) {\n        let _e79 = unnamed.uFogFar;\n        let _e81 = unnamed.uFogNear;\n        span = max((_e79 - _e81), 0.0001f);\n        let _e84 = (*dist);\n        let _e86 = unnamed.uFogNear;\n        let _e88 = span;\n        ramp = clamp(((_e84 - _e86) / _e88), 0f, 1f);\n        let _e92 = unnamed.uUnderwaterFactor;\n        if (_e92 <= 0f) {\n            let _e94 = ramp;\n            return _e94;\n        }\n        let _e96 = unnamed.uUnderwaterFogDensity;\n        let _e97 = (*dist);\n        wetLinear = (_e96 * _e97);\n        let _e99 = ramp;\n        let _e100 = wetLinear;\n        let _e102 = wetLinear;\n        let _e108 = unnamed.uUnderwaterFactor;\n        return mix(_e99, (1f - exp2(((-(_e100) * _e102) * 1.442695f))), _e108);\n    }\n    let _e110 = (*pointY);\n    let _e112 = unnamed.uFogEyeY;\n    let _e115 = unnamed.uFogHeightFalloff;\n    t = ((_e110 - _e112) * _e115);\n    let _e117 = t;\n    let _e120 = t;\n    denom = select(_e120, 0.0001f, (abs(_e117) < 0.0001f));\n    let _e123 = unnamed.uFogDensity;\n    let _e125 = (*dist);\n    let _e127 = denom;\n    let _e132 = denom;\n    air = (1f - exp((((-(_e123) * _e125) * (1f - exp(-(_e127)))) / _e132)));\n    let _e137 = unnamed.uUnderwaterFactor;\n    if (_e137 <= 0f) {\n        let _e139 = air;\n        return _e139;\n    }\n    let _e141 = unnamed.uUnderwaterFogDensity;\n    let _e142 = (*dist);\n    wet = (_e141 * _e142);\n    let _e144 = air;\n    let _e145 = wet;\n    let _e147 = wet;\n    let _e153 = unnamed.uUnderwaterFactor;\n    return mix(_e144, (1f - exp2(((-(_e145) * _e147) * 1.442695f))), _e153);\n}\n\nfn mediumColor_u0028_() -> vec3<f32> {\n    let _e67 = unnamed.uFogColor;\n    let _e69 = unnamed.uUnderwaterColor;\n    let _e71 = unnamed.uUnderwaterFactor;\n    return mix(_e67, _e69, vec3(_e71));\n}\n\nfn hash21_u0028_vf2_u003b(p: ptr<function, vec2<f32>>) -> f32 {\n    let _e67 = (*p);\n    return fract((sin(dot(_e67, 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 param: vec2<f32>;\n    var param_1: vec2<f32>;\n    var param_2: vec2<f32>;\n    var param_3: vec2<f32>;\n\n    let _e74 = (*p_1);\n    i = floor(_e74);\n    let _e76 = (*p_1);\n    f = fract(_e76);\n    let _e78 = f;\n    let _e79 = f;\n    let _e81 = f;\n    u = ((_e78 * _e79) * (vec2(3f) - (_e81 * 2f)));\n    let _e86 = i;\n    param = _e86;\n    let _e87 = hash21_u0028_vf2_u003b((&param));\n    let _e88 = i;\n    param_1 = (_e88 + vec2<f32>(1f, 0f));\n    let _e90 = hash21_u0028_vf2_u003b((&param_1));\n    let _e92 = u[0u];\n    let _e94 = i;\n    param_2 = (_e94 + vec2<f32>(0f, 1f));\n    let _e96 = hash21_u0028_vf2_u003b((&param_2));\n    let _e97 = i;\n    param_3 = (_e97 + vec2<f32>(1f, 1f));\n    let _e99 = hash21_u0028_vf2_u003b((&param_3));\n    let _e101 = u[0u];\n    let _e104 = u[1u];\n    return mix(mix(_e87, _e90, _e92), mix(_e96, _e99, _e101), _e104);\n}\n\nfn billow_u0028_vf2_u003b_f1_u003b(p_2: ptr<function, vec2<f32>>, t_1: ptr<function, 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 _e72 = (*p_2);\n    let _e74 = (*t_1);\n    param_4 = ((_e72 * 2.2f) + vec2<f32>(0f, (-(_e74) * 0.55f)));\n    let _e79 = valueNoise_u0028_vf2_u003b((&param_4));\n    v = (_e79 * 0.55f);\n    let _e82 = unnamed.uNoiseOctaves;\n    if (_e82 == 1i) {\n        let _e84 = v;\n        return (_e84 / 0.55f);\n    }\n    let _e86 = (*p_2);\n    let _e88 = (*t_1);\n    let _e90 = (*t_1);\n    param_5 = ((_e86 * 4.7f) + vec2<f32>((_e88 * 0.12f), (-(_e90) * 0.9f)));\n    let _e95 = valueNoise_u0028_vf2_u003b((&param_5));\n    let _e97 = v;\n    v = (_e97 + (_e95 * 0.29f));\n    let _e100 = unnamed.uNoiseOctaves;\n    if (_e100 == 2i) {\n        let _e102 = v;\n        return (_e102 / 0.84f);\n    }\n    let _e104 = v;\n    let _e105 = (*p_2);\n    let _e107 = (*t_1);\n    let _e110 = (*t_1);\n    param_6 = ((_e105 * 9.3f) + vec2<f32>((-(_e107) * 0.09f), (-(_e110) * 1.4f)));\n    let _e115 = valueNoise_u0028_vf2_u003b((&param_6));\n    return (_e104 + (_e115 * 0.16f));\n}\n\nfn main_1() {\n    var t_2: f32;\n    var height: f32;\n    var spread: f32;\n    var centred: f32;\n    var sides: f32;\n    var drift: f32;\n    var param_7: vec2<f32>;\n    var n: f32;\n    var param_8: vec2<f32>;\n    var param_9: f32;\n    var density: f32;\n    var col: vec3<f32>;\n    var atmosphereColor: vec3<f32>;\n    var emerge: f32;\n    var dissipate: f32;\n    var fog: f32;\n    var param_10: f32;\n    var param_11: f32;\n    var alpha: f32;\n    var phi_312_: bool;\n\n    let _e86 = unnamed.uClipEnabled;\n    let _e87 = (_e86 != 0i);\n    phi_312_ = _e87;\n    if _e87 {\n        let _e88 = vWorldPos_1;\n        let _e94 = unnamed.uClipPlane;\n        phi_312_ = (dot(vec4<f32>(_e88.x, _e88.y, _e88.z, 1f), _e94) < 0f);\n    }\n    let _e98 = phi_312_;\n    if _e98 {\n        discard;\n    }\n    let _e100 = unnamed.uTime;\n    let _e101 = vSeed_1;\n    t_2 = (_e100 + (_e101 * 53f));\n    let _e105 = vUv_1[1u];\n    height = _e105;\n    let _e106 = height;\n    spread = mix(0.5f, 1f, _e106);\n    let _e109 = vUv_1[0u];\n    let _e111 = spread;\n    centred = (((_e109 - 0.5f) / _e111) + 0.5f);\n    let _e114 = centred;\n    sides = smoothstep(0f, 0.55f, (1f - clamp((abs((_e114 - 0.5f)) * 2f), 0f, 1f)));\n    let _e121 = sides;\n    if (_e121 <= 0.001f) {\n        discard;\n    }\n    let _e123 = t_2;\n    let _e125 = vSeed_1;\n    param_7 = vec2<f32>((_e123 * 0.21f), (_e125 * 7f));\n    let _e128 = valueNoise_u0028_vf2_u003b((&param_7));\n    let _e131 = height;\n    let _e133 = height;\n    drift = ((((_e128 - 0.5f) * 0.6f) * _e131) * _e133);\n    let _e135 = centred;\n    let _e136 = drift;\n    let _e138 = height;\n    param_8 = vec2<f32>((_e135 + _e136), _e138);\n    let _e140 = t_2;\n    param_9 = _e140;\n    let _e141 = billow_u0028_vf2_u003b_f1_u003b((&param_8), (&param_9));\n    n = _e141;\n    let _e142 = n;\n    let _e143 = sides;\n    let _e146 = height;\n    density = (((_e142 * _e143) * 1.35f) - (_e146 * 0.88f));\n    let _e149 = density;\n    if (_e149 <= 0.02f) {\n        discard;\n    }\n    let _e151 = height;\n    col = mix(vec3<f32>(0.9f, 0.42f, 0.16f), vec3<f32>(0.11f, 0.1f, 0.1f), vec3(smoothstep(0f, 0.34f, _e151)));\n    let _e155 = mediumColor_u0028_();\n    atmosphereColor = _e155;\n    let _e156 = col;\n    let _e157 = atmosphereColor;\n    let _e158 = height;\n    col = mix(_e156, _e157, vec3(smoothstep(0.3f, 0.95f, _e158)));\n    let _e162 = height;\n    emerge = smoothstep(0f, 0.3f, _e162);\n    let _e164 = height;\n    dissipate = (1f - smoothstep(0.22f, 0.75f, _e164));\n    let _e167 = vDistance_1;\n    param_10 = _e167;\n    let _e169 = vWorldPos_1[1u];\n    param_11 = _e169;\n    let _e170 = mediumFog_u0028_f1_u003b_f1_u003b((&param_10), (&param_11));\n    fog = _e170;\n    let _e171 = col;\n    let _e172 = atmosphereColor;\n    let _e173 = fog;\n    col = mix(_e171, _e172, vec3(_e173));\n    let _e176 = density;\n    let _e179 = emerge;\n    let _e181 = dissipate;\n    alpha = (((clamp((_e176 * 0.95f), 0f, 1f) * _e179) * _e181) * 0.13f);\n    let _e184 = col;\n    let _e185 = alpha;\n    let _e186 = fog;\n    outColor = vec4<f32>(_e184.x, _e184.y, _e184.z, (_e185 * (1f - _e186)));\n    return;\n}\n\n@fragment \nfn main(@location(3) vWorldPos: vec3<f32>, @location(1) vSeed: f32, @location(0) vUv: vec2<f32>, @location(2) vDistance: f32) -> @location(0) vec4<f32> {\n    vWorldPos_1 = vWorldPos;\n    vSeed_1 = vSeed;\n    vUv_1 = vUv;\n    vDistance_1 = vDistance;\n    main_1();\n    let _e9 = outColor;\n    return _e9;\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 SMOKE_BINDINGS = {
+  "SMOKE_FRAG": {
+    "uniforms": 1,
+    "uniformSize": 128,
+    "fields": {
+      "uTime": {
+        "offset": 0,
+        "size": 4,
+        "type": "float"
+      },
+      "uFogColor": {
+        "offset": 16,
+        "size": 12,
+        "type": "vec3"
+      },
+      "uFogDensity": {
+        "offset": 28,
+        "size": 4,
+        "type": "float"
+      },
+      "uFogHeightFalloff": {
+        "offset": 32,
+        "size": 4,
+        "type": "float"
+      },
+      "uFogEyeY": {
+        "offset": 36,
+        "size": 4,
+        "type": "float"
+      },
+      "uUnderwaterColor": {
+        "offset": 48,
+        "size": 12,
+        "type": "vec3"
+      },
+      "uUnderwaterFogDensity": {
+        "offset": 60,
+        "size": 4,
+        "type": "float"
+      },
+      "uUnderwaterFactor": {
+        "offset": 64,
+        "size": 4,
+        "type": "float"
+      },
+      "uFogMode": {
+        "offset": 68,
+        "size": 4,
+        "type": "int"
+      },
+      "uFogNear": {
+        "offset": 72,
+        "size": 4,
+        "type": "float"
+      },
+      "uFogFar": {
+        "offset": 76,
+        "size": 4,
+        "type": "float"
+      },
+      "uNoiseOctaves": {
+        "offset": 80,
+        "size": 4,
+        "type": "int"
+      },
+      "uClipPlane": {
+        "offset": 96,
+        "size": 16,
+        "type": "vec4"
+      },
+      "uClipEnabled": {
+        "offset": 112,
+        "size": 4,
+        "type": "int"
+      }
+    },
+    "textures": {}
+  }
+} as const;

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

@@ -0,0 +1,26 @@
+/*
+ * Generated from ../ssrResolve.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 SSR_RESOLVE_FRAG_WGSL = "var<private> fragColor: vec4<f32>;\n@group(0) @binding(32) \nvar uSsrReflection_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uSsrReflection_s: sampler;\nvar<private> vUv_1: vec2<f32>;\n\nfn main_1() {\n    let _e5 = vUv_1;\n    let _e6 = textureSampleLevel(uSsrReflection_t, uSsrReflection_s, _e5, 0f);\n    fragColor = _e6;\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";
+
+/**
+ * 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 SSRRESOLVE_BINDINGS = {
+  "SSR_RESOLVE_FRAG": {
+    "uniforms": null,
+    "textures": {
+      "uSsrReflection": {
+        "texture": 32,
+        "sampler": 33,
+        "type": "sampler2D"
+      }
+    }
+  }
+} as const;

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

@@ -0,0 +1,94 @@
+/*
+ * Generated from ../ssrTrace.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 SSR_TRACE_FRAG_WGSL = "struct Uniforms {\n    uSsrDepthToWorld: mat4x4<f32>,\n    uSsrViewProj: mat4x4<f32>,\n    uWorldToSurface: mat4x4<f32>,\n    uSsrEye: vec3<f32>,\n    uSsrAxis: vec3<f32>,\n    uSsrTint: vec3<f32>,\n    uSsrStrength: f32,\n    uSsrFacingCos: f32,\n    uSsrReach: f32,\n    uSsrThickness: f32,\n    uSsrSteps: f32,\n    uSsrEdgeFade: f32,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\n@group(0) @binding(32) \nvar uSsrDepth_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uSsrDepth_s: sampler;\nvar<private> vUv_1: vec2<f32>;\n@group(0) @binding(34) \nvar uSsrScene_t: texture_2d<f32>;\n@group(0) @binding(35) \nvar uSsrScene_s: sampler;\nvar<private> fragColor: vec4<f32>;\n\nfn worldAt_u0028_vf2_u003b_f1_u003b(uv: ptr<function, vec2<f32>>, stored: ptr<function, f32>) -> vec3<f32> {\n    var world: vec4<f32>;\n\n    let _e40 = unnamed.uSsrDepthToWorld;\n    let _e41 = (*uv);\n    let _e44 = ((_e41 * 2f) - vec2(1f));\n    let _e45 = (*stored);\n    world = (_e40 * vec4<f32>(_e44.x, _e44.y, _e45, 1f));\n    let _e50 = world;\n    let _e53 = world[3u];\n    return (_e50.xyz / vec3(_e53));\n}\n\nfn sceneDistanceAt_u0028_vf2_u003b(uv_1: ptr<function, vec2<f32>>) -> f32 {\n    var stored_1: f32;\n    var param: vec2<f32>;\n    var param_1: f32;\n\n    let _e40 = (*uv_1);\n    let _e41 = textureSampleLevel(uSsrDepth_t, uSsrDepth_s, _e40, 0f);\n    stored_1 = _e41.x;\n    let _e43 = stored_1;\n    if (_e43 <= 0f) {\n        return 1000000000f;\n    }\n    let _e45 = (*uv_1);\n    param = _e45;\n    let _e46 = stored_1;\n    param_1 = _e46;\n    let _e47 = worldAt_u0028_vf2_u003b_f1_u003b((&param), (&param_1));\n    let _e49 = unnamed.uSsrEye;\n    return length((_e47 - _e49));\n}\n\nfn projectPoint_u0028_vf3_u003b_vf2_u003b(point: ptr<function, vec3<f32>>, uv_2: ptr<function, vec2<f32>>) -> bool {\n    var clip: vec4<f32>;\n    var phi_130_: bool;\n    var phi_137_: bool;\n    var phi_143_: bool;\n\n    let _e40 = unnamed.uSsrViewProj;\n    let _e41 = (*point);\n    clip = (_e40 * vec4<f32>(_e41.x, _e41.y, _e41.z, 1f));\n    let _e48 = clip[3u];\n    if (_e48 <= 0f) {\n        return false;\n    }\n    let _e50 = clip;\n    let _e53 = clip[3u];\n    (*uv_2) = (((_e50.xy / vec2(_e53)) * 0.5f) + vec2(0.5f));\n    let _e60 = (*uv_2)[0u];\n    let _e61 = (_e60 >= 0f);\n    phi_130_ = _e61;\n    if _e61 {\n        let _e63 = (*uv_2)[0u];\n        phi_130_ = (_e63 <= 1f);\n    }\n    let _e66 = phi_130_;\n    phi_137_ = _e66;\n    if _e66 {\n        let _e68 = (*uv_2)[1u];\n        phi_137_ = (_e68 >= 0f);\n    }\n    let _e71 = phi_137_;\n    phi_143_ = _e71;\n    if _e71 {\n        let _e73 = (*uv_2)[1u];\n        phi_143_ = (_e73 <= 1f);\n    }\n    let _e76 = phi_143_;\n    return _e76;\n}\n\nfn main_1() {\n    var stored_2: f32;\n    var point_1: vec3<f32>;\n    var param_2: vec2<f32>;\n    var param_3: f32;\n    var plane: vec3<f32>;\n    var span: f32;\n    var normal: vec3<f32>;\n    var local: vec3<f32>;\n    var toEye: vec3<f32>;\n    var box: vec3<f32>;\n    var inside: vec3<f32>;\n    var mask: f32;\n    var facing: f32;\n    var found: vec3<f32>;\n    var weight: f32;\n    var view: vec3<f32>;\n    var ray: vec3<f32>;\n    var steps: f32;\n    var behind: f32;\n    var previous: f32;\n    var hitUv: vec2<f32>;\n    var hitDistance: f32;\n    var found_hit: bool;\n    var i: i32;\n    var at: f32;\n    var t: f32;\n    var sample_point: vec3<f32>;\n    var uv_3: vec2<f32>;\n    var param_4: vec3<f32>;\n    var param_5: vec2<f32>;\n    var scene: f32;\n    var param_6: vec2<f32>;\n    var gap: f32;\n    var near: f32;\n    var far: f32;\n    var refinedUv: vec2<f32>;\n    var refinedGap: f32;\n    var refine: i32;\n    var mid: f32;\n    var midPoint: vec3<f32>;\n    var midUv: vec2<f32>;\n    var param_7: vec3<f32>;\n    var param_8: vec2<f32>;\n    var midScene: f32;\n    var param_9: vec2<f32>;\n    var midGap: f32;\n    var edge: f32;\n    var away: f32;\n    var reach: f32;\n\n    let _e85 = vUv_1;\n    let _e86 = textureSampleLevel(uSsrDepth_t, uSsrDepth_s, _e85, 0f);\n    stored_2 = _e86.x;\n    let _e88 = vUv_1;\n    param_2 = _e88;\n    let _e89 = stored_2;\n    param_3 = _e89;\n    let _e90 = worldAt_u0028_vf2_u003b_f1_u003b((&param_2), (&param_3));\n    point_1 = _e90;\n    let _e91 = point_1;\n    let _e92 = dpdx(_e91);\n    let _e93 = point_1;\n    let _e94 = dpdy(_e93);\n    plane = cross(_e92, _e94);\n    let _e96 = plane;\n    span = length(_e96);\n    let _e98 = span;\n    if (_e98 > 0f) {\n        let _e100 = plane;\n        let _e101 = span;\n        local = (_e100 / vec3(_e101));\n    } else {\n        let _e105 = unnamed.uSsrAxis;\n        local = -(_e105);\n    }\n    let _e107 = local;\n    normal = _e107;\n    let _e109 = unnamed.uSsrEye;\n    let _e110 = point_1;\n    toEye = (_e109 - _e110);\n    let _e112 = toEye;\n    let _e113 = normal;\n    let _e116 = normal;\n    normal = (_e116 * sign(dot(_e112, _e113)));\n    let _e119 = unnamed.uWorldToSurface;\n    let _e120 = point_1;\n    box = (_e119 * vec4<f32>(_e120.x, _e120.y, _e120.z, 1f)).xyz;\n    let _e127 = box;\n    inside = step(abs(_e127), vec3<f32>(1f, 1f, 1f));\n    let _e131 = inside[0u];\n    let _e133 = inside[1u];\n    let _e136 = inside[2u];\n    mask = ((_e131 * _e133) * _e136);\n    let _e138 = normal;\n    let _e140 = unnamed.uSsrAxis;\n    facing = dot(_e138, -(_e140));\n    let _e144 = unnamed.uSsrFacingCos;\n    let _e146 = unnamed.uSsrFacingCos;\n    let _e149 = facing;\n    let _e151 = mask;\n    mask = (_e151 * smoothstep(_e144, min(1f, (_e146 + 0.25f)), _e149));\n    let _e153 = stored_2;\n    let _e156 = mask;\n    mask = (_e156 * select(1f, 0f, (_e153 <= 0f)));\n    let _e159 = unnamed.uSsrStrength;\n    let _e160 = mask;\n    mask = (_e160 * _e159);\n    found = vec3<f32>(0f, 0f, 0f);\n    weight = 0f;\n    let _e162 = mask;\n    if (_e162 > 0f) {\n        let _e164 = point_1;\n        let _e166 = unnamed.uSsrEye;\n        view = normalize((_e164 - _e166));\n        let _e169 = view;\n        let _e170 = normal;\n        ray = reflect(_e169, _e170);\n        let _e173 = unnamed.uSsrSteps;\n        steps = max(1f, _e173);\n        behind = 0f;\n        previous = 0f;\n        hitUv = vec2<f32>(0f, 0f);\n        hitDistance = 0f;\n        found_hit = false;\n        i = 1i;\n        loop {\n            let _e175 = i;\n            if (_e175 <= 32i) {\n                let _e177 = i;\n                let _e179 = steps;\n                if (f32(_e177) > _e179) {\n                    break;\n                }\n                let _e181 = i;\n                let _e183 = steps;\n                at = (f32(_e181) / _e183);\n                let _e186 = unnamed.uSsrReach;\n                let _e187 = at;\n                let _e189 = at;\n                t = ((_e186 * _e187) * _e189);\n                let _e191 = point_1;\n                let _e192 = ray;\n                let _e193 = t;\n                sample_point = (_e191 + (_e192 * _e193));\n                let _e196 = sample_point;\n                param_4 = _e196;\n                let _e197 = projectPoint_u0028_vf3_u003b_vf2_u003b((&param_4), (&param_5));\n                let _e198 = param_5;\n                uv_3 = _e198;\n                if !(_e197) {\n                    break;\n                }\n                let _e200 = uv_3;\n                param_6 = _e200;\n                let _e201 = sceneDistanceAt_u0028_vf2_u003b((&param_6));\n                scene = _e201;\n                let _e202 = sample_point;\n                let _e204 = unnamed.uSsrEye;\n                let _e207 = scene;\n                gap = (length((_e202 - _e204)) - _e207);\n                let _e209 = behind;\n                let _e211 = gap;\n                if ((_e209 < 0f) && (_e211 >= 0f)) {\n                    let _e214 = previous;\n                    near = _e214;\n                    let _e215 = t;\n                    far = _e215;\n                    let _e216 = uv_3;\n                    refinedUv = _e216;\n                    let _e217 = gap;\n                    refinedGap = _e217;\n                    refine = 0i;\n                    loop {\n                        let _e218 = refine;\n                        if (_e218 < 6i) {\n                            let _e220 = near;\n                            let _e221 = far;\n                            mid = ((_e220 + _e221) * 0.5f);\n                            let _e224 = point_1;\n                            let _e225 = ray;\n                            let _e226 = mid;\n                            midPoint = (_e224 + (_e225 * _e226));\n                            let _e229 = midPoint;\n                            param_7 = _e229;\n                            let _e230 = projectPoint_u0028_vf3_u003b_vf2_u003b((&param_7), (&param_8));\n                            let _e231 = param_8;\n                            midUv = _e231;\n                            if !(_e230) {\n                                break;\n                            }\n                            let _e233 = midUv;\n                            param_9 = _e233;\n                            let _e234 = sceneDistanceAt_u0028_vf2_u003b((&param_9));\n                            midScene = _e234;\n                            let _e235 = midPoint;\n                            let _e237 = unnamed.uSsrEye;\n                            let _e240 = midScene;\n                            midGap = (length((_e235 - _e237)) - _e240);\n                            let _e242 = midGap;\n                            if (_e242 >= 0f) {\n                                let _e244 = mid;\n                                far = _e244;\n                                let _e245 = midUv;\n                                refinedUv = _e245;\n                                let _e246 = midGap;\n                                refinedGap = _e246;\n                            } else {\n                                let _e247 = mid;\n                                near = _e247;\n                            }\n                            continue;\n                        } else {\n                            break;\n                        }\n                        continuing {\n                            let _e248 = refine;\n                            refine = (_e248 + 1i);\n                        }\n                    }\n                    let _e250 = refinedGap;\n                    let _e252 = unnamed.uSsrThickness;\n                    if (_e250 <= _e252) {\n                        found_hit = true;\n                        let _e254 = refinedUv;\n                        hitUv = _e254;\n                        let _e255 = far;\n                        hitDistance = _e255;\n                    }\n                    break;\n                }\n                let _e256 = gap;\n                behind = _e256;\n                let _e257 = t;\n                previous = _e257;\n                continue;\n            } else {\n                break;\n            }\n            continuing {\n                let _e258 = i;\n                i = (_e258 + 1i);\n            }\n        }\n        let _e260 = found_hit;\n        if _e260 {\n            let _e262 = hitUv[0u];\n            let _e264 = hitUv[0u];\n            let _e268 = hitUv[1u];\n            let _e270 = hitUv[1u];\n            let _e275 = unnamed.uSsrEdgeFade;\n            edge = clamp((min(min(_e262, (1f - _e264)), min(_e268, (1f - _e270))) / max(_e275, 0.0001f)), 0f, 1f);\n            let _e279 = ray;\n            let _e281 = view;\n            away = clamp(((dot(normalize(_e279), _e281) + 1f) * 0.5f), 0f, 1f);\n            let _e286 = hitDistance;\n            let _e288 = unnamed.uSsrReach;\n            reach = (1f - clamp((_e286 / max(_e288, 0.0001f)), 0f, 1f));\n            let _e293 = mask;\n            let _e294 = edge;\n            let _e296 = away;\n            let _e298 = reach;\n            weight = (((_e293 * _e294) * _e296) * _e298);\n            let _e300 = hitUv;\n            let _e301 = textureSampleLevel(uSsrScene_t, uSsrScene_s, _e300, 0f);\n            let _e304 = unnamed.uSsrTint;\n            found = (_e301.xyz * _e304);\n        }\n    }\n    let _e306 = found;\n    let _e307 = weight;\n    let _e308 = (_e306 * _e307);\n    let _e309 = weight;\n    fragColor = vec4<f32>(_e308.x, _e308.y, _e308.z, _e309);\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";
+
+/**
+ * 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 SSRTRACE_BINDINGS = {
+  "SSR_TRACE_FRAG": {
+    "uniforms": 1,
+    "uniformSize": 272,
+    "fields": {
+      "uSsrDepthToWorld": {
+        "offset": 0,
+        "size": 64,
+        "type": "mat4"
+      },
+      "uSsrViewProj": {
+        "offset": 64,
+        "size": 64,
+        "type": "mat4"
+      },
+      "uWorldToSurface": {
+        "offset": 128,
+        "size": 64,
+        "type": "mat4"
+      },
+      "uSsrEye": {
+        "offset": 192,
+        "size": 12,
+        "type": "vec3"
+      },
+      "uSsrAxis": {
+        "offset": 208,
+        "size": 12,
+        "type": "vec3"
+      },
+      "uSsrTint": {
+        "offset": 224,
+        "size": 12,
+        "type": "vec3"
+      },
+      "uSsrStrength": {
+        "offset": 236,
+        "size": 4,
+        "type": "float"
+      },
+      "uSsrFacingCos": {
+        "offset": 240,
+        "size": 4,
+        "type": "float"
+      },
+      "uSsrReach": {
+        "offset": 244,
+        "size": 4,
+        "type": "float"
+      },
+      "uSsrThickness": {
+        "offset": 248,
+        "size": 4,
+        "type": "float"
+      },
+      "uSsrSteps": {
+        "offset": 252,
+        "size": 4,
+        "type": "float"
+      },
+      "uSsrEdgeFade": {
+        "offset": 256,
+        "size": 4,
+        "type": "float"
+      }
+    },
+    "textures": {
+      "uSsrDepth": {
+        "texture": 32,
+        "sampler": 33,
+        "type": "sampler2D"
+      },
+      "uSsrScene": {
+        "texture": 34,
+        "sampler": 35,
+        "type": "sampler2D"
+      }
+    }
+  }
+} as const;

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

@@ -0,0 +1,54 @@
+/*
+ * Generated from ../temporalResolve.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 TEMPORAL_RESOLVE_FRAG_WGSL = "struct Uniforms {\n    uReprojection: mat4x4<f32>,\n    uTexel: vec2<f32>,\n    uHistoryBlend: f32,\n}\n\n@group(0) @binding(32) \nvar uScene_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uScene_s: sampler;\nvar<private> vUv_1: vec2<f32>;\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> fragColor: vec4<f32>;\n@group(0) @binding(36) \nvar uDepth_t: texture_2d<f32>;\n@group(0) @binding(37) \nvar uDepth_s: sampler;\n@group(0) @binding(34) \nvar uHistory_t: texture_2d<f32>;\n@group(0) @binding(35) \nvar uHistory_s: sampler;\n\nfn clipToNeighbourhood_u0028_vf3_u003b_vf3_u003b_vf3_u003b(history: ptr<function, vec3<f32>>, lo: ptr<function, vec3<f32>>, hi: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var centre: vec3<f32>;\n    var extent: vec3<f32>;\n    var offset: vec3<f32>;\n    var ratios: vec3<f32>;\n    var ratio: f32;\n\n    let _e35 = (*lo);\n    let _e36 = (*hi);\n    centre = ((_e35 + _e36) * 0.5f);\n    let _e39 = (*hi);\n    let _e40 = (*lo);\n    extent = ((_e39 - _e40) * 0.5f);\n    let _e43 = (*history);\n    let _e44 = centre;\n    offset = (_e43 - _e44);\n    let _e46 = offset;\n    let _e48 = extent;\n    ratios = (abs(_e46) / max(_e48, vec3<f32>(0.0000001f, 0.0000001f, 0.0000001f)));\n    let _e52 = ratios[0u];\n    let _e54 = ratios[1u];\n    let _e56 = ratios[2u];\n    ratio = max(_e52, max(_e54, _e56));\n    let _e59 = ratio;\n    if (_e59 <= 1f) {\n        let _e61 = (*history);\n        return _e61;\n    }\n    let _e62 = centre;\n    let _e63 = offset;\n    let _e64 = ratio;\n    return (_e62 + (_e63 / vec3(_e64)));\n}\n\nfn neighbourhood_u0028_vf3_u003b_vf3_u003b(lo_1: ptr<function, vec3<f32>>, hi_1: ptr<function, vec3<f32>>) {\n    var y: i32;\n    var x: i32;\n    var c: vec3<f32>;\n\n    (*lo_1) = vec3<f32>(1000000000f, 1000000000f, 1000000000f);\n    (*hi_1) = vec3<f32>(-1000000000f, -1000000000f, -1000000000f);\n    y = -1i;\n    loop {\n        let _e32 = y;\n        if (_e32 <= 1i) {\n            x = -1i;\n            loop {\n                let _e34 = x;\n                if (_e34 <= 1i) {\n                    let _e36 = vUv_1;\n                    let _e37 = x;\n                    let _e39 = y;\n                    let _e43 = unnamed.uTexel;\n                    let _e46 = textureSampleLevel(uScene_t, uScene_s, (_e36 + (vec2<f32>(f32(_e37), f32(_e39)) * _e43)), 0f);\n                    c = _e46.xyz;\n                    let _e48 = (*lo_1);\n                    let _e49 = c;\n                    (*lo_1) = min(_e48, _e49);\n                    let _e51 = (*hi_1);\n                    let _e52 = c;\n                    (*hi_1) = max(_e51, _e52);\n                    continue;\n                } else {\n                    break;\n                }\n                continuing {\n                    let _e54 = x;\n                    x = (_e54 + 1i);\n                }\n            }\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e56 = y;\n            y = (_e56 + 1i);\n        }\n    }\n    return;\n}\n\nfn main_1() {\n    var current: vec3<f32>;\n    var depth: f32;\n    var clip: vec4<f32>;\n    var previous: vec4<f32>;\n    var wasUv: vec2<f32>;\n    var lo_2: vec3<f32>;\n    var hi_2: vec3<f32>;\n    var param: vec3<f32>;\n    var param_1: vec3<f32>;\n    var history_1: vec3<f32>;\n    var bounded: vec3<f32>;\n    var param_2: vec3<f32>;\n    var param_3: vec3<f32>;\n    var param_4: vec3<f32>;\n    var phi_223_: bool;\n    var phi_230_: bool;\n    var phi_237_: bool;\n\n    let _e41 = vUv_1;\n    let _e42 = textureSampleLevel(uScene_t, uScene_s, _e41, 0f);\n    current = _e42.xyz;\n    let _e45 = unnamed.uHistoryBlend;\n    if (_e45 <= 0f) {\n        let _e47 = current;\n        fragColor = vec4<f32>(_e47.x, _e47.y, _e47.z, 1f);\n        return;\n    }\n    let _e52 = vUv_1;\n    let _e53 = textureSampleLevel(uDepth_t, uDepth_s, _e52, 0f);\n    depth = _e53.x;\n    let _e55 = vUv_1;\n    let _e58 = ((_e55 * 2f) - vec2(1f));\n    let _e59 = depth;\n    clip = vec4<f32>(_e58.x, _e58.y, (1f - (_e59 * 2f)), 1f);\n    let _e66 = unnamed.uReprojection;\n    let _e67 = clip;\n    previous = (_e66 * _e67);\n    let _e70 = previous[3u];\n    if (_e70 <= 0f) {\n        let _e72 = current;\n        fragColor = vec4<f32>(_e72.x, _e72.y, _e72.z, 1f);\n        return;\n    }\n    let _e77 = previous;\n    let _e80 = previous[3u];\n    wasUv = (((_e77.xy / vec2(_e80)) * 0.5f) + vec2(0.5f));\n    let _e87 = wasUv[0u];\n    let _e88 = (_e87 < 0f);\n    phi_223_ = _e88;\n    if !(_e88) {\n        let _e91 = wasUv[0u];\n        phi_223_ = (_e91 > 1f);\n    }\n    let _e94 = phi_223_;\n    phi_230_ = _e94;\n    if !(_e94) {\n        let _e97 = wasUv[1u];\n        phi_230_ = (_e97 < 0f);\n    }\n    let _e100 = phi_230_;\n    phi_237_ = _e100;\n    if !(_e100) {\n        let _e103 = wasUv[1u];\n        phi_237_ = (_e103 > 1f);\n    }\n    let _e106 = phi_237_;\n    if _e106 {\n        let _e107 = current;\n        fragColor = vec4<f32>(_e107.x, _e107.y, _e107.z, 1f);\n        return;\n    }\n    neighbourhood_u0028_vf3_u003b_vf3_u003b((&param), (&param_1));\n    let _e112 = param;\n    lo_2 = _e112;\n    let _e113 = param_1;\n    hi_2 = _e113;\n    let _e114 = wasUv;\n    let _e115 = textureSampleLevel(uHistory_t, uHistory_s, _e114, 0f);\n    history_1 = _e115.xyz;\n    let _e117 = history_1;\n    param_2 = _e117;\n    let _e118 = lo_2;\n    param_3 = _e118;\n    let _e119 = hi_2;\n    param_4 = _e119;\n    let _e120 = clipToNeighbourhood_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_2), (&param_3), (&param_4));\n    bounded = _e120;\n    let _e121 = current;\n    let _e122 = bounded;\n    let _e124 = unnamed.uHistoryBlend;\n    let _e126 = mix(_e121, _e122, vec3(_e124));\n    fragColor = vec4<f32>(_e126.x, _e126.y, _e126.z, 1f);\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";
+
+/**
+ * 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 TEMPORALRESOLVE_BINDINGS = {
+  "TEMPORAL_RESOLVE_FRAG": {
+    "uniforms": 1,
+    "uniformSize": 80,
+    "fields": {
+      "uReprojection": {
+        "offset": 0,
+        "size": 64,
+        "type": "mat4"
+      },
+      "uTexel": {
+        "offset": 64,
+        "size": 8,
+        "type": "vec2"
+      },
+      "uHistoryBlend": {
+        "offset": 72,
+        "size": 4,
+        "type": "float"
+      }
+    },
+    "textures": {
+      "uScene": {
+        "texture": 32,
+        "sampler": 33,
+        "type": "sampler2D"
+      },
+      "uHistory": {
+        "texture": 34,
+        "sampler": 35,
+        "type": "sampler2D"
+      },
+      "uDepth": {
+        "texture": 36,
+        "sampler": 37,
+        "type": "sampler2D"
+      }
+    }
+  }
+} as const;

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

@@ -0,0 +1,107 @@
+/*
+ * Generated from ../text.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 TEXT_FRAG_WGSL = "struct Uniforms {\n    uColor: vec3<f32>,\n    uGlow: f32,\n    uAlpha: f32,\n}\n\nvar<private> vNormal_1: vec3<f32>;\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vChar_1: f32;\nvar<private> fragColor: vec4<f32>;\nvar<private> vDepth_1: f32;\n\nfn main_1() {\n    var key: vec3<f32>;\n    var lambert: f32;\n    var lit: vec3<f32>;\n    var emissive: vec3<f32>;\n\n    key = vec3<f32>(-0.3549141f, 0.7098282f, 0.6084241f);\n    let _e19 = vNormal_1;\n    let _e21 = key;\n    lambert = (0.55f + (0.45f * max(dot(normalize(_e19), _e21), 0f)));\n    let _e27 = unnamed.uColor;\n    let _e28 = lambert;\n    lit = (_e27 * _e28);\n    let _e31 = unnamed.uColor;\n    let _e33 = unnamed.uGlow;\n    let _e35 = vChar_1;\n    emissive = ((_e31 * _e33) * (0.45f + (0.55f * _e35)));\n    let _e39 = lit;\n    let _e40 = emissive;\n    let _e41 = (_e39 + _e40);\n    let _e43 = unnamed.uAlpha;\n    fragColor = vec4<f32>(_e41.x, _e41.y, _e41.z, _e43);\n    return;\n}\n\n@fragment \nfn main(@location(0) vNormal: vec3<f32>, @location(2) vChar: f32, @location(1) vDepth: f32) -> @location(0) vec4<f32> {\n    vNormal_1 = vNormal;\n    vChar_1 = vChar;\n    vDepth_1 = vDepth;\n    main_1();\n    let _e7 = fragColor;\n    return _e7;\n}\n";
+
+export const TEXT_VERT_WGSL = "struct Uniforms {\n    uViewport: vec2<f32>,\n    uOrigin: vec2<f32>,\n    uCellSize: f32,\n    uDepth: f32,\n    uReveal: f32,\n    uCharCount: f32,\n    uCharOffset: f32,\n    uSpin: f32,\n    uPunch: f32,\n    uBob: f32,\n    uTime: f32,\n    uClipCorrection: mat4x4<f32>,\n}\n\nstruct gl_PerVertex {\n    @builtin(position) gl_Position: vec4<f32>,\n    gl_PointSize: f32,\n}\n\nstruct VertexOutput {\n    @builtin(position) gl_Position: vec4<f32>,\n    @location(0) member: vec3<f32>,\n    @location(1) member_1: f32,\n    @location(2) member_2: f32,\n}\n\n@group(0) @binding(0) \nvar<uniform> unnamed: Uniforms;\nvar<private> aCharIndex_1: f32;\nvar<private> aCorner_1: vec3<f32>;\nvar<private> aCell_1: vec2<f32>;\nvar<private> unnamed_1: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f);\nvar<private> aNormal_1: vec3<f32>;\nvar<private> vNormal: vec3<f32>;\nvar<private> vDepth: f32;\nvar<private> vChar: f32;\n\nfn rot_u0028_f1_u003b(a: ptr<function, f32>) -> mat2x2<f32> {\n    var s: f32;\n    var c: f32;\n\n    let _e40 = (*a);\n    s = sin(_e40);\n    let _e42 = (*a);\n    c = cos(_e42);\n    let _e44 = c;\n    let _e45 = s;\n    let _e47 = s;\n    let _e48 = c;\n    return mat2x2<f32>(vec2<f32>(_e44, -(_e45)), vec2<f32>(_e47, _e48));\n}\n\nfn settle_u0028_f1_u003b(t: ptr<function, f32>) -> f32 {\n    var d: f32;\n\n    let _e39 = (*t);\n    if (_e39 <= 0f) {\n        return 0f;\n    }\n    let _e41 = (*t);\n    if (_e41 >= 1f) {\n        return 1f;\n    }\n    let _e43 = (*t);\n    d = (1f - _e43);\n    let _e45 = d;\n    let _e46 = d;\n    let _e48 = (*t);\n    return (1f - ((_e45 * _e46) * cos((_e48 * 12f))));\n}\n\nfn main_1() {\n    var span: f32;\n    var start: f32;\n    var local: f32;\n    var eased: f32;\n    var param: f32;\n    var spin: f32;\n    var rise: f32;\n    var punch: f32;\n    var local3_: vec3<f32>;\n    var param_1: f32;\n    var cell: vec2<f32>;\n    var bob: f32;\n    var screen: vec2<f32>;\n    var view: vec3<f32>;\n    var invDepth: f32;\n    var ndc: vec2<f32>;\n    var depth: f32;\n    var n: vec3<f32>;\n    var param_2: f32;\n\n    let _e57 = unnamed.uCharCount;\n    span = max(_e57, 1f);\n    let _e59 = aCharIndex_1;\n    let _e61 = unnamed.uCharOffset;\n    let _e63 = span;\n    start = (((_e59 + _e61) / _e63) * 0.55f);\n    let _e67 = unnamed.uReveal;\n    let _e68 = start;\n    let _e70 = start;\n    local = clamp(((_e67 - _e68) / max(0.45f, (1f - _e70))), 0f, 1f);\n    let _e75 = local;\n    param = _e75;\n    let _e76 = settle_u0028_f1_u003b((&param));\n    eased = _e76;\n    let _e78 = unnamed.uSpin;\n    let _e79 = eased;\n    spin = (_e78 * (1f - _e79));\n    let _e82 = eased;\n    let _e85 = unnamed.uCellSize;\n    rise = (((1f - _e82) * _e85) * 6f);\n    let _e89 = unnamed.uPunch;\n    let _e90 = eased;\n    punch = (1f + (_e89 * (1f - abs(((_e90 * 2f) - 1f)))));\n    let _e97 = aCorner_1;\n    let _e99 = unnamed.uCellSize;\n    let _e102 = punch;\n    local3_ = (((_e97 * _e99) * 0.5f) * _e102);\n    let _e104 = spin;\n    param_1 = _e104;\n    let _e105 = rot_u0028_f1_u003b((&param_1));\n    let _e106 = local3_;\n    let _e108 = (_e105 * _e106.yz);\n    let _e109 = local3_;\n    local3_ = vec3<f32>(_e109.x, _e108.x, _e108.y);\n    let _e114 = aCell_1;\n    let _e116 = unnamed.uCellSize;\n    cell = (_e114 * _e116);\n    let _e119 = unnamed.uTime;\n    let _e121 = aCharIndex_1;\n    let _e126 = unnamed.uBob;\n    bob = (sin(((_e119 * 3.1f) + (_e121 * 0.7f))) * _e126);\n    let _e129 = unnamed.uOrigin;\n    let _e131 = cell[0u];\n    let _e133 = cell[1u];\n    let _e137 = rise;\n    let _e138 = bob;\n    screen = ((_e129 + vec2<f32>(_e131, -(_e133))) + vec2<f32>(0f, (_e137 - _e138)));\n    let _e142 = screen;\n    let _e143 = local3_;\n    let _e145 = (_e142 + _e143.xy);\n    let _e147 = unnamed.uDepth;\n    let _e150 = local3_[2u];\n    view = vec3<f32>(_e145.x, _e145.y, (-(_e147) + _e150));\n    let _e156 = unnamed.uDepth;\n    let _e158 = view[2u];\n    invDepth = (_e156 / max(0.001f, -(_e158)));\n    let _e162 = view;\n    let _e164 = invDepth;\n    let _e167 = unnamed.uViewport;\n    ndc = ((((_e162.xy * _e164) / _e167) * 2f) - vec2(1f));\n    let _e173 = local3_[2u];\n    let _e176 = unnamed.uCellSize;\n    depth = (clamp((-(_e173) / max(1f, (_e176 * 2f))), -1f, 1f) * 0.4f);\n    let _e183 = unnamed.uClipCorrection;\n    let _e185 = ndc[0u];\n    let _e187 = ndc[1u];\n    let _e189 = depth;\n    unnamed_1.gl_Position = (_e183 * vec4<f32>(_e185, -(_e187), _e189, 1f));\n    let _e193 = aNormal_1;\n    n = _e193;\n    let _e194 = spin;\n    param_2 = _e194;\n    let _e195 = rot_u0028_f1_u003b((&param_2));\n    let _e196 = n;\n    let _e198 = (_e195 * _e196.yz);\n    let _e199 = n;\n    n = vec3<f32>(_e199.x, _e198.x, _e198.y);\n    let _e204 = n;\n    vNormal = _e204;\n    let _e206 = local3_[2u];\n    vDepth = _e206;\n    let _e207 = eased;\n    vChar = _e207;\n    return;\n}\n\n@vertex \nfn main(@location(3) aCharIndex: f32, @location(0) aCorner: vec3<f32>, @location(2) aCell: vec2<f32>, @location(1) aNormal: vec3<f32>) -> VertexOutput {\n    aCharIndex_1 = aCharIndex;\n    aCorner_1 = aCorner;\n    aCell_1 = aCell;\n    aNormal_1 = aNormal;\n    main_1();\n    let _e14 = unnamed_1.gl_Position.y;\n    unnamed_1.gl_Position.y = -(_e14);\n    let _e16 = unnamed_1.gl_Position;\n    let _e17 = vNormal;\n    let _e18 = vDepth;\n    let _e19 = vChar;\n    return VertexOutput(_e16, _e17, _e18, _e19);\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 TEXT_BINDINGS = {
+  "TEXT_FRAG": {
+    "uniforms": 1,
+    "uniformSize": 32,
+    "fields": {
+      "uColor": {
+        "offset": 0,
+        "size": 12,
+        "type": "vec3"
+      },
+      "uGlow": {
+        "offset": 12,
+        "size": 4,
+        "type": "float"
+      },
+      "uAlpha": {
+        "offset": 16,
+        "size": 4,
+        "type": "float"
+      }
+    },
+    "textures": {}
+  },
+  "TEXT_VERT": {
+    "uniforms": 0,
+    "uniformSize": 128,
+    "fields": {
+      "uViewport": {
+        "offset": 0,
+        "size": 8,
+        "type": "vec2"
+      },
+      "uOrigin": {
+        "offset": 8,
+        "size": 8,
+        "type": "vec2"
+      },
+      "uCellSize": {
+        "offset": 16,
+        "size": 4,
+        "type": "float"
+      },
+      "uDepth": {
+        "offset": 20,
+        "size": 4,
+        "type": "float"
+      },
+      "uReveal": {
+        "offset": 24,
+        "size": 4,
+        "type": "float"
+      },
+      "uCharCount": {
+        "offset": 28,
+        "size": 4,
+        "type": "float"
+      },
+      "uCharOffset": {
+        "offset": 32,
+        "size": 4,
+        "type": "float"
+      },
+      "uSpin": {
+        "offset": 36,
+        "size": 4,
+        "type": "float"
+      },
+      "uPunch": {
+        "offset": 40,
+        "size": 4,
+        "type": "float"
+      },
+      "uBob": {
+        "offset": 44,
+        "size": 4,
+        "type": "float"
+      },
+      "uTime": {
+        "offset": 48,
+        "size": 4,
+        "type": "float"
+      },
+      "uClipCorrection": {
+        "offset": 64,
+        "size": 64,
+        "type": "mat4"
+      }
+    },
+    "textures": {}
+  }
+} as const;