@luma.gl/effects 7.4.0-alpha.2 → 9.1.0-beta.3

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

@@ -0,0 +1,43 @@
+/**
+ * Denoise -
+ * Smooths over grainy noise in dark images using an 9x9 box filter
+ * weighted by color intensity, similar to a bilateral filter.
+ */
+export type DenoiseProps = {
+    /**
+     * The exponent of the color intensity difference, should be greater
+     * than zero. A value of zero just gives an 9x9 box blur and high values
+     * give the original image, but ideal values are usually around 10-20.
+     */
+    strength?: number;
+};
+export type DenoiseUniforms = DenoiseProps;
+/**
+ * Denoise -
+ * Smooths over grainy noise in dark images using an 9x9 box filter
+ * weighted by color intensity, similar to a bilateral filter.
+ */
+export declare const denoise: {
+    readonly props: DenoiseProps;
+    readonly uniforms: DenoiseUniforms;
+    readonly name: "denoise";
+    readonly uniformTypes: {
+        readonly strength: "f32";
+    };
+    readonly propTypes: {
+        readonly strength: {
+            readonly format: "f32";
+            readonly value: 0.5;
+            readonly min: 0;
+            readonly max: 1;
+        };
+    };
+    readonly source: "\n@group(?), @binding(?) var<uniform> denoiseUniforms {\t\tstrength: f32 } noise;\n\nfn denoise_sampleColor(source: sampler2D, texSize: vec2<f32>, texCoord: vec2<f32>) -> vec4<f32> {\n\tlet adjustedExponent: f32 = 3. + 200. * pow(1. - noise.strength, 4.);\n\tlet center: vec4<f32> = sample_texture(BUFFER_source, texCoord);\n\tvar color: vec4<f32> = vec4<f32>(0.);\n\tvar total: f32 = 0.;\n\n\tfor (var x: f32 = -4.; x <= 4.; x = x + (1.)) {\n\n\t\tfor (var y: f32 = -4.; y <= 4.; y = y + (1.)) {\n\t\t\tlet offsetColor: vec4<f32> = sample_texture(BUFFER_source, texCoord + vec2<f32>(x, y) / texSize);\n\t\t\tvar weight: f32 = 1. - abs(dot(offsetColor.rgb - center.rgb, vec3<f32>(0.25)));\n\t\t\tweight = pow(weight, adjustedExponent);\n\t\t\tcolor = color + (offsetColor * weight);\n\t\t\ttotal = total + (weight);\n\t\t}\n\n\t}\n\n\treturn color / total;\n} \n";
+    readonly fs: "uniform denoiseUniforms {\n  float strength;\n} noise;\n\nvec4 denoise_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  float adjustedExponent = 3. + 200. * pow(1. - noise.strength, 4.);\n\n  vec4 center = texture(source, texCoord);\n  vec4 color = vec4(0.0);\n  float total = 0.0;\n  for (float x = -4.0; x <= 4.0; x += 1.0) {\n    for (float y = -4.0; y <= 4.0; y += 1.0) {\n      vec4 offsetColor = texture(source, texCoord + vec2(x, y) / texSize);\n      float weight = 1.0 - abs(dot(offsetColor.rgb - center.rgb, vec3(0.25)));\n      weight = pow(weight, adjustedExponent);\n      color += offsetColor * weight;\n      total += weight;\n    }\n  }\n\n  return color / total;\n}\n";
+    readonly passes: [{
+        readonly sampler: true;
+    }, {
+        readonly sampler: true;
+    }];
+};
+//# sourceMappingURL=denoise.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"denoise.d.ts","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-adjust-filters/denoise.ts"],"names":[],"mappings":"AA0DA;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,YAAY,CAAC;AAE3C;;;;GAIG;AACH,eAAO,MAAM,OAAO;oBACL,YAAY;uBACT,eAAe;;;;;;;;;;;;;;;;;;;;CAe6B,CAAC"}

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

