@luma.gl/effects 9.1.9 → 9.2.0-alpha.2

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

@@ -4,10 +4,14 @@
 // Do a 9x9 bilateral box filter
 const source = /* wgsl */ `\
 
-@group(?), @binding(?) var<uniform> denoiseUniforms {		strength: f32 } noise;
+struct denoiseUniforms {
+  strength: f32
+};
+
+@group(0), @binding(1) var<uniform> denoise: denoiseUniforms;
 
 fn denoise_sampleColor(source: sampler2D, texSize: vec2<f32>, texCoord: vec2<f32>) -> vec4<f32> {
-	let adjustedExponent: f32 = 3. + 200. * pow(1. - noise.strength, 4.);
+	let adjustedExponent: f32 = 3. + 200. * pow(1. - denoise.strength, 4.);
 	let center: vec4<f32> = sample_texture(BUFFER_source, texCoord);
 	var color: vec4<f32> = vec4<f32>(0.);
 	var total: f32 = 0.;
@@ -28,11 +32,11 @@ fn denoise_sampleColor(source: sampler2D, texSize: vec2<f32>, texCoord: vec2<f32
 } 
 `;
 const fs = /* glsl */ `\
-uniform denoiseUniforms {
+uniform dedenoiseUniforms {
   float strength;
-} noise;
+} denoise;
 
-vec4 denoise_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
+vec4 dedenoise_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   float adjustedExponent = 3. + 200. * pow(1. - noise.strength, 4.);
 
   vec4 center = texture(source, texCoord);

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

@@ -1 +1 @@
-{"version":3,"file":"denoise.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/denoise.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,gCAAgC;AAChC,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;CAwBzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;CAuBrB,CAAC;AAkBF;;;;GAIG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,KAAK,EAAE,EAAkB;IACzB,QAAQ,EAAE,EAAqB;IAE/B,IAAI,EAAE,SAAS;IACf,YAAY,EAAE;QACZ,QAAQ,EAAE,KAAK;KAChB;IACD,SAAS,EAAE;QACT,QAAQ,EAAE,EAAC,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAC;QACrD,0HAA0H;KAC3H;IAED,MAAM;IACN,EAAE;IAEF,MAAM,EAAE,CAAC,EAAC,OAAO,EAAE,IAAI,EAAC,EAAE,EAAC,OAAO,EAAE,IAAI,EAAC,CAAC;CACkB,CAAC"}
+{"version":3,"file":"denoise.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/denoise.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,gCAAgC;AAChC,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;CAuBrB,CAAC;AAkBF;;;;GAIG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,KAAK,EAAE,EAAkB;IACzB,QAAQ,EAAE,EAAqB;IAE/B,IAAI,EAAE,SAAS;IACf,YAAY,EAAE;QACZ,QAAQ,EAAE,KAAK;KAChB;IACD,SAAS,EAAE;QACT,QAAQ,EAAE,EAAC,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAC;QACrD,0HAA0H;KAC3H;IAED,MAAM;IACN,EAAE;IAEF,MAAM,EAAE,CAAC,EAAC,OAAO,EAAE,IAAI,EAAC,EAAE,EAAC,OAAO,EAAE,IAAI,EAAC,CAAC;CACkB,CAAC"}

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

@@ -21,7 +21,7 @@ export type HueSaturationUniforms = HueSaturationProps;
 export declare const hueSaturation: {
     readonly props: HueSaturationProps;
     readonly name: "hueSaturation";
-    readonly source: "@group(?), @binding(?)\nvar<uniform> hueSaturationUniforms {\t\thue: f32,\n\n\t\tsaturation: f32,\n\n}hueSaturation;\n\nfn hueSaturation_filterColor(color: vec4<f32>) -> vec4<f32> {\n\tlet angle: f32 = hueSaturation.hue * 3.1415927;\n\tlet s: f32 = sin(angle);\n\tlet c: f32 = cos(angle);\n\tlet weights: vec3<f32> = (vec3<f32>(2. * c, -sqrt(3.) * s - c, sqrt(3.) * s - c) + 1.) / 3.;\n\tlet len: f32 = length(color.rgb);\n\tvar colorrgb = color.rgb;\n\tcolorrgb = vec3<f32>(dot(color.rgb, weights.xyz), dot(color.rgb, weights.zxy), dot(color.rgb, weights.yzx));\n\tcolor.r = colorrgb.x;\n\tcolor.g = colorrgb.y;\n\tcolor.b = colorrgb.z;\n\tlet average: f32 = (color.r + color.g + color.b) / 3.;\n\tif (hueSaturation.saturation > 0.) {\n\t\tvar colorrgb = color.rgb;\n\tcolorrgb = color.rgb + ((average - color.rgb) * (1. - 1. / (1.001 - hueSaturation.saturation)));\n\tcolor.r = colorrgb.x;\n\tcolor.g = colorrgb.y;\n\tcolor.b = colorrgb.z;\n\t} else { \n\t\tvar colorrgb = color.rgb;\n\tcolorrgb = color.rgb + ((average - color.rgb) * -hueSaturation.saturation);\n\tcolor.r = colorrgb.x;\n\tcolor.g = colorrgb.y;\n\tcolor.b = colorrgb.z;\n\t}\n\treturn color;\n} \n\nfn hueSaturation_filterColor_ext(color: vec4<f32>, texSize: vec2<f32>, texCoord: vec2<f32>) -> vec4<f32> {\n\treturn hueSaturation_filterColor(color);\n} \n";
+    readonly source: "\nstruct hueSaturationUniforms {\n  hue: f32,\n  saturation: f32,\n};\n\n@group(0), @binding(1) var<uniform> hueSaturation: hueSaturationUniforms;\n\nfn hueSaturation_filterColor(color: vec4<f32>) -> vec4<f32> {\n\tlet angle: f32 = hueSaturation.hue * 3.1415927;\n\tlet s: f32 = sin(angle);\n\tlet c: f32 = cos(angle);\n\tlet weights: vec3<f32> = (vec3<f32>(2. * c, -sqrt(3.) * s - c, sqrt(3.) * s - c) + 1.) / 3.;\n\tlet len: f32 = length(color.rgb);\n\tvar colorrgb = color.rgb;\n\tcolorrgb = vec3<f32>(dot(color.rgb, weights.xyz), dot(color.rgb, weights.zxy), dot(color.rgb, weights.yzx));\n\tcolor.r = colorrgb.x;\n\tcolor.g = colorrgb.y;\n\tcolor.b = colorrgb.z;\n\tlet average: f32 = (color.r + color.g + color.b) / 3.;\n\tif (hueSaturation.saturation > 0.) {\n\t\tvar colorrgb = color.rgb;\n\tcolorrgb = color.rgb + ((average - color.rgb) * (1. - 1. / (1.001 - hueSaturation.saturation)));\n\tcolor.r = colorrgb.x;\n\tcolor.g = colorrgb.y;\n\tcolor.b = colorrgb.z;\n\t} else { \n\t\tvar colorrgb = color.rgb;\n\tcolorrgb = color.rgb + ((average - color.rgb) * -hueSaturation.saturation);\n\tcolor.r = colorrgb.x;\n\tcolor.g = colorrgb.y;\n\tcolor.b = colorrgb.z;\n\t}\n\treturn color;\n} \n\nfn hueSaturation_filterColor_ext(color: vec4<f32>, texSize: vec2<f32>, texCoord: vec2<f32>) -> vec4<f32> {\n\treturn 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 uniformTypes: {
         readonly hue: "f32";

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

@@ -1 +1 @@
-{"version":3,"file":"huesaturation.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/huesaturation.ts"],"names":[],"mappings":"AAiFA;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B;iEAC6D;IAC7D,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,4EAA4E;IAC5E,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,kBAAkB,CAAC;AAEvD;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa;oBACX,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;CAekB,CAAC"}
+{"version":3,"file":"huesaturation.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/huesaturation.ts"],"names":[],"mappings":"AAkFA;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B;iEAC6D;IAC7D,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,4EAA4E;IAC5E,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,kBAAkB,CAAC;AAEvD;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa;oBACX,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;CAekB,CAAC"}

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

@@ -2,12 +2,13 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 const source = /* wgsl */ `\
-@group(?), @binding(?)
-var<uniform> hueSaturationUniforms {		hue: f32,
 
-		saturation: f32,
+struct hueSaturationUniforms {
+  hue: f32,
+  saturation: f32,
+};
 
-}hueSaturation;
+@group(0), @binding(1) var<uniform> hueSaturation: hueSaturationUniforms;
 
 fn hueSaturation_filterColor(color: vec4<f32>) -> vec4<f32> {
 	let angle: f32 = hueSaturation.hue * 3.1415927;

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCzB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

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

@@ -11,9 +11,11 @@ export type NoiseUniforms = NoiseProps;
  * Adds black and white noise to the image.
  */
 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 props: NoiseProps;
     readonly uniforms: NoiseUniforms;
-    readonly name: "noise";
     readonly uniformTypes: {
         readonly amount: "f32";
     };
@@ -24,8 +26,6 @@ export declare const noise: {
             readonly max: 1;
         };
     };
