@luma.gl/effects 9.3.0-alpha.8 → 9.3.0

package/dist/passes/postprocessing/image-adjust-filters/huesaturation.d.ts

@@ -22,7 +22,7 @@ export declare const hueSaturation: {
     readonly props: HueSaturationProps;
     readonly name: "hueSaturation";
     readonly source: "struct hueSaturationUniforms {\n  hue: f32,\n  saturation: f32,\n};\n\n@group(0) @binding(auto) var<uniform> hueSaturation: hueSaturationUniforms;\n\nfn hueSaturation_filterColor(color: vec4f) -> vec4f {\n  let angle = hueSaturation.hue * 3.14159265;\n  let s = sin(angle);\n  let c = cos(angle);\n  let weights = (vec3f(2.0 * c, -sqrt(3.0) * s - c, sqrt(3.0) * s - c) + vec3f(1.0)) / 3.0;\n\n  var resultRgb = vec3f(\n    dot(color.rgb, weights.xyz),\n    dot(color.rgb, weights.zxy),\n    dot(color.rgb, weights.yzx)\n  );\n\n  let average = (resultRgb.r + resultRgb.g + resultRgb.b) / 3.0;\n  if (hueSaturation.saturation > 0.0) {\n    resultRgb += (vec3f(average) - resultRgb) * (1.0 - 1.0 / (1.001 - hueSaturation.saturation));\n  } else {\n    resultRgb += (vec3f(average) - resultRgb) * (-hueSaturation.saturation);\n  }\n\n  return vec4f(resultRgb, color.a);\n}\n\nfn hueSaturation_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> vec4f {\n  return hueSaturation_filterColor(color);\n}\n";
-    readonly fs: "uniform hueSaturationUniforms {\n  float hue;\n  float saturation;\n} hueSaturation;\n\nvec4 hueSaturation_filterColor(vec4 color) {\n  // hue adjustment, wolfram alpha: RotationTransform[angle, {1, 1, 1}][{x, y, z}]\n  float angle = hueSaturation.hue * 3.14159265;\n  float s = sin(angle), c = cos(angle);\n  vec3 weights = (vec3(2.0 * c, -sqrt(3.0) * s - c, sqrt(3.0) * s - c) + 1.0) / 3.0;\n  float len = length(color.rgb);\n  color.rgb = vec3(\n    dot(color.rgb, weights.xyz),\n    dot(color.rgb, weights.zxy),\n    dot(color.rgb, weights.yzx)\n  );\n\n  // saturation adjustment\n  float average = (color.r + color.g + color.b) / 3.0;\n  if (hueSaturation.saturation > 0.0) {\n    color.rgb += (average - color.rgb) * (1.0 - 1.0 / (1.001 - hueSaturation.saturation));\n  } else {\n    color.rgb += (average - color.rgb) * (-hueSaturation.saturation);\n  }\n\n  return color;\n}\n\nvec4 hueSaturation_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  return hueSaturation_filterColor(color);\n}\n";
+    readonly fs: "layout(std140) uniform hueSaturationUniforms {\n  float hue;\n  float saturation;\n} hueSaturation;\n\nvec4 hueSaturation_filterColor(vec4 color) {\n  // hue adjustment, wolfram alpha: RotationTransform[angle, {1, 1, 1}][{x, y, z}]\n  float angle = hueSaturation.hue * 3.14159265;\n  float s = sin(angle), c = cos(angle);\n  vec3 weights = (vec3(2.0 * c, -sqrt(3.0) * s - c, sqrt(3.0) * s - c) + 1.0) / 3.0;\n  float len = length(color.rgb);\n  color.rgb = vec3(\n    dot(color.rgb, weights.xyz),\n    dot(color.rgb, weights.zxy),\n    dot(color.rgb, weights.yzx)\n  );\n\n  // saturation adjustment\n  float average = (color.r + color.g + color.b) / 3.0;\n  if (hueSaturation.saturation > 0.0) {\n    color.rgb += (average - color.rgb) * (1.0 - 1.0 / (1.001 - hueSaturation.saturation));\n  } else {\n    color.rgb += (average - color.rgb) * (-hueSaturation.saturation);\n  }\n\n  return color;\n}\n\nvec4 hueSaturation_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  return hueSaturation_filterColor(color);\n}\n";
     readonly uniformTypes: {
         readonly hue: "f32";
         readonly saturation: "f32";

package/dist/passes/postprocessing/image-adjust-filters/huesaturation.js

@@ -36,7 +36,7 @@ fn hueSaturation_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f)
 }
 `;
 const fs = /* glsl */ `\