@@ -0,0 +1,74 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Do a 9x9 bilateral box filter
+const source = /* wgsl */ `\
+
+@group(?), @binding(?) var<uniform> denoiseUniforms {		strength: f32 } noise;
+
+fn denoise_sampleColor(source: sampler2D, texSize: vec2<f32>, texCoord: vec2<f32>) -> vec4<f32> {
+	let adjustedExponent: f32 = 3. + 200. * pow(1. - noise.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);
+		}
+
+	}
+
+	return color / total;
+} 
+`;
+const fs = /* glsl */ `\
+uniform denoiseUniforms {
+  float strength;
+} noise;
+
+vec4 denoise_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
+  float adjustedExponent = 3. + 200. * pow(1. - noise.strength, 4.);
+
+  vec4 center = texture(source, texCoord);
+  vec4 color = vec4(0.0);
+  float total = 0.0;
+  for (float x = -4.0; x <= 4.0; x += 1.0) {
+    for (float y = -4.0; y <= 4.0; y += 1.0) {
+      vec4 offsetColor = texture(source, texCoord + vec2(x, y) / texSize);
+      float weight = 1.0 - abs(dot(offsetColor.rgb - center.rgb, vec3(0.25)));
+      weight = pow(weight, adjustedExponent);
+      color += offsetColor * weight;
+      total += weight;
+    }
+  }
+
+  return color / total;
+}
+`;
+/**
+ * Denoise -
+ * Smooths over grainy noise in dark images using an 9x9 box filter
+ * weighted by color intensity, similar to a bilateral filter.
+ */
+export const denoise = {
+    props: {},
+    uniforms: {},
+    name: 'denoise',
+    uniformTypes: {
+        strength: 'f32'
+    },
+    propTypes: {
+        strength: { format: 'f32', value: 0.5, min: 0, max: 1 }
+        // strength: {..., adjust: (strength: number): number => 0.53 + 200 * Math.pow(1 - strength, 4) // TODO - JS preprocessing
+    },
+    source,
+    fs,
+    passes: [{ sampler: true }, { sampler: true }]
+};
+//# sourceMappingURL=denoise.js.map

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

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

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

@@ -0,0 +1,46 @@
+/**
+ * Hue / Saturation
+ */
+export type HueSaturationProps = {
+    /** -1 to 1 (-1 is 180 degree rotation in the negative direction, 0 is no change,
+     * and 1 is 180 degree rotation in the positive direction) */
+    hue?: number;
+    /** -1 to 1 (-1 is solid gray, 0 is no change, and 1 is maximum contrast) */
+    saturation?: number;
+};
+export type HueSaturationUniforms = HueSaturationProps;
+/**
+ * Hue / Saturation
+ * Provides rotational hue and multiplicative saturation control. RGB color space
+ * can be imagined as a cube where the axes are the red, green, and blue color
+ * values. Hue changing works by rotating the color vector around the grayscale
+ * line, which is the straight line from black (0, 0, 0) to white (1, 1, 1).
+ * Saturation is implemented by scaling all color channel values either toward
+ * or away from the average color channel value.
+ */
+export declare const hueSaturation: {
+    readonly props: HueSaturationProps;
+    readonly name: "hueSaturation";
+    readonly source: "@group(?), @binding(?)\nvar<uniform> hueSaturationUniforms {\t\thue: f32,\n\n\t\tsaturation: f32,\n\n}hueSaturation;\n\nfn hueSaturation_filterColor(color: vec4<f32>) -> vec4<f32> {\n\tlet angle: f32 = hueSaturation.hue * 3.1415927;\n\tlet s: f32 = sin(angle);\n\tlet c: f32 = cos(angle);\n\tlet weights: vec3<f32> = (vec3<f32>(2. * c, -sqrt(3.) * s - c, sqrt(3.) * s - c) + 1.) / 3.;\n\tlet len: f32 = length(color.rgb);\n\tvar colorrgb = color.rgb;\n\tcolorrgb = vec3<f32>(dot(color.rgb, weights.xyz), dot(color.rgb, weights.zxy), dot(color.rgb, weights.yzx));\n\tcolor.r = colorrgb.x;\n\tcolor.g = colorrgb.y;\n\tcolor.b = colorrgb.z;\n\tlet average: f32 = (color.r + color.g + color.b) / 3.;\n\tif (hueSaturation.saturation > 0.) {\n\t\tvar colorrgb = color.rgb;\n\tcolorrgb = color.rgb + ((average - color.rgb) * (1. - 1. / (1.001 - hueSaturation.saturation)));\n\tcolor.r = colorrgb.x;\n\tcolor.g = colorrgb.y;\n\tcolor.b = colorrgb.z;\n\t} else { \n\t\tvar colorrgb = color.rgb;\n\tcolorrgb = color.rgb + ((average - color.rgb) * -hueSaturation.saturation);\n\tcolor.r = colorrgb.x;\n\tcolor.g = colorrgb.y;\n\tcolor.b = colorrgb.z;\n\t}\n\treturn color;\n} \n\nfn hueSaturation_filterColor_ext(color: vec4<f32>, texSize: vec2<f32>, texCoord: vec2<f32>) -> vec4<f32> {\n\treturn hueSaturation_filterColor(color);\n} \n";
+    readonly fs: "uniform hueSaturationUniforms {\n  float hue;\n  float saturation;\n} hueSaturation;\n\nvec4 hueSaturation_filterColor(vec4 color) {\n  // hue adjustment, wolfram alpha: RotationTransform[angle, {1, 1, 1}][{x, y, z}]\n  float angle = hueSaturation.hue * 3.14159265;\n  float s = sin(angle), c = cos(angle);\n  vec3 weights = (vec3(2.0 * c, -sqrt(3.0) * s - c, sqrt(3.0) * s - c) + 1.0) / 3.0;\n  float len = length(color.rgb);\n  color.rgb = vec3(\n    dot(color.rgb, weights.xyz),\n    dot(color.rgb, weights.zxy),\n    dot(color.rgb, weights.yzx)\n  );\n\n  // saturation adjustment\n  float average = (color.r + color.g + color.b) / 3.0;\n  if (hueSaturation.saturation > 0.0) {\n    color.rgb += (average - color.rgb) * (1.0 - 1.0 / (1.001 - hueSaturation.saturation));\n  } else {\n    color.rgb += (average - color.rgb) * (-hueSaturation.saturation);\n  }\n\n  return color;\n}\n\nvec4 hueSaturation_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  return hueSaturation_filterColor(color);\n}\n";
+    readonly uniformTypes: {
+        readonly hue: "f32";
+        readonly saturation: "f32";
+    };
+    readonly propTypes: {
+        readonly hue: {
+            readonly value: 0;
+            readonly min: -1;
+            readonly max: 1;
+        };
+        readonly saturation: {
+            readonly value: 0;
+            readonly min: -1;
+            readonly max: 1;
+        };
+    };
+    readonly passes: [{
+        readonly filter: true;
+    }];
+};
+//# sourceMappingURL=huesaturation.d.ts.map

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

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

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