-    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(0) var<uniform> noise: NoiseUniforms;\n\nfn rand(co: vec2<f32>) -> f32 {\n\treturn fract(sin(dot(co.xy, vec2<f32>(12.9898, 78.233))) * 43758.547);\n} \n\nfn noise_filterColor_ext(color: vec4<f32>, texSize: vec2<f32>, texCoord: vec2<f32>) -> vec4<f32> {\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 passes: [{
         readonly filter: true;
     }];

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;oBACH,UAAU;uBACP,aAAa;;;;;;;;;;;;;;;;;CAYwB,CAAC"}
+{"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"}

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

@@ -6,13 +6,13 @@ struct noiseUniforms {
   amount: f32
 };
 
-@group(0), @binding(0) var<uniform> noise: NoiseUniforms;
+@group(0) @binding(1) var<uniform> noise: noiseUniforms;
 
-fn rand(co: vec2<f32>) -> f32 {
-	return fract(sin(dot(co.xy, vec2<f32>(12.9898, 78.233))) * 43758.547);
+fn rand(co: vec2f) -> f32 {
+	return fract(sin(dot(co.xy, vec2f(12.9898, 78.233))) * 43758.547);
 } 
 
-fn noise_filterColor_ext(color: vec4<f32>, texSize: vec2<f32>, texCoord: vec2<f32>) -> vec4<f32> {
+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);
@@ -42,17 +42,17 @@ vec4 noise_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
  * Adds black and white noise to the image.
  */
 export const noise = {
+    name: 'noise',
+    fs,
+    source,
     props: {},
     uniforms: {},
-    name: 'noise',
     uniformTypes: {
         amount: 'f32'
     },
     propTypes: {
         amount: { value: 0.5, min: 0, max: 1 }
     },
-    fs,
-    source,
     passes: [{ filter: true }]
 };
 //# sourceMappingURL=noise.js.map

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,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":"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"}

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

@@ -22,6 +22,7 @@ export declare const sepia: {
         };
     };
     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 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":"AA6BA,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;;;;;;;;;;;;;;;;CAWwB,CAAC"}
+{"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"}

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

@@ -1,6 +1,30 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
+const source = /* wgsl */ `\
+struct sepiaUniforms {
+  amount: f32
+};
+
+@group(0) @binding(1) 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;
+
+  color.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))));
+
+  return color;
+}
+
+vec4 sepia_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
+  return sepia_filterColor(color);
+}
+`;
 const fs = /* glsl */ `\
 uniform sepiaUniforms {
   float amount;
@@ -39,6 +63,7 @@ export const sepia = {
         amount: { value: 0.5, min: 0, max: 1 }
     },
     fs,
+    source,
     passes: [{ filter: true }]
 };
 //# sourceMappingURL=sepia.js.map

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,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,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;;;;;;;;;;;;;;;;;;;;;;;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"}

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

@@ -21,6 +21,7 @@ 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 passes: [{
         readonly filter: true;

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

@@ -1 +1 @@
-{"version":3,"file":"vibrance.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/vibrance.ts"],"names":[],"mappings":"AAwBA;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,kFAAkF;IAClF,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC;AAE7C,qGAAqG;AACrG,eAAO,MAAM,QAAQ;oBACN,aAAa;uBACV,gBAAgB;;;;;;;;;;;;;;;;CAU2B,CAAC"}
+{"version":3,"file":"vibrance.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/vibrance.ts"],"names":[],"mappings":"AA4CA;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,kFAAkF;IAClF,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC;AAE7C,qGAAqG;AACrG,eAAO,MAAM,QAAQ;oBACN,aAAa;uBACV,gBAAgB;;;;;;;;;;;;;;;;;CAW2B,CAAC"}

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

@@ -1,6 +1,25 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
+const source = /* wgsl */ `\
+struct vibranceUniforms {
+  amount: f32
+};
+
+@group(0) @binding(1) 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;
+}
+
+vec4 vibrance_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
+  return vibrance_filterColor(color);
+}
+`;
 const fs = /* glsl */ `\
 uniform vibranceUniforms {
   float amount;
@@ -29,6 +48,7 @@ export const vibrance = {
     propTypes: {
         amount: { value: 0, min: -1, max: 1 }
     },
+    source,
     fs,
     passes: [{ filter: true }]
 };

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

@@ -1 +1 @@
-{"version":3,"file":"vibrance.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/vibrance.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;CAgBrB,CAAC;AAYF,qGAAqG;AACrG,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,KAAK,EAAE,EAAmB;IAC1B,QAAQ,EAAE,EAAsB;IAChC,IAAI,EAAE,UAAU;IAChB,YAAY,EAAE;QACZ,MAAM,EAAE,KAAK;KACd;IACD,SAAS,EAAE;QACT,MAAM,EAAE,EAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAC;KACpC;IACD,EAAE;IACF,MAAM,EAAE,CAAC,EAAC,MAAM,EAAE,IAAI,EAAC,CAAC;CACmC,CAAC"}
+{"version":3,"file":"vibrance.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/vibrance.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,qGAAqG;AACrG,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,KAAK,EAAE,EAAmB;IAC1B,QAAQ,EAAE,EAAsB;IAChC,IAAI,EAAE,UAAU;IAChB,YAAY,EAAE;QACZ,MAAM,EAAE,KAAK;KACd;IACD,SAAS,EAAE;QACT,MAAM,EAAE,EAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAC;KACpC;IACD,MAAM;IACN,EAAE;IACF,MAAM,EAAE,CAAC,EAAC,MAAM,EAAE,IAAI,EAAC,CAAC;CACmC,CAAC"}

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

@@ -39,6 +39,6 @@ export declare const vignette: {
     readonly passes: [{
         readonly filter: true;
     }];
-    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: "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";
 };
 //# sourceMappingURL=vignette.d.ts.map

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":"AAmBA;;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":"AA6BA;;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

@@ -1,16 +1,26 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-const fs = /* glsl */ `\
-uniform vignetteUniforms {
-  float radius;
-  float amount;
-} vignette;
+const fs = /* wgsl */ `\
+struct vignetteUniforms {
+  radius: f32,
+  amount: f32
+};
+
+@group(0) @binding(1) 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;
+}
 
