@luma.gl/effects 9.3.0-alpha.2 → 9.3.0-alpha.6

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

@@ -1 +1 @@
-{"version":3,"file":"magnify.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/magnify.ts"],"names":[],"mappings":"AAsDA;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,wLAAwL;IACxL,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,uDAAuD;IACvD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,2CAA2C;IAC3C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qGAAqG;IACrG,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,kFAAkF;IAClF,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CAChD,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,YAAY,CAAC;AAE3C;;GAEG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;CAsBuC,CAAC"}
+{"version":3,"file":"magnify.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/magnify.ts"],"names":[],"mappings":"AA2DA;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,wLAAwL;IACxL,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,uDAAuD;IACvD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,2CAA2C;IAC3C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qGAAqG;IACrG,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,kFAAkF;IAClF,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CAChD,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,YAAY,CAAC;AAE3C;;GAEG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;CAsBuC,CAAC"}

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

@@ -2,27 +2,32 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 const source = /* wgsl */ `\
-uniform magnifyUniforms {
-  screenXY: vec2f;
-  radiusPixels: f32;
-  zoom: f32;
-  borderWidthPixels: f32;
-  borderColor: vec4f;
+struct 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);
+fn magnify_sampleColor(
+  sourceTexture: texture_2d<f32>,
+  sourceTextureSampler: sampler,
+  texSize: vec2f,
+  texCoord: vec2f
+) -> vec4f {
+  let pos = vec2f(magnify.screenXY.x, 1.0 - magnify.screenXY.y);
+  let dist = distance(texCoord * texSize, pos * texSize);
   if (dist < magnify.radiusPixels) {
-    return texture(source, (texCoord - pos) / magnify.zoom + pos);
+    return textureSample(sourceTexture, sourceTextureSampler, (texCoord - pos) / magnify.zoom + pos);
   }
 
   if (dist <= magnify.radiusPixels + magnify.borderWidthPixels) {
     return magnify.borderColor;
   }
-  return texture(source, texCoord);
+  return textureSample(sourceTexture, sourceTextureSampler, texCoord);
 }
 `;
 const fs = /* glsl */ `\

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

@@ -1 +1 @@
-{"version":3,"file":"magnify.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/magnify.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;AAoBF;;GAEG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,IAAI,EAAE,SAAS;IACf,MAAM;IACN,EAAE;IAEF,YAAY,EAAE;QACZ,QAAQ,EAAE,WAAW;QACrB,YAAY,EAAE,KAAK;QACnB,IAAI,EAAE,KAAK;QACX,iBAAiB,EAAE,KAAK;QACxB,WAAW,EAAE,WAAW;KACzB;IACD,SAAS,EAAE;QACT,eAAe;QACf,QAAQ,EAAE,EAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAC;QACzB,YAAY,EAAE,GAAG;QACjB,IAAI,EAAE,GAAG;QACT,iBAAiB,EAAE,GAAG;QACtB,WAAW,EAAE,EAAC,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAC;KAC3C;IAED,MAAM,EAAE,CAAC,EAAC,OAAO,EAAE,IAAI,EAAC,CAAC;CACgC,CAAC"}
+{"version":3,"file":"magnify.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/magnify.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;CAqBrB,CAAC;AAoBF;;GAEG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,IAAI,EAAE,SAAS;IACf,MAAM;IACN,EAAE;IAEF,YAAY,EAAE;QACZ,QAAQ,EAAE,WAAW;QACrB,YAAY,EAAE,KAAK;QACnB,IAAI,EAAE,KAAK;QACX,iBAAiB,EAAE,KAAK;QACxB,WAAW,EAAE,WAAW;KACzB;IACD,SAAS,EAAE;QACT,eAAe;QACf,QAAQ,EAAE,EAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAC;QACzB,YAAY,EAAE,GAAG;QACjB,IAAI,EAAE,GAAG;QACT,iBAAiB,EAAE,GAAG;QACtB,WAAW,EAAE,EAAC,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAC;KAC3C;IAED,MAAM,EAAE,CAAC,EAAC,OAAO,EAAE,IAAI,EAAC,CAAC;CACgC,CAAC"}

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

@@ -16,11 +16,11 @@ export declare const bulgePinch: {
     readonly name: "bulgePinch";
     readonly dependencies: [{
         readonly name: "warp";
-        readonly source: "vec4 warp_sampleColor(sampler2D source, vec2 texSize, vec2 coord) {\n  vec4 color = texture(source, coord / texSize);\n  vec2 clampedCoord = clamp(coord, vec2(0.0), texSize);\n  if (coord != clampedCoord) {\n    /* fade to transparent if we are outside the image */\n    color.a *= max(0.0, 1.0 - length(coord - clampedCoord));\n  }\n  return color;\n}\n";
+        readonly source: "fn warp_sampleColor(\n  sourceTexture: texture_2d<f32>,\n  sourceTextureSampler: sampler,\n  texSize: vec2f,\n  coord: vec2f\n) -> vec4f {\n  var color = textureSample(sourceTexture, sourceTextureSampler, coord / texSize);\n  let clampedCoord = clamp(coord, vec2f(0.0), texSize);\n  if (any(coord != clampedCoord)) {\n    /* fade to transparent if we are outside the image */\n    color.a *= max(0.0, 1.0 - length(coord - clampedCoord));\n  }\n  return color;\n}\n";
         readonly fs: "vec4 warp_sampleColor(sampler2D source, vec2 texSize, vec2 coord) {\n  vec4 color = texture(source, coord / texSize);\n  vec2 clampedCoord = clamp(coord, vec2(0.0), texSize);\n  if (coord != clampedCoord) {\n    /* fade to transparent if we are outside the image */\n    color.a *= max(0.0, 1.0 - length(coord - clampedCoord));\n  }\n  return color;\n}\n";
         readonly passes: [];
     }];
-    readonly source: "uniform bulgePinchUniforms {\n  radius: f32,\n  strength: f32,\n  center: vec2f,\n};\n\n@group(0) @binding(1) var<uniform> bulgePinch: bulgePinchUniforms;\n\nfn bulgePinch_warp(vec2 coord, vec2 texCenter) -> vec2f {\n  coord -= texCenter;\n  float distance = length(coord);\n  if (distance < bulgePinch.radius) {\n    float percent = distance / bulgePinch.radius;\n    if (bulgePinch.strength > 0.0) {\n      coord *= mix(1.0, smoothstep(0.0, bulgePinch.radius / distance, percent), bulgePinch.strength * 0.75);\n    } else {\n      coord *= mix(1.0, pow(percent, 1.0 + bulgePinch.strength * 0.75) * bulgePinch.radius / distance, 1.0 - percent);\n    }\n  }\n  coord += texCenter;\n  return coord;\n}\n\nfn bulgePinch_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) -> vec4f {\n  vec2 coord = texCoord * texSize;\n  coord = bulgePinch_warp(coord, bulgePinch.center * texSize);\n  return warp_sampleColor(source, texSize, coord);\n}\n";
+    readonly source: "struct bulgePinchUniforms {\n  radius: f32,\n  strength: f32,\n  center: vec2f,\n};\n\n@group(0) @binding(1) var<uniform> bulgePinch: bulgePinchUniforms;\n\nfn bulgePinch_warp(coordIn: vec2f, texCenter: vec2f) -> vec2f {\n  var coord = coordIn - texCenter;\n  let distance = length(coord);\n  if (distance < bulgePinch.radius) {\n    let percent = distance / bulgePinch.radius;\n    let safeDistance = max(distance, 0.00001);\n    if (bulgePinch.strength > 0.0) {\n      coord *= mix(\n        1.0,\n        smoothstep(0.0, bulgePinch.radius / safeDistance, percent),\n        bulgePinch.strength * 0.75\n      );\n    } else {\n      coord *= mix(\n        1.0,\n        pow(percent, 1.0 + bulgePinch.strength * 0.75) * bulgePinch.radius / safeDistance,\n        1.0 - percent\n      );\n    }\n  }\n  coord += texCenter;\n  return coord;\n}\n\nfn bulgePinch_sampleColor(\n  sourceTexture: texture_2d<f32>,\n  sourceTextureSampler: sampler,\n  texSize: vec2f,\n  texCoord: vec2f\n) -> vec4f {\n  var coord = texCoord * texSize;\n  coord = bulgePinch_warp(coord, bulgePinch.center * texSize);\n  return warp_sampleColor(sourceTexture, sourceTextureSampler, texSize, coord);\n}\n";
     readonly fs: "uniform bulgePinchUniforms {\n  float radius;\n  float strength;\n  vec2 center;\n} bulgePinch;\n\nvec2 bulgePinch_warp(vec2 coord, vec2 texCenter) {\n  coord -= texCenter;\n  float distance = length(coord);\n  if (distance < bulgePinch.radius) {\n    float percent = distance / bulgePinch.radius;\n    if (bulgePinch.strength > 0.0) {\n      coord *= mix(1.0, smoothstep(0.0, bulgePinch.radius / distance, percent), bulgePinch.strength * 0.75);\n    } else {\n      coord *= mix(1.0, pow(percent, 1.0 + bulgePinch.strength * 0.75) * bulgePinch.radius / distance, 1.0 - percent);\n    }\n  }\n  coord += texCenter;\n  return coord;\n}\n\nvec4 bulgePinch_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 coord = texCoord * texSize;\n  coord = bulgePinch_warp(coord, bulgePinch.center * texSize);\n\n  return warp_sampleColor(source, texSize, coord);\n}\n";
     readonly props: BulgePinchProps;
     readonly uniforms: BulgePinchUniforms;

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

@@ -1 +1 @@
-{"version":3,"file":"bulgepinch.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-warp-filters/bulgepinch.ts"],"names":[],"mappings":"AAoEA,+CAA+C;AAC/C,MAAM,MAAM,eAAe,GAAG;IAC5B,oEAAoE;IACpE,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1B,0CAA0C;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,eAAe,CAAC;AAEjD;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;oBAMR,eAAe;uBACZ,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;CAa6B,CAAC"}
+{"version":3,"file":"bulgepinch.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-warp-filters/bulgepinch.ts"],"names":[],"mappings":"AAkFA,+CAA+C;AAC/C,MAAM,MAAM,eAAe,GAAG;IAC5B,oEAAoE;IACpE,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1B,0CAA0C;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,eAAe,CAAC;AAEjD;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;oBAMR,eAAe;uBACZ,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;CAa6B,CAAC"}

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

@@ -3,7 +3,7 @@
 // Copyright (c) vis.gl contributors
 import { warp } from "./warp.js";
 const source = /* wgsl */ `\
