@driftengine/core 4.11.1 → 4.13.0

package/src/render/shaders/flat/layered.ts

@@ -1,8 +1,11 @@
+import { layerLooksGlsl } from './layerLooks.ts';
+
 /**
  * A material blended from layers by a mask: `SurfaceMaterial.layers`, packed into `uLayers` by
  * `surfaceLayers.ts`.
  *
- * **Layer `i` is layer `i` of the material's arrays**, each read at its own repeat of where the
+ * **Layer `i` is layer `i` of the material's arrays** — or the layer `layerLooks.ts` picks, with the
+ * tint, ranges and normal strength it gives each — each read at its own repeat of where the
  * layers are laid: the mesh's coordinates, or the world's horizontal plane where the material has a
  * projection (`worldUv.ts`). The mask's channels weigh layers 1 to 4 — red, green, blue, alpha — and
  * come from a map read where a shading model's would be, from the ORM array's layer past the layers,
@@ -21,10 +24,11 @@
  * in uniform control flow (AGENTS.md 2026-08-07), so the loop is bounded by the layer count, a
  * uniform, and never skips on a share, which is the pixel's own.
  *
- * **A lit switch, `LAYERED`**, off until a material first asks, declared last so every switch before
- * it keeps its id. Compiled out, its four vectors are not declared and its calls are constants.
+ * **A lit switch, `LAYERED`**, off until a material first asks, declared after every switch before
+ * it so each keeps its id. Compiled out, its four vectors are not declared and its calls are
+ * constants. `looks` compiles `LAYER_LOOKS` in beside it, and means nothing without it.
  */
