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

package/dist/index.cjs

@@ -47,21 +47,21 @@ module.exports = __toCommonJS(dist_exports);
 var source = (
   /* wgsl */
   `struct brightnessContrastUniforms {
-  float brightness;
-  float contrast;
+  brightness: f32,
+  contrast: f32
 };
 
 // Binding 0:1 is reserved for shader passes
-@binding(1) @group(0) var<uniform> brightnessContrast : brightnessContrastUniforms;
+@group(0) @binding(1) var<uniform> brightnessContrast : brightnessContrastUniforms;
 
-fn brightnessContrast_filterColor_ext(color: vec4<f32>, texSize: vec2<f32>, texCoords: vec2<f32>) -> vec4<f32> {
+fn brightnessContrast_filterColor_ext(color: vec4f, texSize: vec2<f32>, texCoords: vec2<f32>) -> vec4f {
   color.rgb += brightnessContrast.brightness;
   if (brightnessContrast.contrast > 0.0) {
     color.rgb = (color.rgb - 0.5) / (1.0 - brightnessContrast.contrast) + 0.5;
   } else {
     color.rgb = (color.rgb - 0.5) * (1.0 + brightnessContrast.contrast) + 0.5;
   }
-  return color;
+  return vec4f(1.0, 0.0, 0.0, 1.0);
 }
 `
 );
@@ -88,8 +88,10 @@ vec4 brightnessContrast_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord)
 `
 );
 var brightnessContrast = {
-  props: {},
   name: "brightnessContrast",
+  source,
+  fs,
+  props: {},
   uniformTypes: {
     brightness: "f32",
     contrast: "f32"
@@ -102,19 +104,21 @@ var brightnessContrast = {
     brightness: { format: "f32", value: 0, min: -1, max: 1 },
     contrast: { format: "f32", value: 0, min: -1, max: 1 }
   },
-  passes: [{ filter: true }],
-  source,
-  fs
+  passes: [{ filter: true }]
 };
 
 // dist/passes/postprocessing/image-adjust-filters/denoise.js
 var source2 = (
   /* 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.;
@@ -137,11 +141,11 @@ fn denoise_sampleColor(source: sampler2D, texSize: vec2<f32>, texCoord: vec2<f32
 );
 var fs2 = (
   /* 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);
@@ -180,12 +184,13 @@ var denoise = {
 // dist/passes/postprocessing/image-adjust-filters/huesaturation.js
 var source3 = (
   /* 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;
@@ -278,13 +283,13 @@ var source4 = (
   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);
@@ -313,21 +318,47 @@ vec4 noise_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
 `
 );
 var noise = {
+  name: "noise",
+  fs: fs4,
+  source: source4,
   props: {},
   uniforms: {},
-  name: "noise",
   uniformTypes: {
     amount: "f32"
   },
   propTypes: {
     amount: { value: 0.5, min: 0, max: 1 }
   },
-  fs: fs4,
-  source: source4,
   passes: [{ filter: true }]
 };
 
 // dist/passes/postprocessing/image-adjust-filters/sepia.js
