@luma.gl/effects 9.2.5 → 9.3.0-alpha.10

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

@@ -3,36 +3,45 @@
 // Copyright (c) vis.gl contributors
 import { random } from '@luma.gl/shadertools';
 const source = /* wgsl */ `
-uniform zoomBlurUniforms {
+struct zoomBlurUniforms {
   center: vec2f,
   strength: f32,
 };
 
-@group(0) @binding(1) var<uniform> zoomBlur : zoomBlurUniforms;
+@group(0) @binding(auto) 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;
+fn zoomBlur_sampleColor(
+  sourceTexture: texture_2d<f32>,
+  sourceTextureSampler: sampler,
+  texSize: vec2f,
+  texCoord: vec2f
+) -> vec4f {
+  var color = vec4f(0.0);
+  var total = 0.0;
+  let 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);
+  let offset = random(vec3f(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);
+  for (var t = 0.0; t <= 40.0; t += 1.0) {
+    let percent = (t + offset) / 40.0;
+    let weight = 4.0 * (percent - percent * percent);
+    let offsetColor = textureSample(
+      sourceTexture,
+      sourceTextureSampler,
+      texCoord + toCenter * percent * zoomBlur.strength / texSize
+    );
     color += offsetColor * weight;
     total += weight;
   }
 
-  color = color / total;
+  color /= total;
   return color;
 }
 `;
 const fs = /* glsl */ `
-uniform zoomBlurUniforms {
+layout(std140) uniform zoomBlurUniforms {
   vec2 center;
   float strength;
 } zoomBlur;

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

@@ -1 +1 @@
-{"version":3,"file":"zoomblur.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-blur-filters/zoomblur.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;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;CAyBrB,CAAC;AAcF;;;GAGG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,IAAI,EAAE,UAAU;IAChB,YAAY,EAAE,CAAC,MAAM,CAAC;IACtB,MAAM;IACN,EAAE;IAEF,KAAK,EAAE,EAAmB;IAC1B,QAAQ,EAAE,EAAsB;IAChC,YAAY,EAAE;QACZ,MAAM,EAAE,WAAW;QACnB,QAAQ,EAAE,KAAK;KAChB;IACD,SAAS,EAAE;QACT,MAAM,EAAE,EAAC,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAC;QAC3B,QAAQ,EAAE,EAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAC;KAC3C;IAED,MAAM,EAAE,CAAC,EAAC,OAAO,EAAE,IAAI,EAAC,CAAC;CACkC,CAAC"}
+{"version":3,"file":"zoomblur.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-blur-filters/zoomblur.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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;CAyBrB,CAAC;AAcF;;;GAGG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,IAAI,EAAE,UAAU;IAChB,YAAY,EAAE,CAAC,MAAM,CAAC;IACtB,MAAM;IACN,EAAE;IAEF,KAAK,EAAE,EAAmB;IAC1B,QAAQ,EAAE,EAAsB;IAChC,YAAY,EAAE;QACZ,MAAM,EAAE,WAAW;QACnB,QAAQ,EAAE,KAAK;KAChB;IACD,SAAS,EAAE;QACT,MAAM,EAAE,EAAC,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAC;QAC3B,QAAQ,EAAE,EAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAC;KAC3C;IAED,MAAM,EAAE,CAAC,EAAC,OAAO,EAAE,IAAI,EAAC,CAAC;CACkC,CAAC"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"colorhalftone.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/colorhalftone.ts"],"names":[],"mappings":"AAmFA;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,gDAAgD;IAChD,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1B,8CAA8C;IAC9C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uCAAuC;IACvC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,kBAAkB,CAAC;AAEvD;;;;;GAKG;AACH,eAAO,MAAM,aAAa;;;;oBAKX,kBAAkB;uBACf,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;CAagC,CAAC"}
+{"version":3,"file":"colorhalftone.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/colorhalftone.ts"],"names":[],"mappings":"AAqFA;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,gDAAgD;IAChD,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1B,8CAA8C;IAC9C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uCAAuC;IACvC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,kBAAkB,CAAC;AAEvD;;;;;GAKG;AACH,eAAO,MAAM,aAAa;;;;oBAKX,kBAAkB;uBACf,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;CAagC,CAAC"}

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

@@ -5,43 +5,45 @@ const source = /* wgsl */ `\
 struct colorHalftoneUniforms {
   center: vec2f,
   angle: f32,
-  size: f32.
+  size: f32,
 };
 
