@luma.gl/effects 9.2.6 → 9.3.0-alpha.11

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

@@ -2,48 +2,41 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 const source = /* wgsl */ `\
-
 struct hueSaturationUniforms {
   hue: f32,
   saturation: f32,
 };
 
-@group(0), @binding(1) var<uniform> hueSaturation: hueSaturationUniforms;
+@group(0) @binding(auto) var<uniform> hueSaturation: hueSaturationUniforms;
+
+fn hueSaturation_filterColor(color: vec4f) -> vec4f {
+  let angle = hueSaturation.hue * 3.14159265;
+  let s = sin(angle);
+  let c = cos(angle);
+  let weights = (vec3f(2.0 * c, -sqrt(3.0) * s - c, sqrt(3.0) * s - c) + vec3f(1.0)) / 3.0;
+
+  var resultRgb = vec3f(
+    dot(color.rgb, weights.xyz),
+    dot(color.rgb, weights.zxy),
+    dot(color.rgb, weights.yzx)
+  );
+
+  let average = (resultRgb.r + resultRgb.g + resultRgb.b) / 3.0;
+  if (hueSaturation.saturation > 0.0) {
+    resultRgb += (vec3f(average) - resultRgb) * (1.0 - 1.0 / (1.001 - hueSaturation.saturation));
+  } else {
+    resultRgb += (vec3f(average) - resultRgb) * (-hueSaturation.saturation);
+  }
 
-fn hueSaturation_filterColor(color: vec4<f32>) -> vec4<f32> {
-	let angle: f32 = hueSaturation.hue * 3.1415927;
-	let s: f32 = sin(angle);
-	let c: f32 = cos(angle);
-	let weights: vec3<f32> = (vec3<f32>(2. * c, -sqrt(3.) * s - c, sqrt(3.) * s - c) + 1.) / 3.;
-	let len: f32 = length(color.rgb);
-	var colorrgb = color.rgb;
-	colorrgb = vec3<f32>(dot(color.rgb, weights.xyz), dot(color.rgb, weights.zxy), dot(color.rgb, weights.yzx));
-	color.r = colorrgb.x;
-	color.g = colorrgb.y;
-	color.b = colorrgb.z;
-	let average: f32 = (color.r + color.g + color.b) / 3.;
-	if (hueSaturation.saturation > 0.) {
-		var colorrgb = color.rgb;
-	colorrgb = color.rgb + ((average - color.rgb) * (1. - 1. / (1.001 - hueSaturation.saturation)));
-	color.r = colorrgb.x;
-	color.g = colorrgb.y;
-	color.b = colorrgb.z;
-	} else { 
-		var colorrgb = color.rgb;
-	colorrgb = color.rgb + ((average - color.rgb) * -hueSaturation.saturation);
-	color.r = colorrgb.x;
-	color.g = colorrgb.y;
-	color.b = colorrgb.z;
-	}
-	return color;
-} 
+  return vec4f(resultRgb, color.a);
+}
 
-fn hueSaturation_filterColor_ext(color: vec4<f32>, texSize: vec2<f32>, texCoord: vec2<f32>) -> vec4<f32> {
-	return hueSaturation_filterColor(color);
-} 
+fn hueSaturation_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> vec4f {
+  return hueSaturation_filterColor(color);
+}
 `;
 const fs = /* glsl */ `\
-uniform hueSaturationUniforms {
+layout(std140) uniform hueSaturationUniforms {
   float hue;
   float saturation;
 } hueSaturation;

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

@@ -1 +1 @@
-{"version":3,"file":"huesaturation.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/huesaturation.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwCzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCrB,CAAC;AAeF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,KAAK,EAAE,EAAwB;IAE/B,IAAI,EAAE,eAAe;IACrB,MAAM;IACN,EAAE;IAEF,YAAY,EAAE;QACZ,GAAG,EAAE,KAAK;QACV,UAAU,EAAE,KAAK;KAClB;IACD,SAAS,EAAE;QACT,GAAG,EAAE,EAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAC;QAChC,UAAU,EAAE,EAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAC;KACxC;IACD,MAAM,EAAE,CAAC,EAAC,MAAM,EAAE,IAAI,EAAC,CAAC;CACyB,CAAC"}
+{"version":3,"file":"huesaturation.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/huesaturation.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCrB,CAAC;AAeF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,KAAK,EAAE,EAAwB;IAE/B,IAAI,EAAE,eAAe;IACrB,MAAM;IACN,EAAE;IAEF,YAAY,EAAE;QACZ,GAAG,EAAE,KAAK;QACV,UAAU,EAAE,KAAK;KAClB;IACD,SAAS,EAAE;QACT,GAAG,EAAE,EAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAC;QAChC,UAAU,EAAE,EAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAC;KACxC;IACD,MAAM,EAAE,CAAC,EAAC,MAAM,EAAE,IAAI,EAAC,CAAC;CACyB,CAAC"}

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

@@ -12,8 +12,8 @@ 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 source: "struct noiseUniforms {\n  amount: f32\n};\n\n@group(0) @binding(1) 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\tlet diff: f32 = (rand(texCoord) - 0.5) * noise.amount;\n\tcolor.r = color.r + (diff);\n\tcolor.g = color.g + (diff);\n\tcolor.b = color.b + (diff);\n\treturn 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;
     readonly uniformTypes: {

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

@@ -1 +1 @@
-{"version":3,"file":"noise.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/noise.ts"],"names":[],"mappings":"AA4CA;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,qDAAqD;IACrD,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC;AAEvC;;;GAGG;AACH,eAAO,MAAM,KAAK;;;;oBAKH,UAAU;uBACP,aAAa;;;;;;;;;;;;;;CASwB,CAAC"}
+{"version":3,"file":"noise.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/noise.ts"],"names":[],"mappings":"AA6CA;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,qDAAqD;IACrD,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC;AAEvC;;;GAGG;AACH,eAAO,MAAM,KAAK;;;;oBAKH,UAAU;uBACP,aAAa;;;;;;;;;;;;;;CASwB,CAAC"}

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

@@ -3,25 +3,26 @@
 // Copyright (c) vis.gl contributors
 const source = /* wgsl */ `\
 struct noiseUniforms {
-  amount: f32
+  amount: f32,
 };
 