@@ -0,0 +1,101 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const source = /* wgsl */ `\
+@group(?), @binding(?)
+var<uniform> hueSaturationUniforms {		hue: f32,
+
+		saturation: f32,
+
+}hueSaturation;
+
+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);
+} 
+`;
+const fs = /* glsl */ `\
+uniform hueSaturationUniforms {
+  float hue;
+  float saturation;
+} hueSaturation;
+
+vec4 hueSaturation_filterColor(vec4 color) {
+  // hue adjustment, wolfram alpha: RotationTransform[angle, {1, 1, 1}][{x, y, z}]
+  float angle = hueSaturation.hue * 3.14159265;
+  float s = sin(angle), c = cos(angle);
+  vec3 weights = (vec3(2.0 * c, -sqrt(3.0) * s - c, sqrt(3.0) * s - c) + 1.0) / 3.0;
+  float len = length(color.rgb);
+  color.rgb = vec3(
+    dot(color.rgb, weights.xyz),
+    dot(color.rgb, weights.zxy),
+    dot(color.rgb, weights.yzx)
+  );
+
+  // saturation adjustment
+  float average = (color.r + color.g + color.b) / 3.0;
+  if (hueSaturation.saturation > 0.0) {
+    color.rgb += (average - color.rgb) * (1.0 - 1.0 / (1.001 - hueSaturation.saturation));
+  } else {
+    color.rgb += (average - color.rgb) * (-hueSaturation.saturation);
+  }
+
+  return color;
+}
+
+vec4 hueSaturation_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
+  return hueSaturation_filterColor(color);
+}
+`;
+/**
+ * Hue / Saturation
+ * Provides rotational hue and multiplicative saturation control. RGB color space
+ * can be imagined as a cube where the axes are the red, green, and blue color
+ * values. Hue changing works by rotating the color vector around the grayscale
+ * line, which is the straight line from black (0, 0, 0) to white (1, 1, 1).
+ * Saturation is implemented by scaling all color channel values either toward
+ * or away from the average color channel value.
+ */
+export const hueSaturation = {
+    props: {},
+    name: 'hueSaturation',
+    source,
+    fs,
+    uniformTypes: {
+        hue: 'f32',
+        saturation: 'f32'
+    },
+    propTypes: {
+        hue: { value: 0, min: -1, max: 1 },
+        saturation: { value: 0, min: -1, max: 1 }
+    },
+    passes: [{ filter: true }]
+};
+//# sourceMappingURL=huesaturation.js.map

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

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

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