-vec4 vignette_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
-  float dist = distance(texCoord, vec2(0.5, 0.5));
-  float ratio = smoothstep(0.8, vignette.radius * 0.799, dist * (vignette.amount + vignette.radius));
-  return color.rgba * ratio + (1.0 - ratio)*vec4(0.0, 0.0, 0.0, 1.0);
+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);
 }
 `;
 /**

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,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;IAEhB,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;IAExB,EAAE;CACyD,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,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;CAqBrB,CAAC;AAcF;;;GAGG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,KAAK,EAAE,EAAmB;IAC1B,QAAQ,EAAE,EAAsB;IAEhC,IAAI,EAAE,UAAU;IAEhB,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;IAExB,EAAE;CACyD,CAAC"}

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

@@ -27,13 +27,16 @@ export type TiltShiftUniforms = TiltShiftProps;
  * on the line and increases further from the line.
  */
 export declare const tiltShift: {
-    readonly props: TiltShiftProps;
-    readonly uniforms: TiltShiftUniforms;
     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 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    /* 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 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\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: TiltShiftProps;
+    readonly uniforms: TiltShiftUniforms;
     readonly uniformTypes: {
         readonly blurRadius: "f32";
         readonly gradientRadius: "f32";
@@ -74,6 +77,5 @@ export declare const tiltShift: {
             readonly invert: 1;
         };
     }];
-    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\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";
 };
 //# sourceMappingURL=tiltshift.d.ts.map

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":"AAqDA;;;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;oBACP,cAAc;uBACX,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuB4B,CAAC"}
+{"version":3,"file":"tiltshift.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-blur-filters/tiltshift.ts"],"names":[],"mappings":"AAqGA;;;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

@@ -2,6 +2,53 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 import { random } from '@luma.gl/shadertools';
+const source = /* wgsl */ `\
+uniform tiltShiftUniforms {
+  blurRadius: f32,
+  gradientRadius: f32,
+  start: vec2f,
+  end: vec2f,
+  invert: u32,
+};
+
+@group(0) @binding(1) 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_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) -> vec4f {
+  vec4 color = vec4(0.0);
+  float 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);
+
+  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;
+
+  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);
+
+    /* switch to pre-multiplied alpha to correctly blur transparent images */
+    offsetColor.rgb *= offsetColor.a;
+
+    color += offsetColor * weight;
+    total += weight;
+  }
+
+  color = color / total;
+
+  /* switch back from pre-multiplied alpha */
+  color.rgb /= color.a + 0.00001;
+
+  return color;
+}
+`;
 const fs = /* glsl */ `\
 uniform tiltShiftUniforms {
   float blurRadius;
@@ -59,10 +106,12 @@ vec4 tiltShift_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
  * on the line and increases further from the line.
  */
 export const tiltShift = {
-    props: {},
-    uniforms: {},
     name: 'tiltShift',
     dependencies: [random],
+    source,
+    fs,
+    props: {},
+    uniforms: {},
     uniformTypes: {
         blurRadius: 'f32',
         gradientRadius: 'f32',
@@ -80,8 +129,7 @@ export const tiltShift = {
     passes: [
         { sampler: true, uniforms: { invert: 0 } },
         { sampler: true, uniforms: { invert: 1 } }
-    ],
-    fs
+    ]
 };
 /*
 function tiltShift(startX, startY, endX, endY, blurRadius, gradientRadius) {

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,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4CrB,CAAC;AAqBF;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,KAAK,EAAE,EAAoB;IAC3B,QAAQ,EAAE,EAAuB;IAEjC,IAAI,EAAE,WAAW;IACjB,YAAY,EAAE,CAAC,MAAM,CAAC;IACtB,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;IACD,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;IACD,EAAE;CAC2D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8CzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4CrB,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

@@ -18,9 +18,16 @@ export type TriangleBlurUniforms = TriangleBlurProps;
  *               perpendicular triangle filters.
  */
 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 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 props: TriangleBlurProps;
     readonly uniforms: TriangleBlurUniforms;
-    readonly name: "triangleBlur";
     readonly uniformTypes: {
         readonly radius: "f32";
         readonly delta: "vec2<f32>";
@@ -36,11 +43,6 @@ export declare const triangleBlur: {
             readonly private: true;
         };
     };
-    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 dependencies: [{
-        readonly name: "random";
-        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 passes: [{
         readonly sampler: true;
         readonly uniforms: {

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":"AA2CA;;;;;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;oBACV,iBAAiB;uBACd,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiB+B,CAAC"}
+{"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"}

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

@@ -2,6 +2,43 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 import { random } from '@luma.gl/shadertools';
+const source = /* wgsl */ `\
+uniform triangleBlurUniforms {
+  radius: f32,
+  delta: vec2f,
+}
+
+@group(0) @binding(1) var<uniform> triangleBlur: triangleBlurUniforms;
+
+vec4 triangleBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
+  vec2 adjustedDelta = triangleBlur.delta * triangleBlur.radius / texSize;
+
+  vec4 color = vec4(0.0);
+  float 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);
+
+  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);
+
+    /* switch to pre-multiplied alpha to correctly blur transparent images */
+    offsetColor.rgb *= offsetColor.a;
+
+    color += offsetColor * weight;
+    total += weight;
+  }
+
+  color = color / total;
+
+  /* switch back from pre-multiplied alpha */
+  color.rgb /= color.a + 0.00001;
+
+  return color;
+}
+`;
 const fs = /* glsl */ `\
 uniform triangleBlurUniforms {
   float radius;
@@ -44,9 +81,12 @@ vec4 triangleBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
  *               perpendicular triangle filters.
  */
 export const triangleBlur = {
+    name: 'triangleBlur',
+    dependencies: [random],
+    source,
+    fs,
     props: {},
     uniforms: {},
-    name: 'triangleBlur',
     uniformTypes: {
         radius: 'f32',
         delta: 'vec2<f32>'
@@ -55,8 +95,6 @@ export const triangleBlur = {
         radius: { value: 20, min: 0, softMax: 100 },
         delta: { value: [1, 0], private: true }
     },
-    fs,
-    dependencies: [random],
     passes: [
         { sampler: true, uniforms: { delta: [1, 0] } },
         { sampler: true, uniforms: { delta: [0, 1] } }

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,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCrB,CAAC;AAiBF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,KAAK,EAAE,EAAuB;IAC9B,QAAQ,EAAE,EAA0B;IAEpC,IAAI,EAAE,cAAc;IACpB,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;IACD,EAAE;IACF,YAAY,EAAE,CAAC,MAAM,CAAC;IACtB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}