-@group(0) @binding(1) var<uniform> noise: noiseUniforms;
+@group(0) @binding(auto) var<uniform> noise: noiseUniforms;
 
 fn rand(co: vec2f) -> f32 {
 	return fract(sin(dot(co.xy, vec2f(12.9898, 78.233))) * 43758.547);
 } 
 
 fn noise_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> vec4f {
-	let diff: f32 = (rand(texCoord) - 0.5) * noise.amount;
-	color.r = color.r + (diff);
-	color.g = color.g + (diff);
-	color.b = color.b + (diff);
-	return color;
-} 
+  let diff = (rand(texCoord) - 0.5) * noise.amount;
+  var result = color;
+  result.r += diff;
+  result.g += diff;
+  result.b += diff;
+  return result;
+}
 `;
 const fs = /* glsl */ `\
-uniform noiseUniforms {
+layout(std140) uniform noiseUniforms {
   float amount;
 } noise;
 

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

@@ -1 +1 @@
-{"version":3,"file":"noise.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/noise.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;CAkBzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;CAgBrB,CAAC;AAYF;;;GAGG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,IAAI,EAAE,OAAO;IACb,EAAE;IACF,MAAM;IAEN,KAAK,EAAE,EAAgB;IACvB,QAAQ,EAAE,EAAmB;IAC7B,YAAY,EAAE;QACZ,MAAM,EAAE,KAAK;KACd;IACD,SAAS,EAAE;QACT,MAAM,EAAE,EAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAC;KACrC;IAED,MAAM,EAAE,CAAC,EAAC,MAAM,EAAE,IAAI,EAAC,CAAC;CAC6B,CAAC"}
+{"version":3,"file":"noise.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/noise.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;CAmBzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;CAgBrB,CAAC;AAYF;;;GAGG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,IAAI,EAAE,OAAO;IACb,EAAE;IACF,MAAM;IAEN,KAAK,EAAE,EAAgB;IACvB,QAAQ,EAAE,EAAmB;IAC7B,YAAY,EAAE;QACZ,MAAM,EAAE,KAAK;KACd;IACD,SAAS,EAAE;QACT,MAAM,EAAE,EAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAC;KACrC;IAED,MAAM,EAAE,CAAC,EAAC,MAAM,EAAE,IAAI,EAAC,CAAC;CAC6B,CAAC"}

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

@@ -21,8 +21,8 @@ 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 source: "struct sepiaUniforms {\n  amount: f32\n};\n\n@group(0) @binding(1) var<uniform> sepia: sepiaUniforms;\n\nfn sepia_filterColor(color: vec4f) -> vec4f {\n  let r: f32 = color.r;\n  let g: f32 = color.g;\n  let b: f32 = 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.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sepia.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/sepia.ts"],"names":[],"mappings":"AAsDA,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC;AAEvC;;;;GAIG;AACH,eAAO,MAAM,KAAK;oBACH,UAAU;uBACP,aAAa;;;;;;;;;;;;;;;;;CAYwB,CAAC"}
+{"version":3,"file":"sepia.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/sepia.ts"],"names":[],"mappings":"AAuDA,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC;AAEvC;;;;GAIG;AACH,eAAO,MAAM,KAAK;oBACH,UAAU;uBACP,aAAa;;;;;;;;;;;;;;;;;CAYwB,CAAC"}

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