@@ -0,0 +1,33 @@
+/**
+ * Noise - Adds black and white noise to the image.
+ */
+export type NoiseProps = {
+    /**  0 to 1 (0 for no effect, 1 for maximum noise) */
+    amount?: number;
+};
+export type NoiseUniforms = NoiseProps;
+/**
+ * Noise
+ * Adds black and white noise to the image.
+ */
+export declare const noise: {
+    readonly props: NoiseProps;
+    readonly uniforms: NoiseUniforms;
+    readonly name: "noise";
+    readonly uniformTypes: {
+        readonly amount: "f32";
+    };
+    readonly propTypes: {
+        readonly amount: {
+            readonly value: 0.5;
+            readonly min: 0;
+            readonly max: 1;
+        };
+    };
+    readonly fs: "uniform noiseUniforms {\n  float amount;\n} noise;\n\nfloat rand(vec2 co) {\n  return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);\n}\n\nvec4 noise_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  float diff = (rand(texCoord) - 0.5) * noise.amount;\n  color.r += diff;\n  color.g += diff;\n  color.b += diff;\n  return color;\n}\n";
+    readonly source: "struct noiseUniforms {\n  amount: f32\n};\n\n@group(0), @binding(0) var<uniform> noise: NoiseUniforms;\n\nfn rand(co: vec2<f32>) -> f32 {\n\treturn fract(sin(dot(co.xy, vec2<f32>(12.9898, 78.233))) * 43758.547);\n} \n\nfn noise_filterColor_ext(color: vec4<f32>, texSize: vec2<f32>, texCoord: vec2<f32>) -> vec4<f32> {\n\tlet diff: f32 = (rand(texCoord) - 0.5) * noise.amount;\n\tcolor.r = color.r + (diff);\n\tcolor.g = color.g + (diff);\n\tcolor.b = color.b + (diff);\n\treturn color;\n} \n";
+    readonly passes: [{
+        readonly filter: true;
+    }];
+};
+//# sourceMappingURL=noise.d.ts.map

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

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

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

@@ -0,0 +1,58 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const source = /* wgsl */ `\
+struct noiseUniforms {
+  amount: f32
+};
+
+@group(0), @binding(0) var<uniform> noise: NoiseUniforms;
+
+fn rand(co: vec2<f32>) -> f32 {
+	return fract(sin(dot(co.xy, vec2<f32>(12.9898, 78.233))) * 43758.547);
+} 
+
+fn noise_filterColor_ext(color: vec4<f32>, texSize: vec2<f32>, texCoord: vec2<f32>) -> vec4<f32> {
+	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;
+} 
+`;
+const fs = /* glsl */ `\
+uniform noiseUniforms {
+  float amount;
+} noise;
+
+float rand(vec2 co) {
+  return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
+}
+
+vec4 noise_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
+  float diff = (rand(texCoord) - 0.5) * noise.amount;
+  color.r += diff;
+  color.g += diff;
+  color.b += diff;
+  return color;
+}
+`;
+/**
+ * Noise
+ * Adds black and white noise to the image.
+ */
+export const noise = {
+    props: {},
+    uniforms: {},
+    name: 'noise',
+    uniformTypes: {
+        amount: 'f32'
+    },
+    propTypes: {
+        amount: { value: 0.5, min: 0, max: 1 }
+    },
+    fs,
+    source,
+    passes: [{ filter: true }]
+};
+//# sourceMappingURL=noise.js.map

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

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

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