+var source5 = (
+  /* 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);
+}
+`
+);
 var fs5 = (
   /* glsl */
   `uniform sepiaUniforms {
@@ -363,10 +394,32 @@ var sepia = {
     amount: { value: 0.5, min: 0, max: 1 }
   },
   fs: fs5,
+  source: source5,
   passes: [{ filter: true }]
 };
 
 // dist/passes/postprocessing/image-adjust-filters/vibrance.js
+var source6 = (
+  /* 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);
+}
+`
+);
 var fs6 = (
   /* glsl */
   `uniform vibranceUniforms {
@@ -396,22 +449,33 @@ var vibrance = {
   propTypes: {
     amount: { value: 0, min: -1, max: 1 }
   },
+  source: source6,
   fs: fs6,
   passes: [{ filter: true }]
 };
 
 // dist/passes/postprocessing/image-adjust-filters/vignette.js
 var fs7 = (
-  /* glsl */
-  `uniform vignetteUniforms {
-  float radius;
-  float amount;
-} vignette;
+  /* 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);
 }
 `
 );
@@ -437,6 +501,55 @@ var vignette = {
 
 // dist/passes/postprocessing/image-blur-filters/tiltshift.js
 var import_shadertools = require("@luma.gl/shadertools");
+var source7 = (
+  /* 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;
+}
+`
+);
 var fs8 = (
   /* glsl */
   `uniform tiltShiftUniforms {
@@ -485,10 +598,12 @@ vec4 tiltShift_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
 `
 );
 var tiltShift = {
-  props: {},
-  uniforms: {},
   name: "tiltShift",
   dependencies: [import_shadertools.random],
+  source: source7,
+  fs: fs8,
+  props: {},
+  uniforms: {},
   uniformTypes: {
     blurRadius: "f32",
     gradientRadius: "f32",
@@ -506,12 +621,50 @@ var tiltShift = {
   passes: [
     { sampler: true, uniforms: { invert: 0 } },
     { sampler: true, uniforms: { invert: 1 } }
-  ],
-  fs: fs8
+  ]
 };
 
 // dist/passes/postprocessing/image-blur-filters/triangleblur.js
 var import_shadertools2 = require("@luma.gl/shadertools");
+var source8 = (
+  /* 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;
+}
+`
+);
 var fs9 = (
   /* glsl */
   `uniform triangleBlurUniforms {
@@ -550,9 +703,12 @@ vec4 triangleBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
 `
 );
 var triangleBlur = {
+  name: "triangleBlur",
+  dependencies: [import_shadertools2.random],
+  source: source8,
+  fs: fs9,
   props: {},
   uniforms: {},
-  name: "triangleBlur",
   uniformTypes: {
     radius: "f32",
     delta: "vec2<f32>"
@@ -561,8 +717,6 @@ var triangleBlur = {
     radius: { value: 20, min: 0, softMax: 100 },
     delta: { value: [1, 0], private: true }
   },
-  fs: fs9,
-  dependencies: [import_shadertools2.random],
   passes: [
     { sampler: true, uniforms: { delta: [1, 0] } },
     { sampler: true, uniforms: { delta: [0, 1] } }
@@ -571,7 +725,49 @@ var triangleBlur = {
 
 // dist/passes/postprocessing/image-blur-filters/zoomblur.js
 var import_shadertools3 = require("@luma.gl/shadertools");
-var fs10 = `
+var source9 = (
+  /* wgsl */
+  `
+uniform zoomBlurUniforms {
+  center: vec2f,
+  strength: f32,
+};
+
+@group(0) @binding(1) var<uniform> zoomBlur : zoomBlurUniforms;
+
+
+fn zoomBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) -> vec4f {
+  vec4 color = vec4(0.0);
+  float total = 0.0;
+  vec2 toCenter = zoomBlur.center * texSize - texCoord * texSize;
+
+  /* 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 = 0.0; t <= 40.0; t++) {
+    float percent = (t + offset) / 40.0;
+    float weight = 4.0 * (percent - percent * percent);
+    vec4 offsetColor = texture(source, texCoord + toCenter * percent * zoomBlur.strength / texSize);
+
+    /* 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;
+}
+`
+);
+var fs10 = (
+  /* glsl */
+  `
 uniform zoomBlurUniforms {
   vec2 center;
   float strength;
@@ -604,11 +800,15 @@ vec4 zoomBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
 
   return color;
 }
-`;
+`
+);
 var zoomBlur = {
+  name: "zoomBlur",
+  dependencies: [import_shadertools3.random],
+  source: source9,
+  fs: fs10,
   props: {},
   uniforms: {},
-  name: "zoomBlur",
   uniformTypes: {
     center: "vec2<f32>",
     strength: "f32"
@@ -617,12 +817,50 @@ var zoomBlur = {
     center: { value: [0.5, 0.5] },
     strength: { value: 0.3, min: 0, softMax: 1 }
   },
-  fs: fs10,
-  dependencies: [import_shadertools3.random],
   passes: [{ sampler: true }]
 };
 
 // dist/passes/postprocessing/image-fun-filters/colorhalftone.js
+var source10 = (
+  /* wgsl */
+  `struct colorHalftoneUniforms {
+  center: vec2f,
+  angle: f32,
+  size: f32.
+};
+
+@group(0) @binding(1) var<uniform> colorHalftone: colorHalftoneUniforms;
+
+fn pattern(angle: f32, scale: f32, texSize: vec2f, texCoord: vec2f) -> f32 {
+  let s: f32 = sin(angle), c = cos(angle);
+  let tex: vec2f = texCoord * texSize - colorHalftone.center * texSize;
+  let point: vec2f = vec2(
+	  c * tex.x - s * tex.y,
+	  s * tex.x + c * tex.y
+  ) * scale;
+  return (sin(point.x) * sin(point.y)) * 4.0;
+}
+
+fn colorHalftone_filterColor_ext(vec4f color, vec2f texSize, vec2f texCoord) -> vec4f {
+  let scale: f32 = 3.1514 / colorHalftone.size;
+  let cmy: vec3f = 1.0 - color.rgb;
+  let k: f32 = min(cmy.x, min(cmy.y, cmy.z));
+
+  cmy = (cmy - k) / (1.0 - k);
+  cmy = clamp(
+	  cmy * 10.0 - 3.0 + vec3(
+      pattern(colorHalftone.angle + 0.26179, scale, texSize, texCoord),
+	    pattern(colorHalftone.angle + 1.30899, scale, texSize, texCoord),
+      pattern(colorHalftone.angle, scale, texSize, texCoord)
+    ),
+	  0.0,
+	  1.0
+  );
+  k = clamp(k * 10.0 - 5.0 + pattern(colorHalftone.angle + 0.78539, scale, texSize, texCoord), 0.0, 1.0);
+  return vec4(1.0 - cmy - k, color.a);
+}
+`
+);
 var fs11 = (
   /* glsl */
   `uniform colorHalftoneUniforms {
@@ -662,9 +900,11 @@ vec4 colorHalftone_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
 `
 );
 var colorHalftone = {
+  name: "colorHalftone",
+  source: source10,
+  fs: fs11,
   props: {},
   uniforms: {},
-  name: "colorHalftone",
   uniformTypes: {
     center: "vec2<f32>",
     angle: "f32",
@@ -675,11 +915,38 @@ var colorHalftone = {
     angle: { value: 1.1, softMin: 0, softMax: Math.PI / 2 },
     size: { value: 4, min: 1, softMin: 3, softMax: 20 }
   },
-  fs: fs11,
   passes: [{ filter: true }]
 };
 
 // dist/passes/postprocessing/image-fun-filters/dotscreen.js
+var source11 = (
+  /* wgsl */
+  `uniform dotScreenUniforms {
+  center: vec2f,
+  angle: f32,
+  size: f32,
+};
+
+@group(0) @binding(1) dotScreen: dotScreenUniforms;
+
+fn pattern(texSize: vec2f, texCoord: vec2f) -> f32 {
+  let scale: f32 = 3.1415 / dotScreen.size;
+
+  let s: f32 = sin(dotScreen.angle), c = cos(dotScreen.angle);
+  tex: vec2f = texCoord * texSize - dotScreen.center * texSize;
+  point = vec2f( 
+    c: * tex.x - s * tex.y,
+    s * tex.x + c * tex.y
+  ) * scale;
+  return (sin(point.x) * sin(point.y)) * 4.0;
+}
+
+fn dotScreen_filterColor_ext(vec4 color, texSize: vec2f, texCoord: vec2f) -> vec4f {
+  let average: f32 = (color.r + color.g + color.b) / 3.0;
+  return vec4(vec3(average * 10.0 - 5.0 + pattern(texSize, texCoord)), color.a);
+}
+`
+);
 var fs12 = (
   /* glsl */
   `uniform dotScreenUniforms {
@@ -707,9 +974,11 @@ vec4 dotScreen_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
 `
 );
 var dotScreen = {
+  name: "dotScreen",
+  source: source11,
+  fs: fs12,
   props: {},
   uniforms: {},
-  name: "dotScreen",
   uniformTypes: {
     center: "vec2<f32>",
     angle: "f32",
@@ -720,12 +989,46 @@ var dotScreen = {
     angle: { value: 1.1, softMin: 0, softMax: Math.PI / 2 },
     size: { value: 3, min: 1, softMin: 3, softMax: 20 }
   },
-  fs: fs12,
   passes: [{ filter: true }]
 };
 
 // dist/passes/postprocessing/image-fun-filters/edgework.js
 var import_shadertools4 = require("@luma.gl/shadertools");
+var source12 = (
+  /* wgsl */
+  `struct edgeWorkUniforms {
+  radius: f32,
+  int mode: uint32,
+};
+
+@group(0) @binding(1) var<uniform> edgeWork: edgeWorkUniforms;
+
+fn edgeWork_sampleColorRGB(sampler2D source, vec2 texSize, vec2 texCoord, vec2 delta) -> vec4f {
+  vec2 relativeDelta = edgeWork.radius * delta / texSize;
+
+  vec2 color = vec2(0.0);
+  vec2 total = vec2(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);
+    vec3 sampleColor = texture(source, texCoord + relativeDelta * percent).rgb;
+    float average = (sampleColor.r + sampleColor.g + sampleColor.b) / 3.0;
+    color.x += average * weight;
+    total.x += weight;
+    if (abs(t) < 15.0) {
+      weight = weight * 2.0 - 1.0;
+      color.y += average * weight;
+      total.y += weight;
+    }
+  }
+  return vec4(color / total, 0.0, 1.0);
+}
+`
+);
 var fs13 = (
   /* glsl */
   `uniform edgeWorkUniforms {
@@ -795,11 +1098,12 @@ vec4 edgeWork_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
 `
 );
 var edgeWork = {
-  props: {},
-  uniforms: {},
   name: "edgeWork",
   dependencies: [import_shadertools4.random],
+  source: source12,
   fs: fs13,
+  props: {},
+  uniforms: {},
   uniformTypes: {
     radius: "f32",
     mode: "i32"
@@ -821,6 +1125,54 @@ var edgeWork = {
 };
 
 // dist/passes/postprocessing/image-fun-filters/hexagonalpixelate.js
+var source13 = (
+  /* wgsl */
+  `struct hexagonalPixelateUniforms {
+  center: vec2f,
+  scale: f32,
+};
+
+@group(0) @binding(1) var<uniform> hexagonalPixelate: hexagonalPixelateUniforms;
+
+fn hexagonalPixelate_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) -> vec4f {
+  vec2 tex = (texCoord * texSize - hexagonalPixelate.center * texSize) / hexagonalPixelate.scale;
+  tex.y /= 0.866025404;
+  tex.x -= tex.y * 0.5;
+
+  vec2 a;
+  if (tex.x + tex.y - floor(tex.x) - floor(tex.y) < 1.0) {
+    a = vec2(floor(tex.x), floor(tex.y));
+  }
+  else a = vec2(ceil(tex.x), ceil(tex.y));
+  vec2 b = vec2(ceil(tex.x), floor(tex.y));
+  vec2 c = vec2(floor(tex.x), ceil(tex.y));
+
+  vec3 TEX = vec3(tex.x, tex.y, 1.0 - tex.x - tex.y);
+  vec3 A = vec3(a.x, a.y, 1.0 - a.x - a.y);
+  vec3 B = vec3(b.x, b.y, 1.0 - b.x - b.y);
+  vec3 C = vec3(c.x, c.y, 1.0 - c.x - c.y);
+
+  float alen = length(TEX - A);
+  float blen = length(TEX - B);
+  float clen = length(TEX - C);
+
+  vec2 choice;
+  if (alen < blen) {
+    if (alen < clen) choice = a;
+    else choice = c;
+  } else {
+    if (blen < clen) choice = b;
+    else choice = c;
+  }
+
+  choice.x += choice.y * 0.5;
+  choice.y *= 0.866025404;
+  choice *= hexagonalPixelate.scale / texSize;
+
+  return texture(source, choice + hexagonalPixelate.center);
+}
+`
+);
 var fs14 = (
   /* glsl */
   `uniform hexagonalPixelateUniforms {
@@ -868,9 +1220,11 @@ vec4 hexagonalPixelate_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord
 `
 );
 var hexagonalPixelate = {
+  name: "hexagonalPixelate",
+  source: source13,
+  fs: fs14,
   props: {},
   uniforms: {},
-  name: "hexagonalPixelate",
   uniformTypes: {
     center: "vec2<f32>",
     scale: "f32"
@@ -879,11 +1233,43 @@ var hexagonalPixelate = {
     center: { value: [0.5, 0.5], hint: "screenspace" },
     scale: { value: 10, min: 1, softMin: 5, softMax: 50 }
   },
-  fs: fs14,
   passes: [{ sampler: true }]
 };
 
 // dist/passes/postprocessing/image-fun-filters/ink.js
+var source14 = (
+  /* wgsl */
+  `uniform inkUniforms {
+  strength: f32,
+};
+
+@group(0) @binding(1) var<uniform> ink: inkUniforms;
+
+fn ink_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) -> vec4f {
+  vec2 dx = vec2(1.0 / texSize.x, 0.0);
+  vec2 dy = vec2(0.0, 1.0 / texSize.y);
+  vec4 color = texture(source, texCoord);
+  float bigTotal = 0.0;
+  float smallTotal = 0.0;
+  vec3 bigAverage = vec3(0.0);
+  vec3 smallAverage = vec3(0.0);
+  for (float x = -2.0; x <= 2.0; x += 1.0) {
+    for (float y = -2.0; y <= 2.0; y += 1.0) {
+      vec3 offsetColor = texture(source, texCoord + dx * x + dy * y).rgb;
+      bigAverage += offsetColor;
+      bigTotal += 1.0;
+      if (abs(x) + abs(y) < 2.0) {
+        smallAverage += offsetColor;
+        smallTotal += 1.0;
+      }
+    }
+  }
+  vec3 edge = max(vec3(0.0), bigAverage / bigTotal - smallAverage / smallTotal);
+  float power = ink.strength * ink.strength * ink.strength * ink.strength * ink.strength;
+  return vec4(color.rgb - dot(edge, edge) * power * 100000.0, color.a);
+}
+`
+);
 var fs15 = (
   /* glsl */
   `uniform inkUniforms {
@@ -916,10 +1302,11 @@ vec4 ink_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
 `
 );
 var ink = {
-  props: {},
-  uniforms: {},
   name: "ink",
+  source: source14,
   fs: fs15,
+  props: {},
+  uniforms: {},
   uniformTypes: {
     strength: "f32"
   },
@@ -930,6 +1317,32 @@ var ink = {
 };
 
 // dist/passes/postprocessing/image-fun-filters/magnify.js
+var source15 = (
+  /* wgsl */
+  `uniform magnifyUniforms {
+  screenXY: vec2f;
+  radiusPixels: f32;
+  zoom: f32;
+  borderWidthPixels: f32;
+  borderColor: vec4f;
+};
+
+@group(0) @binding(1) var<uniform> magnify: magnifyUniforms;
+
+fn magnify_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) -> vec4f {
+  vec2 pos = vec2(magnify.screenXY.x, 1.0 - magnify.screenXY.y);
+  float dist = distance(texCoord * texSize, pos * texSize);
+  if (dist < magnify.radiusPixels) {
+    return texture(source, (texCoord - pos) / magnify.zoom + pos);
+  }
+
+  if (dist <= magnify.radiusPixels + magnify.borderWidthPixels) {
+    return magnify.borderColor;
+  }
+  return texture(source, texCoord);
+}
+`
+);
 var fs16 = (
   /* glsl */
   `uniform magnifyUniforms {
@@ -956,6 +1369,8 @@ vec4 magnify_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
 );
 var magnify = {
   name: "magnify",
+  source: source15,
+  fs: fs16,
   uniformTypes: {
     screenXY: "vec2<f32>",
     radiusPixels: "f32",
@@ -971,11 +1386,23 @@ var magnify = {
     borderWidthPixels: 0,
     borderColor: { value: [255, 255, 255, 255] }
   },
-  fs: fs16,
   passes: [{ sampler: true }]
 };
 
 // dist/passes/postprocessing/image-warp-filters/warp.js
+var source16 = (
+  /* wgsl */
+  `vec4 warp_sampleColor(sampler2D source, vec2 texSize, vec2 coord) {
+  vec4 color = texture(source, coord / texSize);
+  vec2 clampedCoord = clamp(coord, vec2(0.0), texSize);
+  if (coord != clampedCoord) {
+    /* fade to transparent if we are outside the image */
+    color.a *= max(0.0, 1.0 - length(coord - clampedCoord));
+  }
+  return color;
+}
+`
+);
 var fs17 = (
   /* glsl */
   `vec4 warp_sampleColor(sampler2D source, vec2 texSize, vec2 coord) {
@@ -985,18 +1412,50 @@ var fs17 = (
     /* fade to transparent if we are outside the image */
     color.a *= max(0.0, 1.0 - length(coord - clampedCoord));
   }
-
   return color;
 }
 `
 );
 var warp = {
   name: "warp",
-  passes: [],
-  fs: fs17
+  source: source16,
+  fs: fs17,
+  passes: []
 };
 
 // dist/passes/postprocessing/image-warp-filters/bulgepinch.js
+var source17 = (
+  /* wgsl */
+  `uniform bulgePinchUniforms {
+  radius: f32,
+  strength: f32,
+  center: vec2f,
+};
+
+@group(0) @binding(1) var<uniform> bulgePinch: bulgePinchUniforms;
+
+fn bulgePinch_warp(vec2 coord, vec2 texCenter) -> vec2f {
+  coord -= texCenter;
+  float distance = length(coord);
+  if (distance < bulgePinch.radius) {
+    float percent = distance / bulgePinch.radius;
+    if (bulgePinch.strength > 0.0) {
+      coord *= mix(1.0, smoothstep(0.0, bulgePinch.radius / distance, percent), bulgePinch.strength * 0.75);
+    } else {
+      coord *= mix(1.0, pow(percent, 1.0 + bulgePinch.strength * 0.75) * bulgePinch.radius / distance, 1.0 - percent);
+    }
+  }
+  coord += texCenter;
+  return coord;
+}
+
+fn bulgePinch_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) -> vec4f {
+  vec2 coord = texCoord * texSize;
+  coord = bulgePinch_warp(coord, bulgePinch.center * texSize);
+  return warp_sampleColor(source, texSize, coord);
+}
+`
+);
 var fs18 = (
   /* glsl */
   `uniform bulgePinchUniforms {
@@ -1029,11 +1488,12 @@ vec4 bulgePinch_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
 `
 );
 var bulgePinch = {
-  props: {},
-  uniforms: {},
   name: "bulgePinch",
   dependencies: [warp],
+  source: source17,
   fs: fs18,
+  props: {},
+  uniforms: {},
   uniformTypes: {
     center: "vec2<f32>",
     radius: "f32",
@@ -1048,6 +1508,40 @@ var bulgePinch = {
 };
 
 // dist/passes/postprocessing/image-warp-filters/swirl.js
+var source18 = (
+  /* wgsl */
+  `uniform swirlUniforms {
+  radius: f32,
+  angle: f32,
+  center: vec2f,
+};
+
+@group(0) @binding(1) swirl: swirlUniforms;
+
+fn swirl_warp(vec2 coord, vec2 texCenter) -> vec2f {
+  coord -= texCenter;
+  float distance = length(coord);
+  if (distance < swirl.radius) {
+    float percent = (swirl.radius - distance) / swirl.radius;
+    float theta = percent * percent * swirl.angle;
+    float s = sin(theta);
+    float c = cos(theta);
+    coord = vec2(
+      coord.x * c - coord.y * s,
+      coord.x * s + coord.y * c
+    );
+  }
+  coord += texCenter;
+  return coord;
+}
+
+fn swirl_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) -> vec4f {
+  vec2 coord = texCoord * texSize;
+  coord = swirl_warp(coord, swirl.center * texSize);
+  return warp_sampleColor(source, texSize, coord);
+}
+`
+);
 var fs19 = (
   /* glsl */
   `uniform swirlUniforms {
@@ -1082,11 +1576,12 @@ vec4 swirl_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
 `
 );
 var swirl = {
-  props: {},
-  uniforms: {},
   name: "swirl",
   dependencies: [warp],
+  source: source18,
   fs: fs19,
+  props: {},
+  uniforms: {},
   uniformTypes: {
     center: "vec2<f32>",
     radius: "f32",