@@ -3,30 +3,31 @@
 // Copyright (c) vis.gl contributors
 const source = /* wgsl */ `\
 struct sepiaUniforms {
-  amount: f32
+  amount: f32,
 };
 
-@group(0) @binding(1) var<uniform> sepia: sepiaUniforms;
+@group(0) @binding(auto) var<uniform> sepia: sepiaUniforms;
 
 fn sepia_filterColor(color: vec4f) -> vec4f {
-  let r: f32 = color.r;
-  let g: f32 = color.g;
-  let b: f32 = color.b;
+  let r = color.r;
+  let g = color.g;
+  let b = color.b;
 
-  color.r =
+  var result = color;
+  result.r =
     min(1.0, (r * (1.0 - (0.607 * sepia.amount))) + (g * (0.769 * sepia.amount)) + (b * (0.189 * sepia.amount)));
-  color.g = min(1.0, (r * 0.349 * sepia.amount) + (g * (1.0 - (0.314 * sepia.amount))) + (b * 0.168 * sepia.amount));
-  color.b = min(1.0, (r * 0.272 * sepia.amount) + (g * 0.534 * sepia.amount) + (b * (1.0 - (0.869 * sepia.amount))));
+  result.g = min(1.0, (r * 0.349 * sepia.amount) + (g * (1.0 - (0.314 * sepia.amount))) + (b * 0.168 * sepia.amount));
+  result.b = min(1.0, (r * 0.272 * sepia.amount) + (g * 0.534 * sepia.amount) + (b * (1.0 - (0.869 * sepia.amount))));
 
-  return color;
+  return result;
 }
 
-vec4 sepia_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
+fn sepia_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> vec4f {
   return sepia_filterColor(color);
 }
 `;
 const fs = /* glsl */ `\
-uniform sepiaUniforms {
+layout(std140) uniform sepiaUniforms {
   float amount;
 } sepia;
 

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

@@ -1 +1 @@
-{"version":3,"file":"sepia.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/sepia.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;CAuBzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;CAqBrB,CAAC;AAQF;;;;GAIG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,KAAK,EAAE,EAAgB;IACvB,QAAQ,EAAE,EAAmB;IAE7B,IAAI,EAAE,OAAO;IACb,YAAY,EAAE;QACZ,MAAM,EAAE,KAAK;KACd;IACD,SAAS,EAAE;QACT,MAAM,EAAE,EAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAC;KACrC;IACD,EAAE;IACF,MAAM;IACN,MAAM,EAAE,CAAC,EAAC,MAAM,EAAE,IAAI,EAAC,CAAC;CAC6B,CAAC"}
+{"version":3,"file":"sepia.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/sepia.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;CAwBzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;CAqBrB,CAAC;AAQF;;;;GAIG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,KAAK,EAAE,EAAgB;IACvB,QAAQ,EAAE,EAAmB;IAE7B,IAAI,EAAE,OAAO;IACb,YAAY,EAAE;QACZ,MAAM,EAAE,KAAK;KACd;IACD,SAAS,EAAE;QACT,MAAM,EAAE,EAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAC;KACrC;IACD,EAAE;IACF,MAAM;IACN,MAAM,EAAE,CAAC,EAAC,MAAM,EAAE,IAAI,EAAC,CAAC;CAC6B,CAAC"}

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

@@ -21,8 +21,8 @@ export declare const vibrance: {
             readonly max: 1;
         };
     };
-    readonly source: "struct vibranceUniforms {\n  amount: f32\n};\n\n@group(0) @binding(1) var<uniform> vibrance: vibranceUniforms;\n\nfn vibrance_filterColor(vec4f color) -> vec4f {\n  let average: f32 = (color.r + color.g + color.b) / 3.0;\n  let mx: f32 = max(color.r, max(color.g, color.b));\n  let amt: f32 = (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: "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 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: "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

@@ -3,25 +3,25 @@
 // Copyright (c) vis.gl contributors
 const source = /* wgsl */ `\
 struct vibranceUniforms {
-  amount: f32
+  amount: f32,
 };
 