@@ -0,0 +1,29 @@
+export type SepiaProps = {
+    amount?: number;
+};
+export type SepiaUniforms = SepiaProps;
+/**
+ * @filter         Sepia
+ * @description    Gives the image a reddish-brown monochrome tint that imitates an old photograph.
+ * @param amount   0 to 1 (0 for no effect, 1 for full sepia coloring)
+ */
+export declare const sepia: {
+    readonly props: SepiaProps;
+    readonly uniforms: SepiaUniforms;
+    readonly name: "sepia";
+    readonly uniformTypes: {
+        readonly amount: "f32";
+    };
+    readonly propTypes: {
+        readonly amount: {
+            readonly value: 0.5;
+            readonly min: 0;
+            readonly max: 1;
+        };
+    };
+    readonly fs: "uniform sepiaUniforms {\n  float amount;\n} sepia;\n\nvec4 sepia_filterColor(vec4 color) {\n  float r = color.r;\n  float g = color.g;\n  float b = color.b;\n\n  color.r =\n    min(1.0, (r * (1.0 - (0.607 * sepia.amount))) + (g * (0.769 * sepia.amount)) + (b * (0.189 * sepia.amount)));\n  color.g = min(1.0, (r * 0.349 * sepia.amount) + (g * (1.0 - (0.314 * sepia.amount))) + (b * 0.168 * sepia.amount));\n  color.b = min(1.0, (r * 0.272 * sepia.amount) + (g * 0.534 * sepia.amount) + (b * (1.0 - (0.869 * sepia.amount))));\n\n  return color;\n}\n\nvec4 sepia_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  return sepia_filterColor(color);\n}\n";
+    readonly passes: [{
+        readonly filter: true;
+    }];
+};
+//# sourceMappingURL=sepia.d.ts.map

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

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

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

@@ -0,0 +1,44 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const fs = /* glsl */ `\
+uniform sepiaUniforms {
+  float amount;
+} sepia;
+
+vec4 sepia_filterColor(vec4 color) {
+  float r = color.r;
+  float g = color.g;
+  float b = color.b;
+
+  color.r =
+    min(1.0, (r * (1.0 - (0.607 * sepia.amount))) + (g * (0.769 * sepia.amount)) + (b * (0.189 * sepia.amount)));
+  color.g = min(1.0, (r * 0.349 * sepia.amount) + (g * (1.0 - (0.314 * sepia.amount))) + (b * 0.168 * sepia.amount));
+  color.b = min(1.0, (r * 0.272 * sepia.amount) + (g * 0.534 * sepia.amount) + (b * (1.0 - (0.869 * sepia.amount))));
+
+  return color;
+}
+
+vec4 sepia_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
+  return sepia_filterColor(color);
+}
+`;
+/**
+ * @filter         Sepia
+ * @description    Gives the image a reddish-brown monochrome tint that imitates an old photograph.
+ * @param amount   0 to 1 (0 for no effect, 1 for full sepia coloring)
+ */
+export const sepia = {
+    props: {},
+    uniforms: {},
+    name: 'sepia',
+    uniformTypes: {
+        amount: 'f32'
+    },
+    propTypes: {
+        amount: { value: 0.5, min: 0, max: 1 }
+    },
+    fs,
+    passes: [{ filter: true }]
+};
+//# sourceMappingURL=sepia.js.map

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

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

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

@@ -0,0 +1,29 @@
+/**
+ * Vibrance - Modifies the saturation of desaturated colors, leaving saturated colors unmodified.
+ */
+export type VibranceProps = {
+    /** -1 to 1 (-1 is minimum vibrance, 0 is no change, and 1 is maximum vibrance) */
+    amount?: number;
+};
+export type VibranceUniforms = VibranceProps;
+/** Vibrance - Modifies the saturation of desaturated colors, leaving saturated colors unmodified. */
+export declare const vibrance: {
+    readonly props: VibranceProps;
+    readonly uniforms: VibranceUniforms;
+    readonly name: "vibrance";
+    readonly uniformTypes: {
+        readonly amount: "f32";
+    };
+    readonly propTypes: {
+        readonly amount: {
+            readonly value: 0;
+            readonly min: -1;
+            readonly max: 1;
+        };
+    };
+    readonly fs: "uniform vibranceUniforms {\n  float amount;\n} vibrance;\n\nvec4 vibrance_filterColor(vec4 color) {\n  float average = (color.r + color.g + color.b) / 3.0;\n  float mx = max(color.r, max(color.g, color.b));\n  float amt = (mx - average) * (-vibrance.amount * 3.0);\n  color.rgb = mix(color.rgb, vec3(mx), amt);\n  return color;\n}\n\nvec4 vibrance_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  return vibrance_filterColor(color);\n}\n";
+    readonly passes: [{
+        readonly filter: true;
+    }];
+};
+//# sourceMappingURL=vibrance.d.ts.map

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

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

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