-export function layeredGlsl(on: boolean): string {
+export function layeredGlsl(on: boolean, looks = false): string {
   if (!on) {
     return /* glsl */ `
 const bool LAYERED = false;  // wgsl:override
@@ -38,6 +42,8 @@ bool layeredMeshNormal() { return false; }
 vec3 layeredMeshTexel() { return vec3(0.0, 0.0, 1.0); }
 bool layeredGlows() { return false; }
 vec3 layeredEmissive() { return vec3(0.0); }
+float layeredAmbient() { return 1.0; }
+float layeredSpecular(float own) { return own; }
 `;
   }
   return /* glsl */ `
@@ -51,10 +57,16 @@ const bool LAYERED = true;  // wgsl:override
  * layer or -1 (y), its bias (z) and its sharpness (w).
  */
 uniform vec4 uLayers[4]; // wgsl:material
-
+${layerLooksGlsl(looks)}
 /* Each layer's share of this point, the base's and layers 1 to 4's: worked out once, in layeredBegin. */
 float lShareBase;
 vec4 lShare;
+/*
+ * What an occlusion read at the mesh's coordinates leaves of this point's colour and of its ambient
+ * light, 1 where none: layeredBegin.
+ */
+float lColorOcclusion;
+float lAmbientOcclusion;
 
 bool layered() {
   return uLayers[1].y > 0.5;
@@ -71,14 +83,15 @@ vec2 layerPlace() {
 }
 
 vec3 layerAt(int i) {
-  return vec3(layerPlace() * layerRepeat(i), float(i));
+  float across = layerRepeat(i);
+  return vec3(layerPlace() * vec2(across, layerRepeatDown(i, across)), layerArray(i));
 }
 
 /* The weights as the material keeps them: the mask's channels, at the mesh's own coordinates. */
 vec4 layerWeights() {
   float source = uLayers[1].w;
   if (source > 1.5) return vec4(vColor, 0.0);
-  if (source > 0.5) return texture(uOrmMap, vec3(vUv.xy, uLayers[1].y));
+  if (source > 0.5) return texture(uOrmMap, vec3(vUv.xy, layerExtras()));
   return texture(uModelMap, vec3(vUv.xy, 0.0));
 }
 
@@ -92,10 +105,25 @@ vec4 layerPick(float layer) {
  * Under a branch on uniforms, as its reads are.
  */
 void layeredBegin() {
+  /*
+   * The occlusion at the mesh's coordinates, once: the ORM array's layer past the layers and past
+   * any mask and added mask it carries, spread over its range and taken at each strength. The
+   * colour's may pass 1, darkening faster than the occlusion does, and is held at black.
+   */
+  lColorOcclusion = 1.0;
+  lAmbientOcclusion = 1.0;
+  vec2 strength = layerOcclusionStrengths();
+  if (strength.x > 0.0 || strength.y > 0.0) {
+    float at = layerExtras() + (abs(uLayers[1].w - 1.0) < 0.5 ? 1.0 : 0.0) + (uLayers[2].z > 0.5 ? 1.0 : 0.0);
+    vec2 range = layerOcclusionRange();
+    float bare = 1.0 - mix(range.x, range.y, texture(uOrmMap, vec3(vUv.xy, at)).r);
+    lColorOcclusion = max(0.0, 1.0 - strength.x * bare);
+    lAmbientOcclusion = 1.0 - strength.y * bare;
+  }
   vec4 m = layerWeights();
   if (uLayers[2].z > 0.5) {
     /* The ORM array's layer past the layers, and past the mask where the array carries that too. */
-    float at = uLayers[1].y + (abs(uLayers[1].w - 1.0) < 0.5 ? 1.0 : 0.0);
+    float at = layerExtras() + (abs(uLayers[1].w - 1.0) < 0.5 ? 1.0 : 0.0);
     float added = texture(uOrmMap, vec3(layerPlace() * uLayers[2].w, at)).r * uLayers[3].x;
     m = mix(m, clamp(m + added, 0.0, 1.0), layerPick(uLayers[2].z));
   }
@@ -135,23 +163,60 @@ vec3 layeredColor(vec3 color) {
   return uLayers[1].w > 1.5 ? vec3(1.0) : color;
 }
 
-/* Colour by the shares, and the base layer's coverage, which a cutout reads. */
+/*
+ * Colour by the shares, each layer's tinted, and the base layer's coverage, which a cutout reads;
+ * then darkened by the occlusion at the mesh's coordinates, at the colour's strength.
+ */
 vec4 layeredAlbedo() {
   vec4 sum = vec4(0.0);
   for (int i = 0; i < 5; i++) {
     if (float(i) >= uLayers[1].y) break;
     vec4 t = texture(uAlbedo, layerAt(i));
-    sum.rgb += t.rgb * layerShare(i);
+    sum.rgb += t.rgb * layerTint(i) * layerShare(i);
     if (i == 0) sum.a = t.a;
   }
+  sum.rgb *= lColorOcclusion;
   return sum;
 }
 
+/* What the ambient light keeps: the occlusion at the mesh's coordinates, at the ambient's strength. */
+float layeredAmbient() {
+  return lAmbientOcclusion;
+}
+
+/*
+ * The specular by the shares: each layer's named one at its share, and the surface's own over the
+ * layers naming none, once at most. Under a summed blend the shares add past 1 where the weights
+ * do, and a surface whose layers leave the specular to it reflects its own, not its own times that
+ * sum; under a blend laid over, the shares never pass 1 and this is the sum it always was. What it
+ * gives up: named speculars still add as their colours do, so a summed blend that names them
+ * reflects their sum. The surface's own, untouched, where no material has asked for looks: shares
+ * summing to one in floating point are not quite one, and a layered material that names nothing
+ * must draw exactly as before.
+ */
+float layeredSpecular(float own) {
+  if (LAYER_LOOKS) {
+    float named = 0.0;
+    float unnamed = 0.0;
+    for (int i = 0; i < 5; i++) {
+      if (float(i) >= uLayers[1].y) break;
+      float specular = layerNamedSpecular(i);
+      if (specular < 0.0) unnamed += layerShare(i);
+      else named += specular * layerShare(i);
+    }
+    return named + own * min(unnamed, 1.0);
+  }
+  return own;
+}
+
+/* Occlusion, roughness and metalness by the shares, each layer's spread over its own ranges. */
 vec3 layeredOrm() {
   vec3 sum = vec3(0.0);
   for (int i = 0; i < 5; i++) {
     if (float(i) >= uLayers[1].y) break;
-    sum += texture(uOrmMap, layerAt(i)).rgb * layerShare(i);
+    vec3 t = texture(uOrmMap, layerAt(i)).rgb;
+    t.yz = layerRanges(i, t.yz);
+    sum += t * layerShare(i);
   }
   return sum;
 }
@@ -168,7 +233,7 @@ vec3 layeredTexel() {
   vec3 sum = vec3(0.0);
   for (int i = 0; i < 5; i++) {
     if (float(i) >= uLayers[1].y) break;
-    sum += layerNormalTexel(layerAt(i)) * layerShare(i);
+    sum += layerStrengthen(i, layerNormalTexel(layerAt(i))) * layerShare(i);
   }
   float len = length(sum);
   return len > 1e-5 ? sum / len : vec3(0.0, 0.0, 1.0);
@@ -181,7 +246,7 @@ bool layeredMeshNormal() {
 
 /* That normal's texel: the normal array's layer past the layers, at the mesh's coordinates. */
 vec3 layeredMeshTexel() {
-  return layerNormalTexel(vec3(vUv.xy, uLayers[1].y));
+  return layerNormalTexel(vec3(vUv.xy, layerExtras()));
 }
 
 /* Whether the emissive map belongs to one layer rather than to the whole surface. */

package/src/render/shaders/flat/main.ts

@@ -18,6 +18,9 @@ export const MAIN_GLSL = `void main() {
   projectSurface(surfaceAt, frameAt, frameTangents);
   /* A layered material's mask, read once for every layer's share below: layered.ts. */
   if (LAYERED && layered()) layeredBegin();
+  /* And the specular every highlight below reads: its layers' own, where a material gives them. */
+  surfaceSpecular = vSpecular;
+  if (LAYERED && layered()) surfaceSpecular = layeredSpecular(vSpecular);
   if (dot(vec4(vWorldPos, 1.0), uClipPlane) < 0.0) discard;
   /*
    * The layer's surface effects, zeros where the albedo array carries no table — see
@@ -511,6 +514,8 @@ export const MAIN_GLSL = `void main() {
 #endif
     /* A draw's own ambient, where one is set, in place of the frame's: \`setAmbientSH\`. */
     if (uAmbientSH[6].w > 0.5) ambient = ambientHarmonics(n);
+    /* Less of it where a layered material's mesh occlusion darkens the ambient light: layered.ts. */
+    if (LAYERED && layered()) ambient *= layeredAmbient();
     /*
      * A metal keeps its ambient and loses its direct diffuse.
      *
@@ -564,7 +569,7 @@ export const MAIN_GLSL = `void main() {
      * mix(x, y, 0) is exactly x, so at metal 0 this is vec3(vSpecular) and the line below is the
      * one it replaces with the scalar broadened to three components.
      */
-    vec3 specColor = mix(vec3(vSpecular), albedo, metal);
+    vec3 specColor = mix(vec3(surfaceSpecular), albedo, metal);
     /*
      * **A metal's highlight goes white at a grazing angle, and that is most of what reads as
      * polished.**
@@ -1657,7 +1662,7 @@ export const MAIN_GLSL = `void main() {
        * any lamp in the scene. The condition is the old one exactly when metal is 0, so nothing
        * that binds no map takes a different branch than it took before.
        */
-      if (vSpecular > 0.0 || metal > 0.0) {
+      if (surfaceSpecular > 0.0 || metal > 0.0) {
         vec3 toEyeLamp = normalize(uCameraPos - vWorldPos);
         vec3 lampHalfway = normalize(toLight / max(dist, 1e-4) + toEyeLamp);
         /* The same grazing whitening the sun's highlight takes, and zero at metal 0 for the look. */

package/src/render/shaders/flat/models.ts

@@ -221,7 +221,7 @@ void modelSurface(vec3 n, vec3 albedo, float roughness, float metal, vec3 at) {
   if (MODEL_SKIN) {
     if (SKIN_DIFFUSE) mAlbedo = vec3(1.0);
   }
-  mSpecColor = mix(vec3(vSpecular), albedo, metal);
+  mSpecColor = mix(vec3(surfaceSpecular), albedo, metal);
   mRoughness = roughness;
   mMetal = metal;
   mMap = vec4(0.5, 0.5, 1.0, 1.0);

package/src/render/shaders/flat/preamble.ts

@@ -52,6 +52,12 @@ in vec3 vColor;
 in vec3 vWorldPos;
 in float vEmissive;
 in float vSpecular;
+/*
+ * The specular this fragment shades with: its vertices' own, or a layered material's layers'
+ * blend of theirs, set once at the top of main. Every read of the specular reads this rather than
+ * the varying, so a layer's specular reaches the highlight, the reflection and the area lights alike.
+ */
+float surfaceSpecular;
 in vec4 vLightPos;
 in vec3 vUv;
 in vec3 vEmissiveColor;

package/src/render/shaders/flock.ts

@@ -1,3 +1,4 @@
+import { OUTPUT_TRANSFORM_GLSL } from './outputTransform.ts';
 /**
  * Birds: two triangles each, circling on a path computed entirely in the vertex
  * shader.
@@ -96,8 +97,10 @@ precision highp float;
 in float vShade;
 uniform vec3 uTint;
 out vec4 outColor;
+${OUTPUT_TRANSFORM_GLSL}
 
 void main() {
-  outColor = vec4(uTint * vShade, 1.0);
+  /* Graded where nothing after this will grade it, as every pass is. */
+  outColor = vec4(applyOutputTransform(uTint * vShade), 1.0);
 }
 `;

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

@@ -5,7 +5,7 @@
  * the next generation, and `npm run wgsl:check` fails the build when this is stale.
  */
 
-export const ARCANE_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    uTint: vec3<f32>,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vWorldPos_1: vec3<f32>;\nvar<private> vUv_1: vec2<f32>;\nvar<private> vSeed_1: f32;\nvar<private> vDistance_1: f32;\nvar<private> outColor: vec4<f32>;\n\nfn mediumColor_u0028_() -> vec3<f32> {\n    let _e59 = unnamed.uFogColor;\n    let _e61 = unnamed.uUnderwaterColor;\n    let _e63 = unnamed.uUnderwaterFactor;\n    return mix(_e59, _e61, vec3(_e63));\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 start: f32;\n    var before: f32;\n    var local: f32;\n    var t: f32;\n    var rest: f32;\n    var denom: f32;\n    var air: f32;\n    var wet: f32;\n\n    let _e72 = unnamed.uFogMode;\n    if (_e72 == 1i) {\n        let _e75 = unnamed.uFogFar;\n        let _e77 = unnamed.uFogNear;\n        span = max((_e75 - _e77), 0.0001f);\n        let _e80 = (*dist);\n        let _e82 = unnamed.uFogNear;\n        let _e84 = span;\n        ramp = clamp(((_e80 - _e82) / _e84), 0f, 1f);\n        let _e88 = unnamed.uUnderwaterFactor;\n        if (_e88 <= 0f) {\n            let _e90 = ramp;\n            return _e90;\n        }\n        let _e92 = unnamed.uUnderwaterFogDensity;\n        let _e93 = (*dist);\n        wetLinear = (_e92 * _e93);\n        let _e95 = ramp;\n        let _e96 = wetLinear;\n        let _e98 = wetLinear;\n        let _e104 = unnamed.uUnderwaterFactor;\n        return mix(_e95, (1f - exp2(((-(_e96) * _e98) * 1.442695f))), _e104);\n    }\n    let _e107 = unnamed.uFogNear;\n    let _e108 = (*dist);\n    start = min(_e107, _e108);\n    let _e110 = (*dist);\n    if (_e110 > 0f) {\n        let _e112 = start;\n        let _e113 = (*dist);\n        local = (_e112 / _e113);\n    } else {\n        local = 0f;\n    }\n    let _e115 = local;\n    before = _e115;\n    let _e116 = (*pointY);\n    let _e118 = unnamed.uFogEyeY;\n    let _e121 = unnamed.uFogHeightFalloff;\n    t = ((_e116 - _e118) * _e121);\n    let _e123 = t;\n    let _e124 = before;\n    rest = (_e123 * (1f - _e124));\n    let _e127 = rest;\n    let _e130 = rest;\n    denom = select(_e130, 0.0001f, (abs(_e127) < 0.0001f));\n    let _e133 = unnamed.uFogDensity;\n    let _e135 = t;\n    let _e137 = before;\n    let _e141 = (*dist);\n    let _e142 = start;\n    let _e145 = denom;\n    let _e150 = denom;\n    air = (1f - exp(((((-(_e133) * exp((-(_e135) * _e137))) * (_e141 - _e142)) * (1f - exp(-(_e145)))) / _e150)));\n    let _e155 = unnamed.uUnderwaterFactor;\n    if (_e155 <= 0f) {\n        let _e157 = air;\n        return _e157;\n    }\n    let _e159 = unnamed.uUnderwaterFogDensity;\n    let _e160 = (*dist);\n    wet = (_e159 * _e160);\n    let _e162 = air;\n    let _e163 = wet;\n    let _e165 = wet;\n    let _e171 = unnamed.uUnderwaterFactor;\n    return mix(_e162, (1f - exp2(((-(_e163) * _e165) * 1.442695f))), _e171);\n}\n\nfn hash21_u0028_vf2_u003b(p: ptr<function, vec2<f32>>) -> f32 {\n    let _e59 = (*p);\n    return fract((sin(dot(_e59, 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 _e66 = (*p_1);\n    i = floor(_e66);\n    let _e68 = (*p_1);\n    f = fract(_e68);\n    let _e70 = f;\n    let _e71 = f;\n    let _e73 = f;\n    u = ((_e70 * _e71) * (vec2(3f) - (_e73 * 2f)));\n    let _e78 = i;\n    param = _e78;\n    let _e79 = hash21_u0028_vf2_u003b((&param));\n    let _e80 = i;\n    param_1 = (_e80 + vec2<f32>(1f, 0f));\n    let _e82 = hash21_u0028_vf2_u003b((&param_1));\n    let _e84 = u[0u];\n    let _e86 = i;\n    param_2 = (_e86 + vec2<f32>(0f, 1f));\n    let _e88 = hash21_u0028_vf2_u003b((&param_2));\n    let _e89 = i;\n    param_3 = (_e89 + vec2<f32>(1f, 1f));\n    let _e91 = hash21_u0028_vf2_u003b((&param_3));\n    let _e93 = u[0u];\n    let _e96 = u[1u];\n    return mix(mix(_e79, _e82, _e84), mix(_e88, _e91, _e93), _e96);\n}\n\nfn main_1() {\n    var radius: f32;\n    var d: vec2<f32>;\n    var angle: f32;\n    var t_1: f32;\n    var inner: f32;\n    var param_4: vec2<f32>;\n    var outer: f32;\n    var param_5: vec2<f32>;\n    var swirl: f32;\n    var param_6: vec2<f32>;\n    var core: f32;\n    var corona: f32;\n    var body: f32;\n    var col: vec3<f32>;\n    var alpha: f32;\n    var fog: f32;\n    var param_7: f32;\n    var param_8: f32;\n    var phi_266_: bool;\n\n    let _e77 = unnamed.uClipEnabled;\n    let _e78 = (_e77 != 0i);\n    phi_266_ = _e78;\n    if _e78 {\n        let _e79 = vWorldPos_1;\n        let _e85 = unnamed.uClipPlane;\n        phi_266_ = (dot(vec4<f32>(_e79.x, _e79.y, _e79.z, 1f), _e85) < 0f);\n    }\n    let _e89 = phi_266_;\n    if _e89 {\n        discard;\n    }\n    let _e90 = vUv_1;\n    radius = (length((_e90 - vec2(0.5f))) * 2f);\n    let _e95 = radius;\n    if (_e95 >= 1f) {\n        discard;\n    }\n    let _e97 = vUv_1;\n    d = (_e97 - vec2(0.5f));\n    let _e101 = d[1u];\n    let _e103 = d[0u];\n    angle = atan2(_e101, _e103);\n    let _e106 = unnamed.uTime;\n    let _e107 = vSeed_1;\n    t_1 = (_e106 + (_e107 * 37f));\n    let _e110 = angle;\n    let _e112 = t_1;\n    let _e115 = radius;\n    param_4 = vec2<f32>(((_e110 * 1.9f) + (_e112 * 0.55f)), (_e115 * 4.2f));\n    let _e118 = valueNoise_u0028_vf2_u003b((&param_4));\n    inner = _e118;\n    let _e119 = angle;\n    let _e121 = t_1;\n    let _e124 = radius;\n    param_5 = vec2<f32>(((_e119 * 3.1f) - (_e121 * 0.34f)), (_e124 * 2.6f));\n    let _e127 = valueNoise_u0028_vf2_u003b((&param_5));\n    outer = _e127;\n    let _e128 = inner;\n    let _e130 = outer;\n    swirl = ((_e128 * 0.62f) + (_e130 * 0.38f));\n    let _e134 = unnamed.uNoiseOctaves;\n    if (_e134 > 1i) {\n        let _e136 = swirl;\n        let _e137 = swirl;\n        let _e138 = angle;\n        let _e140 = t_1;\n        let _e143 = radius;\n        param_6 = vec2<f32>(((_e138 * 6.3f) + (_e140 * 0.9f)), (_e143 * 8f));\n        let _e146 = valueNoise_u0028_vf2_u003b((&param_6));\n        swirl = mix(_e136, ((_e137 * _e146) * 2f), 0.35f);\n    }\n    let _e150 = radius;\n    core = (1f - smoothstep(0f, 0.28f, _e150));\n    let _e153 = radius;\n    let _e156 = swirl;\n    corona = ((1f - smoothstep(0.18f, 1f, _e153)) * (0.35f + (_e156 * 0.65f)));\n    let _e160 = core;\n    let _e162 = corona;\n    body = ((_e160 * 0.9f) + _e162);\n    let _e164 = body;\n    if (_e164 <= 0.02f) {\n        discard;\n    }\n    let _e167 = unnamed.uTint;\n    let _e170 = unnamed.uTint;\n    let _e171 = body;\n    col = mix((_e167 * 0.35f), _e170, vec3(smoothstep(0f, 0.55f, _e171)));\n    let _e175 = col;\n    let _e176 = body;\n    col = mix(_e175, vec3<f32>(1f, 1f, 1f), vec3(smoothstep(0.82f, 1.4f, _e176)));\n    let _e181 = unnamed.uTint;\n    let _e182 = col;\n    col = (_e182 * _e181);\n    let _e184 = body;\n    alpha = clamp((_e184 * 1.6f), 0f, 1f);\n    let _e187 = vDistance_1;\n    param_7 = _e187;\n    let _e189 = vWorldPos_1[1u];\n    param_8 = _e189;\n    let _e190 = mediumFog_u0028_f1_u003b_f1_u003b((&param_7), (&param_8));\n    fog = _e190;\n    let _e191 = col;\n    let _e192 = mediumColor_u0028_();\n    let _e193 = fog;\n    col = mix(_e191, _e192, vec3(_e193));\n    let _e196 = fog;\n    let _e198 = alpha;\n    alpha = (_e198 * (1f - _e196));\n    let _e200 = col;\n    let _e201 = alpha;\n    outColor = vec4<f32>(_e200.x, _e200.y, _e200.z, _e201);\n    return;\n}\n\n@fragment \nfn main(@location(3) vWorldPos: vec3<f32>, @location(0) vUv: vec2<f32>, @location(1) vSeed: f32, @location(2) vDistance: f32) -> @location(0) vec4<f32> {\n    vWorldPos_1 = vWorldPos;\n    vUv_1 = vUv;\n    vSeed_1 = vSeed;\n    vDistance_1 = vDistance;\n    main_1();\n    let _e9 = outColor;\n    return _e9;\n}\n";
+export const ARCANE_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    uOutputTransform: i32,\n    uOutputExposure: f32,\n    uTint: vec3<f32>,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vWorldPos_1: vec3<f32>;\nvar<private> vUv_1: vec2<f32>;\nvar<private> vSeed_1: f32;\nvar<private> vDistance_1: 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 _e105 = (*c);\n    low = (_e105 * 12.92f);\n    let _e107 = (*c);\n    high = ((pow(max(_e107, vec3<f32>(0f, 0f, 0f)), vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3(0.055f));\n    let _e113 = high;\n    let _e114 = low;\n    let _e115 = (*c);\n    return mix(_e113, _e114, step(_e115, vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f)));\n}\n\nfn highlightShoulder_u0028_vf3_u003b(c_1: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var m: f32;\n    var e: f32;\n\n    let _e106 = (*c_1)[0u];\n    let _e108 = (*c_1)[1u];\n    let _e110 = (*c_1)[2u];\n    m = max(_e106, max(_e108, _e110));\n    let _e113 = m;\n    if (_e113 <= 0.8f) {\n        let _e115 = (*c_1);\n        return _e115;\n    }\n    let _e116 = m;\n    e = (_e116 - 0.8f);\n    let _e118 = (*c_1);\n    let _e119 = e;\n    let _e121 = e;\n    let _e125 = m;\n    return (_e118 * ((0.8f + ((0.2f * _e119) / (_e121 + 0.2f))) / _e125));\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 _e105 = (*v);\n    let _e106 = (*v);\n    a = ((_e105 * (_e106 + vec3(0.0245786f))) - vec3(0.000090537f));\n    let _e112 = (*v);\n    let _e113 = (*v);\n    b = ((_e112 * ((_e113 * 0.983729f) + vec3(0.432951f))) + vec3(0.238081f));\n    let _e120 = a;\n    let _e121 = b;\n    return (_e120 / _e121);\n}\n\nfn acesFilmic_u0028_vf3_u003b(x: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var param: vec3<f32>;\n\n    let _e105 = unnamed.uOutputExposure;\n    let _e106 = (*x);\n    (*x) = (_e106 * _e105);\n    let _e108 = (*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)) * _e108);\n    let _e110 = 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)) * _e110), vec3(0f), vec3(1f));\n}\n\nfn applyOutputTransform_u0028_vf3_u003b(c_2: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var param_1: vec3<f32>;\n    var param_2: vec3<f32>;\n    var param_3: vec3<f32>;\n\n    let _e107 = unnamed.uOutputTransform;\n    if (_e107 == 0i) {\n        let _e109 = (*c_2);\n        return _e109;\n    }\n    let _e111 = unnamed.uOutputTransform;\n    if (_e111 == 2i) {\n        let _e113 = (*c_2);\n        param_1 = _e113;\n        let _e114 = acesFilmic_u0028_vf3_u003b((&param_1));\n        (*c_2) = _e114;\n    }\n    let _e116 = unnamed.uOutputTransform;\n    if (_e116 == 3i) {\n        let _e118 = (*c_2);\n        let _e120 = unnamed.uOutputExposure;\n        param_2 = (_e118 * _e120);\n        let _e122 = highlightShoulder_u0028_vf3_u003b((&param_2));\n        (*c_2) = _e122;\n    }\n    let _e123 = (*c_2);\n    param_3 = _e123;\n    let _e124 = linearToSrgb_u0028_vf3_u003b((&param_3));\n    return _e124;\n}\n\nfn mediumColor_u0028_() -> vec3<f32> {\n    let _e103 = unnamed.uFogColor;\n    let _e105 = unnamed.uUnderwaterColor;\n    let _e107 = unnamed.uUnderwaterFactor;\n    return mix(_e103, _e105, vec3(_e107));\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 start: f32;\n    var before: f32;\n    var local: f32;\n    var t: f32;\n    var rest: f32;\n    var denom: f32;\n    var air: f32;\n    var wet: f32;\n\n    let _e116 = unnamed.uFogMode;\n    if (_e116 == 1i) {\n        let _e119 = unnamed.uFogFar;\n        let _e121 = unnamed.uFogNear;\n        span = max((_e119 - _e121), 0.0001f);\n        let _e124 = (*dist);\n        let _e126 = unnamed.uFogNear;\n        let _e128 = span;\n        ramp = clamp(((_e124 - _e126) / _e128), 0f, 1f);\n        let _e132 = unnamed.uUnderwaterFactor;\n        if (_e132 <= 0f) {\n            let _e134 = ramp;\n            return _e134;\n        }\n        let _e136 = unnamed.uUnderwaterFogDensity;\n        let _e137 = (*dist);\n        wetLinear = (_e136 * _e137);\n        let _e139 = ramp;\n        let _e140 = wetLinear;\n        let _e142 = wetLinear;\n        let _e148 = unnamed.uUnderwaterFactor;\n        return mix(_e139, (1f - exp2(((-(_e140) * _e142) * 1.442695f))), _e148);\n    }\n    let _e151 = unnamed.uFogNear;\n    let _e152 = (*dist);\n    start = min(_e151, _e152);\n    let _e154 = (*dist);\n    if (_e154 > 0f) {\n        let _e156 = start;\n        let _e157 = (*dist);\n        local = (_e156 / _e157);\n    } else {\n        local = 0f;\n    }\n    let _e159 = local;\n    before = _e159;\n    let _e160 = (*pointY);\n    let _e162 = unnamed.uFogEyeY;\n    let _e165 = unnamed.uFogHeightFalloff;\n    t = ((_e160 - _e162) * _e165);\n    let _e167 = t;\n    let _e168 = before;\n    rest = (_e167 * (1f - _e168));\n    let _e171 = rest;\n    let _e174 = rest;\n    denom = select(_e174, 0.0001f, (abs(_e171) < 0.0001f));\n    let _e177 = unnamed.uFogDensity;\n    let _e179 = t;\n    let _e181 = before;\n    let _e185 = (*dist);\n    let _e186 = start;\n    let _e189 = denom;\n    let _e194 = denom;\n    air = (1f - exp(((((-(_e177) * exp((-(_e179) * _e181))) * (_e185 - _e186)) * (1f - exp(-(_e189)))) / _e194)));\n    let _e199 = unnamed.uUnderwaterFactor;\n    if (_e199 <= 0f) {\n        let _e201 = air;\n        return _e201;\n    }\n    let _e203 = unnamed.uUnderwaterFogDensity;\n    let _e204 = (*dist);\n    wet = (_e203 * _e204);\n    let _e206 = air;\n    let _e207 = wet;\n    let _e209 = wet;\n    let _e215 = unnamed.uUnderwaterFactor;\n    return mix(_e206, (1f - exp2(((-(_e207) * _e209) * 1.442695f))), _e215);\n}\n\nfn hash21_u0028_vf2_u003b(p: ptr<function, vec2<f32>>) -> f32 {\n    let _e103 = (*p);\n    return fract((sin(dot(_e103, 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_4: vec2<f32>;\n    var param_5: vec2<f32>;\n    var param_6: vec2<f32>;\n    var param_7: vec2<f32>;\n\n    let _e110 = (*p_1);\n    i = floor(_e110);\n    let _e112 = (*p_1);\n    f = fract(_e112);\n    let _e114 = f;\n    let _e115 = f;\n    let _e117 = f;\n    u = ((_e114 * _e115) * (vec2(3f) - (_e117 * 2f)));\n    let _e122 = i;\n    param_4 = _e122;\n    let _e123 = hash21_u0028_vf2_u003b((&param_4));\n    let _e124 = i;\n    param_5 = (_e124 + vec2<f32>(1f, 0f));\n    let _e126 = hash21_u0028_vf2_u003b((&param_5));\n    let _e128 = u[0u];\n    let _e130 = i;\n    param_6 = (_e130 + vec2<f32>(0f, 1f));\n    let _e132 = hash21_u0028_vf2_u003b((&param_6));\n    let _e133 = i;\n    param_7 = (_e133 + vec2<f32>(1f, 1f));\n    let _e135 = hash21_u0028_vf2_u003b((&param_7));\n    let _e137 = u[0u];\n    let _e140 = u[1u];\n    return mix(mix(_e123, _e126, _e128), mix(_e132, _e135, _e137), _e140);\n}\n\nfn main_1() {\n    var radius: f32;\n    var d: vec2<f32>;\n    var angle: f32;\n    var t_1: f32;\n    var inner: f32;\n    var param_8: vec2<f32>;\n    var outer: f32;\n    var param_9: vec2<f32>;\n    var swirl: f32;\n    var param_10: vec2<f32>;\n    var core: f32;\n    var corona: f32;\n    var body: f32;\n    var col: vec3<f32>;\n    var alpha: f32;\n    var fog: f32;\n    var param_11: f32;\n    var param_12: f32;\n    var param_13: vec3<f32>;\n    var phi_442_: bool;\n\n    let _e122 = unnamed.uClipEnabled;\n    let _e123 = (_e122 != 0i);\n    phi_442_ = _e123;\n    if _e123 {\n        let _e124 = vWorldPos_1;\n        let _e130 = unnamed.uClipPlane;\n        phi_442_ = (dot(vec4<f32>(_e124.x, _e124.y, _e124.z, 1f), _e130) < 0f);\n    }\n    let _e134 = phi_442_;\n    if _e134 {\n        discard;\n    }\n    let _e135 = vUv_1;\n    radius = (length((_e135 - vec2(0.5f))) * 2f);\n    let _e140 = radius;\n    if (_e140 >= 1f) {\n        discard;\n    }\n    let _e142 = vUv_1;\n    d = (_e142 - vec2(0.5f));\n    let _e146 = d[1u];\n    let _e148 = d[0u];\n    angle = atan2(_e146, _e148);\n    let _e151 = unnamed.uTime;\n    let _e152 = vSeed_1;\n    t_1 = (_e151 + (_e152 * 37f));\n    let _e155 = angle;\n    let _e157 = t_1;\n    let _e160 = radius;\n    param_8 = vec2<f32>(((_e155 * 1.9f) + (_e157 * 0.55f)), (_e160 * 4.2f));\n    let _e163 = valueNoise_u0028_vf2_u003b((&param_8));\n    inner = _e163;\n    let _e164 = angle;\n    let _e166 = t_1;\n    let _e169 = radius;\n    param_9 = vec2<f32>(((_e164 * 3.1f) - (_e166 * 0.34f)), (_e169 * 2.6f));\n    let _e172 = valueNoise_u0028_vf2_u003b((&param_9));\n    outer = _e172;\n    let _e173 = inner;\n    let _e175 = outer;\n    swirl = ((_e173 * 0.62f) + (_e175 * 0.38f));\n    let _e179 = unnamed.uNoiseOctaves;\n    if (_e179 > 1i) {\n        let _e181 = swirl;\n        let _e182 = swirl;\n        let _e183 = angle;\n        let _e185 = t_1;\n        let _e188 = radius;\n        param_10 = vec2<f32>(((_e183 * 6.3f) + (_e185 * 0.9f)), (_e188 * 8f));\n        let _e191 = valueNoise_u0028_vf2_u003b((&param_10));\n        swirl = mix(_e181, ((_e182 * _e191) * 2f), 0.35f);\n    }\n    let _e195 = radius;\n    core = (1f - smoothstep(0f, 0.28f, _e195));\n    let _e198 = radius;\n    let _e201 = swirl;\n    corona = ((1f - smoothstep(0.18f, 1f, _e198)) * (0.35f + (_e201 * 0.65f)));\n    let _e205 = core;\n    let _e207 = corona;\n    body = ((_e205 * 0.9f) + _e207);\n    let _e209 = body;\n    if (_e209 <= 0.02f) {\n        discard;\n    }\n    let _e212 = unnamed.uTint;\n    let _e215 = unnamed.uTint;\n    let _e216 = body;\n    col = mix((_e212 * 0.35f), _e215, vec3(smoothstep(0f, 0.55f, _e216)));\n    let _e220 = col;\n    let _e221 = body;\n    col = mix(_e220, vec3<f32>(1f, 1f, 1f), vec3(smoothstep(0.82f, 1.4f, _e221)));\n    let _e226 = unnamed.uTint;\n    let _e227 = col;\n    col = (_e227 * _e226);\n    let _e229 = body;\n    alpha = clamp((_e229 * 1.6f), 0f, 1f);\n    let _e232 = vDistance_1;\n    param_11 = _e232;\n    let _e234 = vWorldPos_1[1u];\n    param_12 = _e234;\n    let _e235 = mediumFog_u0028_f1_u003b_f1_u003b((&param_11), (&param_12));\n    fog = _e235;\n    let _e236 = col;\n    let _e237 = mediumColor_u0028_();\n    let _e238 = fog;\n    col = mix(_e236, _e237, vec3(_e238));\n    let _e241 = fog;\n    let _e243 = alpha;\n    alpha = (_e243 * (1f - _e241));\n    let _e245 = col;\n    param_13 = _e245;\n    let _e246 = applyOutputTransform_u0028_vf3_u003b((&param_13));\n    let _e247 = alpha;\n    outColor = vec4<f32>(_e246.x, _e246.y, _e246.z, _e247);\n    return;\n}\n\n@fragment \nfn main(@location(3) vWorldPos: vec3<f32>, @location(0) vUv: vec2<f32>, @location(1) vSeed: f32, @location(2) vDistance: f32) -> @location(0) vec4<f32> {\n    vWorldPos_1 = vWorldPos;\n    vUv_1 = vUv;\n    vSeed_1 = vSeed;\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.
@@ -87,6 +87,16 @@ export const ARCANE_BINDINGS = {
         "size": 4,
         "type": "int"
       },
+      "uOutputTransform": {
+        "offset": 116,
+        "size": 4,
+        "type": "int"
+      },
+      "uOutputExposure": {
+        "offset": 120,
+        "size": 4,
+        "type": "float"
+      },
       "uTint": {
         "offset": 128,
         "size": 12,

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

@@ -5,7 +5,7 @@
  * the next generation, and `npm run wgsl:check` fails the build when this is stale.
  */
 
-export const BOLT_FRAG_WGSL = "struct Uniforms {\n    uTime: f32,\n    uCoreColor: vec3<f32>,\n    uEdgeColor: vec3<f32>,\n    uCoreGain: 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    uCameraPos: vec3<f32>,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vSide_1: f32;\nvar<private> vSeed_1: f32;\nvar<private> vAlong_1: f32;\nvar<private> vFade_1: f32;\nvar<private> vGain_1: f32;\nvar<private> vWorldPos_1: vec3<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 start: f32;\n    var before: f32;\n    var local: f32;\n    var t: f32;\n    var rest: f32;\n    var denom: f32;\n    var air: f32;\n    var wet: f32;\n\n    let _e52 = unnamed.uFogMode;\n    if (_e52 == 1i) {\n        let _e55 = unnamed.uFogFar;\n        let _e57 = unnamed.uFogNear;\n        span = max((_e55 - _e57), 0.0001f);\n        let _e60 = (*dist);\n        let _e62 = unnamed.uFogNear;\n        let _e64 = span;\n        ramp = clamp(((_e60 - _e62) / _e64), 0f, 1f);\n        let _e68 = unnamed.uUnderwaterFactor;\n        if (_e68 <= 0f) {\n            let _e70 = ramp;\n            return _e70;\n        }\n        let _e72 = unnamed.uUnderwaterFogDensity;\n        let _e73 = (*dist);\n        wetLinear = (_e72 * _e73);\n        let _e75 = ramp;\n        let _e76 = wetLinear;\n        let _e78 = wetLinear;\n        let _e84 = unnamed.uUnderwaterFactor;\n        return mix(_e75, (1f - exp2(((-(_e76) * _e78) * 1.442695f))), _e84);\n    }\n    let _e87 = unnamed.uFogNear;\n    let _e88 = (*dist);\n    start = min(_e87, _e88);\n    let _e90 = (*dist);\n    if (_e90 > 0f) {\n        let _e92 = start;\n        let _e93 = (*dist);\n        local = (_e92 / _e93);\n    } else {\n        local = 0f;\n    }\n    let _e95 = local;\n    before = _e95;\n    let _e96 = (*pointY);\n    let _e98 = unnamed.uFogEyeY;\n    let _e101 = unnamed.uFogHeightFalloff;\n    t = ((_e96 - _e98) * _e101);\n    let _e103 = t;\n    let _e104 = before;\n    rest = (_e103 * (1f - _e104));\n    let _e107 = rest;\n    let _e110 = rest;\n    denom = select(_e110, 0.0001f, (abs(_e107) < 0.0001f));\n    let _e113 = unnamed.uFogDensity;\n    let _e115 = t;\n    let _e117 = before;\n    let _e121 = (*dist);\n    let _e122 = start;\n    let _e125 = denom;\n    let _e130 = denom;\n    air = (1f - exp(((((-(_e113) * exp((-(_e115) * _e117))) * (_e121 - _e122)) * (1f - exp(-(_e125)))) / _e130)));\n    let _e135 = unnamed.uUnderwaterFactor;\n    if (_e135 <= 0f) {\n        let _e137 = air;\n        return _e137;\n    }\n    let _e139 = unnamed.uUnderwaterFogDensity;\n    let _e140 = (*dist);\n    wet = (_e139 * _e140);\n    let _e142 = air;\n    let _e143 = wet;\n    let _e145 = wet;\n    let _e151 = unnamed.uUnderwaterFactor;\n    return mix(_e142, (1f - exp2(((-(_e143) * _e145) * 1.442695f))), _e151);\n}\n\nfn hash11_u0028_f1_u003b(p: ptr<function, f32>) -> f32 {\n    let _e39 = (*p);\n    return fract((sin((_e39 * 12.9898f)) * 43758.547f));\n}\n\nfn main_1() {\n    var across: f32;\n    var core: f32;\n    var glow: f32;\n    var t_1: f32;\n    var stutter: f32;\n    var param: f32;\n    var param_1: f32;\n    var taper: f32;\n    var energy: f32;\n    var lit: vec3<f32>;\n    var fog: f32;\n    var param_2: f32;\n    var param_3: f32;\n\n    let _e51 = vSide_1;\n    across = clamp((1f - abs(_e51)), 0f, 1f);\n    let _e55 = across;\n    core = pow(_e55, 10f);\n    let _e57 = across;\n    glow = pow(_e57, 1.1f);\n    let _e60 = unnamed.uTime;\n    let _e62 = vSeed_1;\n    t_1 = ((_e60 * 47f) + (_e62 * 17f));\n    let _e65 = t_1;\n    param = floor(_e65);\n    let _e67 = hash11_u0028_f1_u003b((&param));\n    let _e69 = t_1;\n    param_1 = floor((_e69 * 2.37f));\n    let _e72 = hash11_u0028_f1_u003b((&param_1));\n    stutter = (0.78f + (0.22f * ((_e67 * 0.6f) + (_e72 * 0.4f))));\n    let _e77 = vAlong_1;\n    taper = (1f - (_e77 * 0.55f));\n    let _e80 = vFade_1;\n    let _e81 = stutter;\n    let _e83 = taper;\n    let _e85 = vGain_1;\n    energy = (((_e80 * _e81) * _e83) * _e85);\n    let _e88 = unnamed.uEdgeColor;\n    let _e89 = glow;\n    let _e92 = unnamed.uCoreColor;\n    let _e93 = core;\n    let _e96 = unnamed.uCoreGain;\n    lit = ((_e88 * _e89) + ((_e92 * _e93) * _e96));\n    let _e99 = vWorldPos_1;\n    let _e101 = unnamed.uCameraPos;\n    param_2 = distance(_e99, _e101);\n    let _e104 = vWorldPos_1[1u];\n    param_3 = _e104;\n    let _e105 = mediumFog_u0028_f1_u003b_f1_u003b((&param_2), (&param_3));\n    fog = _e105;\n    let _e106 = lit;\n    let _e107 = energy;\n    let _e109 = fog;\n    let _e111 = ((_e106 * _e107) * (1f - _e109));\n    outColor = vec4<f32>(_e111.x, _e111.y, _e111.z, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(0) vSide: f32, @location(3) vSeed: f32, @location(1) vAlong: f32, @location(2) vFade: f32, @location(4) vGain: f32, @location(5) vWorldPos: vec3<f32>) -> @location(0) vec4<f32> {\n    vSide_1 = vSide;\n    vSeed_1 = vSeed;\n    vAlong_1 = vAlong;\n    vFade_1 = vFade;\n    vGain_1 = vGain;\n    vWorldPos_1 = vWorldPos;\n    main_1();\n    let _e13 = outColor;\n    return _e13;\n}\n";
+export const BOLT_FRAG_WGSL = "struct Uniforms {\n    uTime: f32,\n    uCoreColor: vec3<f32>,\n    uEdgeColor: vec3<f32>,\n    uCoreGain: 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    uCameraPos: vec3<f32>,\n    uOutputTransform: i32,\n    uOutputExposure: f32,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vSide_1: f32;\nvar<private> vSeed_1: f32;\nvar<private> vAlong_1: f32;\nvar<private> vFade_1: f32;\nvar<private> vGain_1: f32;\nvar<private> vWorldPos_1: vec3<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 _e86 = (*c);\n    low = (_e86 * 12.92f);\n    let _e88 = (*c);\n    high = ((pow(max(_e88, vec3<f32>(0f, 0f, 0f)), vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3(0.055f));\n    let _e94 = high;\n    let _e95 = low;\n    let _e96 = (*c);\n    return mix(_e94, _e95, step(_e96, vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f)));\n}\n\nfn highlightShoulder_u0028_vf3_u003b(c_1: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var m: f32;\n    var e: f32;\n\n    let _e87 = (*c_1)[0u];\n    let _e89 = (*c_1)[1u];\n    let _e91 = (*c_1)[2u];\n    m = max(_e87, max(_e89, _e91));\n    let _e94 = m;\n    if (_e94 <= 0.8f) {\n        let _e96 = (*c_1);\n        return _e96;\n    }\n    let _e97 = m;\n    e = (_e97 - 0.8f);\n    let _e99 = (*c_1);\n    let _e100 = e;\n    let _e102 = e;\n    let _e106 = m;\n    return (_e99 * ((0.8f + ((0.2f * _e100) / (_e102 + 0.2f))) / _e106));\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 _e86 = (*v);\n    let _e87 = (*v);\n    a = ((_e86 * (_e87 + vec3(0.0245786f))) - vec3(0.000090537f));\n    let _e93 = (*v);\n    let _e94 = (*v);\n    b = ((_e93 * ((_e94 * 0.983729f) + vec3(0.432951f))) + vec3(0.238081f));\n    let _e101 = a;\n    let _e102 = b;\n    return (_e101 / _e102);\n}\n\nfn acesFilmic_u0028_vf3_u003b(x: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var param: vec3<f32>;\n\n    let _e86 = unnamed.uOutputExposure;\n    let _e87 = (*x);\n    (*x) = (_e87 * _e86);\n    let _e89 = (*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)) * _e89);\n    let _e91 = 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)) * _e91), vec3(0f), vec3(1f));\n}\n\nfn applyOutputTransform_u0028_vf3_u003b(c_2: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var param_1: vec3<f32>;\n    var param_2: vec3<f32>;\n    var param_3: vec3<f32>;\n\n    let _e88 = unnamed.uOutputTransform;\n    if (_e88 == 0i) {\n        let _e90 = (*c_2);\n        return _e90;\n    }\n    let _e92 = unnamed.uOutputTransform;\n    if (_e92 == 2i) {\n        let _e94 = (*c_2);\n        param_1 = _e94;\n        let _e95 = acesFilmic_u0028_vf3_u003b((&param_1));\n        (*c_2) = _e95;\n    }\n    let _e97 = unnamed.uOutputTransform;\n    if (_e97 == 3i) {\n        let _e99 = (*c_2);\n        let _e101 = unnamed.uOutputExposure;\n        param_2 = (_e99 * _e101);\n        let _e103 = highlightShoulder_u0028_vf3_u003b((&param_2));\n        (*c_2) = _e103;\n    }\n    let _e104 = (*c_2);\n    param_3 = _e104;\n    let _e105 = linearToSrgb_u0028_vf3_u003b((&param_3));\n    return _e105;\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 start: f32;\n    var before: f32;\n    var local: f32;\n    var t: f32;\n    var rest: f32;\n    var denom: f32;\n    var air: f32;\n    var wet: f32;\n\n    let _e97 = unnamed.uFogMode;\n    if (_e97 == 1i) {\n        let _e100 = unnamed.uFogFar;\n        let _e102 = unnamed.uFogNear;\n        span = max((_e100 - _e102), 0.0001f);\n        let _e105 = (*dist);\n        let _e107 = unnamed.uFogNear;\n        let _e109 = span;\n        ramp = clamp(((_e105 - _e107) / _e109), 0f, 1f);\n        let _e113 = unnamed.uUnderwaterFactor;\n        if (_e113 <= 0f) {\n            let _e115 = ramp;\n            return _e115;\n        }\n        let _e117 = unnamed.uUnderwaterFogDensity;\n        let _e118 = (*dist);\n        wetLinear = (_e117 * _e118);\n        let _e120 = ramp;\n        let _e121 = wetLinear;\n        let _e123 = wetLinear;\n        let _e129 = unnamed.uUnderwaterFactor;\n        return mix(_e120, (1f - exp2(((-(_e121) * _e123) * 1.442695f))), _e129);\n    }\n    let _e132 = unnamed.uFogNear;\n    let _e133 = (*dist);\n    start = min(_e132, _e133);\n    let _e135 = (*dist);\n    if (_e135 > 0f) {\n        let _e137 = start;\n        let _e138 = (*dist);\n        local = (_e137 / _e138);\n    } else {\n        local = 0f;\n    }\n    let _e140 = local;\n    before = _e140;\n    let _e141 = (*pointY);\n    let _e143 = unnamed.uFogEyeY;\n    let _e146 = unnamed.uFogHeightFalloff;\n    t = ((_e141 - _e143) * _e146);\n    let _e148 = t;\n    let _e149 = before;\n    rest = (_e148 * (1f - _e149));\n    let _e152 = rest;\n    let _e155 = rest;\n    denom = select(_e155, 0.0001f, (abs(_e152) < 0.0001f));\n    let _e158 = unnamed.uFogDensity;\n    let _e160 = t;\n    let _e162 = before;\n    let _e166 = (*dist);\n    let _e167 = start;\n    let _e170 = denom;\n    let _e175 = denom;\n    air = (1f - exp(((((-(_e158) * exp((-(_e160) * _e162))) * (_e166 - _e167)) * (1f - exp(-(_e170)))) / _e175)));\n    let _e180 = unnamed.uUnderwaterFactor;\n    if (_e180 <= 0f) {\n        let _e182 = air;\n        return _e182;\n    }\n    let _e184 = unnamed.uUnderwaterFogDensity;\n    let _e185 = (*dist);\n    wet = (_e184 * _e185);\n    let _e187 = air;\n    let _e188 = wet;\n    let _e190 = wet;\n    let _e196 = unnamed.uUnderwaterFactor;\n    return mix(_e187, (1f - exp2(((-(_e188) * _e190) * 1.442695f))), _e196);\n}\n\nfn hash11_u0028_f1_u003b(p: ptr<function, f32>) -> f32 {\n    let _e84 = (*p);\n    return fract((sin((_e84 * 12.9898f)) * 43758.547f));\n}\n\nfn main_1() {\n    var across: f32;\n    var core: f32;\n    var glow: f32;\n    var t_1: f32;\n    var stutter: f32;\n    var param_4: f32;\n    var param_5: f32;\n    var taper: f32;\n    var energy: f32;\n    var lit: vec3<f32>;\n    var fog: f32;\n    var param_6: f32;\n    var param_7: f32;\n    var param_8: vec3<f32>;\n\n    let _e97 = vSide_1;\n    across = clamp((1f - abs(_e97)), 0f, 1f);\n    let _e101 = across;\n    core = pow(_e101, 10f);\n    let _e103 = across;\n    glow = pow(_e103, 1.1f);\n    let _e106 = unnamed.uTime;\n    let _e108 = vSeed_1;\n    t_1 = ((_e106 * 47f) + (_e108 * 17f));\n    let _e111 = t_1;\n    param_4 = floor(_e111);\n    let _e113 = hash11_u0028_f1_u003b((&param_4));\n    let _e115 = t_1;\n    param_5 = floor((_e115 * 2.37f));\n    let _e118 = hash11_u0028_f1_u003b((&param_5));\n    stutter = (0.78f + (0.22f * ((_e113 * 0.6f) + (_e118 * 0.4f))));\n    let _e123 = vAlong_1;\n    taper = (1f - (_e123 * 0.55f));\n    let _e126 = vFade_1;\n    let _e127 = stutter;\n    let _e129 = taper;\n    let _e131 = vGain_1;\n    energy = (((_e126 * _e127) * _e129) * _e131);\n    let _e134 = unnamed.uEdgeColor;\n    let _e135 = glow;\n    let _e138 = unnamed.uCoreColor;\n    let _e139 = core;\n    let _e142 = unnamed.uCoreGain;\n    lit = ((_e134 * _e135) + ((_e138 * _e139) * _e142));\n    let _e145 = vWorldPos_1;\n    let _e147 = unnamed.uCameraPos;\n    param_6 = distance(_e145, _e147);\n    let _e150 = vWorldPos_1[1u];\n    param_7 = _e150;\n    let _e151 = mediumFog_u0028_f1_u003b_f1_u003b((&param_6), (&param_7));\n    fog = _e151;\n    let _e152 = lit;\n    let _e153 = energy;\n    let _e155 = fog;\n    param_8 = ((_e152 * _e153) * (1f - _e155));\n    let _e158 = applyOutputTransform_u0028_vf3_u003b((&param_8));\n    outColor = vec4<f32>(_e158.x, _e158.y, _e158.z, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(0) vSide: f32, @location(3) vSeed: f32, @location(1) vAlong: f32, @location(2) vFade: f32, @location(4) vGain: f32, @location(5) vWorldPos: vec3<f32>) -> @location(0) vec4<f32> {\n    vSide_1 = vSide;\n    vSeed_1 = vSeed;\n    vAlong_1 = vAlong;\n    vFade_1 = vFade;\n    vGain_1 = vGain;\n    vWorldPos_1 = vWorldPos;\n    main_1();\n    let _e13 = outColor;\n    return _e13;\n}\n";
 
 export const BOLT_VERT_WGSL = "struct Uniforms {\n    uViewProj: mat4x4<f32>,\n    uCameraPos: vec3<f32>,\n    uWidth: f32,\n    uMinWidthPerMetre: 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: f32,\n    @location(1) member_1: f32,\n    @location(2) member_2: f32,\n    @location(3) member_3: f32,\n    @location(4) member_4: f32,\n    @location(5) member_5: vec3<f32>,\n    @builtin(position) gl_Position: vec4<f32>,\n}\n\nvar<private> aFrom_1: vec3<f32>;\nvar<private> aTo_1: vec3<f32>;\nvar<private> aCorner_1: vec2<f32>;\n@group(0) @binding(0) \nvar<uniform> unnamed: Uniforms;\nvar<private> vSide: f32;\nvar<private> vAlong: f32;\nvar<private> aArc_1: vec4<f32>;\nvar<private> vFade: f32;\nvar<private> vSeed: f32;\nvar<private> vGain: f32;\nvar<private> vWorldPos: vec3<f32>;\nvar<private> unnamed_1: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f);\n\nfn main_1() {\n    var mid: vec3<f32>;\n    var dir: vec3<f32>;\n    var len: f32;\n    var local: vec3<f32>;\n    var view: vec3<f32>;\n    var dist: f32;\n    var local_1: vec3<f32>;\n    var across: vec3<f32>;\n    var span: f32;\n    var local_2: vec3<f32>;\n    var halfWidth: f32;\n    var world: vec3<f32>;\n\n    let _e40 = aFrom_1;\n    let _e41 = aTo_1;\n    let _e43 = aCorner_1[0u];\n    mid = mix(_e40, _e41, vec3(_e43));\n    let _e46 = aTo_1;\n    let _e47 = aFrom_1;\n    dir = (_e46 - _e47);\n    let _e49 = dir;\n    len = length(_e49);\n    let _e51 = len;\n    if (_e51 > 0.000001f) {\n        let _e53 = dir;\n        let _e54 = len;\n        local = (_e53 / vec3(_e54));\n    } else {\n        local = vec3<f32>(0f, 1f, 0f);\n    }\n    let _e57 = local;\n    dir = _e57;\n    let _e58 = mid;\n    let _e60 = unnamed.uCameraPos;\n    view = (_e58 - _e60);\n    let _e62 = view;\n    dist = length(_e62);\n    let _e64 = dist;\n    if (_e64 > 0.000001f) {\n        let _e66 = view;\n        let _e67 = dist;\n        local_1 = (_e66 / vec3(_e67));\n    } else {\n        local_1 = vec3<f32>(0f, 0f, 1f);\n    }\n    let _e70 = local_1;\n    view = _e70;\n    let _e71 = dir;\n    let _e72 = view;\n    across = cross(_e71, _e72);\n    let _e74 = across;\n    span = length(_e74);\n    let _e76 = span;\n    if (_e76 > 0.0001f) {\n        let _e78 = across;\n        let _e79 = span;\n        local_2 = (_e78 / vec3(_e79));\n    } else {\n        let _e82 = dir;\n        local_2 = normalize((cross(_e82, vec3<f32>(0f, 1f, 0f)) + vec3<f32>(0.001f, 0.001f, 0.001f)));\n    }\n    let _e86 = local_2;\n    across = _e86;\n    let _e88 = unnamed.uWidth;\n    let _e89 = dist;\n    let _e91 = unnamed.uMinWidthPerMetre;\n    halfWidth = max(_e88, (_e89 * _e91));\n    let _e94 = mid;\n    let _e95 = across;\n    let _e97 = aCorner_1[1u];\n    let _e99 = halfWidth;\n    world = (_e94 + ((_e95 * _e97) * _e99));\n    let _e103 = aCorner_1[1u];\n    vSide = _e103;\n    let _e105 = aArc_1[0u];\n    vAlong = _e105;\n    let _e107 = aArc_1[1u];\n    vFade = _e107;\n    let _e109 = aArc_1[2u];\n    vSeed = _e109;\n    let _e111 = aArc_1[3u];\n    vGain = _e111;\n    let _e112 = world;\n    vWorldPos = _e112;\n    let _e114 = unnamed.uViewProj;\n    let _e115 = world;\n    unnamed_1.gl_Position = (_e114 * vec4<f32>(_e115.x, _e115.y, _e115.z, 1f));\n    return;\n}\n\n@vertex \nfn main(@location(0) aFrom: vec3<f32>, @location(1) aTo: vec3<f32>, @location(2) aCorner: vec2<f32>, @location(3) aArc: vec4<f32>) -> VertexOutput {\n    aFrom_1 = aFrom;\n    aTo_1 = aTo;\n    aCorner_1 = aCorner;\n    aArc_1 = aArc;\n    main_1();\n    let _e17 = unnamed_1.gl_Position.y;\n    unnamed_1.gl_Position.y = -(_e17);\n    let _e19 = vSide;\n    let _e20 = vAlong;\n    let _e21 = vFade;\n    let _e22 = vSeed;\n    let _e23 = vGain;\n    let _e24 = vWorldPos;\n    let _e25 = unnamed_1.gl_Position;\n    return VertexOutput(_e19, _e20, _e21, _e22, _e23, _e24, _e25);\n}\n";
 
@@ -17,7 +17,7 @@ export const BOLT_VERT_WGSL = "struct Uniforms {\n    uViewProj: mat4x4<f32>,\n
 export const BOLT_BINDINGS = {
   "BOLT_FRAG": {
     "uniforms": 1,
-    "uniformSize": 128,
+    "uniformSize": 144,
     "fields": {
       "uTime": {
         "offset": 0,
@@ -93,6 +93,16 @@ export const BOLT_BINDINGS = {
         "offset": 112,
         "size": 12,
         "type": "vec3"
+      },
+      "uOutputTransform": {
+        "offset": 124,
+        "size": 4,
+        "type": "int"
+      },
+      "uOutputExposure": {
+        "offset": 128,
+        "size": 4,
+        "type": "float"
       }
     },
     "textures": {}

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

@@ -5,7 +5,7 @@
  * the next generation, and `npm run wgsl:check` fails the build when this is stale.
  */
 
-export const CAUSTICS_FRAG_WGSL = "struct Uniforms {\n    uCameraPos: vec3<f32>,\n    uWindDir: vec2<f32>,\n    uWaveGain: f32,\n    uTime: f32,\n    uLightDir: vec3<f32>,\n    uTint: vec3<f32>,\n    uStrength: f32,\n    uMaxDrop: 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> vParams_1: vec2<f32>;\nvar<private> vWorldPos_1: vec3<f32>;\nvar<private> vLocal_1: vec2<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 start: f32;\n    var before: f32;\n    var local: f32;\n    var t: f32;\n    var rest: f32;\n    var denom: f32;\n    var air: f32;\n    var wet: f32;\n\n    let _e78 = unnamed.uFogMode;\n    if (_e78 == 1i) {\n        let _e81 = unnamed.uFogFar;\n        let _e83 = unnamed.uFogNear;\n        span = max((_e81 - _e83), 0.0001f);\n        let _e86 = (*dist);\n        let _e88 = unnamed.uFogNear;\n        let _e90 = span;\n        ramp = clamp(((_e86 - _e88) / _e90), 0f, 1f);\n        let _e94 = unnamed.uUnderwaterFactor;\n        if (_e94 <= 0f) {\n            let _e96 = ramp;\n            return _e96;\n        }\n        let _e98 = unnamed.uUnderwaterFogDensity;\n        let _e99 = (*dist);\n        wetLinear = (_e98 * _e99);\n        let _e101 = ramp;\n        let _e102 = wetLinear;\n        let _e104 = wetLinear;\n        let _e110 = unnamed.uUnderwaterFactor;\n        return mix(_e101, (1f - exp2(((-(_e102) * _e104) * 1.442695f))), _e110);\n    }\n    let _e113 = unnamed.uFogNear;\n    let _e114 = (*dist);\n    start = min(_e113, _e114);\n    let _e116 = (*dist);\n    if (_e116 > 0f) {\n        let _e118 = start;\n        let _e119 = (*dist);\n        local = (_e118 / _e119);\n    } else {\n        local = 0f;\n    }\n    let _e121 = local;\n    before = _e121;\n    let _e122 = (*pointY);\n    let _e124 = unnamed.uFogEyeY;\n    let _e127 = unnamed.uFogHeightFalloff;\n    t = ((_e122 - _e124) * _e127);\n    let _e129 = t;\n    let _e130 = before;\n    rest = (_e129 * (1f - _e130));\n    let _e133 = rest;\n    let _e136 = rest;\n    denom = select(_e136, 0.0001f, (abs(_e133) < 0.0001f));\n    let _e139 = unnamed.uFogDensity;\n    let _e141 = t;\n    let _e143 = before;\n    let _e147 = (*dist);\n    let _e148 = start;\n    let _e151 = denom;\n    let _e156 = denom;\n    air = (1f - exp(((((-(_e139) * exp((-(_e141) * _e143))) * (_e147 - _e148)) * (1f - exp(-(_e151)))) / _e156)));\n    let _e161 = unnamed.uUnderwaterFactor;\n    if (_e161 <= 0f) {\n        let _e163 = air;\n        return _e163;\n    }\n    let _e165 = unnamed.uUnderwaterFogDensity;\n    let _e166 = (*dist);\n    wet = (_e165 * _e166);\n    let _e168 = air;\n    let _e169 = wet;\n    let _e171 = wet;\n    let _e177 = unnamed.uUnderwaterFactor;\n    return mix(_e168, (1f - exp2(((-(_e169) * _e171) * 1.442695f))), _e177);\n}\n\nfn gerstnerPhase_u0028_f1_u003b_vf2_u003b_vf2_u003b_f1_u003b(k: ptr<function, f32>, dir: ptr<function, vec2<f32>>, p: ptr<function, vec2<f32>>, time: ptr<function, f32>) -> f32 {\n    var c: f32;\n\n    let _e69 = (*k);\n    c = sqrt((9.81f / _e69));\n    let _e72 = (*k);\n    let _e73 = (*dir);\n    let _e74 = (*p);\n    let _e76 = c;\n    let _e77 = (*time);\n    return (_e72 * (dot(_e73, _e74) - (_e76 * _e77)));\n}\n\nfn gerstnerWavenumber_u0028_i1_u003b(i: ptr<function, i32>) -> f32 {\n    var indexable: array<vec4<f32>, 4>;\n\n    let _e66 = (*i);\n    indexable = array<vec4<f32>, 4>(vec4<f32>(1f, 0f, 0.115f, 34f), vec4<f32>(0.6f, 0.8f, 0.1f, 18f), vec4<f32>(-0.7f, 0.7f, 0.08f, 9f), vec4<f32>(0.2f, -0.98f, 0.06f, 5f));\n    let _e69 = indexable[_e66][3u];\n    return (6.2831855f / _e69);\n}\n\nfn gerstnerDirection_u0028_i1_u003b_vf2_u003b(i_1: ptr<function, i32>, windDir: ptr<function, vec2<f32>>) -> vec2<f32> {\n    var indexable_1: array<vec4<f32>, 4>;\n\n    let _e67 = (*i_1);\n    indexable_1 = array<vec4<f32>, 4>(vec4<f32>(1f, 0f, 0.115f, 34f), vec4<f32>(0.6f, 0.8f, 0.1f, 18f), vec4<f32>(-0.7f, 0.7f, 0.08f, 9f), vec4<f32>(0.2f, -0.98f, 0.06f, 5f));\n    let _e69 = indexable_1[_e67];\n    let _e72 = (*windDir);\n    return normalize(mix(normalize(_e69.xy), _e72, vec2(0.62f)));\n}\n\nfn gerstnerCurvature_u0028_vf2_u003b_f1_u003b_vf2_u003b_f1_u003b(p_1: ptr<function, vec2<f32>>, time_1: ptr<function, f32>, windDir_1: ptr<function, vec2<f32>>, gain: ptr<function, f32>) -> vec3<f32> {\n    var h: vec3<f32>;\n    var i_2: i32;\n    var dir_1: vec2<f32>;\n    var param: i32;\n    var param_1: vec2<f32>;\n    var steepness: f32;\n    var indexable_2: array<vec4<f32>, 4>;\n    var k_1: f32;\n    var param_2: i32;\n    var f: f32;\n    var param_3: f32;\n    var param_4: vec2<f32>;\n    var param_5: vec2<f32>;\n    var param_6: f32;\n    var second: f32;\n\n    h = vec3<f32>(0f, 0f, 0f);\n    i_2 = 0i;\n    loop {\n        let _e83 = i_2;\n        if (_e83 < 4i) {\n            let _e85 = i_2;\n            param = _e85;\n            let _e86 = (*windDir_1);\n            param_1 = _e86;\n            let _e87 = gerstnerDirection_u0028_i1_u003b_vf2_u003b((&param), (&param_1));\n            dir_1 = _e87;\n            let _e88 = i_2;\n            indexable_2 = array<vec4<f32>, 4>(vec4<f32>(1f, 0f, 0.115f, 34f), vec4<f32>(0.6f, 0.8f, 0.1f, 18f), vec4<f32>(-0.7f, 0.7f, 0.08f, 9f), vec4<f32>(0.2f, -0.98f, 0.06f, 5f));\n            let _e91 = indexable_2[_e88][2u];\n            let _e92 = (*gain);\n            steepness = (_e91 * _e92);\n            let _e94 = i_2;\n            param_2 = _e94;\n            let _e95 = gerstnerWavenumber_u0028_i1_u003b((&param_2));\n            k_1 = _e95;\n            let _e96 = k_1;\n            param_3 = _e96;\n            let _e97 = dir_1;\n            param_4 = _e97;\n            let _e98 = (*p_1);\n            param_5 = _e98;\n            let _e99 = (*time_1);\n            param_6 = _e99;\n            let _e100 = gerstnerPhase_u0028_f1_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_3), (&param_4), (&param_5), (&param_6));\n            f = _e100;\n            let _e101 = steepness;\n            let _e103 = k_1;\n            let _e105 = f;\n            second = ((-(_e101) * _e103) * sin(_e105));\n            let _e108 = second;\n            let _e110 = dir_1[0u];\n            let _e113 = dir_1[0u];\n            let _e116 = h[0u];\n            h[0u] = (_e116 + ((_e108 * _e110) * _e113));\n            let _e119 = second;\n            let _e121 = dir_1[1u];\n            let _e124 = dir_1[1u];\n            let _e127 = h[1u];\n            h[1u] = (_e127 + ((_e119 * _e121) * _e124));\n            let _e130 = second;\n            let _e132 = dir_1[0u];\n            let _e135 = dir_1[1u];\n            let _e138 = h[2u];\n            h[2u] = (_e138 + ((_e130 * _e132) * _e135));\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e141 = i_2;\n            i_2 = (_e141 + 1i);\n        }\n    }\n    let _e143 = h;\n    return _e143;\n}\n\nfn main_1() {\n    var waterY: f32;\n    var drop: f32;\n    var distanceFromWater: f32;\n    var clear: f32;\n    var height: f32;\n    var rim: f32;\n    var edge: f32;\n    var reach: f32;\n    var elevation: f32;\n    var slant: f32;\n    var d: f32;\n    var water: vec2<f32>;\n    var h_1: vec3<f32>;\n    var param_7: vec2<f32>;\n    var param_8: f32;\n    var param_9: vec2<f32>;\n    var param_10: f32;\n    var a: f32;\n    var b: f32;\n    var c_1: f32;\n    var det: f32;\n    var soft: f32;\n    var lines: f32;\n    var sheen: f32;\n    var caustic: f32;\n    var fog: f32;\n    var param_11: f32;\n    var param_12: f32;\n\n    let _e93 = vParams_1[0u];\n    waterY = _e93;\n    let _e95 = vWorldPos_1[1u];\n    let _e96 = waterY;\n    drop = (_e95 - _e96);\n    let _e98 = drop;\n    distanceFromWater = abs(_e98);\n    let _e100 = distanceFromWater;\n    clear = step(0.02f, _e100);\n    let _e103 = unnamed.uMaxDrop;\n    let _e106 = unnamed.uMaxDrop;\n    let _e107 = distanceFromWater;\n    height = (1f - smoothstep((_e103 * 0.45f), _e106, _e107));\n    let _e111 = vLocal_1[0u];\n    let _e113 = vLocal_1[0u];\n    let _e117 = vLocal_1[1u];\n    let _e119 = vLocal_1[1u];\n    rim = min(min(_e111, (1f - _e113)), min(_e117, (1f - _e119)));\n    let _e123 = rim;\n    edge = smoothstep(0f, 0.12f, _e123);\n    let _e125 = clear;\n    let _e126 = height;\n    let _e128 = edge;\n    reach = ((_e125 * _e126) * _e128);\n    let _e132 = unnamed.uLightDir[1u];\n    elevation = max(_e132, 0.16f);\n    let _e134 = elevation;\n    slant = (1f / _e134);\n    let _e136 = drop;\n    let _e137 = slant;\n    d = (_e136 * _e137);\n    let _e139 = vWorldPos_1;\n    let _e142 = unnamed.uLightDir;\n    let _e144 = d;\n    water = (_e139.xz + (_e142.xz * _e144));\n    let _e147 = water;\n    param_7 = _e147;\n    let _e149 = unnamed.uTime;\n    param_8 = _e149;\n    let _e151 = unnamed.uWindDir;\n    param_9 = _e151;\n    let _e153 = unnamed.uWaveGain;\n    param_10 = _e153;\n    let _e154 = gerstnerCurvature_u0028_vf2_u003b_f1_u003b_vf2_u003b_f1_u003b((&param_7), (&param_8), (&param_9), (&param_10));\n    h_1 = _e154;\n    let _e155 = d;\n    let _e158 = h_1[0u];\n    a = (1f - ((2f * _e155) * _e158));\n    let _e161 = d;\n    let _e164 = h_1[1u];\n    b = (1f - ((2f * _e161) * _e164));\n    let _e167 = d;\n    let _e170 = h_1[2u];\n    c_1 = ((2f * _e167) * _e170);\n    let _e172 = a;\n    let _e173 = b;\n    let _e175 = c_1;\n    let _e176 = c_1;\n    det = ((_e172 * _e173) - (_e175 * _e176));\n    let _e179 = det;\n    let _e180 = fwidth(_e179);\n    soft = max(0.05f, (_e180 * 1.6f));\n    let _e183 = soft;\n    let _e184 = det;\n    let _e186 = soft;\n    lines = (_e183 / max(abs(_e184), _e186));\n    let _e189 = det;\n    sheen = clamp(((1f / max(abs(_e189), 0.18f)) - 0.85f), 0f, 1f);\n    let _e195 = lines;\n    let _e197 = sheen;\n    caustic = clamp(((_e195 * 0.9f) + (_e197 * 0.09f)), 0f, 1.6f);\n    let _e201 = vWorldPos_1;\n    let _e203 = unnamed.uCameraPos;\n    param_11 = distance(_e201, _e203);\n    let _e206 = vWorldPos_1[1u];\n    param_12 = _e206;\n    let _e207 = mediumFog_u0028_f1_u003b_f1_u003b((&param_11), (&param_12));\n    fog = _e207;\n    let _e209 = unnamed.uTint;\n    let _e210 = caustic;\n    let _e212 = unnamed.uStrength;\n    let _e214 = reach;\n    let _e216 = fog;\n    let _e219 = (_e209 * (((_e210 * _e212) * _e214) * (1f - _e216)));\n    outColor = vec4<f32>(_e219.x, _e219.y, _e219.z, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(2) vParams: vec2<f32>, @location(0) vWorldPos: vec3<f32>, @location(1) vLocal: vec2<f32>) -> @location(0) vec4<f32> {\n    vParams_1 = vParams;\n    vWorldPos_1 = vWorldPos;\n    vLocal_1 = vLocal;\n    main_1();\n    let _e7 = outColor;\n    return _e7;\n}\n";
+export const CAUSTICS_FRAG_WGSL = "struct Uniforms {\n    uCameraPos: vec3<f32>,\n    uWindDir: vec2<f32>,\n    uWaveGain: f32,\n    uTime: f32,\n    uLightDir: vec3<f32>,\n    uTint: vec3<f32>,\n    uStrength: f32,\n    uMaxDrop: 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    uOutputTransform: i32,\n    uOutputExposure: f32,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vParams_1: vec2<f32>;\nvar<private> vWorldPos_1: vec3<f32>;\nvar<private> vLocal_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 _e107 = (*c);\n    low = (_e107 * 12.92f);\n    let _e109 = (*c);\n    high = ((pow(max(_e109, vec3<f32>(0f, 0f, 0f)), vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3(0.055f));\n    let _e115 = high;\n    let _e116 = low;\n    let _e117 = (*c);\n    return mix(_e115, _e116, step(_e117, vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f)));\n}\n\nfn highlightShoulder_u0028_vf3_u003b(c_1: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var m: f32;\n    var e: f32;\n\n    let _e108 = (*c_1)[0u];\n    let _e110 = (*c_1)[1u];\n    let _e112 = (*c_1)[2u];\n    m = max(_e108, max(_e110, _e112));\n    let _e115 = m;\n    if (_e115 <= 0.8f) {\n        let _e117 = (*c_1);\n        return _e117;\n    }\n    let _e118 = m;\n    e = (_e118 - 0.8f);\n    let _e120 = (*c_1);\n    let _e121 = e;\n    let _e123 = e;\n    let _e127 = m;\n    return (_e120 * ((0.8f + ((0.2f * _e121) / (_e123 + 0.2f))) / _e127));\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 _e107 = (*v);\n    let _e108 = (*v);\n    a = ((_e107 * (_e108 + vec3(0.0245786f))) - vec3(0.000090537f));\n    let _e114 = (*v);\n    let _e115 = (*v);\n    b = ((_e114 * ((_e115 * 0.983729f) + vec3(0.432951f))) + vec3(0.238081f));\n    let _e122 = a;\n    let _e123 = b;\n    return (_e122 / _e123);\n}\n\nfn acesFilmic_u0028_vf3_u003b(x: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var param: vec3<f32>;\n\n    let _e107 = unnamed.uOutputExposure;\n    let _e108 = (*x);\n    (*x) = (_e108 * _e107);\n    let _e110 = (*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)) * _e110);\n    let _e112 = 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)) * _e112), vec3(0f), vec3(1f));\n}\n\nfn applyOutputTransform_u0028_vf3_u003b(c_2: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var param_1: vec3<f32>;\n    var param_2: vec3<f32>;\n    var param_3: vec3<f32>;\n\n    let _e109 = unnamed.uOutputTransform;\n    if (_e109 == 0i) {\n        let _e111 = (*c_2);\n        return _e111;\n    }\n    let _e113 = unnamed.uOutputTransform;\n    if (_e113 == 2i) {\n        let _e115 = (*c_2);\n        param_1 = _e115;\n        let _e116 = acesFilmic_u0028_vf3_u003b((&param_1));\n        (*c_2) = _e116;\n    }\n    let _e118 = unnamed.uOutputTransform;\n    if (_e118 == 3i) {\n        let _e120 = (*c_2);\n        let _e122 = unnamed.uOutputExposure;\n        param_2 = (_e120 * _e122);\n        let _e124 = highlightShoulder_u0028_vf3_u003b((&param_2));\n        (*c_2) = _e124;\n    }\n    let _e125 = (*c_2);\n    param_3 = _e125;\n    let _e126 = linearToSrgb_u0028_vf3_u003b((&param_3));\n    return _e126;\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 start: f32;\n    var before: f32;\n    var local: f32;\n    var t: f32;\n    var rest: f32;\n    var denom: f32;\n    var air: f32;\n    var wet: f32;\n\n    let _e118 = unnamed.uFogMode;\n    if (_e118 == 1i) {\n        let _e121 = unnamed.uFogFar;\n        let _e123 = unnamed.uFogNear;\n        span = max((_e121 - _e123), 0.0001f);\n        let _e126 = (*dist);\n        let _e128 = unnamed.uFogNear;\n        let _e130 = span;\n        ramp = clamp(((_e126 - _e128) / _e130), 0f, 1f);\n        let _e134 = unnamed.uUnderwaterFactor;\n        if (_e134 <= 0f) {\n            let _e136 = ramp;\n            return _e136;\n        }\n        let _e138 = unnamed.uUnderwaterFogDensity;\n        let _e139 = (*dist);\n        wetLinear = (_e138 * _e139);\n        let _e141 = ramp;\n        let _e142 = wetLinear;\n        let _e144 = wetLinear;\n        let _e150 = unnamed.uUnderwaterFactor;\n        return mix(_e141, (1f - exp2(((-(_e142) * _e144) * 1.442695f))), _e150);\n    }\n    let _e153 = unnamed.uFogNear;\n    let _e154 = (*dist);\n    start = min(_e153, _e154);\n    let _e156 = (*dist);\n    if (_e156 > 0f) {\n        let _e158 = start;\n        let _e159 = (*dist);\n        local = (_e158 / _e159);\n    } else {\n        local = 0f;\n    }\n    let _e161 = local;\n    before = _e161;\n    let _e162 = (*pointY);\n    let _e164 = unnamed.uFogEyeY;\n    let _e167 = unnamed.uFogHeightFalloff;\n    t = ((_e162 - _e164) * _e167);\n    let _e169 = t;\n    let _e170 = before;\n    rest = (_e169 * (1f - _e170));\n    let _e173 = rest;\n    let _e176 = rest;\n    denom = select(_e176, 0.0001f, (abs(_e173) < 0.0001f));\n    let _e179 = unnamed.uFogDensity;\n    let _e181 = t;\n    let _e183 = before;\n    let _e187 = (*dist);\n    let _e188 = start;\n    let _e191 = denom;\n    let _e196 = denom;\n    air = (1f - exp(((((-(_e179) * exp((-(_e181) * _e183))) * (_e187 - _e188)) * (1f - exp(-(_e191)))) / _e196)));\n    let _e201 = unnamed.uUnderwaterFactor;\n    if (_e201 <= 0f) {\n        let _e203 = air;\n        return _e203;\n    }\n    let _e205 = unnamed.uUnderwaterFogDensity;\n    let _e206 = (*dist);\n    wet = (_e205 * _e206);\n    let _e208 = air;\n    let _e209 = wet;\n    let _e211 = wet;\n    let _e217 = unnamed.uUnderwaterFactor;\n    return mix(_e208, (1f - exp2(((-(_e209) * _e211) * 1.442695f))), _e217);\n}\n\nfn gerstnerPhase_u0028_f1_u003b_vf2_u003b_vf2_u003b_f1_u003b(k: ptr<function, f32>, dir: ptr<function, vec2<f32>>, p: ptr<function, vec2<f32>>, time: ptr<function, f32>) -> f32 {\n    var c_3: f32;\n\n    let _e109 = (*k);\n    c_3 = sqrt((9.81f / _e109));\n    let _e112 = (*k);\n    let _e113 = (*dir);\n    let _e114 = (*p);\n    let _e116 = c_3;\n    let _e117 = (*time);\n    return (_e112 * (dot(_e113, _e114) - (_e116 * _e117)));\n}\n\nfn gerstnerWavenumber_u0028_i1_u003b(i: ptr<function, i32>) -> f32 {\n    var indexable: array<vec4<f32>, 4>;\n\n    let _e106 = (*i);\n    indexable = array<vec4<f32>, 4>(vec4<f32>(1f, 0f, 0.115f, 34f), vec4<f32>(0.6f, 0.8f, 0.1f, 18f), vec4<f32>(-0.7f, 0.7f, 0.08f, 9f), vec4<f32>(0.2f, -0.98f, 0.06f, 5f));\n    let _e109 = indexable[_e106][3u];\n    return (6.2831855f / _e109);\n}\n\nfn gerstnerDirection_u0028_i1_u003b_vf2_u003b(i_1: ptr<function, i32>, windDir: ptr<function, vec2<f32>>) -> vec2<f32> {\n    var indexable_1: array<vec4<f32>, 4>;\n\n    let _e107 = (*i_1);\n    indexable_1 = array<vec4<f32>, 4>(vec4<f32>(1f, 0f, 0.115f, 34f), vec4<f32>(0.6f, 0.8f, 0.1f, 18f), vec4<f32>(-0.7f, 0.7f, 0.08f, 9f), vec4<f32>(0.2f, -0.98f, 0.06f, 5f));\n    let _e109 = indexable_1[_e107];\n    let _e112 = (*windDir);\n    return normalize(mix(normalize(_e109.xy), _e112, vec2(0.62f)));\n}\n\nfn gerstnerCurvature_u0028_vf2_u003b_f1_u003b_vf2_u003b_f1_u003b(p_1: ptr<function, vec2<f32>>, time_1: ptr<function, f32>, windDir_1: ptr<function, vec2<f32>>, gain: ptr<function, f32>) -> vec3<f32> {\n    var h: vec3<f32>;\n    var i_2: i32;\n    var dir_1: vec2<f32>;\n    var param_4: i32;\n    var param_5: vec2<f32>;\n    var steepness: f32;\n    var indexable_2: array<vec4<f32>, 4>;\n    var k_1: f32;\n    var param_6: i32;\n    var f: f32;\n    var param_7: f32;\n    var param_8: vec2<f32>;\n    var param_9: vec2<f32>;\n    var param_10: f32;\n    var second: f32;\n\n    h = vec3<f32>(0f, 0f, 0f);\n    i_2 = 0i;\n    loop {\n        let _e123 = i_2;\n        if (_e123 < 4i) {\n            let _e125 = i_2;\n            param_4 = _e125;\n            let _e126 = (*windDir_1);\n            param_5 = _e126;\n            let _e127 = gerstnerDirection_u0028_i1_u003b_vf2_u003b((&param_4), (&param_5));\n            dir_1 = _e127;\n            let _e128 = i_2;\n            indexable_2 = array<vec4<f32>, 4>(vec4<f32>(1f, 0f, 0.115f, 34f), vec4<f32>(0.6f, 0.8f, 0.1f, 18f), vec4<f32>(-0.7f, 0.7f, 0.08f, 9f), vec4<f32>(0.2f, -0.98f, 0.06f, 5f));\n            let _e131 = indexable_2[_e128][2u];\n            let _e132 = (*gain);\n            steepness = (_e131 * _e132);\n            let _e134 = i_2;\n            param_6 = _e134;\n            let _e135 = gerstnerWavenumber_u0028_i1_u003b((&param_6));\n            k_1 = _e135;\n            let _e136 = k_1;\n            param_7 = _e136;\n            let _e137 = dir_1;\n            param_8 = _e137;\n            let _e138 = (*p_1);\n            param_9 = _e138;\n            let _e139 = (*time_1);\n            param_10 = _e139;\n            let _e140 = gerstnerPhase_u0028_f1_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_7), (&param_8), (&param_9), (&param_10));\n            f = _e140;\n            let _e141 = steepness;\n            let _e143 = k_1;\n            let _e145 = f;\n            second = ((-(_e141) * _e143) * sin(_e145));\n            let _e148 = second;\n            let _e150 = dir_1[0u];\n            let _e153 = dir_1[0u];\n            let _e156 = h[0u];\n            h[0u] = (_e156 + ((_e148 * _e150) * _e153));\n            let _e159 = second;\n            let _e161 = dir_1[1u];\n            let _e164 = dir_1[1u];\n            let _e167 = h[1u];\n            h[1u] = (_e167 + ((_e159 * _e161) * _e164));\n            let _e170 = second;\n            let _e172 = dir_1[0u];\n            let _e175 = dir_1[1u];\n            let _e178 = h[2u];\n            h[2u] = (_e178 + ((_e170 * _e172) * _e175));\n            continue;\n        } else {\n            break;\n        }\n        continuing {\n            let _e181 = i_2;\n            i_2 = (_e181 + 1i);\n        }\n    }\n    let _e183 = h;\n    return _e183;\n}\n\nfn main_1() {\n    var waterY: f32;\n    var drop: f32;\n    var distanceFromWater: f32;\n    var clear: f32;\n    var height: f32;\n    var rim: f32;\n    var edge: f32;\n    var reach: f32;\n    var elevation: f32;\n    var slant: f32;\n    var d: f32;\n    var water: vec2<f32>;\n    var h_1: vec3<f32>;\n    var param_11: vec2<f32>;\n    var param_12: f32;\n    var param_13: vec2<f32>;\n    var param_14: f32;\n    var a_1: f32;\n    var b_1: f32;\n    var c_4: f32;\n    var det: f32;\n    var soft: f32;\n    var lines: f32;\n    var sheen: f32;\n    var caustic: f32;\n    var fog: f32;\n    var param_15: f32;\n    var param_16: f32;\n    var param_17: vec3<f32>;\n\n    let _e134 = vParams_1[0u];\n    waterY = _e134;\n    let _e136 = vWorldPos_1[1u];\n    let _e137 = waterY;\n    drop = (_e136 - _e137);\n    let _e139 = drop;\n    distanceFromWater = abs(_e139);\n    let _e141 = distanceFromWater;\n    clear = step(0.02f, _e141);\n    let _e144 = unnamed.uMaxDrop;\n    let _e147 = unnamed.uMaxDrop;\n    let _e148 = distanceFromWater;\n    height = (1f - smoothstep((_e144 * 0.45f), _e147, _e148));\n    let _e152 = vLocal_1[0u];\n    let _e154 = vLocal_1[0u];\n    let _e158 = vLocal_1[1u];\n    let _e160 = vLocal_1[1u];\n    rim = min(min(_e152, (1f - _e154)), min(_e158, (1f - _e160)));\n    let _e164 = rim;\n    edge = smoothstep(0f, 0.12f, _e164);\n    let _e166 = clear;\n    let _e167 = height;\n    let _e169 = edge;\n    reach = ((_e166 * _e167) * _e169);\n    let _e173 = unnamed.uLightDir[1u];\n    elevation = max(_e173, 0.16f);\n    let _e175 = elevation;\n    slant = (1f / _e175);\n    let _e177 = drop;\n    let _e178 = slant;\n    d = (_e177 * _e178);\n    let _e180 = vWorldPos_1;\n    let _e183 = unnamed.uLightDir;\n    let _e185 = d;\n    water = (_e180.xz + (_e183.xz * _e185));\n    let _e188 = water;\n    param_11 = _e188;\n    let _e190 = unnamed.uTime;\n    param_12 = _e190;\n    let _e192 = unnamed.uWindDir;\n    param_13 = _e192;\n    let _e194 = unnamed.uWaveGain;\n    param_14 = _e194;\n    let _e195 = gerstnerCurvature_u0028_vf2_u003b_f1_u003b_vf2_u003b_f1_u003b((&param_11), (&param_12), (&param_13), (&param_14));\n    h_1 = _e195;\n    let _e196 = d;\n    let _e199 = h_1[0u];\n    a_1 = (1f - ((2f * _e196) * _e199));\n    let _e202 = d;\n    let _e205 = h_1[1u];\n    b_1 = (1f - ((2f * _e202) * _e205));\n    let _e208 = d;\n    let _e211 = h_1[2u];\n    c_4 = ((2f * _e208) * _e211);\n    let _e213 = a_1;\n    let _e214 = b_1;\n    let _e216 = c_4;\n    let _e217 = c_4;\n    det = ((_e213 * _e214) - (_e216 * _e217));\n    let _e220 = det;\n    let _e221 = fwidth(_e220);\n    soft = max(0.05f, (_e221 * 1.6f));\n    let _e224 = soft;\n    let _e225 = det;\n    let _e227 = soft;\n    lines = (_e224 / max(abs(_e225), _e227));\n    let _e230 = det;\n    sheen = clamp(((1f / max(abs(_e230), 0.18f)) - 0.85f), 0f, 1f);\n    let _e236 = lines;\n    let _e238 = sheen;\n    caustic = clamp(((_e236 * 0.9f) + (_e238 * 0.09f)), 0f, 1.6f);\n    let _e242 = vWorldPos_1;\n    let _e244 = unnamed.uCameraPos;\n    param_15 = distance(_e242, _e244);\n    let _e247 = vWorldPos_1[1u];\n    param_16 = _e247;\n    let _e248 = mediumFog_u0028_f1_u003b_f1_u003b((&param_15), (&param_16));\n    fog = _e248;\n    let _e250 = unnamed.uTint;\n    let _e251 = caustic;\n    let _e253 = unnamed.uStrength;\n    let _e255 = reach;\n    let _e257 = fog;\n    param_17 = (_e250 * (((_e251 * _e253) * _e255) * (1f - _e257)));\n    let _e261 = applyOutputTransform_u0028_vf3_u003b((&param_17));\n    outColor = vec4<f32>(_e261.x, _e261.y, _e261.z, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(2) vParams: vec2<f32>, @location(0) vWorldPos: vec3<f32>, @location(1) vLocal: vec2<f32>) -> @location(0) vec4<f32> {\n    vParams_1 = vParams;\n    vWorldPos_1 = vWorldPos;\n    vLocal_1 = vLocal;\n    main_1();\n    let _e7 = outColor;\n    return _e7;\n}\n";
 
 export const CAUSTICS_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}\n\nstruct VertexOutput {\n    @location(0) member: vec3<f32>,\n    @location(1) member_1: vec2<f32>,\n    @location(2) member_2: vec2<f32>,\n    @builtin(position) gl_Position: vec4<f32>,\n}\n\nvar<private> vWorldPos: vec3<f32>;\nvar<private> aRest_1: vec3<f32>;\nvar<private> vLocal: vec2<f32>;\nvar<private> aLocal_1: vec2<f32>;\nvar<private> vParams: vec2<f32>;\nvar<private> aParams_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;\n\nfn main_1() {\n    let _e10 = aRest_1;\n    vWorldPos = _e10;\n    let _e11 = aLocal_1;\n    vLocal = _e11;\n    let _e12 = aParams_1;\n    vParams = _e12;\n    let _e14 = unnamed_1.uViewProj;\n    let _e15 = aRest_1;\n    unnamed.gl_Position = (_e14 * vec4<f32>(_e15.x, _e15.y, _e15.z, 1f));\n    return;\n}\n\n@vertex \nfn main(@location(0) aRest: vec3<f32>, @location(1) aLocal: vec2<f32>, @location(2) aParams: vec2<f32>) -> VertexOutput {\n    aRest_1 = aRest;\n    aLocal_1 = aLocal;\n    aParams_1 = aParams;\n    main_1();\n    let _e12 = unnamed.gl_Position.y;\n    unnamed.gl_Position.y = -(_e12);\n    let _e14 = vWorldPos;\n    let _e15 = vLocal;\n    let _e16 = vParams;\n    let _e17 = unnamed.gl_Position;\n    return VertexOutput(_e14, _e15, _e16, _e17);\n}\n";
 
@@ -17,7 +17,7 @@ export const CAUSTICS_VERT_WGSL = "struct gl_PerVertex {\n    @builtin(position)
 export const CAUSTICS_BINDINGS = {
   "CAUSTICS_FRAG": {
     "uniforms": 1,
-    "uniformSize": 144,
+    "uniformSize": 160,
     "fields": {
       "uCameraPos": {
         "offset": 0,
@@ -108,6 +108,16 @@ export const CAUSTICS_BINDINGS = {
         "offset": 140,
         "size": 4,
         "type": "float"
+      },
+      "uOutputTransform": {
+        "offset": 144,
+        "size": 4,
+        "type": "int"
+      },
+      "uOutputExposure": {
+        "offset": 148,
+        "size": 4,
+        "type": "float"
       }
     },
     "textures": {}

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

@@ -5,7 +5,7 @@
  * the next generation, and `npm run wgsl:check` fails the build when this is stale.
  */
 
-export const DECAL_PROJECT_FRAG_WGSL = "struct Uniforms {\n    uDecalDepthToWorld: mat4x4<f32>,\n    uWorldToDecal: mat4x4<f32>,\n    uDecalEye: vec3<f32>,\n    uDecalAxis: vec3<f32>,\n    uDecalColor: vec3<f32>,\n    uDecalOpacity: f32,\n    uDecalFacingCos: f32,\n    uDecalSoftness: f32,\n}\n\n@group(0) @binding(32) \nvar uDecalDepth_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uDecalDepth_s: sampler;\nvar<private> vUv_1: vec2<f32>;\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> fragColor: vec4<f32>;\n\nfn main_1() {\n    var stored: f32;\n    var world: vec4<f32>;\n    var point: vec3<f32>;\n    var plane: vec3<f32>;\n    var span: f32;\n    var normal: vec3<f32>;\n    var local: vec3<f32>;\n    var box: vec3<f32>;\n    var inside: vec3<f32>;\n    var mark: f32;\n    var radius: f32;\n    var facing: f32;\n\n    let _e34 = vUv_1;\n    let _e35 = textureSampleLevel(uDecalDepth_t, uDecalDepth_s, _e34, 0f);\n    stored = _e35.x;\n    let _e38 = unnamed.uDecalDepthToWorld;\n    let _e39 = vUv_1;\n    let _e42 = ((_e39 * 2f) - vec2(1f));\n    let _e43 = stored;\n    world = (_e38 * vec4<f32>(_e42.x, _e42.y, _e43, 1f));\n    let _e48 = world;\n    let _e51 = world[3u];\n    point = (_e48.xyz / vec3(_e51));\n    let _e54 = point;\n    let _e55 = dpdx(_e54);\n    let _e56 = point;\n    let _e57 = dpdy(_e56);\n    plane = cross(_e55, _e57);\n    let _e59 = plane;\n    span = length(_e59);\n    let _e61 = span;\n    if (_e61 > 0f) {\n        let _e63 = plane;\n        let _e64 = span;\n        local = (_e63 / vec3(_e64));\n    } else {\n        let _e68 = unnamed.uDecalAxis;\n        local = _e68;\n    }\n    let _e69 = local;\n    normal = _e69;\n    let _e71 = unnamed.uDecalEye;\n    let _e72 = point;\n    let _e74 = normal;\n    let _e77 = normal;\n    normal = (_e77 * sign(dot((_e71 - _e72), _e74)));\n    let _e80 = unnamed.uWorldToDecal;\n    let _e81 = point;\n    box = (_e80 * vec4<f32>(_e81.x, _e81.y, _e81.z, 1f)).xyz;\n    let _e88 = box;\n    inside = step(abs(_e88), vec3<f32>(1f, 1f, 1f));\n    let _e92 = inside[0u];\n    let _e94 = inside[1u];\n    let _e97 = inside[2u];\n    mark = ((_e92 * _e94) * _e97);\n    let _e99 = box;\n    radius = length(_e99.xy);\n    let _e103 = unnamed.uDecalSoftness;\n    let _e105 = radius;\n    let _e108 = mark;\n    mark = (_e108 * (1f - smoothstep((1f - _e103), 1f, _e105)));\n    let _e110 = normal;\n    let _e112 = unnamed.uDecalAxis;\n    facing = dot(_e110, -(_e112));\n    let _e116 = unnamed.uDecalFacingCos;\n    let _e118 = unnamed.uDecalFacingCos;\n    let _e121 = facing;\n    let _e123 = mark;\n    mark = (_e123 * smoothstep(_e116, min(1f, (_e118 + 0.25f)), _e121));\n    let _e125 = stored;\n    let _e128 = mark;\n    mark = (_e128 * select(1f, 0f, (_e125 <= 0f)));\n    let _e131 = unnamed.uDecalColor;\n    let _e132 = mark;\n    let _e134 = unnamed.uDecalOpacity;\n    let _e137 = mix(vec3<f32>(1f, 1f, 1f), _e131, vec3((_e132 * _e134)));\n    fragColor = vec4<f32>(_e137.x, _e137.y, _e137.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";
+export const DECAL_PROJECT_FRAG_WGSL = "struct Uniforms {\n    uDecalDepthToWorld: mat4x4<f32>,\n    uWorldToDecal: mat4x4<f32>,\n    uDecalEye: vec3<f32>,\n    uDecalAxis: vec3<f32>,\n    uDecalColor: vec3<f32>,\n    uDecalOpacity: f32,\n    uDecalFacingCos: f32,\n    uDecalSoftness: f32,\n    uOutputTransform: i32,\n}\n\n@group(0) @binding(32) \nvar uDecalDepth_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uDecalDepth_s: sampler;\nvar<private> vUv_1: vec2<f32>;\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> fragColor: 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 _e34 = (*c);\n    low = (_e34 * 12.92f);\n    let _e36 = (*c);\n    high = ((pow(max(_e36, vec3<f32>(0f, 0f, 0f)), vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3(0.055f));\n    let _e42 = high;\n    let _e43 = low;\n    let _e44 = (*c);\n    return mix(_e42, _e43, step(_e44, vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f)));\n}\n\nfn main_1() {\n    var stored: f32;\n    var world: vec4<f32>;\n    var point: vec3<f32>;\n    var plane: vec3<f32>;\n    var span: f32;\n    var normal: vec3<f32>;\n    var local: vec3<f32>;\n    var box: vec3<f32>;\n    var inside: vec3<f32>;\n    var mark: f32;\n    var radius: f32;\n    var facing: f32;\n    var multiply: vec3<f32>;\n    var param: vec3<f32>;\n\n    let _e45 = vUv_1;\n    let _e46 = textureSampleLevel(uDecalDepth_t, uDecalDepth_s, _e45, 0f);\n    stored = _e46.x;\n    let _e49 = unnamed.uDecalDepthToWorld;\n    let _e50 = vUv_1;\n    let _e53 = ((_e50 * 2f) - vec2(1f));\n    let _e54 = stored;\n    world = (_e49 * vec4<f32>(_e53.x, _e53.y, _e54, 1f));\n    let _e59 = world;\n    let _e62 = world[3u];\n    point = (_e59.xyz / vec3(_e62));\n    let _e65 = point;\n    let _e66 = dpdx(_e65);\n    let _e67 = point;\n    let _e68 = dpdy(_e67);\n    plane = cross(_e66, _e68);\n    let _e70 = plane;\n    span = length(_e70);\n    let _e72 = span;\n    if (_e72 > 0f) {\n        let _e74 = plane;\n        let _e75 = span;\n        local = (_e74 / vec3(_e75));\n    } else {\n        let _e79 = unnamed.uDecalAxis;\n        local = _e79;\n    }\n    let _e80 = local;\n    normal = _e80;\n    let _e82 = unnamed.uDecalEye;\n    let _e83 = point;\n    let _e85 = normal;\n    let _e88 = normal;\n    normal = (_e88 * sign(dot((_e82 - _e83), _e85)));\n    let _e91 = unnamed.uWorldToDecal;\n    let _e92 = point;\n    box = (_e91 * vec4<f32>(_e92.x, _e92.y, _e92.z, 1f)).xyz;\n    let _e99 = box;\n    inside = step(abs(_e99), vec3<f32>(1f, 1f, 1f));\n    let _e103 = inside[0u];\n    let _e105 = inside[1u];\n    let _e108 = inside[2u];\n    mark = ((_e103 * _e105) * _e108);\n    let _e110 = box;\n    radius = length(_e110.xy);\n    let _e114 = unnamed.uDecalSoftness;\n    let _e116 = radius;\n    let _e119 = mark;\n    mark = (_e119 * (1f - smoothstep((1f - _e114), 1f, _e116)));\n    let _e121 = normal;\n    let _e123 = unnamed.uDecalAxis;\n    facing = dot(_e121, -(_e123));\n    let _e127 = unnamed.uDecalFacingCos;\n    let _e129 = unnamed.uDecalFacingCos;\n    let _e132 = facing;\n    let _e134 = mark;\n    mark = (_e134 * smoothstep(_e127, min(1f, (_e129 + 0.25f)), _e132));\n    let _e136 = stored;\n    let _e139 = mark;\n    mark = (_e139 * select(1f, 0f, (_e136 <= 0f)));\n    let _e142 = unnamed.uDecalColor;\n    let _e143 = mark;\n    let _e145 = unnamed.uDecalOpacity;\n    multiply = mix(vec3<f32>(1f, 1f, 1f), _e142, vec3((_e143 * _e145)));\n    let _e149 = multiply;\n    let _e150 = multiply;\n    param = _e150;\n    let _e151 = linearToSrgb_u0028_vf3_u003b((&param));\n    let _e153 = unnamed.uOutputTransform;\n    let _e157 = mix(_e149, _e151, vec3(select(0f, 1f, (_e153 != 0i))));\n    fragColor = vec4<f32>(_e157.x, _e157.y, _e157.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.
@@ -56,6 +56,11 @@ export const DECALPROJECT_BINDINGS = {
         "offset": 180,
         "size": 4,
         "type": "float"
+      },
+      "uOutputTransform": {
+        "offset": 184,
+        "size": 4,
+        "type": "int"
       }
     },
     "textures": {