-@group(0) @binding(1) var<uniform> vibrance: vibranceUniforms;
+@group(0) @binding(auto) var<uniform> vibrance: vibranceUniforms;
 
-fn vibrance_filterColor(vec4f color) -> vec4f {
-  let average: f32 = (color.r + color.g + color.b) / 3.0;
-  let mx: f32 = max(color.r, max(color.g, color.b));
-  let amt: f32 = (mx - average) * (-vibrance.amount * 3.0);
-  color.rgb = mix(color.rgb, vec3(mx), amt);
-  return color;
+fn vibrance_filterColor(color: vec4f) -> vec4f {
+  let average = (color.r + color.g + color.b) / 3.0;
+  let mx = max(color.r, max(color.g, color.b));
+  let amt = (mx - average) * (-vibrance.amount * 3.0);
+  let resultRgb = mix(color.rgb, vec3f(mx), amt);
+  return vec4f(resultRgb, color.a);
 }
 
-vec4 vibrance_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
+fn vibrance_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> vec4f {
   return vibrance_filterColor(color);
 }
 `;
 const fs = /* glsl */ `\
-uniform vibranceUniforms {
+layout(std140) uniform vibranceUniforms {
   float amount;
 } vibrance;
 

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

@@ -16,8 +16,8 @@ export declare const vignette: {
     readonly props: VignetteProps;
     readonly uniforms: VignetteUniforms;
     readonly name: "vignette";
-    readonly source: "struct vignetteUniforms {\n  radius: f32,\n  amount: f32\n};\n\n@group(0) @binding(1) var<uniform> vignette: vignetteUniforms;\n\nfn vibrance_filterColor(color: vec4f) -> vec4f {\n  let average: f32 = (color.r + color.g + color.b) / 3.0;\n  let mx: f32 = max(color.r, max(color.g, color.b));\n  let amt: f32 = (mx - average) * (-vibrance.amount * 3.0);\n  color.rgb = mix(color.rgb, vec3f(mx), amt);\n  return color;\n}\n\nfn vignette_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) ->vec4f {\n  let dist: f32 = distance(texCoord, vec2f(0.5, 0.5));\n  let ratio: f32 = smoothstep(0.8, vignette.radius * 0.799, dist * (vignette.amount + vignette.radius));\n  return color.rgba * ratio + (1.0 - ratio)*vec4f(0.0, 0.0, 0.0, 1.0);\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 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: "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.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vignette.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/vignette.ts"],"names":[],"mappings":"AA0CA;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,0DAA0D;IAC1D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6DAA6D;IAC7D,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC;AAE7C;;;GAGG;AACH,eAAO,MAAM,QAAQ;oBACN,aAAa;uBACV,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoB2B,CAAC"}
+{"version":3,"file":"vignette.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/vignette.ts"],"names":[],"mappings":"AAsCA;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,0DAA0D;IAC1D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6DAA6D;IAC7D,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC;AAE7C;;;GAGG;AACH,eAAO,MAAM,QAAQ;oBACN,aAAa;uBACV,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoB2B,CAAC"}

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

@@ -4,27 +4,23 @@
 const source = /* wgsl */ `\
 struct vignetteUniforms {
   radius: f32,
-  amount: f32
+  amount: f32,
 };
 
-@group(0) @binding(1) var<uniform> vignette: vignetteUniforms;
+@group(0) @binding(auto) var<uniform> vignette: vignetteUniforms;
 
-fn vibrance_filterColor(color: vec4f) -> vec4f {
-  let average: f32 = (color.r + color.g + color.b) / 3.0;
-  let mx: f32 = max(color.r, max(color.g, color.b));
-  let amt: f32 = (mx - average) * (-vibrance.amount * 3.0);
-  color.rgb = mix(color.rgb, vec3f(mx), amt);
-  return color;
-}
-
-fn vignette_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) ->vec4f {
-  let dist: f32 = distance(texCoord, vec2f(0.5, 0.5));
-  let ratio: f32 = smoothstep(0.8, vignette.radius * 0.799, dist * (vignette.amount + vignette.radius));
-  return color.rgba * ratio + (1.0 - ratio)*vec4f(0.0, 0.0, 0.0, 1.0);
+fn vignette_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> vec4f {
+  let dist = distance(texCoord, vec2f(0.5, 0.5));
+  let ratio = smoothstep(
+    0.8,
+    vignette.radius * 0.799,
+    dist * (vignette.amount + vignette.radius)
+  );
+  return color * ratio + vec4f(0.0, 0.0, 0.0, 1.0) * (1.0 - ratio);
 }
 `;
 const fs = /* glsl */ `\
-uniform vignetteUniforms {
+layout(std140) uniform vignetteUniforms {
   float radius;
   float amount;
 } vignette;

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

@@ -1 +1 @@
-{"version":3,"file":"vignette.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/vignette.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;CAqBzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;CAWrB,CAAC;AAcF;;;GAGG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,KAAK,EAAE,EAAmB;IAC1B,QAAQ,EAAE,EAAsB;IAEhC,IAAI,EAAE,UAAU;IAChB,MAAM;IACN,EAAE;IAEF,YAAY,EAAE;QACZ,MAAM,EAAE,KAAK;QACb,MAAM,EAAE,KAAK;KACd;IACD,eAAe,EAAE;QACf,MAAM,EAAE,GAAG;QACX,MAAM,EAAE,GAAG;KACZ;IACD,SAAS,EAAE;QACT,MAAM,EAAE,EAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAC;QACpC,MAAM,EAAE,EAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAC;KACrC;IAED,MAAM,EAAE,CAAC,EAAC,MAAM,EAAE,IAAI,EAAC,CAAC;CACmC,CAAC"}
+{"version":3,"file":"vignette.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/vignette.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;CAiBzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;CAWrB,CAAC;AAcF;;;GAGG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,KAAK,EAAE,EAAmB;IAC1B,QAAQ,EAAE,EAAsB;IAEhC,IAAI,EAAE,UAAU;IAChB,MAAM;IACN,EAAE;IAEF,YAAY,EAAE;QACZ,MAAM,EAAE,KAAK;QACb,MAAM,EAAE,KAAK;KACd;IACD,eAAe,EAAE;QACf,MAAM,EAAE,GAAG;QACX,MAAM,EAAE,GAAG;KACZ;IACD,SAAS,EAAE;QACT,MAAM,EAAE,EAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAC;QACpC,MAAM,EAAE,EAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAC;KACrC;IAED,MAAM,EAAE,CAAC,EAAC,MAAM,EAAE,IAAI,EAAC,CAAC;CACmC,CAAC"}

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

@@ -30,11 +30,11 @@ export declare const tiltShift: {
     readonly name: "tiltShift";
     readonly dependencies: [{
         readonly name: "random";
-        readonly source: "fn random(scale: vec3f, seed: float) -> f32 {\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: "fn random(scale: vec3f, seed: f32) -> f32 {\n  return fract(sin(dot(scale + vec3f(seed), vec3f(12.9898, 78.233, 151.7182))) * 43758.5453 + seed);\n}\n";
         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: "uniform tiltShiftUniforms {\n  blurRadius: f32,\n  gradientRadius: f32,\n  start: vec2f,\n  end: vec2f,\n  invert: u32,\n};\n\n@group(0) @binding(1) var<uniform> tiltShift: tiltShiftUniforms;\n\nfn tiltShift_getDelta(vec2 texSize) -> vec2f {\n  vec2 vector = normalize((tiltShift.end - tiltShift.start) * texSize);\n  return tiltShift.invert ? vec2(-vector.y, vector.x) : vector;\n}\n\nfn tiltShift_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) -> vec4f {\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\n    color += offsetColor * weight;\n    total += weight;\n  }\n\n  color = 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 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: "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.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tiltshift.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-blur-filters/tiltshift.ts"],"names":[],"mappings":"AAsFA;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,2DAA2D;IAC3D,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzB,0DAA0D;IAC1D,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvB,8CAA8C;IAC9C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8EAA8E;IAC9E,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,0CAA0C;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,cAAc,CAAC;AAE/C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS;;;;;;;;;oBAMP,cAAc;uBACX,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoB4B,CAAC"}
+{"version":3,"file":"tiltshift.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-blur-filters/tiltshift.ts"],"names":[],"mappings":"AAwGA;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,2DAA2D;IAC3D,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzB,0DAA0D;IAC1D,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvB,8CAA8C;IAC9C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8EAA8E;IAC9E,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,0CAA0C;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,cAAc,CAAC;AAE/C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS;;;;;;;;;oBAMP,cAAc;uBACX,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoB4B,CAAC"}

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

@@ -3,7 +3,7 @@
 // Copyright (c) vis.gl contributors
 import { random } from '@luma.gl/shadertools';
 const source = /* wgsl */ `\
-uniform tiltShiftUniforms {
+struct tiltShiftUniforms {
   blurRadius: f32,
   gradientRadius: f32,
   start: vec2f,
@@ -11,39 +11,57 @@ uniform tiltShiftUniforms {
   invert: u32,
 };
 
-@group(0) @binding(1) var<uniform> tiltShift: tiltShiftUniforms;
+@group(0) @binding(auto) var<uniform> tiltShift: tiltShiftUniforms;
 
-fn tiltShift_getDelta(vec2 texSize) -> vec2f {
-  vec2 vector = normalize((tiltShift.end - tiltShift.start) * texSize);
-  return tiltShift.invert ? vec2(-vector.y, vector.x) : vector;
+fn tiltShift_getDelta(texSize: vec2f) -> vec2f {
+  let vector = normalize((tiltShift.end - tiltShift.start) * texSize);
+  return select(vector, vec2f(-vector.y, vector.x), tiltShift.invert != 0u);
 }
 
-fn tiltShift_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) -> vec4f {
-  vec4 color = vec4(0.0);
-  float total = 0.0;
+fn tiltShift_sampleColor(
+  sourceTexture: texture_2d<f32>,
+  sourceTextureSampler: sampler,
+  texSize: vec2f,
+  texCoord: vec2f
+) -> vec4f {
+  var color = vec4f(0.0);
+  var total = 0.0;
 
   /* randomize the lookup values to hide the fixed number of samples */
-  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);
+  let offset = random(vec3f(12.9898, 78.233, 151.7182), 0.0);
 
-  vec2 normal = normalize(vec2((tiltShift.start.y - tiltShift.end.y) * texSize.y, (tiltShift.end.x - tiltShift.start.x) * texSize.x));
-  float radius = smoothstep(0.0, 1.0,
-    abs(dot(texCoord * texSize - tiltShift.start * texSize, normal)) / tiltShift.gradientRadius) * tiltShift.blurRadius;
+  let normal = normalize(
+    vec2f(
+      (tiltShift.start.y - tiltShift.end.y) * texSize.y,
+      (tiltShift.end.x - tiltShift.start.x) * texSize.x
+    )
+  );
+  let radius =
+    smoothstep(
+      0.0,
+      1.0,
+      abs(dot(texCoord * texSize - tiltShift.start * texSize, normal)) / tiltShift.gradientRadius
+    ) * tiltShift.blurRadius;
 
-  for (float t = -30.0; t <= 30.0; t++) {
-    float percent = (t + offset - 0.5) / 30.0;
-    float weight = 1.0 - abs(percent);
-    vec4 offsetColor = texture(source, texCoord + tiltShift_getDelta(texSize) / texSize * percent * radius);
+  for (var t = -30.0; t <= 30.0; t += 1.0) {
+    let percent = (t + offset - 0.5) / 30.0;
+    let weight = 1.0 - abs(percent);
+    let offsetColor = textureSample(
+      sourceTexture,
+      sourceTextureSampler,
+      texCoord + tiltShift_getDelta(texSize) / texSize * percent * radius
+    );
 
     color += offsetColor * weight;
     total += weight;
   }
 
-  color = color / total;
+  color /= total;
   return color;
 }
 `;
 const fs = /* glsl */ `\
-uniform tiltShiftUniforms {
+layout(std140) uniform tiltShiftUniforms {
   float blurRadius;
   float gradientRadius;
   vec2 start;

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

@@ -1 +1 @@
-{"version":3,"file":"tiltshift.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-blur-filters/tiltshift.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAGpC,OAAO,EAAC,MAAM,EAAC,MAAM,sBAAsB,CAAC;AAE5C,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCrB,CAAC;AAqBF;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,IAAI,EAAE,WAAW;IACjB,YAAY,EAAE,CAAC,MAAM,CAAC;IACtB,MAAM;IACN,EAAE;IAEF,KAAK,EAAE,EAAoB;IAC3B,QAAQ,EAAE,EAAuB;IACjC,YAAY,EAAE;QACZ,UAAU,EAAE,KAAK;QACjB,cAAc,EAAE,KAAK;QACrB,KAAK,EAAE,WAAW;QAClB,GAAG,EAAE,WAAW;QAChB,MAAM,EAAE,KAAK;KACd;IACD,SAAS,EAAE;QACT,UAAU,EAAE,EAAC,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,EAAC;QACxC,cAAc,EAAE,EAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,EAAC;QAC9C,KAAK,EAAE,EAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAC;QACtB,GAAG,EAAE,EAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAC;QACpB,MAAM,EAAE,EAAC,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,IAAI,EAAC;KAClC;IAED,MAAM,EAAE;QACN,EAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAC,MAAM,EAAE,CAAC,EAAC,EAAC;QACtC,EAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAC,MAAM,EAAE,CAAC,EAAC,EAAC;KACvC;CAC4D,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;EAwBE"}
+{"version":3,"file":"tiltshift.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-blur-filters/tiltshift.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAGpC,OAAO,EAAC,MAAM,EAAC,MAAM,sBAAsB,CAAC;AAE5C,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyDzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCrB,CAAC;AAqBF;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,IAAI,EAAE,WAAW;IACjB,YAAY,EAAE,CAAC,MAAM,CAAC;IACtB,MAAM;IACN,EAAE;IAEF,KAAK,EAAE,EAAoB;IAC3B,QAAQ,EAAE,EAAuB;IACjC,YAAY,EAAE;QACZ,UAAU,EAAE,KAAK;QACjB,cAAc,EAAE,KAAK;QACrB,KAAK,EAAE,WAAW;QAClB,GAAG,EAAE,WAAW;QAChB,MAAM,EAAE,KAAK;KACd;IACD,SAAS,EAAE;QACT,UAAU,EAAE,EAAC,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,EAAC;QACxC,cAAc,EAAE,EAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,EAAC;QAC9C,KAAK,EAAE,EAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAC;QACtB,GAAG,EAAE,EAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAC;QACpB,MAAM,EAAE,EAAC,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,IAAI,EAAC;KAClC;IAED,MAAM,EAAE;QACN,EAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAC,MAAM,EAAE,CAAC,EAAC,EAAC;QACtC,EAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAC,MAAM,EAAE,CAAC,EAAC,EAAC;KACvC;CAC4D,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;EAwBE"}

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

@@ -21,11 +21,11 @@ export declare const triangleBlur: {
     readonly name: "triangleBlur";
     readonly dependencies: [{
         readonly name: "random";
-        readonly source: "fn random(scale: vec3f, seed: float) -> f32 {\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: "fn random(scale: vec3f, seed: f32) -> f32 {\n  return fract(sin(dot(scale + vec3f(seed), vec3f(12.9898, 78.233, 151.7182))) * 43758.5453 + seed);\n}\n";
         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: "uniform triangleBlurUniforms {\n  radius: f32,\n  delta: vec2f,\n}\n\n@group(0) @binding(1) var<uniform> triangleBlur: triangleBlurUniforms;\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: "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 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: "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.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"triangleblur.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-blur-filters/triangleblur.ts"],"names":[],"mappings":"AAiFA;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,0DAA0D;IAC1D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oCAAoC;IACpC,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,iBAAiB,CAAC;AAErD;;;;;GAKG;AACH,eAAO,MAAM,YAAY;;;;;;;;;oBAMV,iBAAiB;uBACd,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAc+B,CAAC"}
+{"version":3,"file":"triangleblur.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-blur-filters/triangleblur.ts"],"names":[],"mappings":"AA0FA;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,0DAA0D;IAC1D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oCAAoC;IACpC,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,iBAAiB,CAAC;AAErD;;;;;GAKG;AACH,eAAO,MAAM,YAAY;;;;;;;;;oBAMV,iBAAiB;uBACd,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAc+B,CAAC"}

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

@@ -3,44 +3,53 @@
 // Copyright (c) vis.gl contributors
 import { random } from '@luma.gl/shadertools';
 const source = /* wgsl */ `\
-uniform triangleBlurUniforms {
+struct triangleBlurUniforms {
   radius: f32,
   delta: vec2f,
-}
+};
 
-@group(0) @binding(1) var<uniform> triangleBlur: triangleBlurUniforms;
+@group(0) @binding(auto) var<uniform> triangleBlur: triangleBlurUniforms;
 
-vec4 triangleBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
-  vec2 adjustedDelta = triangleBlur.delta * triangleBlur.radius / texSize;
+fn triangleBlur_sampleColor(
+  sourceTexture: texture_2d<f32>,
+  sourceTextureSampler: sampler,
+  texSize: vec2f,
+  texCoord: vec2f
+) -> vec4f {
+  let adjustedDelta = triangleBlur.delta * triangleBlur.radius / texSize;
 
-  vec4 color = vec4(0.0);
-  float total = 0.0;
+  var color = vec4f(0.0);
+  var total = 0.0;
 
   /* randomize the lookup values to hide the fixed number of samples */
-  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);
+  let offset = random(vec3f(12.9898, 78.233, 151.7182), 0.0);
 
-  for (float t = -30.0; t <= 30.0; t++) {
-    float percent = (t + offset - 0.5) / 30.0;
-    float weight = 1.0 - abs(percent);
-    vec4 offsetColor = texture(source, texCoord + adjustedDelta * percent);
+  for (var t = -30.0; t <= 30.0; t += 1.0) {
+    let percent = (t + offset - 0.5) / 30.0;
+    let weight = 1.0 - abs(percent);
+    let offsetColor = textureSample(
+      sourceTexture,
+      sourceTextureSampler,
+      texCoord + adjustedDelta * percent
+    );
 
     /* switch to pre-multiplied alpha to correctly blur transparent images */
-    offsetColor.rgb *= offsetColor.a;
+    let premultipliedOffsetColor = vec4f(offsetColor.rgb * vec3f(offsetColor.a), offsetColor.a);
 
-    color += offsetColor * weight;
+    color += premultipliedOffsetColor * weight;
     total += weight;
   }
 
-  color = color / total;
+  color /= total;
 
   /* switch back from pre-multiplied alpha */
-  color.rgb /= color.a + 0.00001;
+  let unpremultipliedRgb = color.rgb / vec3f(color.a + 0.00001);
 
-  return color;
+  return vec4f(unpremultipliedRgb, color.a);
 }
 `;
 const fs = /* glsl */ `\
-uniform triangleBlurUniforms {
+layout(std140) uniform triangleBlurUniforms {
   float radius;
   vec2 delta;
 } triangleBlur;

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

@@ -1 +1 @@
-{"version":3,"file":"triangleblur.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-blur-filters/triangleblur.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAGpC,OAAO,EAAC,MAAM,EAAC,MAAM,sBAAsB,CAAC;AAE5C,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCrB,CAAC;AAiBF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,YAAY,EAAE,CAAC,MAAM,CAAC;IACtB,MAAM;IACN,EAAE;IAEF,KAAK,EAAE,EAAuB;IAC9B,QAAQ,EAAE,EAA0B;IACpC,YAAY,EAAE;QACZ,MAAM,EAAE,KAAK;QACb,KAAK,EAAE,WAAW;KACnB;IACD,SAAS,EAAE;QACT,MAAM,EAAE,EAAC,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,GAAG,EAAC;QACzC,KAAK,EAAE,EAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAC;KACtC;IAED,MAAM,EAAE;QACN,EAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAC,EAAC;QAC1C,EAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAC,EAAC;KAC3C;CACkE,CAAC"}
+{"version":3,"file":"triangleblur.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-blur-filters/triangleblur.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAGpC,OAAO,EAAC,MAAM,EAAC,MAAM,sBAAsB,CAAC;AAE5C,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6CzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCrB,CAAC;AAiBF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,YAAY,EAAE,CAAC,MAAM,CAAC;IACtB,MAAM;IACN,EAAE;IAEF,KAAK,EAAE,EAAuB;IAC9B,QAAQ,EAAE,EAA0B;IACpC,YAAY,EAAE;QACZ,MAAM,EAAE,KAAK;QACb,KAAK,EAAE,WAAW;KACnB;IACD,SAAS,EAAE;QACT,MAAM,EAAE,EAAC,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,GAAG,EAAC;QACzC,KAAK,EAAE,EAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAC;KACtC;IAED,MAAM,EAAE;QACN,EAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAC,EAAC;QAC1C,EAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAC,EAAC;KAC3C;CACkE,CAAC"}

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

@@ -16,11 +16,11 @@ export declare const zoomBlur: {
     readonly name: "zoomBlur";
     readonly dependencies: [{
         readonly name: "random";
-        readonly source: "fn random(scale: vec3f, seed: float) -> f32 {\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: "fn random(scale: vec3f, seed: f32) -> f32 {\n  return fract(sin(dot(scale + vec3f(seed), vec3f(12.9898, 78.233, 151.7182))) * 43758.5453 + seed);\n}\n";
         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: "\nuniform zoomBlurUniforms {\n  center: vec2f,\n  strength: f32,\n};\n\n@group(0) @binding(1) var<uniform> zoomBlur : zoomBlurUniforms;\n\n\nfn zoomBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) -> vec4f {\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: "\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 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: "\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.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zoomblur.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-blur-filters/zoomblur.ts"],"names":[],"mappings":"AAgEA;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,gDAAgD;IAChD,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1B,4JAA4J;IAC5J,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC;AAE7C;;;GAGG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;oBAMN,aAAa;uBACV,gBAAgB;;;;;;;;;;;;;;;;;;CAW2B,CAAC"}
+{"version":3,"file":"zoomblur.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-blur-filters/zoomblur.ts"],"names":[],"mappings":"AAyEA;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,gDAAgD;IAChD,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1B,4JAA4J;IAC5J,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC;AAE7C;;;GAGG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;oBAMN,aAAa;uBACV,gBAAgB;;;;;;;;;;;;;;;;;;CAW2B,CAAC"}