@@ -0,0 +1,35 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const fs = /* glsl */ `\
+uniform vibranceUniforms {
+  float amount;
+} vibrance;
+
+vec4 vibrance_filterColor(vec4 color) {
+  float average = (color.r + color.g + color.b) / 3.0;
+  float mx = max(color.r, max(color.g, color.b));
+  float amt = (mx - average) * (-vibrance.amount * 3.0);
+  color.rgb = mix(color.rgb, vec3(mx), amt);
+  return color;
+}
+
+vec4 vibrance_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
+  return vibrance_filterColor(color);
+}
+`;
+/** Vibrance - Modifies the saturation of desaturated colors, leaving saturated colors unmodified. */
+export const vibrance = {
+    props: {},
+    uniforms: {},
+    name: 'vibrance',
+    uniformTypes: {
+        amount: 'f32'
+    },
+    propTypes: {
+        amount: { value: 0, min: -1, max: 1 }
+    },
+    fs,
+    passes: [{ filter: true }]
+};
+//# sourceMappingURL=vibrance.js.map

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

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

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

@@ -0,0 +1,44 @@
+/**
+ * Vignette - Adds a simulated lens edge darkening effect.
+ */
+export type VignetteProps = {
+    /** 0 to 1 (0 for center of frame, 1 for edge of frame) */
+    radius?: number;
+    /** 0 to 1 (0 for no effect, 1 for maximum lens darkening) */
+    amount?: number;
+};
+export type VignetteUniforms = VignetteProps;
+/**
+ * Vignette -
+ * Adds a simulated lens edge darkening effect.
+ */
+export declare const vignette: {
+    readonly props: VignetteProps;
+    readonly uniforms: VignetteUniforms;
+    readonly name: "vignette";
+    readonly uniformTypes: {
+        readonly radius: "f32";
+        readonly amount: "f32";
+    };
+    readonly defaultUniforms: {
+        readonly radius: 0.5;
+        readonly amount: 0.5;
+    };
+    readonly propTypes: {
+        readonly radius: {
+            readonly value: 0.5;
+            readonly min: 0;
+            readonly max: 1;
+        };
+        readonly amount: {
+            readonly value: 0.5;
+            readonly min: 0;
+            readonly max: 1;
+        };
+    };
+    readonly passes: [{
+        readonly filter: true;
+    }];
+    readonly fs: "uniform vignetteUniforms {\n  float radius;\n  float amount;\n} vignette;\n\nvec4 vignette_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {\n  float dist = distance(texCoord, vec2(0.5, 0.5));\n  float ratio = smoothstep(0.8, vignette.radius * 0.799, dist * (vignette.amount + vignette.radius));\n  return color.rgba * ratio + (1.0 - ratio)*vec4(0.0, 0.0, 0.0, 1.0);\n}\n";
+};
+//# sourceMappingURL=vignette.d.ts.map

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

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

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

@@ -0,0 +1,39 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const fs = /* glsl */ `\
+uniform vignetteUniforms {
+  float radius;
+  float amount;
+} vignette;
+
+vec4 vignette_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
+  float dist = distance(texCoord, vec2(0.5, 0.5));
+  float ratio = smoothstep(0.8, vignette.radius * 0.799, dist * (vignette.amount + vignette.radius));
+  return color.rgba * ratio + (1.0 - ratio)*vec4(0.0, 0.0, 0.0, 1.0);
+}
+`;
+/**
+ * Vignette -
+ * Adds a simulated lens edge darkening effect.
+ */
+export const vignette = {
+    props: {},
+    uniforms: {},
+    name: 'vignette',
+    uniformTypes: {
+        radius: 'f32',
+        amount: 'f32'
+    },
+    defaultUniforms: {
+        radius: 0.5,
+        amount: 0.5
+    },
+    propTypes: {
+        radius: { value: 0.5, min: 0, max: 1 },
+        amount: { value: 0.5, min: 0, max: 1 }
+    },
+    passes: [{ filter: true }],
+    fs
+};
+//# sourceMappingURL=vignette.js.map

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

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