-@group(0) @binding(1) var<uniform> colorHalftone: colorHalftoneUniforms;
+@group(0) @binding(auto) 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
+  let s = sin(angle);
+  let c = cos(angle);
+  let tex = texCoord * texSize - colorHalftone.center * texSize;
+  let 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 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));
+fn colorHalftone_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> vec4f {
+  let scale = 3.1514 / colorHalftone.size;
+  var cmy = vec3f(1.0) - color.rgb;
+  var k = min(cmy.x, min(cmy.y, cmy.z));
+  let safeDenominator = max(1.0 - k, 0.00001);
 
-  cmy = (cmy - k) / (1.0 - k);
+  cmy = (cmy - vec3f(k)) / safeDenominator;
   cmy = clamp(
-	  cmy * 10.0 - 3.0 + vec3(
+    cmy * 10.0 - vec3f(3.0) + vec3f(
       pattern(colorHalftone.angle + 0.26179, scale, texSize, texCoord),
-	    pattern(colorHalftone.angle + 1.30899, scale, texSize, texCoord),
+      pattern(colorHalftone.angle + 1.30899, scale, texSize, texCoord),
       pattern(colorHalftone.angle, scale, texSize, texCoord)
     ),
-	  0.0,
-	  1.0
+    vec3f(0.0),
+    vec3f(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);
+  return vec4f(vec3f(1.0) - cmy - vec3f(k), color.a);
 }
 `;
 // TODO pass texCoord to angle
 const fs = /* glsl */ `\
-uniform colorHalftoneUniforms {
+layout(std140) uniform colorHalftoneUniforms {
   vec2 center;
   float angle;
   float size;

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

@@ -1 +1 @@
-{"version":3,"file":"colorhalftone.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/colorhalftone.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCzB,CAAC;AAEF,8BAA8B;AAC9B,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmCrB,CAAC;AAmBF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,IAAI,EAAE,eAAe;IACrB,MAAM;IACN,EAAE;IAEF,KAAK,EAAE,EAAwB;IAC/B,QAAQ,EAAE,EAA2B;IACrC,YAAY,EAAE;QACZ,MAAM,EAAE,WAAW;QACnB,KAAK,EAAE,KAAK;QACZ,IAAI,EAAE,KAAK;KACZ;IACD,SAAS,EAAE;QACT,MAAM,EAAE,EAAC,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAC;QAC3B,KAAK,EAAE,EAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,GAAG,CAAC,EAAC;QACrD,IAAI,EAAE,EAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAC;KAClD;IAED,MAAM,EAAE,CAAC,EAAC,MAAM,EAAE,IAAI,EAAC,CAAC;CAC6C,CAAC"}
+{"version":3,"file":"colorhalftone.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/colorhalftone.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCzB,CAAC;AAEF,8BAA8B;AAC9B,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmCrB,CAAC;AAmBF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,IAAI,EAAE,eAAe;IACrB,MAAM;IACN,EAAE;IAEF,KAAK,EAAE,EAAwB;IAC/B,QAAQ,EAAE,EAA2B;IACrC,YAAY,EAAE;QACZ,MAAM,EAAE,WAAW;QACnB,KAAK,EAAE,KAAK;QACZ,IAAI,EAAE,KAAK;KACZ;IACD,SAAS,EAAE;QACT,MAAM,EAAE,EAAC,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAC;QAC3B,KAAK,EAAE,EAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,GAAG,CAAC,EAAC;QACrD,IAAI,EAAE,EAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAC;KAClD;IAED,MAAM,EAAE,CAAC,EAAC,MAAM,EAAE,IAAI,EAAC,CAAC;CAC6C,CAAC"}

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

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

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

@@ -2,33 +2,33 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 const source = /* wgsl */ `\
-uniform dotScreenUniforms {
+struct dotScreenUniforms {
   center: vec2f,
   angle: f32,
   size: f32,
 };
 
-@group(0) @binding(1) dotScreen: dotScreenUniforms;
+@group(0) @binding(auto) var<uniform> 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,
+  let scale = 3.1415 / dotScreen.size;
+  let s = sin(dotScreen.angle);
+  let c = cos(dotScreen.angle);
+  let tex = texCoord * texSize - dotScreen.center * texSize;
+  let 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);
+fn dotScreen_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> vec4f {
+  let average = (color.r + color.g + color.b) / 3.0;
+  return vec4f(vec3f(average * 10.0 - 5.0 + pattern(texSize, texCoord)), color.a);
 }
 `;
 const fs = /* glsl */ `\
-uniform dotScreenUniforms {
+layout(std140) uniform dotScreenUniforms {
   vec2 center;
   float angle;
   float size;

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"edgework.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/edgework.ts"],"names":[],"mappings":"AA4GA;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4BAA4B;IAC5B,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC;AAE7C;;;;GAIG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;oBAMN,aAAa;uBACV,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoB8B,CAAC"}
+{"version":3,"file":"edgework.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/edgework.ts"],"names":[],"mappings":"AAmLA;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4BAA4B;IAC5B,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC;AAE7C;;;;GAIG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;oBAMN,aAAa;uBACV,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoB8B,CAAC"}

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

@@ -5,25 +5,35 @@ import { random } from '@luma.gl/shadertools';
 const source = /* wgsl */ `\
 struct edgeWorkUniforms {
   radius: f32,
-  int mode: uint32,
+  mode: u32,
 };
 
-@group(0) @binding(1) var<uniform> edgeWork: edgeWorkUniforms;
+@group(0) @binding(auto) var<uniform> edgeWork: edgeWorkUniforms;
 
-fn edgeWork_sampleColorRGB(sampler2D source, vec2 texSize, vec2 texCoord, vec2 delta) -> vec4f {
-  vec2 relativeDelta = edgeWork.radius * delta / texSize;
+fn edgeWork_sampleColorRGB(
+  sourceTexture: texture_2d<f32>,
+  sourceTextureSampler: sampler,
+  texSize: vec2f,
+  texCoord: vec2f,
+  delta: vec2f
+) -> vec4f {
+  let relativeDelta = edgeWork.radius * delta / texSize;
 
-  vec2 color = vec2(0.0);
-  vec2 total = vec2(0.0);
+  var color = vec2f(0.0);
+  var total = vec2f(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);
-    vec3 sampleColor = texture(source, texCoord + relativeDelta * percent).rgb;
-    float average = (sampleColor.r + sampleColor.g + sampleColor.b) / 3.0;
+  for (var t = -30.0; t <= 30.0; t += 1.0) {
+    let percent = (t + offset - 0.5) / 30.0;
+    var weight = 1.0 - abs(percent);
+    let sampleColor = textureSample(
+      sourceTexture,
+      sourceTextureSampler,
+      texCoord + relativeDelta * percent
+    ).rgb;
+    let average = (sampleColor.r + sampleColor.g + sampleColor.b) / 3.0;
     color.x += average * weight;
     total.x += weight;
     if (abs(t) < 15.0) {
@@ -32,11 +42,72 @@ fn edgeWork_sampleColorRGB(sampler2D source, vec2 texSize, vec2 texCoord, vec2 d
       total.y += weight;
     }
   }
-  return vec4(color / total, 0.0, 1.0);
+  return vec4f(color / total, 0.0, 1.0);
+}
+
+fn edgeWork_sampleColorXY(
+  sourceTexture: texture_2d<f32>,
+  sourceTextureSampler: sampler,
+  texSize: vec2f,
+  texCoord: vec2f,
+  delta: vec2f
+) -> vec4f {
+  let relativeDelta = edgeWork.radius * delta / texSize;
+
+  var color = vec2f(0.0);
+  var total = vec2f(0.0);
+
+  /* randomize the lookup values to hide the fixed number of samples */
+  let offset = random(vec3f(12.9898, 78.233, 151.7182), 0.0);
+
+  for (var t = -30.0; t <= 30.0; t += 1.0) {
+    let percent = (t + offset - 0.5) / 30.0;
+    var weight = 1.0 - abs(percent);
+    let sampleColor = textureSample(
+      sourceTexture,
+      sourceTextureSampler,
+      texCoord + relativeDelta * percent
+    ).xy;
+    color.x += sampleColor.x * weight;
+    total.x += weight;
+    if (abs(t) < 15.0) {
+      weight = weight * 2.0 - 1.0;
+      color.y += sampleColor.y * weight;
+      total.y += weight;
+    }
+  }
+
+  let c = clamp(10000.0 * (color.y / total.y - color.x / total.x) + 0.5, 0.0, 1.0);
+  return vec4f(c, c, c, 1.0);
+}
+
+fn edgeWork_sampleColor(
+  sourceTexture: texture_2d<f32>,
+  sourceTextureSampler: sampler,
+  texSize: vec2f,
+  texCoord: vec2f
+) -> vec4f {
+  if (edgeWork.mode == 0u) {
+    return edgeWork_sampleColorRGB(
+      sourceTexture,
+      sourceTextureSampler,
+      texSize,
+      texCoord,
+      vec2f(1.0, 0.0)
+    );
+  }
+
+  return edgeWork_sampleColorXY(
+    sourceTexture,
+    sourceTextureSampler,
+    texSize,
+    texCoord,
+    vec2f(0.0, 1.0)
+  );
 }
 `;
 const fs = /* glsl */ `\
-uniform edgeWorkUniforms {
+layout(std140) uniform edgeWorkUniforms {
   float radius;
   int mode;
 } edgeWork;

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

@@ -1 +1 @@
-{"version":3,"file":"edgework.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/edgework.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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiErB,CAAC;AAgBF;;;;GAIG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,IAAI,EAAE,UAAU;IAChB,YAAY,EAAE,CAAC,MAAM,CAAC;IACtB,MAAM;IACN,EAAE;IAEF,KAAK,EAAE,EAAmB;IAC1B,QAAQ,EAAE,EAAmB;IAC7B,YAAY,EAAE;QACZ,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,KAAK;KACZ;IACD,SAAS,EAAE;QACT,MAAM,EAAE,EAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAC;QACvC,IAAI,EAAE,EAAC,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,IAAI,EAAC;KAChC;IAED,MAAM,EAAE;QACN;YACE,OAAO,EAAE,IAAI;YACb,QAAQ,EAAE,EAAC,IAAI,EAAE,CAAC,EAAC;SACpB;QACD;YACE,OAAO,EAAE,IAAI;YACb,QAAQ,EAAE,EAAC,IAAI,EAAE,CAAC,EAAC;SACpB;KACF;CAC0D,CAAC"}
+{"version":3,"file":"edgework.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/edgework.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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuGzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiErB,CAAC;AAgBF;;;;GAIG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,IAAI,EAAE,UAAU;IAChB,YAAY,EAAE,CAAC,MAAM,CAAC;IACtB,MAAM;IACN,EAAE;IAEF,KAAK,EAAE,EAAmB;IAC1B,QAAQ,EAAE,EAAmB;IAC7B,YAAY,EAAE;QACZ,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,KAAK;KACZ;IACD,SAAS,EAAE;QACT,MAAM,EAAE,EAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAC;QACvC,IAAI,EAAE,EAAC,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,IAAI,EAAC;KAChC;IAED,MAAM,EAAE;QACN;YACE,OAAO,EAAE,IAAI;YACb,QAAQ,EAAE,EAAC,IAAI,EAAE,CAAC,EAAC;SACpB;QACD;YACE,OAAO,EAAE,IAAI;YACb,QAAQ,EAAE,EAAC,IAAI,EAAE,CAAC,EAAC;SACpB;KACF;CAC0D,CAAC"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"hexagonalpixelate.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/hexagonalpixelate.ts"],"names":[],"mappings":"AAkGA;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,oDAAoD;IACpD,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1B,kDAAkD;IAClD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,sBAAsB,CAAC;AAE/D;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;;;oBAKf,sBAAsB;uBACnB,yBAAyB;;;;;;;;;;;;;;;;;;;;CAWoC,CAAC"}
+{"version":3,"file":"hexagonalpixelate.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/hexagonalpixelate.ts"],"names":[],"mappings":"AA8GA;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,oDAAoD;IACpD,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1B,kDAAkD;IAClD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,sBAAsB,CAAC;AAE/D;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;;;oBAKf,sBAAsB;uBACnB,yBAAyB;;;;;;;;;;;;;;;;;;;;CAWoC,CAAC"}

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

@@ -7,48 +7,60 @@ struct hexagonalPixelateUniforms {
   scale: f32,
 };
 
-@group(0) @binding(1) var<uniform> hexagonalPixelate: hexagonalPixelateUniforms;
+@group(0) @binding(auto) var<uniform> hexagonalPixelate: hexagonalPixelateUniforms;
 
-fn hexagonalPixelate_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) -> vec4f {
-  vec2 tex = (texCoord * texSize - hexagonalPixelate.center * texSize) / hexagonalPixelate.scale;
+fn hexagonalPixelate_sampleColor(
+  sourceTexture: texture_2d<f32>,
+  sourceTextureSampler: sampler,
+  texSize: vec2f,
+  texCoord: vec2f
+) -> vec4f {
+  var tex = (texCoord * texSize - hexagonalPixelate.center * texSize) / hexagonalPixelate.scale;
   tex.y /= 0.866025404;
   tex.x -= tex.y * 0.5;
 
-  vec2 a;
+  var a = vec2f(0.0);
   if (tex.x + tex.y - floor(tex.x) - floor(tex.y) < 1.0) {
-    a = vec2(floor(tex.x), floor(tex.y));
+    a = vec2f(floor(tex.x), floor(tex.y));
+  } else {
+    a = vec2f(ceil(tex.x), ceil(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));
+  let b = vec2f(ceil(tex.x), floor(tex.y));
+  let c = vec2f(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);
+  let texBarycentric = vec3f(tex.x, tex.y, 1.0 - tex.x - tex.y);
+  let aBarycentric = vec3f(a.x, a.y, 1.0 - a.x - a.y);
+  let bBarycentric = vec3f(b.x, b.y, 1.0 - b.x - b.y);
+  let cBarycentric = vec3f(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);
+  let aLength = length(texBarycentric - aBarycentric);
+  let bLength = length(texBarycentric - bBarycentric);
+  let cLength = length(texBarycentric - cBarycentric);
 
-  vec2 choice;
-  if (alen < blen) {
-    if (alen < clen) choice = a;
-    else choice = c;
+  var choice = vec2f(0.0);
+  if (aLength < bLength) {
+    if (aLength < cLength) {
+      choice = a;
+    } else {
+      choice = c;
+    }
   } else {
-    if (blen < clen) choice = b;
-    else choice = c;
+    if (bLength < cLength) {
+      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);
+  return textureSample(sourceTexture, sourceTextureSampler, choice + hexagonalPixelate.center);
 }
 `;
 const fs = /* glsl */ `\
-uniform hexagonalPixelateUniforms {
+layout(std140) uniform hexagonalPixelateUniforms {
   vec2 center;
   float scale;
 } hexagonalPixelate;

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

@@ -1 +1 @@
-{"version":3,"file":"hexagonalpixelate.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/hexagonalpixelate.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6CzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2CrB,CAAC;AAgBF;;;;GAIG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,IAAI,EAAE,mBAAmB;IACzB,MAAM;IACN,EAAE;IAEF,KAAK,EAAE,EAA4B;IACnC,QAAQ,EAAE,EAA+B;IACzC,YAAY,EAAE;QACZ,MAAM,EAAE,WAAW;QACnB,KAAK,EAAE,KAAK;KACb;IACD,SAAS,EAAE;QACT,MAAM,EAAE,EAAC,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,IAAI,EAAE,aAAa,EAAC;QAChD,KAAK,EAAE,EAAC,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAC;KACpD;IAED,MAAM,EAAE,CAAC,EAAC,OAAO,EAAE,IAAI,EAAC,CAAC;CACoD,CAAC"}
+{"version":3,"file":"hexagonalpixelate.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/hexagonalpixelate.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyDzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2CrB,CAAC;AAgBF;;;;GAIG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,IAAI,EAAE,mBAAmB;IACzB,MAAM;IACN,EAAE;IAEF,KAAK,EAAE,EAA4B;IACnC,QAAQ,EAAE,EAA+B;IACzC,YAAY,EAAE;QACZ,MAAM,EAAE,WAAW;QACnB,KAAK,EAAE,KAAK;KACb;IACD,SAAS,EAAE;QACT,MAAM,EAAE,EAAC,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,IAAI,EAAE,aAAa,EAAC;QAChD,KAAK,EAAE,EAAC,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAC;KACpD;IAED,MAAM,EAAE,CAAC,EAAC,OAAO,EAAE,IAAI,EAAC,CAAC;CACoD,CAAC"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"ink.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/ink.ts"],"names":[],"mappings":"AAoEA;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC;AAEnC;;;;;GAKG;AACH,eAAO,MAAM,GAAG;;;;oBAKD,QAAQ;uBACL,WAAW;;;;;;;;;;;;;;CASsB,CAAC"}
+{"version":3,"file":"ink.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/ink.ts"],"names":[],"mappings":"AA6EA;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC;AAEnC;;;;;GAKG;AACH,eAAO,MAAM,GAAG;;;;oBAKD,QAAQ;uBACL,WAAW;;;;;;;;;;;;;;CASsB,CAAC"}

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

@@ -2,23 +2,32 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 const source = /* wgsl */ `\
-uniform inkUniforms {
+struct inkUniforms {
   strength: f32,
 };
 
-@group(0) @binding(1) var<uniform> ink: inkUniforms;
+@group(0) @binding(auto) 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;
+fn ink_sampleColor(
+  sourceTexture: texture_2d<f32>,
+  sourceTextureSampler: sampler,
+  texSize: vec2f,
+  texCoord: vec2f
+) -> vec4f {
+  let dx = vec2f(1.0 / texSize.x, 0.0);
+  let dy = vec2f(0.0, 1.0 / texSize.y);
+  let color = textureSample(sourceTexture, sourceTextureSampler, texCoord);
+  var bigTotal = 0.0;
+  var smallTotal = 0.0;
+  var bigAverage = vec3f(0.0);
+  var smallAverage = vec3f(0.0);
+  for (var x = -2.0; x <= 2.0; x += 1.0) {
+    for (var y = -2.0; y <= 2.0; y += 1.0) {
+      let offsetColor = textureSample(
+        sourceTexture,
+        sourceTextureSampler,
+        texCoord + dx * x + dy * y
+      ).rgb;
       bigAverage += offsetColor;
       bigTotal += 1.0;
       if (abs(x) + abs(y) < 2.0) {
@@ -27,13 +36,13 @@ fn ink_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) -> vec4f {
       }
     }
   }
-  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);
+  let edge = max(vec3f(0.0), bigAverage / bigTotal - smallAverage / smallTotal);
+  let power = ink.strength * ink.strength * ink.strength * ink.strength * ink.strength;
+  return vec4f(color.rgb - vec3f(dot(edge, edge) * power * 100000.0), color.a);
 }
 `;
 const fs = /* glsl */ `\
-uniform inkUniforms {
+layout(std140) uniform inkUniforms {
   float strength;
 } ink;
 

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

@@ -1 +1 @@
-{"version":3,"file":"ink.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/ink.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BrB,CAAC;AAkBF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG;IACjB,IAAI,EAAE,KAAK;IACX,MAAM;IACN,EAAE;IAEF,KAAK,EAAE,EAAc;IACrB,QAAQ,EAAE,EAAiB;IAC3B,YAAY,EAAE;QACZ,QAAQ,EAAE,KAAK;KAChB;IACD,SAAS,EAAE;QACT,QAAQ,EAAE,EAAC,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAC;KAC5C;IAED,MAAM,EAAE,CAAC,EAAC,OAAO,EAAE,IAAI,EAAC,CAAC;CACwB,CAAC"}
+{"version":3,"file":"ink.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/ink.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;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BrB,CAAC;AAkBF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG;IACjB,IAAI,EAAE,KAAK;IACX,MAAM;IACN,EAAE;IAEF,KAAK,EAAE,EAAc;IACrB,QAAQ,EAAE,EAAiB;IAC3B,YAAY,EAAE;QACZ,QAAQ,EAAE,KAAK;KAChB;IACD,SAAS,EAAE;QACT,QAAQ,EAAE,EAAC,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAC;KAC5C;IAED,MAAM,EAAE,CAAC,EAAC,OAAO,EAAE,IAAI,EAAC,CAAC;CACwB,CAAC"}