-uniform bulgePinchUniforms {
+struct bulgePinchUniforms {
   radius: f32,
   strength: f32,
   center: vec2f,
@@ -11,25 +11,39 @@ uniform bulgePinchUniforms {
 
 @group(0) @binding(1) var<uniform> bulgePinch: bulgePinchUniforms;
 
-fn bulgePinch_warp(vec2 coord, vec2 texCenter) -> vec2f {
-  coord -= texCenter;
-  float distance = length(coord);
+fn bulgePinch_warp(coordIn: vec2f, texCenter: vec2f) -> vec2f {
+  var coord = coordIn - texCenter;
+  let distance = length(coord);
   if (distance < bulgePinch.radius) {
-    float percent = distance / bulgePinch.radius;
+    let percent = distance / bulgePinch.radius;
+    let safeDistance = max(distance, 0.00001);
     if (bulgePinch.strength > 0.0) {
-      coord *= mix(1.0, smoothstep(0.0, bulgePinch.radius / distance, percent), bulgePinch.strength * 0.75);
+      coord *= mix(
+        1.0,
+        smoothstep(0.0, bulgePinch.radius / safeDistance, 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 *= mix(
+        1.0,
+        pow(percent, 1.0 + bulgePinch.strength * 0.75) * bulgePinch.radius / safeDistance,
+        1.0 - percent
+      );
     }
   }
   coord += texCenter;
   return coord;
 }
 
-fn bulgePinch_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) -> vec4f {
-  vec2 coord = texCoord * texSize;
+fn bulgePinch_sampleColor(
+  sourceTexture: texture_2d<f32>,
+  sourceTextureSampler: sampler,
+  texSize: vec2f,
+  texCoord: vec2f
+) -> vec4f {
+  var coord = texCoord * texSize;
   coord = bulgePinch_warp(coord, bulgePinch.center * texSize);
-  return warp_sampleColor(source, texSize, coord);
+  return warp_sampleColor(sourceTexture, sourceTextureSampler, texSize, coord);
 }
 `;
 const fs = /* glsl */ `\

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

@@ -1 +1 @@
-{"version":3,"file":"bulgepinch.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-warp-filters/bulgepinch.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAGpC,OAAO,EAAC,IAAI,EAAC,kBAAe;AAE5B,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BrB,CAAC;AAcF;;;GAGG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,IAAI,EAAE,YAAY;IAClB,YAAY,EAAE,CAAC,IAAI,CAAC;IACpB,MAAM;IACN,EAAE;IAEF,KAAK,EAAE,EAAqB;IAC5B,QAAQ,EAAE,EAAwB;IAClC,YAAY,EAAE;QACZ,MAAM,EAAE,WAAW;QACnB,MAAM,EAAE,KAAK;QACb,QAAQ,EAAE,KAAK;KAChB;IACD,SAAS,EAAE;QACT,MAAM,EAAE,EAAC,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAC;QAC3B,MAAM,EAAE,EAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,GAAG,EAAC;QAC1C,QAAQ,EAAE,EAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAC;KACxC;IAED,MAAM,EAAE,CAAC,EAAC,OAAO,EAAE,IAAI,EAAC,CAAC;CACsC,CAAC"}
+{"version":3,"file":"bulgepinch.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-warp-filters/bulgepinch.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAGpC,OAAO,EAAC,IAAI,EAAC,kBAAe;AAE5B,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2CzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BrB,CAAC;AAcF;;;GAGG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,IAAI,EAAE,YAAY;IAClB,YAAY,EAAE,CAAC,IAAI,CAAC;IACpB,MAAM;IACN,EAAE;IAEF,KAAK,EAAE,EAAqB;IAC5B,QAAQ,EAAE,EAAwB;IAClC,YAAY,EAAE;QACZ,MAAM,EAAE,WAAW;QACnB,MAAM,EAAE,KAAK;QACb,QAAQ,EAAE,KAAK;KAChB;IACD,SAAS,EAAE;QACT,MAAM,EAAE,EAAC,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAC;QAC3B,MAAM,EAAE,EAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,GAAG,EAAC;QAC1C,QAAQ,EAAE,EAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAC;KACxC;IAED,MAAM,EAAE,CAAC,EAAC,OAAO,EAAE,IAAI,EAAC,CAAC;CACsC,CAAC"}

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

@@ -17,11 +17,11 @@ export declare const swirl: {
     readonly name: "swirl";
     readonly dependencies: [{
         readonly name: "warp";
-        readonly source: "vec4 warp_sampleColor(sampler2D source, vec2 texSize, vec2 coord) {\n  vec4 color = texture(source, coord / texSize);\n  vec2 clampedCoord = clamp(coord, vec2(0.0), texSize);\n  if (coord != clampedCoord) {\n    /* fade to transparent if we are outside the image */\n    color.a *= max(0.0, 1.0 - length(coord - clampedCoord));\n  }\n  return color;\n}\n";
+        readonly source: "fn warp_sampleColor(\n  sourceTexture: texture_2d<f32>,\n  sourceTextureSampler: sampler,\n  texSize: vec2f,\n  coord: vec2f\n) -> vec4f {\n  var color = textureSample(sourceTexture, sourceTextureSampler, coord / texSize);\n  let clampedCoord = clamp(coord, vec2f(0.0), texSize);\n  if (any(coord != clampedCoord)) {\n    /* fade to transparent if we are outside the image */\n    color.a *= max(0.0, 1.0 - length(coord - clampedCoord));\n  }\n  return color;\n}\n";
         readonly fs: "vec4 warp_sampleColor(sampler2D source, vec2 texSize, vec2 coord) {\n  vec4 color = texture(source, coord / texSize);\n  vec2 clampedCoord = clamp(coord, vec2(0.0), texSize);\n  if (coord != clampedCoord) {\n    /* fade to transparent if we are outside the image */\n    color.a *= max(0.0, 1.0 - length(coord - clampedCoord));\n  }\n  return color;\n}\n";
         readonly passes: [];
     }];
-    readonly source: "uniform swirlUniforms {\n  radius: f32,\n  angle: f32,\n  center: vec2f,\n};\n\n@group(0) @binding(1) swirl: swirlUniforms;\n\nfn swirl_warp(vec2 coord, vec2 texCenter) -> vec2f {\n  coord -= texCenter;\n  float distance = length(coord);\n  if (distance < swirl.radius) {\n    float percent = (swirl.radius - distance) / swirl.radius;\n    float theta = percent * percent * swirl.angle;\n    float s = sin(theta);\n    float c = cos(theta);\n    coord = vec2(\n      coord.x * c - coord.y * s,\n      coord.x * s + coord.y * c\n    );\n  }\n  coord += texCenter;\n  return coord;\n}\n\nfn swirl_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) -> vec4f {\n  vec2 coord = texCoord * texSize;\n  coord = swirl_warp(coord, swirl.center * texSize);\n  return warp_sampleColor(source, texSize, coord);\n}\n";
+    readonly source: "struct swirlUniforms {\n  radius: f32,\n  angle: f32,\n  center: vec2f,\n};\n\n@group(0) @binding(1) var<uniform> swirl: swirlUniforms;\n\nfn swirl_warp(coordIn: vec2f, texCenter: vec2f) -> vec2f {\n  var coord = coordIn - texCenter;\n  let distance = length(coord);\n  if (distance < swirl.radius) {\n    let percent = (swirl.radius - distance) / swirl.radius;\n    let theta = percent * percent * swirl.angle;\n    let s = sin(theta);\n    let c = cos(theta);\n    coord = vec2f(\n      coord.x * c - coord.y * s,\n      coord.x * s + coord.y * c\n    );\n  }\n  coord += texCenter;\n  return coord;\n}\n\nfn swirl_sampleColor(\n  sourceTexture: texture_2d<f32>,\n  sourceTextureSampler: sampler,\n  texSize: vec2f,\n  texCoord: vec2f\n) -> vec4f {\n  var coord = texCoord * texSize;\n  coord = swirl_warp(coord, swirl.center * texSize);\n  return warp_sampleColor(sourceTexture, sourceTextureSampler, texSize, coord);\n}\n";
     readonly fs: "uniform swirlUniforms {\n  float radius;\n  float angle;\n  vec2 center;\n} swirl;\n\nvec2 swirl_warp(vec2 coord, vec2 texCenter) {\n  coord -= texCenter;\n  float distance = length(coord);\n  if (distance < swirl.radius) {\n    float percent = (swirl.radius - distance) / swirl.radius;\n    float theta = percent * percent * swirl.angle;\n    float s = sin(theta);\n    float c = cos(theta);\n    coord = vec2(\n      coord.x * c - coord.y * s,\n      coord.x * s + coord.y * c\n    );\n  }\n  coord += texCenter;\n  return coord;\n}\n\nvec4 swirl_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 coord = texCoord * texSize;\n  coord = swirl_warp(coord, swirl.center * texSize);\n\n  return warp_sampleColor(source, texSize, coord);\n}\n";
     readonly props: SwirlProps;
     readonly uniforms: SwirlProps;

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

@@ -1 +1 @@
-{"version":3,"file":"swirl.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-warp-filters/swirl.ts"],"names":[],"mappings":"AAwEA;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,oFAAoF;IACpF,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1B,0CAA0C;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oGAAoG;IACpG,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC;AAEvC;;GAEG;AACH,eAAO,MAAM,KAAK;;;;;;;;;;oBAMH,UAAU;uBACP,UAAU;;;;;;;;;;;;;;;;;;;;;;;;CAa2B,CAAC"}
+{"version":3,"file":"swirl.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-warp-filters/swirl.ts"],"names":[],"mappings":"AA6EA;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,oFAAoF;IACpF,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1B,0CAA0C;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oGAAoG;IACpG,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC;AAEvC;;GAEG;AACH,eAAO,MAAM,KAAK;;;;;;;;;;oBAMH,UAAU;uBACP,UAAU;;;;;;;;;;;;;;;;;;;;;;;;CAa2B,CAAC"}

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

@@ -3,23 +3,23 @@
 // Copyright (c) vis.gl contributors
 import { warp } from "./warp.js";
 const source = /* wgsl */ `\
-uniform swirlUniforms {
+struct swirlUniforms {
   radius: f32,
   angle: f32,
   center: vec2f,
 };
 
-@group(0) @binding(1) swirl: swirlUniforms;
+@group(0) @binding(1) var<uniform> swirl: swirlUniforms;
 
-fn swirl_warp(vec2 coord, vec2 texCenter) -> vec2f {
-  coord -= texCenter;
-  float distance = length(coord);
+fn swirl_warp(coordIn: vec2f, texCenter: vec2f) -> vec2f {
+  var coord = coordIn - texCenter;
+  let 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(
+    let percent = (swirl.radius - distance) / swirl.radius;
+    let theta = percent * percent * swirl.angle;
+    let s = sin(theta);
+    let c = cos(theta);
+    coord = vec2f(
       coord.x * c - coord.y * s,
       coord.x * s + coord.y * c
     );
@@ -28,10 +28,15 @@ fn swirl_warp(vec2 coord, vec2 texCenter) -> vec2f {
   return coord;
 }
 
-fn swirl_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) -> vec4f {
-  vec2 coord = texCoord * texSize;
+fn swirl_sampleColor(
+  sourceTexture: texture_2d<f32>,
+  sourceTextureSampler: sampler,
+  texSize: vec2f,
+  texCoord: vec2f
+) -> vec4f {
+  var coord = texCoord * texSize;
   coord = swirl_warp(coord, swirl.center * texSize);
-  return warp_sampleColor(source, texSize, coord);
+  return warp_sampleColor(sourceTexture, sourceTextureSampler, texSize, coord);
 }
 `;
 const fs = /* glsl */ `\

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

@@ -1 +1 @@
-{"version":3,"file":"swirl.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-warp-filters/swirl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAGpC,OAAO,EAAC,IAAI,EAAC,kBAAe;AAE5B,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BrB,CAAC;AAgBF;;GAEG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,IAAI,EAAE,OAAO;IACb,YAAY,EAAE,CAAC,IAAI,CAAC;IACpB,MAAM;IACN,EAAE;IAEF,KAAK,EAAE,EAAgB;IACvB,QAAQ,EAAE,EAAgB;IAC1B,YAAY,EAAE;QACZ,MAAM,EAAE,WAAW;QACnB,MAAM,EAAE,KAAK;QACb,KAAK,EAAE,KAAK;KACb;IACD,SAAS,EAAE;QACT,MAAM,EAAE,EAAC,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAC;QAC3B,MAAM,EAAE,EAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,GAAG,EAAC;QAC1C,KAAK,EAAE,EAAC,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,EAAE,OAAO,EAAE,EAAE,EAAC;KAC7C;IAED,MAAM,EAAE,CAAC,EAAC,OAAO,EAAE,IAAI,EAAC,CAAC;CAC4B,CAAC"}
+{"version":3,"file":"swirl.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-warp-filters/swirl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAGpC,OAAO,EAAC,IAAI,EAAC,kBAAe;AAE5B,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BrB,CAAC;AAgBF;;GAEG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,IAAI,EAAE,OAAO;IACb,YAAY,EAAE,CAAC,IAAI,CAAC;IACpB,MAAM;IACN,EAAE;IAEF,KAAK,EAAE,EAAgB;IACvB,QAAQ,EAAE,EAAgB;IAC1B,YAAY,EAAE;QACZ,MAAM,EAAE,WAAW;QACnB,MAAM,EAAE,KAAK;QACb,KAAK,EAAE,KAAK;KACb;IACD,SAAS,EAAE;QACT,MAAM,EAAE,EAAC,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAC;QAC3B,MAAM,EAAE,EAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,GAAG,EAAC;QAC1C,KAAK,EAAE,EAAC,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,EAAE,OAAO,EAAE,EAAE,EAAC;KAC7C;IAED,MAAM,EAAE,CAAC,EAAC,OAAO,EAAE,IAAI,EAAC,CAAC;CAC4B,CAAC"}

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

@@ -2,7 +2,7 @@ export type WarpProps = {};
 export type WarpUniforms = WarpProps;
 export declare const warp: {
     readonly name: "warp";
-    readonly source: "vec4 warp_sampleColor(sampler2D source, vec2 texSize, vec2 coord) {\n  vec4 color = texture(source, coord / texSize);\n  vec2 clampedCoord = clamp(coord, vec2(0.0), texSize);\n  if (coord != clampedCoord) {\n    /* fade to transparent if we are outside the image */\n    color.a *= max(0.0, 1.0 - length(coord - clampedCoord));\n  }\n  return color;\n}\n";
+    readonly source: "fn warp_sampleColor(\n  sourceTexture: texture_2d<f32>,\n  sourceTextureSampler: sampler,\n  texSize: vec2f,\n  coord: vec2f\n) -> vec4f {\n  var color = textureSample(sourceTexture, sourceTextureSampler, coord / texSize);\n  let clampedCoord = clamp(coord, vec2f(0.0), texSize);\n  if (any(coord != clampedCoord)) {\n    /* fade to transparent if we are outside the image */\n    color.a *= max(0.0, 1.0 - length(coord - clampedCoord));\n  }\n  return color;\n}\n";
     readonly fs: "vec4 warp_sampleColor(sampler2D source, vec2 texSize, vec2 coord) {\n  vec4 color = texture(source, coord / texSize);\n  vec2 clampedCoord = clamp(coord, vec2(0.0), texSize);\n  if (coord != clampedCoord) {\n    /* fade to transparent if we are outside the image */\n    color.a *= max(0.0, 1.0 - length(coord - clampedCoord));\n  }\n  return color;\n}\n";
     readonly passes: [];
 };

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

@@ -1 +1 @@
-{"version":3,"file":"warp.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-warp-filters/warp.ts"],"names":[],"mappings":"AA8BA,MAAM,MAAM,SAAS,GAAG,EAAE,CAAC;AAE3B,MAAM,MAAM,YAAY,GAAG,SAAS,CAAC;AAErC,eAAO,MAAM,IAAI;;;;;CAMoC,CAAC"}
+{"version":3,"file":"warp.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-warp-filters/warp.ts"],"names":[],"mappings":"AAmCA,MAAM,MAAM,SAAS,GAAG,EAAE,CAAC;AAE3B,MAAM,MAAM,YAAY,GAAG,SAAS,CAAC;AAErC,eAAO,MAAM,IAAI;;;;;CAMoC,CAAC"}

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

@@ -2,10 +2,15 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 const source = /* 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) {
+fn warp_sampleColor(
+  sourceTexture: texture_2d<f32>,
+  sourceTextureSampler: sampler,
+  texSize: vec2f,
+  coord: vec2f
+) -> vec4f {
+  var color = textureSample(sourceTexture, sourceTextureSampler, coord / texSize);
+  let clampedCoord = clamp(coord, vec2f(0.0), texSize);
+  if (any(coord != clampedCoord)) {
     /* fade to transparent if we are outside the image */
     color.a *= max(0.0, 1.0 - length(coord - clampedCoord));
   }

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

@@ -1 +1 @@
-{"version":3,"file":"warp.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-warp-filters/warp.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;CAUzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;CAUrB,CAAC;AAMF,MAAM,CAAC,MAAM,IAAI,GAAG;IAClB,IAAI,EAAE,MAAM;IACZ,MAAM;IACN,EAAE;IAEF,MAAM,EAAE,EAAE;CACyC,CAAC"}
+{"version":3,"file":"warp.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-warp-filters/warp.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;CAezB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;CAUrB,CAAC;AAMF,MAAM,CAAC,MAAM,IAAI,GAAG;IAClB,IAAI,EAAE,MAAM;IACZ,MAAM;IACN,EAAE;IAEF,MAAM,EAAE,EAAE;CACyC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luma.gl/effects",
-  "version": "9.3.0-alpha.2",
+  "version": "9.3.0-alpha.6",
   "description": "Post-processing effects for luma.gl",
   "type": "module",
   "license": "MIT",
@@ -52,5 +52,5 @@
     "@math.gl/core": "^4.1.0",
     "@math.gl/types": "^4.1.0"
   },
-  "gitHead": "7fedf8d8902f58490a4ffca9a873daee3c732f24"
+  "gitHead": "59fda5480c4d0bb3d64545d4621175221f2b6c7c"
 }

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

@@ -14,13 +14,14 @@ struct brightnessContrastUniforms {
 @group(0) @binding(1) var<uniform> brightnessContrast : brightnessContrastUniforms;
 
 fn brightnessContrast_filterColor_ext(color: vec4f, texSize: vec2<f32>, texCoords: vec2<f32>) -> vec4f {
-  color.rgb += brightnessContrast.brightness;
+  var result = color;
+  result.rgb += vec3f(brightnessContrast.brightness);
   if (brightnessContrast.contrast > 0.0) {
-    color.rgb = (color.rgb - 0.5) / (1.0 - brightnessContrast.contrast) + 0.5;
+    result.rgb = (result.rgb - vec3f(0.5)) / (1.0 - brightnessContrast.contrast) + vec3f(0.5);
   } else {
-    color.rgb = (color.rgb - 0.5) * (1.0 + brightnessContrast.contrast) + 0.5;
+    result.rgb = (result.rgb - vec3f(0.5)) * (1.0 + brightnessContrast.contrast) + vec3f(0.5);
   }
-  return vec4f(1.0, 0.0, 0.0, 1.0);
+  return result;
 }
 `;
 

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

@@ -6,33 +6,41 @@ import type {ShaderPass} from '@luma.gl/shadertools';
 
 // Do a 9x9 bilateral box filter
 const source = /* wgsl */ `\
-
 struct denoiseUniforms {
-  strength: f32
+  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. - denoise.strength, 4.);
-	let center: vec4<f32> = sample_texture(BUFFER_source, texCoord);
-	var color: vec4<f32> = vec4<f32>(0.);
-	var total: f32 = 0.;
-
-	for (var x: f32 = -4.; x <= 4.; x = x + (1.)) {
-
-		for (var y: f32 = -4.; y <= 4.; y = y + (1.)) {
-			let offsetColor: vec4<f32> = sample_texture(BUFFER_source, texCoord + vec2<f32>(x, y) / texSize);
-			var weight: f32 = 1. - abs(dot(offsetColor.rgb - center.rgb, vec3<f32>(0.25)));
-			weight = pow(weight, adjustedExponent);
-			color = color + (offsetColor * weight);
-			total = total + (weight);
-		}
-
-	}
+@group(0) @binding(1) var<uniform> denoise: denoiseUniforms;
+
+fn denoise_sampleColor(
+  sourceTexture: texture_2d<f32>,
+  sourceTextureSampler: sampler,
+  texSize: vec2f,
+  texCoord: vec2f
+) -> vec4f {
+  let adjustedExponent = 3.0 + 200.0 * pow(1.0 - denoise.strength, 4.0);
+  let center = textureSample(sourceTexture, sourceTextureSampler, texCoord);
+  var color = vec4f(0.0);
+  var total = 0.0;
+
+  for (var x = -4.0; x <= 4.0; x += 1.0) {
+    for (var y = -4.0; y <= 4.0; y += 1.0) {
+      let offsetColor = textureSample(
+        sourceTexture,
+        sourceTextureSampler,
+        texCoord + vec2f(x, y) / texSize
+      );
+      let weight = pow(
+        1.0 - abs(dot(offsetColor.rgb - center.rgb, vec3f(0.25))),
+        adjustedExponent
+      );
+      color += offsetColor * weight;
+      total += weight;
+    }
+  }
 
-	return color / total;
-} 
+  return color / total;
+}
 `;
 
 const fs = /* glsl */ `\

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

@@ -5,45 +5,39 @@
 import type {ShaderPass} from '@luma.gl/shadertools';
 
 const source = /* wgsl */ `\
-
 struct hueSaturationUniforms {
   hue: f32,
   saturation: f32,
 };
 
-@group(0), @binding(1) var<uniform> hueSaturation: hueSaturationUniforms;
-
-fn hueSaturation_filterColor(color: vec4<f32>) -> vec4<f32> {
-	let angle: f32 = hueSaturation.hue * 3.1415927;
-	let s: f32 = sin(angle);
-	let c: f32 = cos(angle);
-	let weights: vec3<f32> = (vec3<f32>(2. * c, -sqrt(3.) * s - c, sqrt(3.) * s - c) + 1.) / 3.;
-	let len: f32 = length(color.rgb);
-	var colorrgb = color.rgb;
-	colorrgb = vec3<f32>(dot(color.rgb, weights.xyz), dot(color.rgb, weights.zxy), dot(color.rgb, weights.yzx));
-	color.r = colorrgb.x;
-	color.g = colorrgb.y;
-	color.b = colorrgb.z;
-	let average: f32 = (color.r + color.g + color.b) / 3.;
-	if (hueSaturation.saturation > 0.) {
-		var colorrgb = color.rgb;
-	colorrgb = color.rgb + ((average - color.rgb) * (1. - 1. / (1.001 - hueSaturation.saturation)));
-	color.r = colorrgb.x;
-	color.g = colorrgb.y;
-	color.b = colorrgb.z;
-	} else { 
-		var colorrgb = color.rgb;
-	colorrgb = color.rgb + ((average - color.rgb) * -hueSaturation.saturation);
-	color.r = colorrgb.x;
-	color.g = colorrgb.y;
-	color.b = colorrgb.z;
-	}
-	return color;
-} 
-
-fn hueSaturation_filterColor_ext(color: vec4<f32>, texSize: vec2<f32>, texCoord: vec2<f32>) -> vec4<f32> {
-	return hueSaturation_filterColor(color);
-} 
+@group(0) @binding(1) var<uniform> hueSaturation: hueSaturationUniforms;
+
+fn hueSaturation_filterColor(color: vec4f) -> vec4f {
+  let angle = hueSaturation.hue * 3.14159265;
+  let s = sin(angle);
+  let c = cos(angle);
+  let weights = (vec3f(2.0 * c, -sqrt(3.0) * s - c, sqrt(3.0) * s - c) + vec3f(1.0)) / 3.0;
+
+  var result = color;
+  result.rgb = vec3f(
+    dot(result.rgb, weights.xyz),
+    dot(result.rgb, weights.zxy),
+    dot(result.rgb, weights.yzx)
+  );
+
+  let average = (result.r + result.g + result.b) / 3.0;
+  if (hueSaturation.saturation > 0.0) {
+    result.rgb += (vec3f(average) - result.rgb) * (1.0 - 1.0 / (1.001 - hueSaturation.saturation));
+  } else {
+    result.rgb += (vec3f(average) - result.rgb) * (-hueSaturation.saturation);
+  }
+
+  return result;
+}
+
+fn hueSaturation_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> vec4f {
+  return hueSaturation_filterColor(color);
+}
 `;
 
 const fs = /* glsl */ `\

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

@@ -6,7 +6,7 @@ import type {ShaderPass} from '@luma.gl/shadertools';
 
 const source = /* wgsl */ `\
 struct noiseUniforms {
-  amount: f32
+  amount: f32,
 };
 
 @group(0) @binding(1) var<uniform> noise: noiseUniforms;
@@ -16,12 +16,13 @@ fn rand(co: vec2f) -> 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);
-	color.b = color.b + (diff);
-	return color;
-} 
+  let diff = (rand(texCoord) - 0.5) * noise.amount;
+  var result = color;
+  result.r += diff;
+  result.g += diff;
+  result.b += diff;
+  return result;
+}
 `;
 
 const fs = /* glsl */ `\

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

@@ -6,25 +6,26 @@ import type {ShaderPass} from '@luma.gl/shadertools';
 
 const source = /* wgsl */ `\
 struct sepiaUniforms {
-  amount: f32
+  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;
+  let r = color.r;
+  let g = color.g;
+  let b = color.b;
 
-  color.r =
+  var result = color;
+  result.r =
     min(1.0, (r * (1.0 - (0.607 * sepia.amount))) + (g * (0.769 * sepia.amount)) + (b * (0.189 * sepia.amount)));
-  color.g = min(1.0, (r * 0.349 * sepia.amount) + (g * (1.0 - (0.314 * sepia.amount))) + (b * 0.168 * sepia.amount));
-  color.b = min(1.0, (r * 0.272 * sepia.amount) + (g * 0.534 * sepia.amount) + (b * (1.0 - (0.869 * sepia.amount))));
+  result.g = min(1.0, (r * 0.349 * sepia.amount) + (g * (1.0 - (0.314 * sepia.amount))) + (b * 0.168 * sepia.amount));
+  result.b = min(1.0, (r * 0.272 * sepia.amount) + (g * 0.534 * sepia.amount) + (b * (1.0 - (0.869 * sepia.amount))));
 
-  return color;
+  return result;
 }
 
-vec4 sepia_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
+fn sepia_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> vec4f {
   return sepia_filterColor(color);
 }
 `;

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

@@ -6,20 +6,21 @@ import type {ShaderPass} from '@luma.gl/shadertools';
 
 const source = /* wgsl */ `\
 struct vibranceUniforms {
-  amount: f32
+  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;
+fn vibrance_filterColor(color: vec4f) -> vec4f {
+  let average = (color.r + color.g + color.b) / 3.0;
+  let mx = max(color.r, max(color.g, color.b));
+  let amt = (mx - average) * (-vibrance.amount * 3.0);
+  var result = color;
+  result.rgb = mix(result.rgb, vec3f(mx), amt);
+  return result;
 }
 
-vec4 vibrance_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
+fn vibrance_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> vec4f {
   return vibrance_filterColor(color);
 }
 `;

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

@@ -7,23 +7,19 @@ import type {ShaderPass} from '@luma.gl/shadertools';
 const source = /* wgsl */ `\
 struct vignetteUniforms {
   radius: f32,
-  amount: 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;
-}
-
-fn vignette_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) ->vec4f {
-  let dist: f32 = distance(texCoord, vec2f(0.5, 0.5));
-  let ratio: f32 = smoothstep(0.8, vignette.radius * 0.799, dist * (vignette.amount + vignette.radius));
-  return color.rgba * ratio + (1.0 - ratio)*vec4f(0.0, 0.0, 0.0, 1.0);
+fn vignette_filterColor_ext(color: vec4f, texSize: vec2f, texCoord: vec2f) -> vec4f {
+  let dist = distance(texCoord, vec2f(0.5, 0.5));
+  let ratio = smoothstep(
+    0.8,
+    vignette.radius * 0.799,
+    dist * (vignette.amount + vignette.radius)
+  );
+  return color * ratio + vec4f(0.0, 0.0, 0.0, 1.0) * (1.0 - ratio);
 }
 `;