-uniform hueSaturationUniforms {
+layout(std140) uniform hueSaturationUniforms {
   float hue;
   float saturation;
 } hueSaturation;

package/dist/passes/postprocessing/image-adjust-filters/noise.d.ts

@@ -12,7 +12,7 @@ export type NoiseUniforms = NoiseProps;
  */
 export declare const noise: {
     readonly name: "noise";
-    readonly fs: "uniform noiseUniforms {\n  float amount;\n} noise;\n\nfloat rand(vec2 co) {\n  return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);\n}\n\nvec4 noise_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  float diff = (rand(texCoord) - 0.5) * noise.amount;\n  color.r += diff;\n  color.g += diff;\n  color.b += diff;\n  return color;\n}\n";
+    readonly fs: "layout(std140) uniform noiseUniforms {\n  float amount;\n} noise;\n\nfloat rand(vec2 co) {\n  return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);\n}\n\nvec4 noise_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  float diff = (rand(texCoord) - 0.5) * noise.amount;\n  color.r += diff;\n  color.g += diff;\n  color.b += diff;\n  return color;\n}\n";
     readonly source: "struct noiseUniforms {\n  amount: f32,\n};\n\n@group(0) @binding(auto) var<uniform> noise: noiseUniforms;\n\nfn rand(co: vec2f) -> f32 {\n\treturn fract(sin(dot(co.xy, vec2f(12.9898, 78.233))) * 43758.547);\n} \n\nfn noise_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> vec4f {\n  let diff = (rand(texCoord) - 0.5) * noise.amount;\n  var result = color;\n  result.r += diff;\n  result.g += diff;\n  result.b += diff;\n  return result;\n}\n";
     readonly props: NoiseProps;
     readonly uniforms: NoiseUniforms;

package/dist/passes/postprocessing/image-adjust-filters/noise.js

@@ -22,7 +22,7 @@ fn noise_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> vec4f
 }
 `;
 const fs = /* glsl */ `\
-uniform noiseUniforms {
+layout(std140) uniform noiseUniforms {
   float amount;
 } noise;
 

package/dist/passes/postprocessing/image-adjust-filters/sepia.d.ts

@@ -21,7 +21,7 @@ export declare const sepia: {
             readonly max: 1;
         };
     };
-    readonly fs: "uniform sepiaUniforms {\n  float amount;\n} sepia;\n\nvec4 sepia_filterColor(vec4 color) {\n  float r = color.r;\n  float g = color.g;\n  float b = color.b;\n\n  color.r =\n    min(1.0, (r * (1.0 - (0.607 * sepia.amount))) + (g * (0.769 * sepia.amount)) + (b * (0.189 * sepia.amount)));\n  color.g = min(1.0, (r * 0.349 * sepia.amount) + (g * (1.0 - (0.314 * sepia.amount))) + (b * 0.168 * sepia.amount));\n  color.b = min(1.0, (r * 0.272 * sepia.amount) + (g * 0.534 * sepia.amount) + (b * (1.0 - (0.869 * sepia.amount))));\n\n  return color;\n}\n\nvec4 sepia_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  return sepia_filterColor(color);\n}\n";
+    readonly fs: "layout(std140) uniform sepiaUniforms {\n  float amount;\n} sepia;\n\nvec4 sepia_filterColor(vec4 color) {\n  float r = color.r;\n  float g = color.g;\n  float b = color.b;\n\n  color.r =\n    min(1.0, (r * (1.0 - (0.607 * sepia.amount))) + (g * (0.769 * sepia.amount)) + (b * (0.189 * sepia.amount)));\n  color.g = min(1.0, (r * 0.349 * sepia.amount) + (g * (1.0 - (0.314 * sepia.amount))) + (b * 0.168 * sepia.amount));\n  color.b = min(1.0, (r * 0.272 * sepia.amount) + (g * 0.534 * sepia.amount) + (b * (1.0 - (0.869 * sepia.amount))));\n\n  return color;\n}\n\nvec4 sepia_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  return sepia_filterColor(color);\n}\n";
     readonly source: "struct sepiaUniforms {\n  amount: f32,\n};\n\n@group(0) @binding(auto) var<uniform> sepia: sepiaUniforms;\n\nfn sepia_filterColor(color: vec4f) -> vec4f {\n  let r = color.r;\n  let g = color.g;\n  let b = color.b;\n\n  var result = color;\n  result.r =\n    min(1.0, (r * (1.0 - (0.607 * sepia.amount))) + (g * (0.769 * sepia.amount)) + (b * (0.189 * sepia.amount)));\n  result.g = min(1.0, (r * 0.349 * sepia.amount) + (g * (1.0 - (0.314 * sepia.amount))) + (b * 0.168 * sepia.amount));\n  result.b = min(1.0, (r * 0.272 * sepia.amount) + (g * 0.534 * sepia.amount) + (b * (1.0 - (0.869 * sepia.amount))));\n\n  return result;\n}\n\nfn sepia_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> vec4f {\n  return sepia_filterColor(color);\n}\n";
     readonly passes: [{
         readonly filter: true;

package/dist/passes/postprocessing/image-adjust-filters/sepia.js

@@ -27,7 +27,7 @@ fn sepia_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> vec4f
 }
 `;
 const fs = /* glsl */ `\
-uniform sepiaUniforms {
+layout(std140) uniform sepiaUniforms {
   float amount;
 } sepia;
 

package/dist/passes/postprocessing/image-adjust-filters/vibrance.d.ts

@@ -22,7 +22,7 @@ export declare const vibrance: {
         };
     };
     readonly source: "struct vibranceUniforms {\n  amount: f32,\n};\n\n@group(0) @binding(auto) var<uniform> vibrance: vibranceUniforms;\n\nfn vibrance_filterColor(color: vec4f) -> vec4f {\n  let average = (color.r + color.g + color.b) / 3.0;\n  let mx = max(color.r, max(color.g, color.b));\n  let amt = (mx - average) * (-vibrance.amount * 3.0);\n  let resultRgb = mix(color.rgb, vec3f(mx), amt);\n  return vec4f(resultRgb, color.a);\n}\n\nfn vibrance_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> vec4f {\n  return vibrance_filterColor(color);\n}\n";
-    readonly fs: "uniform vibranceUniforms {\n  float amount;\n} vibrance;\n\nvec4 vibrance_filterColor(vec4 color) {\n  float average = (color.r + color.g + color.b) / 3.0;\n  float mx = max(color.r, max(color.g, color.b));\n  float amt = (mx - average) * (-vibrance.amount * 3.0);\n  color.rgb = mix(color.rgb, vec3(mx), amt);\n  return color;\n}\n\nvec4 vibrance_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  return vibrance_filterColor(color);\n}\n";
+    readonly fs: "layout(std140) uniform vibranceUniforms {\n  float amount;\n} vibrance;\n\nvec4 vibrance_filterColor(vec4 color) {\n  float average = (color.r + color.g + color.b) / 3.0;\n  float mx = max(color.r, max(color.g, color.b));\n  float amt = (mx - average) * (-vibrance.amount * 3.0);\n  color.rgb = mix(color.rgb, vec3(mx), amt);\n  return color;\n}\n\nvec4 vibrance_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  return vibrance_filterColor(color);\n}\n";
     readonly passes: [{
         readonly filter: true;
     }];

package/dist/passes/postprocessing/image-adjust-filters/vibrance.js

@@ -21,7 +21,7 @@ fn vibrance_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> ve
 }
 `;
 const fs = /* glsl */ `\
-uniform vibranceUniforms {
+layout(std140) uniform vibranceUniforms {
   float amount;
 } vibrance;
 

package/dist/passes/postprocessing/image-adjust-filters/vignette.d.ts

@@ -17,7 +17,7 @@ export declare const vignette: {
     readonly uniforms: VignetteUniforms;
     readonly name: "vignette";
     readonly source: "struct vignetteUniforms {\n  radius: f32,\n  amount: f32,\n};\n\n@group(0) @binding(auto) var<uniform> vignette: vignetteUniforms;\n\nfn vignette_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> vec4f {\n  let dist = distance(texCoord, vec2f(0.5, 0.5));\n  let ratio = smoothstep(\n    0.8,\n    vignette.radius * 0.799,\n    dist * (vignette.amount + vignette.radius)\n  );\n  return color * ratio + vec4f(0.0, 0.0, 0.0, 1.0) * (1.0 - ratio);\n}\n";
-    readonly fs: "uniform vignetteUniforms {\n  float radius;\n  float amount;\n} vignette;\n\nvec4 vignette_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  float dist = distance(texCoord, vec2(0.5, 0.5));\n  float ratio = smoothstep(0.8, vignette.radius * 0.799, dist * (vignette.amount + vignette.radius));\n  return color.rgba * ratio + (1.0 - ratio)*vec4(0.0, 0.0, 0.0, 1.0);\n}\n";
+    readonly fs: "layout(std140) uniform vignetteUniforms {\n  float radius;\n  float amount;\n} vignette;\n\nvec4 vignette_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  float dist = distance(texCoord, vec2(0.5, 0.5));\n  float ratio = smoothstep(0.8, vignette.radius * 0.799, dist * (vignette.amount + vignette.radius));\n  return color.rgba * ratio + (1.0 - ratio)*vec4(0.0, 0.0, 0.0, 1.0);\n}\n";
     readonly uniformTypes: {
         readonly radius: "f32";
         readonly amount: "f32";

package/dist/passes/postprocessing/image-adjust-filters/vignette.js

@@ -20,7 +20,7 @@ fn vignette_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> ve
 }
 `;
 const fs = /* glsl */ `\
-uniform vignetteUniforms {
+layout(std140) uniform vignetteUniforms {
   float radius;
   float amount;
 } vignette;

package/dist/passes/postprocessing/image-blur-filters/tiltshift.d.ts

@@ -34,7 +34,7 @@ export declare const tiltShift: {
         readonly fs: "float random(vec3 scale, float seed) {\n  /* use the fragment position for a different seed per-pixel */\n  return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);\n}\n";
     }];
     readonly source: "struct tiltShiftUniforms {\n  blurRadius: f32,\n  gradientRadius: f32,\n  start: vec2f,\n  end: vec2f,\n  invert: u32,\n};\n\n@group(0) @binding(auto) var<uniform> tiltShift: tiltShiftUniforms;\n\nfn tiltShift_getDelta(texSize: vec2f) -> vec2f {\n  let vector = normalize((tiltShift.end - tiltShift.start) * texSize);\n  return select(vector, vec2f(-vector.y, vector.x), tiltShift.invert != 0u);\n}\n\nfn tiltShift_sampleColor(\n  sourceTexture: texture_2d<f32>,\n  sourceTextureSampler: sampler,\n  texSize: vec2f,\n  texCoord: vec2f\n) -> vec4f {\n  var color = vec4f(0.0);\n  var total = 0.0;\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  let offset = random(vec3f(12.9898, 78.233, 151.7182), 0.0);\n\n  let normal = normalize(\n    vec2f(\n      (tiltShift.start.y - tiltShift.end.y) * texSize.y,\n      (tiltShift.end.x - tiltShift.start.x) * texSize.x\n    )\n  );\n  let radius =\n    smoothstep(\n      0.0,\n      1.0,\n      abs(dot(texCoord * texSize - tiltShift.start * texSize, normal)) / tiltShift.gradientRadius\n    ) * tiltShift.blurRadius;\n\n  for (var t = -30.0; t <= 30.0; t += 1.0) {\n    let percent = (t + offset - 0.5) / 30.0;\n    let weight = 1.0 - abs(percent);\n    let offsetColor = textureSample(\n      sourceTexture,\n      sourceTextureSampler,\n      texCoord + tiltShift_getDelta(texSize) / texSize * percent * radius\n    );\n\n    color += offsetColor * weight;\n    total += weight;\n  }\n\n  color /= total;\n  return color;\n}\n";
-    readonly fs: "uniform tiltShiftUniforms {\n  float blurRadius;\n  float gradientRadius;\n  vec2 start;\n  vec2 end;\n  bool invert;\n} tiltShift;\n\nvec2 tiltShift_getDelta(vec2 texSize) {\n  vec2 vector = normalize((tiltShift.end - tiltShift.start) * texSize);\n  return tiltShift.invert ? vec2(-vector.y, vector.x) : vector;\n}\n\nvec4 tiltShift_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec4 color = vec4(0.0);\n  float total = 0.0;\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  vec2 normal = normalize(vec2((tiltShift.start.y - tiltShift.end.y) * texSize.y, (tiltShift.end.x - tiltShift.start.x) * texSize.x));\n  float radius = smoothstep(0.0, 1.0,\n    abs(dot(texCoord * texSize - tiltShift.start * texSize, normal)) / tiltShift.gradientRadius) * tiltShift.blurRadius;\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec4 offsetColor = texture(source, texCoord + tiltShift_getDelta(texSize) / texSize * percent * radius);\n    color += offsetColor * weight;\n    total += weight;\n  }\n\n  color = color / total;\n  return color;\n}\n";
+    readonly fs: "layout(std140) uniform tiltShiftUniforms {\n  float blurRadius;\n  float gradientRadius;\n  vec2 start;\n  vec2 end;\n  bool invert;\n} tiltShift;\n\nvec2 tiltShift_getDelta(vec2 texSize) {\n  vec2 vector = normalize((tiltShift.end - tiltShift.start) * texSize);\n  return tiltShift.invert ? vec2(-vector.y, vector.x) : vector;\n}\n\nvec4 tiltShift_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec4 color = vec4(0.0);\n  float total = 0.0;\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  vec2 normal = normalize(vec2((tiltShift.start.y - tiltShift.end.y) * texSize.y, (tiltShift.end.x - tiltShift.start.x) * texSize.x));\n  float radius = smoothstep(0.0, 1.0,\n    abs(dot(texCoord * texSize - tiltShift.start * texSize, normal)) / tiltShift.gradientRadius) * tiltShift.blurRadius;\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec4 offsetColor = texture(source, texCoord + tiltShift_getDelta(texSize) / texSize * percent * radius);\n    color += offsetColor * weight;\n    total += weight;\n  }\n\n  color = color / total;\n  return color;\n}\n";
     readonly props: TiltShiftProps;
     readonly uniforms: TiltShiftUniforms;
     readonly uniformTypes: {

package/dist/passes/postprocessing/image-blur-filters/tiltshift.js

@@ -61,7 +61,7 @@ fn tiltShift_sampleColor(
 }
 `;
 const fs = /* glsl */ `\
-uniform tiltShiftUniforms {
+layout(std140) uniform tiltShiftUniforms {
   float blurRadius;
   float gradientRadius;
   vec2 start;

package/dist/passes/postprocessing/image-blur-filters/triangleblur.d.ts

@@ -25,7 +25,7 @@ export declare const triangleBlur: {
         readonly fs: "float random(vec3 scale, float seed) {\n  /* use the fragment position for a different seed per-pixel */\n  return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);\n}\n";
     }];
     readonly source: "struct triangleBlurUniforms {\n  radius: f32,\n  delta: vec2f,\n};\n\n@group(0) @binding(auto) var<uniform> triangleBlur: triangleBlurUniforms;\n\nfn triangleBlur_sampleColor(\n  sourceTexture: texture_2d<f32>,\n  sourceTextureSampler: sampler,\n  texSize: vec2f,\n  texCoord: vec2f\n) -> vec4f {\n  let adjustedDelta = triangleBlur.delta * triangleBlur.radius / texSize;\n\n  var color = vec4f(0.0);\n  var total = 0.0;\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  let offset = random(vec3f(12.9898, 78.233, 151.7182), 0.0);\n\n  for (var t = -30.0; t <= 30.0; t += 1.0) {\n    let percent = (t + offset - 0.5) / 30.0;\n    let weight = 1.0 - abs(percent);\n    let offsetColor = textureSample(\n      sourceTexture,\n      sourceTextureSampler,\n      texCoord + adjustedDelta * percent\n    );\n\n    /* switch to pre-multiplied alpha to correctly blur transparent images */\n    let premultipliedOffsetColor = vec4f(offsetColor.rgb * vec3f(offsetColor.a), offsetColor.a);\n\n    color += premultipliedOffsetColor * weight;\n    total += weight;\n  }\n\n  color /= total;\n\n  /* switch back from pre-multiplied alpha */\n  let unpremultipliedRgb = color.rgb / vec3f(color.a + 0.00001);\n\n  return vec4f(unpremultipliedRgb, color.a);\n}\n";
-    readonly fs: "uniform triangleBlurUniforms {\n  float radius;\n  vec2 delta;\n} triangleBlur;\n\nvec4 triangleBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 adjustedDelta = triangleBlur.delta * triangleBlur.radius / texSize;\n\n  vec4 color = vec4(0.0);\n  float total = 0.0;\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec4 offsetColor = texture(source, texCoord + adjustedDelta * percent);\n\n    /* switch to pre-multiplied alpha to correctly blur transparent images */\n    offsetColor.rgb *= offsetColor.a;\n\n    color += offsetColor * weight;\n    total += weight;\n  }\n\n  color = color / total;\n\n  /* switch back from pre-multiplied alpha */\n  color.rgb /= color.a + 0.00001;\n\n  return color;\n}\n";
+    readonly fs: "layout(std140) uniform triangleBlurUniforms {\n  float radius;\n  vec2 delta;\n} triangleBlur;\n\nvec4 triangleBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 adjustedDelta = triangleBlur.delta * triangleBlur.radius / texSize;\n\n  vec4 color = vec4(0.0);\n  float total = 0.0;\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec4 offsetColor = texture(source, texCoord + adjustedDelta * percent);\n\n    /* switch to pre-multiplied alpha to correctly blur transparent images */\n    offsetColor.rgb *= offsetColor.a;\n\n    color += offsetColor * weight;\n    total += weight;\n  }\n\n  color = color / total;\n\n  /* switch back from pre-multiplied alpha */\n  color.rgb /= color.a + 0.00001;\n\n  return color;\n}\n";
     readonly props: TriangleBlurProps;
     readonly uniforms: TriangleBlurUniforms;
     readonly uniformTypes: {

package/dist/passes/postprocessing/image-blur-filters/triangleblur.js

@@ -49,7 +49,7 @@ fn triangleBlur_sampleColor(
 }
 `;
 const fs = /* glsl */ `\
-uniform triangleBlurUniforms {
+layout(std140) uniform triangleBlurUniforms {
   float radius;
   vec2 delta;
 } triangleBlur;

package/dist/passes/postprocessing/image-blur-filters/zoomblur.d.ts

@@ -20,7 +20,7 @@ export declare const zoomBlur: {
         readonly fs: "float random(vec3 scale, float seed) {\n  /* use the fragment position for a different seed per-pixel */\n  return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);\n}\n";
     }];
     readonly source: "\nstruct zoomBlurUniforms {\n  center: vec2f,\n  strength: f32,\n};\n\n@group(0) @binding(auto) var<uniform> zoomBlur : zoomBlurUniforms;\n\n\nfn zoomBlur_sampleColor(\n  sourceTexture: texture_2d<f32>,\n  sourceTextureSampler: sampler,\n  texSize: vec2f,\n  texCoord: vec2f\n) -> vec4f {\n  var color = vec4f(0.0);\n  var total = 0.0;\n  let toCenter = zoomBlur.center * texSize - texCoord * texSize;\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  let offset = random(vec3f(12.9898, 78.233, 151.7182), 0.0);\n\n  for (var t = 0.0; t <= 40.0; t += 1.0) {\n    let percent = (t + offset) / 40.0;\n    let weight = 4.0 * (percent - percent * percent);\n    let offsetColor = textureSample(\n      sourceTexture,\n      sourceTextureSampler,\n      texCoord + toCenter * percent * zoomBlur.strength / texSize\n    );\n    color += offsetColor * weight;\n    total += weight;\n  }\n\n  color /= total;\n  return color;\n}\n";
-    readonly fs: "\nuniform zoomBlurUniforms {\n  vec2 center;\n  float strength;\n} zoomBlur;\n\nvec4 zoomBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec4 color = vec4(0.0);\n  float total = 0.0;\n  vec2 toCenter = zoomBlur.center * texSize - texCoord * texSize;\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = 0.0; t <= 40.0; t++) {\n    float percent = (t + offset) / 40.0;\n    float weight = 4.0 * (percent - percent * percent);\n    vec4 offsetColor = texture(source, texCoord + toCenter * percent * zoomBlur.strength / texSize);\n    color += offsetColor * weight;\n    total += weight;\n  }\n\n  color = color / total;\n  return color;\n}\n";
+    readonly fs: "\nlayout(std140) uniform zoomBlurUniforms {\n  vec2 center;\n  float strength;\n} zoomBlur;\n\nvec4 zoomBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec4 color = vec4(0.0);\n  float total = 0.0;\n  vec2 toCenter = zoomBlur.center * texSize - texCoord * texSize;\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = 0.0; t <= 40.0; t++) {\n    float percent = (t + offset) / 40.0;\n    float weight = 4.0 * (percent - percent * percent);\n    vec4 offsetColor = texture(source, texCoord + toCenter * percent * zoomBlur.strength / texSize);\n    color += offsetColor * weight;\n    total += weight;\n  }\n\n  color = color / total;\n  return color;\n}\n";
     readonly props: ZoomBlurProps;
     readonly uniforms: ZoomBlurUniforms;
     readonly uniformTypes: {

package/dist/passes/postprocessing/image-blur-filters/zoomblur.js

@@ -41,7 +41,7 @@ fn zoomBlur_sampleColor(
 }
 `;
 const fs = /* glsl */ `
-uniform zoomBlurUniforms {
+layout(std140) uniform zoomBlurUniforms {
   vec2 center;
   float strength;
 } zoomBlur;

package/dist/passes/postprocessing/image-fun-filters/colorhalftone.d.ts

@@ -22,7 +22,7 @@ export type ColorHalftoneUniforms = ColorHalftoneProps;
 export declare const colorHalftone: {
     readonly name: "colorHalftone";
     readonly source: "struct colorHalftoneUniforms {\n  center: vec2f,\n  angle: f32,\n  size: f32,\n};\n\n@group(0) @binding(auto) var<uniform> colorHalftone: colorHalftoneUniforms;\n\nfn pattern(angle: f32, scale: f32, texSize: vec2f, texCoord: vec2f) -> f32 {\n  let s = sin(angle);\n  let c = cos(angle);\n  let tex = texCoord * texSize - colorHalftone.center * texSize;\n  let point = vec2f(\n    c * tex.x - s * tex.y,\n    s * tex.x + c * tex.y\n  ) * scale;\n  return (sin(point.x) * sin(point.y)) * 4.0;\n}\n\nfn colorHalftone_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> vec4f {\n  let scale = 3.1514 / colorHalftone.size;\n  var cmy = vec3f(1.0) - color.rgb;\n  var k = min(cmy.x, min(cmy.y, cmy.z));\n  let safeDenominator = max(1.0 - k, 0.00001);\n\n  cmy = (cmy - vec3f(k)) / safeDenominator;\n  cmy = clamp(\n    cmy * 10.0 - vec3f(3.0) + vec3f(\n      pattern(colorHalftone.angle + 0.26179, scale, texSize, texCoord),\n      pattern(colorHalftone.angle + 1.30899, scale, texSize, texCoord),\n      pattern(colorHalftone.angle, scale, texSize, texCoord)\n    ),\n    vec3f(0.0),\n    vec3f(1.0)\n  );\n  k = clamp(k * 10.0 - 5.0 + pattern(colorHalftone.angle + 0.78539, scale, texSize, texCoord), 0.0, 1.0);\n  return vec4f(vec3f(1.0) - cmy - vec3f(k), color.a);\n}\n";
-    readonly fs: "uniform colorHalftoneUniforms {\n  vec2 center;\n  float angle;\n  float size;\n} colorHalftone;\n\nfloat pattern(float angle, float scale, vec2 texSize, vec2 texCoord) {\n  float s = sin(angle), c = cos(angle);\n  vec2 tex = texCoord * texSize - colorHalftone.center * texSize;\n  vec2 point = vec2(\n\tc * tex.x - s * tex.y,\n\ts * tex.x + c * tex.y\n  ) * scale;\n  return (sin(point.x) * sin(point.y)) * 4.0;\n}\n\nvec4 colorHalftone_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  float scale = 3.1514 / colorHalftone.size;\n  vec3 cmy = 1.0 - color.rgb;\n  float k = min(cmy.x, min(cmy.y, cmy.z));\n\n  cmy = (cmy - k) / (1.0 - k);\n  cmy = clamp(\n\t  cmy * 10.0 - 3.0 + vec3(\n      pattern(colorHalftone.angle + 0.26179, scale, texSize, texCoord),\n\t    pattern(colorHalftone.angle + 1.30899, scale, texSize, texCoord),\n      pattern(colorHalftone.angle, scale, texSize, texCoord)\n    ),\n\t  0.0,\n\t  1.0\n  );\n  k = clamp(k * 10.0 - 5.0 + pattern(colorHalftone.angle + 0.78539, scale, texSize, texCoord), 0.0, 1.0);\n  return vec4(1.0 - cmy - k, color.a);\n}\n";
+    readonly fs: "layout(std140) uniform colorHalftoneUniforms {\n  vec2 center;\n  float angle;\n  float size;\n} colorHalftone;\n\nfloat pattern(float angle, float scale, vec2 texSize, vec2 texCoord) {\n  float s = sin(angle), c = cos(angle);\n  vec2 tex = texCoord * texSize - colorHalftone.center * texSize;\n  vec2 point = vec2(\n\tc * tex.x - s * tex.y,\n\ts * tex.x + c * tex.y\n  ) * scale;\n  return (sin(point.x) * sin(point.y)) * 4.0;\n}\n\nvec4 colorHalftone_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  float scale = 3.1514 / colorHalftone.size;\n  vec3 cmy = 1.0 - color.rgb;\n  float k = min(cmy.x, min(cmy.y, cmy.z));\n\n  cmy = (cmy - k) / (1.0 - k);\n  cmy = clamp(\n\t  cmy * 10.0 - 3.0 + vec3(\n      pattern(colorHalftone.angle + 0.26179, scale, texSize, texCoord),\n\t    pattern(colorHalftone.angle + 1.30899, scale, texSize, texCoord),\n      pattern(colorHalftone.angle, scale, texSize, texCoord)\n    ),\n\t  0.0,\n\t  1.0\n  );\n  k = clamp(k * 10.0 - 5.0 + pattern(colorHalftone.angle + 0.78539, scale, texSize, texCoord), 0.0, 1.0);\n  return vec4(1.0 - cmy - k, color.a);\n}\n";
     readonly props: ColorHalftoneProps;
     readonly uniforms: ColorHalftoneUniforms;
     readonly uniformTypes: {

package/dist/passes/postprocessing/image-fun-filters/colorhalftone.js

@@ -43,7 +43,7 @@ fn colorHalftone_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f)
 `;
 // TODO pass texCoord to angle
 const fs = /* glsl */ `\
-uniform colorHalftoneUniforms {
+layout(std140) uniform colorHalftoneUniforms {
   vec2 center;
   float angle;
   float size;

package/dist/passes/postprocessing/image-fun-filters/dotscreen.d.ts

@@ -20,7 +20,7 @@ export type DotScreenUniforms = DotScreenProps;
 export declare const dotScreen: {
     readonly name: "dotScreen";
     readonly source: "struct dotScreenUniforms {\n  center: vec2f,\n  angle: f32,\n  size: f32,\n};\n\n@group(0) @binding(auto) var<uniform> dotScreen: dotScreenUniforms;\n\nfn pattern(texSize: vec2f, texCoord: vec2f) -> f32 {\n  let scale = 3.1415 / dotScreen.size;\n  let s = sin(dotScreen.angle);\n  let c = cos(dotScreen.angle);\n  let tex = texCoord * texSize - dotScreen.center * texSize;\n  let point = vec2f(\n    c * tex.x - s * tex.y,\n    s * tex.x + c * tex.y\n  ) * scale;\n  return (sin(point.x) * sin(point.y)) * 4.0;\n}\n\nfn dotScreen_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> vec4f {\n  let average = (color.r + color.g + color.b) / 3.0;\n  return vec4f(vec3f(average * 10.0 - 5.0 + pattern(texSize, texCoord)), color.a);\n}\n";
-    readonly fs: "uniform dotScreenUniforms {\n  vec2 center;\n  float angle;\n  float size;\n} dotScreen;\n\nfloat pattern(vec2 texSize, vec2 texCoord) {\n  float scale = 3.1415 / dotScreen.size;\n\n  float s = sin(dotScreen.angle), c = cos(dotScreen.angle);\n  vec2 tex = texCoord * texSize - dotScreen.center * texSize;\n  vec2 point = vec2(\n    c * tex.x - s * tex.y,\n    s * tex.x + c * tex.y\n  ) * scale;\n  return (sin(point.x) * sin(point.y)) * 4.0;\n}\n\nvec4 dotScreen_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  float average = (color.r + color.g + color.b) / 3.0;\n  return vec4(vec3(average * 10.0 - 5.0 + pattern(texSize, texCoord)), color.a);\n}\n";
+    readonly fs: "layout(std140) uniform dotScreenUniforms {\n  vec2 center;\n  float angle;\n  float size;\n} dotScreen;\n\nfloat pattern(vec2 texSize, vec2 texCoord) {\n  float scale = 3.1415 / dotScreen.size;\n\n  float s = sin(dotScreen.angle), c = cos(dotScreen.angle);\n  vec2 tex = texCoord * texSize - dotScreen.center * texSize;\n  vec2 point = vec2(\n    c * tex.x - s * tex.y,\n    s * tex.x + c * tex.y\n  ) * scale;\n  return (sin(point.x) * sin(point.y)) * 4.0;\n}\n\nvec4 dotScreen_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  float average = (color.r + color.g + color.b) / 3.0;\n  return vec4(vec3(average * 10.0 - 5.0 + pattern(texSize, texCoord)), color.a);\n}\n";
     readonly props: DotScreenProps;
     readonly uniforms: DotScreenUniforms;
     readonly uniformTypes: {

package/dist/passes/postprocessing/image-fun-filters/dotscreen.js

@@ -28,7 +28,7 @@ fn dotScreen_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> v
 }
 `;
 const fs = /* glsl */ `\
-uniform dotScreenUniforms {
+layout(std140) uniform dotScreenUniforms {
   vec2 center;
   float angle;
   float size;

package/dist/passes/postprocessing/image-fun-filters/edgework.d.ts

@@ -23,7 +23,7 @@ export declare const edgeWork: {
         readonly fs: "float random(vec3 scale, float seed) {\n  /* use the fragment position for a different seed per-pixel */\n  return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);\n}\n";
     }];
     readonly source: "struct edgeWorkUniforms {\n  radius: f32,\n  mode: u32,\n};\n\n@group(0) @binding(auto) var<uniform> edgeWork: edgeWorkUniforms;\n\nfn edgeWork_sampleColorRGB(\n  sourceTexture: texture_2d<f32>,\n  sourceTextureSampler: sampler,\n  texSize: vec2f,\n  texCoord: vec2f,\n  delta: vec2f\n) -> vec4f {\n  let relativeDelta = edgeWork.radius * delta / texSize;\n\n  var color = vec2f(0.0);\n  var total = vec2f(0.0);\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  let offset = random(vec3f(12.9898, 78.233, 151.7182), 0.0);\n\n  for (var t = -30.0; t <= 30.0; t += 1.0) {\n    let percent = (t + offset - 0.5) / 30.0;\n    var weight = 1.0 - abs(percent);\n    let sampleColor = textureSample(\n      sourceTexture,\n      sourceTextureSampler,\n      texCoord + relativeDelta * percent\n    ).rgb;\n    let average = (sampleColor.r + sampleColor.g + sampleColor.b) / 3.0;\n    color.x += average * weight;\n    total.x += weight;\n    if (abs(t) < 15.0) {\n      weight = weight * 2.0 - 1.0;\n      color.y += average * weight;\n      total.y += weight;\n    }\n  }\n  return vec4f(color / total, 0.0, 1.0);\n}\n\nfn edgeWork_sampleColorXY(\n  sourceTexture: texture_2d<f32>,\n  sourceTextureSampler: sampler,\n  texSize: vec2f,\n  texCoord: vec2f,\n  delta: vec2f\n) -> vec4f {\n  let relativeDelta = edgeWork.radius * delta / texSize;\n\n  var color = vec2f(0.0);\n  var total = vec2f(0.0);\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  let offset = random(vec3f(12.9898, 78.233, 151.7182), 0.0);\n\n  for (var t = -30.0; t <= 30.0; t += 1.0) {\n    let percent = (t + offset - 0.5) / 30.0;\n    var weight = 1.0 - abs(percent);\n    let sampleColor = textureSample(\n      sourceTexture,\n      sourceTextureSampler,\n      texCoord + relativeDelta * percent\n    ).xy;\n    color.x += sampleColor.x * weight;\n    total.x += weight;\n    if (abs(t) < 15.0) {\n      weight = weight * 2.0 - 1.0;\n      color.y += sampleColor.y * weight;\n      total.y += weight;\n    }\n  }\n\n  let c = clamp(10000.0 * (color.y / total.y - color.x / total.x) + 0.5, 0.0, 1.0);\n  return vec4f(c, c, c, 1.0);\n}\n\nfn edgeWork_sampleColor(\n  sourceTexture: texture_2d<f32>,\n  sourceTextureSampler: sampler,\n  texSize: vec2f,\n  texCoord: vec2f\n) -> vec4f {\n  if (edgeWork.mode == 0u) {\n    return edgeWork_sampleColorRGB(\n      sourceTexture,\n      sourceTextureSampler,\n      texSize,\n      texCoord,\n      vec2f(1.0, 0.0)\n    );\n  }\n\n  return edgeWork_sampleColorXY(\n    sourceTexture,\n    sourceTextureSampler,\n    texSize,\n    texCoord,\n    vec2f(0.0, 1.0)\n  );\n}\n";
-    readonly fs: "uniform edgeWorkUniforms {\n  float radius;\n  int mode;\n} edgeWork;\n\nvec4 edgeWork_sampleColorRGB(sampler2D source, vec2 texSize, vec2 texCoord, vec2 delta) {\n  vec2 relativeDelta = edgeWork.radius * delta / texSize;\n\n  vec2 color = vec2(0.0);\n  vec2 total = vec2(0.0);\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec3 sampleColor = texture(source, texCoord + relativeDelta * percent).rgb;\n    float average = (sampleColor.r + sampleColor.g + sampleColor.b) / 3.0;\n    color.x += average * weight;\n    total.x += weight;\n    if (abs(t) < 15.0) {\n      weight = weight * 2.0 - 1.0;\n      color.y += average * weight;\n      total.y += weight;\n    }\n  }\n  return vec4(color / total, 0.0, 1.0);\n}\n\nvec4 edgeWork_sampleColorXY(sampler2D source, vec2 texSize, vec2 texCoord, vec2 delta) {\n  vec2 relativeDelta = edgeWork.radius * delta / texSize;\n\n  vec2 color = vec2(0.0);\n  vec2 total = vec2(0.0);\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec2 sampleColor = texture(source, texCoord + relativeDelta * percent).xy;\n    color.x += sampleColor.x * weight;\n    total.x += weight;\n    if (abs(t) < 15.0) {\n      weight = weight * 2.0 - 1.0;\n      color.y += sampleColor.y * weight;\n      total.y += weight;\n    }\n  }\n  float c = clamp(10000.0 * (color.y / total.y - color.x / total.x) + 0.5, 0.0, 1.0);\n  return vec4(c, c, c, 1.0);\n}\n\nvec4 edgeWork_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  switch (edgeWork.mode) {\n    case 0: \n    return edgeWork_sampleColorRGB(source, texSize, texCoord, vec2(1., 0.));\n    case 1: \n    default:\n      return edgeWork_sampleColorXY(source, texSize, texCoord, vec2(0., 1.));\n  }\n}\n";
+    readonly fs: "layout(std140) uniform edgeWorkUniforms {\n  float radius;\n  int mode;\n} edgeWork;\n\nvec4 edgeWork_sampleColorRGB(sampler2D source, vec2 texSize, vec2 texCoord, vec2 delta) {\n  vec2 relativeDelta = edgeWork.radius * delta / texSize;\n\n  vec2 color = vec2(0.0);\n  vec2 total = vec2(0.0);\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec3 sampleColor = texture(source, texCoord + relativeDelta * percent).rgb;\n    float average = (sampleColor.r + sampleColor.g + sampleColor.b) / 3.0;\n    color.x += average * weight;\n    total.x += weight;\n    if (abs(t) < 15.0) {\n      weight = weight * 2.0 - 1.0;\n      color.y += average * weight;\n      total.y += weight;\n    }\n  }\n  return vec4(color / total, 0.0, 1.0);\n}\n\nvec4 edgeWork_sampleColorXY(sampler2D source, vec2 texSize, vec2 texCoord, vec2 delta) {\n  vec2 relativeDelta = edgeWork.radius * delta / texSize;\n\n  vec2 color = vec2(0.0);\n  vec2 total = vec2(0.0);\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec2 sampleColor = texture(source, texCoord + relativeDelta * percent).xy;\n    color.x += sampleColor.x * weight;\n    total.x += weight;\n    if (abs(t) < 15.0) {\n      weight = weight * 2.0 - 1.0;\n      color.y += sampleColor.y * weight;\n      total.y += weight;\n    }\n  }\n  float c = clamp(10000.0 * (color.y / total.y - color.x / total.x) + 0.5, 0.0, 1.0);\n  return vec4(c, c, c, 1.0);\n}\n\nvec4 edgeWork_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  switch (edgeWork.mode) {\n    case 0: \n    return edgeWork_sampleColorRGB(source, texSize, texCoord, vec2(1., 0.));\n    case 1: \n    default:\n      return edgeWork_sampleColorXY(source, texSize, texCoord, vec2(0., 1.));\n  }\n}\n";
     readonly props: EdgeWorkProps;
     readonly uniforms: EdgeWorkProps;
     readonly uniformTypes: {

package/dist/passes/postprocessing/image-fun-filters/edgework.js

@@ -107,7 +107,7 @@ fn edgeWork_sampleColor(
 }
 `;
 const fs = /* glsl */ `\
-uniform edgeWorkUniforms {
+layout(std140) uniform edgeWorkUniforms {
   float radius;
   int mode;
 } edgeWork;

package/dist/passes/postprocessing/image-fun-filters/hexagonalpixelate.d.ts

@@ -18,7 +18,7 @@ export type HexagonalPixelateUniforms = HexagonalPixelateProps;
 export declare const hexagonalPixelate: {
     readonly name: "hexagonalPixelate";
     readonly source: "struct hexagonalPixelateUniforms {\n  center: vec2f,\n  scale: f32,\n};\n\n@group(0) @binding(auto) var<uniform> hexagonalPixelate: hexagonalPixelateUniforms;\n\nfn hexagonalPixelate_sampleColor(\n  sourceTexture: texture_2d<f32>,\n  sourceTextureSampler: sampler,\n  texSize: vec2f,\n  texCoord: vec2f\n) -> vec4f {\n  var tex = (texCoord * texSize - hexagonalPixelate.center * texSize) / hexagonalPixelate.scale;\n  tex.y /= 0.866025404;\n  tex.x -= tex.y * 0.5;\n\n  var a = vec2f(0.0);\n  if (tex.x + tex.y - floor(tex.x) - floor(tex.y) < 1.0) {\n    a = vec2f(floor(tex.x), floor(tex.y));\n  } else {\n    a = vec2f(ceil(tex.x), ceil(tex.y));\n  }\n  let b = vec2f(ceil(tex.x), floor(tex.y));\n  let c = vec2f(floor(tex.x), ceil(tex.y));\n\n  let texBarycentric = vec3f(tex.x, tex.y, 1.0 - tex.x - tex.y);\n  let aBarycentric = vec3f(a.x, a.y, 1.0 - a.x - a.y);\n  let bBarycentric = vec3f(b.x, b.y, 1.0 - b.x - b.y);\n  let cBarycentric = vec3f(c.x, c.y, 1.0 - c.x - c.y);\n\n  let aLength = length(texBarycentric - aBarycentric);\n  let bLength = length(texBarycentric - bBarycentric);\n  let cLength = length(texBarycentric - cBarycentric);\n\n  var choice = vec2f(0.0);\n  if (aLength < bLength) {\n    if (aLength < cLength) {\n      choice = a;\n    } else {\n      choice = c;\n    }\n  } else {\n    if (bLength < cLength) {\n      choice = b;\n    } else {\n      choice = c;\n    }\n  }\n\n  choice.x += choice.y * 0.5;\n  choice.y *= 0.866025404;\n  choice *= hexagonalPixelate.scale / texSize;\n\n  return textureSample(sourceTexture, sourceTextureSampler, choice + hexagonalPixelate.center);\n}\n";
-    readonly fs: "uniform hexagonalPixelateUniforms {\n  vec2 center;\n  float scale;\n} hexagonalPixelate;\n\nvec4 hexagonalPixelate_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 tex = (texCoord * texSize - hexagonalPixelate.center * texSize) / hexagonalPixelate.scale;\n  tex.y /= 0.866025404;\n  tex.x -= tex.y * 0.5;\n\n  vec2 a;\n  if (tex.x + tex.y - floor(tex.x) - floor(tex.y) < 1.0) {\n    a = vec2(floor(tex.x), floor(tex.y));\n  }\n  else a = vec2(ceil(tex.x), ceil(tex.y));\n  vec2 b = vec2(ceil(tex.x), floor(tex.y));\n  vec2 c = vec2(floor(tex.x), ceil(tex.y));\n\n  vec3 TEX = vec3(tex.x, tex.y, 1.0 - tex.x - tex.y);\n  vec3 A = vec3(a.x, a.y, 1.0 - a.x - a.y);\n  vec3 B = vec3(b.x, b.y, 1.0 - b.x - b.y);\n  vec3 C = vec3(c.x, c.y, 1.0 - c.x - c.y);\n\n  float alen = length(TEX - A);\n  float blen = length(TEX - B);\n  float clen = length(TEX - C);\n\n  vec2 choice;\n  if (alen < blen) {\n    if (alen < clen) choice = a;\n    else choice = c;\n  } else {\n    if (blen < clen) choice = b;\n    else choice = c;\n  }\n\n  choice.x += choice.y * 0.5;\n  choice.y *= 0.866025404;\n  choice *= hexagonalPixelate.scale / texSize;\n\n  return texture(source, choice + hexagonalPixelate.center);\n}\n";
+    readonly fs: "layout(std140) uniform hexagonalPixelateUniforms {\n  vec2 center;\n  float scale;\n} hexagonalPixelate;\n\nvec4 hexagonalPixelate_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 tex = (texCoord * texSize - hexagonalPixelate.center * texSize) / hexagonalPixelate.scale;\n  tex.y /= 0.866025404;\n  tex.x -= tex.y * 0.5;\n\n  vec2 a;\n  if (tex.x + tex.y - floor(tex.x) - floor(tex.y) < 1.0) {\n    a = vec2(floor(tex.x), floor(tex.y));\n  }\n  else a = vec2(ceil(tex.x), ceil(tex.y));\n  vec2 b = vec2(ceil(tex.x), floor(tex.y));\n  vec2 c = vec2(floor(tex.x), ceil(tex.y));\n\n  vec3 TEX = vec3(tex.x, tex.y, 1.0 - tex.x - tex.y);\n  vec3 A = vec3(a.x, a.y, 1.0 - a.x - a.y);\n  vec3 B = vec3(b.x, b.y, 1.0 - b.x - b.y);\n  vec3 C = vec3(c.x, c.y, 1.0 - c.x - c.y);\n\n  float alen = length(TEX - A);\n  float blen = length(TEX - B);\n  float clen = length(TEX - C);\n\n  vec2 choice;\n  if (alen < blen) {\n    if (alen < clen) choice = a;\n    else choice = c;\n  } else {\n    if (blen < clen) choice = b;\n    else choice = c;\n  }\n\n  choice.x += choice.y * 0.5;\n  choice.y *= 0.866025404;\n  choice *= hexagonalPixelate.scale / texSize;\n\n  return texture(source, choice + hexagonalPixelate.center);\n}\n";
     readonly props: HexagonalPixelateProps;
     readonly uniforms: HexagonalPixelateUniforms;
     readonly uniformTypes: {

package/dist/passes/postprocessing/image-fun-filters/hexagonalpixelate.js

@@ -60,7 +60,7 @@ fn hexagonalPixelate_sampleColor(
 }
 `;
 const fs = /* glsl */ `\
-uniform hexagonalPixelateUniforms {
+layout(std140) uniform hexagonalPixelateUniforms {
   vec2 center;
   float scale;
 } hexagonalPixelate;

package/dist/passes/postprocessing/image-fun-filters/ink.d.ts

@@ -21,7 +21,7 @@ export type InkUniforms = InkProps;
 export declare const ink: {
     readonly name: "ink";
     readonly source: "struct inkUniforms {\n  strength: f32,\n};\n\n@group(0) @binding(auto) var<uniform> ink: inkUniforms;\n\nfn ink_sampleColor(\n  sourceTexture: texture_2d<f32>,\n  sourceTextureSampler: sampler,\n  texSize: vec2f,\n  texCoord: vec2f\n) -> vec4f {\n  let dx = vec2f(1.0 / texSize.x, 0.0);\n  let dy = vec2f(0.0, 1.0 / texSize.y);\n  let color = textureSample(sourceTexture, sourceTextureSampler, texCoord);\n  var bigTotal = 0.0;\n  var smallTotal = 0.0;\n  var bigAverage = vec3f(0.0);\n  var smallAverage = vec3f(0.0);\n  for (var x = -2.0; x <= 2.0; x += 1.0) {\n    for (var y = -2.0; y <= 2.0; y += 1.0) {\n      let offsetColor = textureSample(\n        sourceTexture,\n        sourceTextureSampler,\n        texCoord + dx * x + dy * y\n      ).rgb;\n      bigAverage += offsetColor;\n      bigTotal += 1.0;\n      if (abs(x) + abs(y) < 2.0) {\n        smallAverage += offsetColor;\n        smallTotal += 1.0;\n      }\n    }\n  }\n  let edge = max(vec3f(0.0), bigAverage / bigTotal - smallAverage / smallTotal);\n  let power = ink.strength * ink.strength * ink.strength * ink.strength * ink.strength;\n  return vec4f(color.rgb - vec3f(dot(edge, edge) * power * 100000.0), color.a);\n}\n";
-    readonly fs: "uniform inkUniforms {\n  float strength;\n} ink;\n\nvec4 ink_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 dx = vec2(1.0 / texSize.x, 0.0);\n  vec2 dy = vec2(0.0, 1.0 / texSize.y);\n  vec4 color = texture(source, texCoord);\n  float bigTotal = 0.0;\n  float smallTotal = 0.0;\n  vec3 bigAverage = vec3(0.0);\n  vec3 smallAverage = vec3(0.0);\n  for (float x = -2.0; x <= 2.0; x += 1.0) {\n    for (float y = -2.0; y <= 2.0; y += 1.0) {\n      vec3 offsetColor = texture(source, texCoord + dx * x + dy * y).rgb;\n      bigAverage += offsetColor;\n      bigTotal += 1.0;\n      if (abs(x) + abs(y) < 2.0) {\n        smallAverage += offsetColor;\n        smallTotal += 1.0;\n      }\n    }\n  }\n  vec3 edge = max(vec3(0.0), bigAverage / bigTotal - smallAverage / smallTotal);\n  float power = ink.strength * ink.strength * ink.strength * ink.strength * ink.strength;\n  return vec4(color.rgb - dot(edge, edge) * power * 100000.0, color.a);\n}\n";
+    readonly fs: "layout(std140) uniform inkUniforms {\n  float strength;\n} ink;\n\nvec4 ink_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 dx = vec2(1.0 / texSize.x, 0.0);\n  vec2 dy = vec2(0.0, 1.0 / texSize.y);\n  vec4 color = texture(source, texCoord);\n  float bigTotal = 0.0;\n  float smallTotal = 0.0;\n  vec3 bigAverage = vec3(0.0);\n  vec3 smallAverage = vec3(0.0);\n  for (float x = -2.0; x <= 2.0; x += 1.0) {\n    for (float y = -2.0; y <= 2.0; y += 1.0) {\n      vec3 offsetColor = texture(source, texCoord + dx * x + dy * y).rgb;\n      bigAverage += offsetColor;\n      bigTotal += 1.0;\n      if (abs(x) + abs(y) < 2.0) {\n        smallAverage += offsetColor;\n        smallTotal += 1.0;\n      }\n    }\n  }\n  vec3 edge = max(vec3(0.0), bigAverage / bigTotal - smallAverage / smallTotal);\n  float power = ink.strength * ink.strength * ink.strength * ink.strength * ink.strength;\n  return vec4(color.rgb - dot(edge, edge) * power * 100000.0, color.a);\n}\n";
     readonly props: InkProps;
     readonly uniforms: InkUniforms;
     readonly uniformTypes: {

package/dist/passes/postprocessing/image-fun-filters/ink.js

@@ -42,7 +42,7 @@ fn ink_sampleColor(
 }
 `;
 const fs = /* glsl */ `\
-uniform inkUniforms {
+layout(std140) uniform inkUniforms {
   float strength;
 } ink;
 

package/dist/passes/postprocessing/image-fun-filters/magnify.d.ts

@@ -20,7 +20,7 @@ export type MagnifyUniforms = MagnifyProps;
 export declare const magnify: {
     readonly name: "magnify";
     readonly source: "struct magnifyUniforms {\n  screenXY: vec2f,\n  radiusPixels: f32,\n  zoom: f32,\n  borderWidthPixels: f32,\n  borderColor: vec4f,\n};\n\n@group(0) @binding(auto) var<uniform> magnify: magnifyUniforms;\n\nfn magnify_sampleColor(\n  sourceTexture: texture_2d<f32>,\n  sourceTextureSampler: sampler,\n  texSize: vec2f,\n  texCoord: vec2f\n) -> vec4f {\n  let pos = vec2f(magnify.screenXY.x, 1.0 - magnify.screenXY.y);\n  let dist = distance(texCoord * texSize, pos * texSize);\n  if (dist < magnify.radiusPixels) {\n    return textureSampleLevel(\n      sourceTexture,\n      sourceTextureSampler,\n      (texCoord - pos) / magnify.zoom + pos,\n      0.0\n    );\n  }\n\n  if (dist <= magnify.radiusPixels + magnify.borderWidthPixels) {\n    return magnify.borderColor;\n  }\n  return textureSampleLevel(sourceTexture, sourceTextureSampler, texCoord, 0.0);\n}\n";
-    readonly fs: "uniform magnifyUniforms {\n  vec2 screenXY;\n  float radiusPixels;\n  float zoom;\n  float borderWidthPixels;\n  vec4 borderColor;\n} magnify;\n\nvec4 magnify_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 pos = vec2(magnify.screenXY.x, 1.0 - magnify.screenXY.y);\n  float dist = distance(texCoord * texSize, pos * texSize);\n  if (dist < magnify.radiusPixels) {\n    return texture(source, (texCoord - pos) / magnify.zoom + pos);\n  }\n\n  if (dist <= magnify.radiusPixels + magnify.borderWidthPixels) {\n    return magnify.borderColor;\n  }\n  return texture(source, texCoord);\n}\n";
+    readonly fs: "layout(std140) uniform magnifyUniforms {\n  vec2 screenXY;\n  float radiusPixels;\n  float zoom;\n  float borderWidthPixels;\n  vec4 borderColor;\n} magnify;\n\nvec4 magnify_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 pos = vec2(magnify.screenXY.x, 1.0 - magnify.screenXY.y);\n  float dist = distance(texCoord * texSize, pos * texSize);\n  if (dist < magnify.radiusPixels) {\n    return texture(source, (texCoord - pos) / magnify.zoom + pos);\n  }\n\n  if (dist <= magnify.radiusPixels + magnify.borderWidthPixels) {\n    return magnify.borderColor;\n  }\n  return texture(source, texCoord);\n}\n";
     readonly uniformTypes: {
         readonly screenXY: "vec2<f32>";
         readonly radiusPixels: "f32";

package/dist/passes/postprocessing/image-fun-filters/magnify.js

@@ -36,7 +36,7 @@ fn magnify_sampleColor(
 }
 `;
 const fs = /* glsl */ `\
-uniform magnifyUniforms {
+layout(std140) uniform magnifyUniforms {
   vec2 screenXY;
   float radiusPixels;
   float zoom;

package/dist/passes/postprocessing/image-warp-filters/bulgepinch.d.ts

@@ -21,7 +21,7 @@ export declare const bulgePinch: {
         readonly passes: [];
     }];
     readonly source: "struct bulgePinchUniforms {\n  center: vec2f,\n  radius: f32,\n  strength: f32,\n};\n\n@group(0) @binding(auto) var<uniform> bulgePinch: bulgePinchUniforms;\n\nfn bulgePinch_warp(coordIn: vec2f, texCenter: vec2f) -> vec2f {\n  var coord = coordIn - texCenter;\n  let distance = length(coord);\n  if (distance < bulgePinch.radius) {\n    let percent = distance / bulgePinch.radius;\n    let safeDistance = max(distance, 0.00001);\n    if (bulgePinch.strength > 0.0) {\n      coord *= mix(\n        1.0,\n        smoothstep(0.0, bulgePinch.radius / safeDistance, percent),\n        bulgePinch.strength * 0.75\n      );\n    } else {\n      coord *= mix(\n        1.0,\n        pow(percent, 1.0 + bulgePinch.strength * 0.75) * bulgePinch.radius / safeDistance,\n        1.0 - percent\n      );\n    }\n  }\n  coord += texCenter;\n  return coord;\n}\n\nfn bulgePinch_sampleColor(\n  sourceTexture: texture_2d<f32>,\n  sourceTextureSampler: sampler,\n  texSize: vec2f,\n  texCoord: vec2f\n) -> vec4f {\n  var coord = texCoord * texSize;\n  coord = bulgePinch_warp(coord, bulgePinch.center * texSize);\n  return warp_sampleColor(sourceTexture, sourceTextureSampler, texSize, coord);\n}\n";
-    readonly fs: "uniform bulgePinchUniforms {\n  vec2 center;\n  float radius;\n  float strength;\n} bulgePinch;\n\nvec2 bulgePinch_warp(vec2 coord, vec2 texCenter) {\n  coord -= texCenter;\n  float distance = length(coord);\n  if (distance < bulgePinch.radius) {\n    float percent = distance / bulgePinch.radius;\n    if (bulgePinch.strength > 0.0) {\n      coord *= mix(1.0, smoothstep(0.0, bulgePinch.radius / distance, percent), bulgePinch.strength * 0.75);\n    } else {\n      coord *= mix(1.0, pow(percent, 1.0 + bulgePinch.strength * 0.75) * bulgePinch.radius / distance, 1.0 - percent);\n    }\n  }\n  coord += texCenter;\n  return coord;\n}\n\nvec4 bulgePinch_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 coord = texCoord * texSize;\n  coord = bulgePinch_warp(coord, bulgePinch.center * texSize);\n\n  return warp_sampleColor(source, texSize, coord);\n}\n";
+    readonly fs: "layout(std140) uniform bulgePinchUniforms {\n  vec2 center;\n  float radius;\n  float strength;\n} bulgePinch;\n\nvec2 bulgePinch_warp(vec2 coord, vec2 texCenter) {\n  coord -= texCenter;\n  float distance = length(coord);\n  if (distance < bulgePinch.radius) {\n    float percent = distance / bulgePinch.radius;\n    if (bulgePinch.strength > 0.0) {\n      coord *= mix(1.0, smoothstep(0.0, bulgePinch.radius / distance, percent), bulgePinch.strength * 0.75);\n    } else {\n      coord *= mix(1.0, pow(percent, 1.0 + bulgePinch.strength * 0.75) * bulgePinch.radius / distance, 1.0 - percent);\n    }\n  }\n  coord += texCenter;\n  return coord;\n}\n\nvec4 bulgePinch_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 coord = texCoord * texSize;\n  coord = bulgePinch_warp(coord, bulgePinch.center * texSize);\n\n  return warp_sampleColor(source, texSize, coord);\n}\n";
     readonly props: BulgePinchProps;
     readonly uniforms: BulgePinchUniforms;
     readonly uniformTypes: {

package/dist/passes/postprocessing/image-warp-filters/bulgepinch.js

@@ -47,7 +47,7 @@ fn bulgePinch_sampleColor(
 }
 `;
 const fs = /* glsl */ `\
-uniform bulgePinchUniforms {
+layout(std140) uniform bulgePinchUniforms {
   vec2 center;
   float radius;
   float strength;

package/dist/passes/postprocessing/image-warp-filters/swirl.d.ts

@@ -22,7 +22,7 @@ export declare const swirl: {
         readonly passes: [];
     }];
     readonly source: "struct swirlUniforms {\n  center: vec2f,\n  radius: f32,\n  angle: f32,\n};\n\n@group(0) @binding(auto) var<uniform> swirl: swirlUniforms;\n\nfn swirl_warp(coordIn: vec2f, texCenter: vec2f) -> vec2f {\n  var coord = coordIn - texCenter;\n  let distance = length(coord);\n  if (distance < swirl.radius) {\n    let percent = (swirl.radius - distance) / swirl.radius;\n    let theta = percent * percent * swirl.angle;\n    let s = sin(theta);\n    let c = cos(theta);\n    coord = vec2f(\n      coord.x * c - coord.y * s,\n      coord.x * s + coord.y * c\n    );\n  }\n  coord += texCenter;\n  return coord;\n}\n\nfn swirl_sampleColor(\n  sourceTexture: texture_2d<f32>,\n  sourceTextureSampler: sampler,\n  texSize: vec2f,\n  texCoord: vec2f\n) -> vec4f {\n  var coord = texCoord * texSize;\n  coord = swirl_warp(coord, swirl.center * texSize);\n  return warp_sampleColor(sourceTexture, sourceTextureSampler, texSize, coord);\n}\n";
-    readonly fs: "uniform swirlUniforms {\n  vec2 center;\n  float radius;\n  float angle;\n} swirl;\n\nvec2 swirl_warp(vec2 coord, vec2 texCenter) {\n  coord -= texCenter;\n  float distance = length(coord);\n  if (distance < swirl.radius) {\n    float percent = (swirl.radius - distance) / swirl.radius;\n    float theta = percent * percent * swirl.angle;\n    float s = sin(theta);\n    float c = cos(theta);\n    coord = vec2(\n      coord.x * c - coord.y * s,\n      coord.x * s + coord.y * c\n    );\n  }\n  coord += texCenter;\n  return coord;\n}\n\nvec4 swirl_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 coord = texCoord * texSize;\n  coord = swirl_warp(coord, swirl.center * texSize);\n\n  return warp_sampleColor(source, texSize, coord);\n}\n";
+    readonly fs: "layout(std140) uniform swirlUniforms {\n  vec2 center;\n  float radius;\n  float angle;\n} swirl;\n\nvec2 swirl_warp(vec2 coord, vec2 texCenter) {\n  coord -= texCenter;\n  float distance = length(coord);\n  if (distance < swirl.radius) {\n    float percent = (swirl.radius - distance) / swirl.radius;\n    float theta = percent * percent * swirl.angle;\n    float s = sin(theta);\n    float c = cos(theta);\n    coord = vec2(\n      coord.x * c - coord.y * s,\n      coord.x * s + coord.y * c\n    );\n  }\n  coord += texCenter;\n  return coord;\n}\n\nvec4 swirl_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 coord = texCoord * texSize;\n  coord = swirl_warp(coord, swirl.center * texSize);\n\n  return warp_sampleColor(source, texSize, coord);\n}\n";
     readonly props: SwirlProps;
     readonly uniforms: SwirlProps;
     readonly uniformTypes: {

package/dist/passes/postprocessing/image-warp-filters/swirl.js

@@ -40,7 +40,7 @@ fn swirl_sampleColor(
 }
 `;
 const fs = /* glsl */ `\
-uniform swirlUniforms {
+layout(std140) uniform swirlUniforms {
   vec2 center;
   float radius;
   float angle;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luma.gl/effects",
-  "version": "9.3.0-alpha.8",
+  "version": "9.3.0",
   "description": "Post-processing effects for luma.gl",
   "type": "module",
   "license": "MIT",
@@ -52,5 +52,5 @@
     "@math.gl/core": "^4.1.0",
     "@math.gl/types": "^4.1.0"
   },
-  "gitHead": "371f0979c1cd01563badc36118f314365a66e1a1"
+  "gitHead": "c5e44faacd07b315a8622b5927e724f15a3d40ae"
 }

package/src/passes/postprocessing/image-adjust-filters/brightnesscontrast.ts

@@ -24,7 +24,7 @@ fn brightnessContrast_filterColor_ext(color: vec4f, texSize: vec2<f32>, texCoord
 `;
 
 const fs = /* glsl */ `\
-uniform brightnessContrastUniforms {
+layout(std140) uniform brightnessContrastUniforms {
   float brightness;
   float contrast;
 } brightnessContrast;

package/src/passes/postprocessing/image-adjust-filters/denoise.ts

@@ -44,7 +44,7 @@ fn denoise_sampleColor(
 `;
 
 const fs = /* glsl */ `\
-uniform denoiseUniforms {
+layout(std140) uniform denoiseUniforms {
   float strength;
 } denoise;
 

package/src/passes/postprocessing/image-adjust-filters/huesaturation.ts

@@ -40,7 +40,7 @@ fn hueSaturation_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f)
 `;
 
 const fs = /* glsl */ `\
-uniform hueSaturationUniforms {
+layout(std140) uniform hueSaturationUniforms {
   float hue;
   float saturation;
 } hueSaturation;

package/src/passes/postprocessing/image-adjust-filters/noise.ts

@@ -26,7 +26,7 @@ fn noise_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> vec4f
 `;
 
 const fs = /* glsl */ `\
-uniform noiseUniforms {
+layout(std140) uniform noiseUniforms {
   float amount;
 } noise;
 

package/src/passes/postprocessing/image-adjust-filters/sepia.ts

@@ -31,7 +31,7 @@ fn sepia_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> vec4f
 `;
 
 const fs = /* glsl */ `\
-uniform sepiaUniforms {
+layout(std140) uniform sepiaUniforms {
   float amount;
 } sepia;
 

package/src/passes/postprocessing/image-adjust-filters/vibrance.ts

@@ -25,7 +25,7 @@ fn vibrance_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> ve
 `;
 
 const fs = /* glsl */ `\
-uniform vibranceUniforms {
+layout(std140) uniform vibranceUniforms {
   float amount;
 } vibrance;
 

package/src/passes/postprocessing/image-adjust-filters/vignette.ts

@@ -24,7 +24,7 @@ fn vignette_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> ve
 `;
 
 const fs = /* glsl */ `\
-uniform vignetteUniforms {
+layout(std140) uniform vignetteUniforms {
   float radius;
   float amount;
 } vignette;

package/src/passes/postprocessing/image-blur-filters/tiltshift.ts

@@ -65,7 +65,7 @@ fn tiltShift_sampleColor(
 `;
 
 const fs = /* glsl */ `\
-uniform tiltShiftUniforms {
+layout(std140) uniform tiltShiftUniforms {
   float blurRadius;
   float gradientRadius;
   vec2 start;

package/src/passes/postprocessing/image-blur-filters/triangleblur.ts

@@ -53,7 +53,7 @@ fn triangleBlur_sampleColor(
 `;
 
 const fs = /* glsl */ `\
-uniform triangleBlurUniforms {
+layout(std140) uniform triangleBlurUniforms {
   float radius;
   vec2 delta;
 } triangleBlur;

package/src/passes/postprocessing/image-blur-filters/zoomblur.ts

@@ -45,7 +45,7 @@ fn zoomBlur_sampleColor(
 `;
 
 const fs = /* glsl */ `
-uniform zoomBlurUniforms {
+layout(std140) uniform zoomBlurUniforms {
   vec2 center;
   float strength;
 } zoomBlur;

package/src/passes/postprocessing/image-fun-filters/colorhalftone.ts

@@ -47,7 +47,7 @@ fn colorHalftone_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f)
 
 // TODO pass texCoord to angle
 const fs = /* glsl */ `\
-uniform colorHalftoneUniforms {
+layout(std140) uniform colorHalftoneUniforms {
   vec2 center;
   float angle;
   float size;

package/src/passes/postprocessing/image-fun-filters/dotscreen.ts

@@ -32,7 +32,7 @@ fn dotScreen_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> v
 `;
 
 const fs = /* glsl */ `\
-uniform dotScreenUniforms {
+layout(std140) uniform dotScreenUniforms {
   vec2 center;
   float angle;
   float size;

package/src/passes/postprocessing/image-fun-filters/edgework.ts

@@ -111,7 +111,7 @@ fn edgeWork_sampleColor(
 `;
 
 const fs = /* glsl */ `\
-uniform edgeWorkUniforms {
+layout(std140) uniform edgeWorkUniforms {
   float radius;
   int mode;
 } edgeWork;

package/src/passes/postprocessing/image-fun-filters/hexagonalpixelate.ts

@@ -64,7 +64,7 @@ fn hexagonalPixelate_sampleColor(
 `;
 
 const fs = /* glsl */ `\
-uniform hexagonalPixelateUniforms {
+layout(std140) uniform hexagonalPixelateUniforms {
   vec2 center;
   float scale;
 } hexagonalPixelate;

package/src/passes/postprocessing/image-fun-filters/ink.ts

@@ -46,7 +46,7 @@ fn ink_sampleColor(
 `;
 
 const fs = /* glsl */ `\
-uniform inkUniforms {
+layout(std140) uniform inkUniforms {
   float strength;
 } ink;
 

package/src/passes/postprocessing/image-fun-filters/magnify.ts

@@ -40,7 +40,7 @@ fn magnify_sampleColor(
 `;
 
 const fs = /* glsl */ `\
-uniform magnifyUniforms {
+layout(std140) uniform magnifyUniforms {
   vec2 screenXY;
   float radiusPixels;
   float zoom;

package/src/passes/postprocessing/image-warp-filters/bulgepinch.ts

@@ -51,7 +51,7 @@ fn bulgePinch_sampleColor(
 `;
 
 const fs = /* glsl */ `\
-uniform bulgePinchUniforms {
+layout(std140) uniform bulgePinchUniforms {
   vec2 center;
   float radius;
   float strength;

package/src/passes/postprocessing/image-warp-filters/swirl.ts

@@ -44,7 +44,7 @@ fn swirl_sampleColor(
 `;
 
 const fs = /* glsl */ `\
-uniform swirlUniforms {
+layout(std140) uniform swirlUniforms {
   vec2 center;
   float radius;
   float angle;