@luma.gl/shadertools 9.1.0-alpha.1 → 9.1.0-alpha.12

package/dist/modules/module-injectors.d.ts

@@ -1,3 +1,3 @@
-export declare const MODULE_INJECTORS_VS: string;
-export declare const MODULE_INJECTORS_FS: string;
+export declare const MODULE_INJECTORS_VS = "#ifdef MODULE_LOGDEPTH\n  logdepth_adjustPosition(gl_Position);\n#endif\n";
+export declare const MODULE_INJECTORS_FS = "#ifdef MODULE_MATERIAL\n  gl_FragColor = material_filterColor(gl_FragColor);\n#endif\n\n#ifdef MODULE_LIGHTING\n  gl_FragColor = lighting_filterColor(gl_FragColor);\n#endif\n\n#ifdef MODULE_FOG\n  gl_FragColor = fog_filterColor(gl_FragColor);\n#endif\n\n#ifdef MODULE_PICKING\n  gl_FragColor = picking_filterHighlightColor(gl_FragColor);\n  gl_FragColor = picking_filterPickingColor(gl_FragColor);\n#endif\n\n#ifdef MODULE_LOGDEPTH\n  logdepth_setFragDepth();\n#endif\n";
 //# sourceMappingURL=module-injectors.d.ts.map

package/dist/modules/module-injectors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"module-injectors.d.ts","sourceRoot":"","sources":["../../src/modules/module-injectors.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,mBAAmB,QAI/B,CAAC;AAEF,eAAO,MAAM,mBAAmB,QAqB/B,CAAC"}
+{"version":3,"file":"module-injectors.d.ts","sourceRoot":"","sources":["../../src/modules/module-injectors.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,mBAAmB,8EAI/B,CAAC;AAEF,eAAO,MAAM,mBAAmB,0dAqB/B,CAAC"}

package/dist/modules/module-injectors.js

@@ -1,27 +1,30 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { glsl } from "../lib/glsl-utils/highlight.js";
-export const MODULE_INJECTORS_VS = `\
+export const MODULE_INJECTORS_VS = /* glsl */ `\
 #ifdef MODULE_LOGDEPTH
-logdepth_adjustPosition(gl_Position);
+  logdepth_adjustPosition(gl_Position);
 #endif
 `;
-export const MODULE_INJECTORS_FS = `\
+export const MODULE_INJECTORS_FS = /* glsl */ `\
 #ifdef MODULE_MATERIAL
-gl_FragColor = material_filterColor(gl_FragColor);
+  gl_FragColor = material_filterColor(gl_FragColor);
 #endif
+
 #ifdef MODULE_LIGHTING
-gl_FragColor = lighting_filterColor(gl_FragColor);
+  gl_FragColor = lighting_filterColor(gl_FragColor);
 #endif
+
 #ifdef MODULE_FOG
-gl_FragColor = fog_filterColor(gl_FragColor);
+  gl_FragColor = fog_filterColor(gl_FragColor);
 #endif
+
 #ifdef MODULE_PICKING
-gl_FragColor = picking_filterHighlightColor(gl_FragColor);
-gl_FragColor = picking_filterPickingColor(gl_FragColor);
+  gl_FragColor = picking_filterHighlightColor(gl_FragColor);
+  gl_FragColor = picking_filterPickingColor(gl_FragColor);
 #endif
+
 #ifdef MODULE_LOGDEPTH
-logdepth_setFragDepth();
+  logdepth_setFragDepth();
 #endif
 `;

package/dist/modules/postprocessing/image-adjust-filters/brightnesscontrast.d.ts

@@ -2,6 +2,7 @@ export type BrightnessContrastProps = {
     brightness?: number;
     contrast?: number;
 };
+export type BrightnessContrastUniforms = BrightnessContrastProps;
 /**
  * Brightness / Contrast -
  * Provides additive brightness and multiplicative contrast control.
@@ -9,6 +10,8 @@ export type BrightnessContrastProps = {
  * @param contrast   -1 to 1 (-1 is solid gray, 0 is no change, and 1 is maximum contrast)
  */
 export declare const brightnessContrast: {
+    readonly props: BrightnessContrastProps;
+    readonly uniforms: BrightnessContrastUniforms;
     readonly name: "brightnessContrast";
     readonly uniformTypes: {
         readonly brightness: "f32";
@@ -28,7 +31,7 @@ export declare const brightnessContrast: {
             readonly max: 1;
         };
     };
-    readonly fs: string;
+    readonly fs: "\nuniform brightnessContrastUniforms {\n  float brightness;\n  float contrast;\n} brightnessContrast;\n\nvec4 brightnessContrast_filterColor(vec4 color) {\n  color.rgb += brightnessContrast.brightness;\n  if (brightnessContrast.contrast > 0.0) {\n    color.rgb = (color.rgb - 0.5) / (1.0 - brightnessContrast.contrast) + 0.5;\n  } else {\n    color.rgb = (color.rgb - 0.5) * (1.0 + brightnessContrast.contrast) + 0.5;\n  }\n  return color;\n}\n\nvec4 brightnessContrast_filterColor(vec4 color, vec2 texSize, vec2 texCoords) {\n  return brightnessContrast_filterColor(color);\n}\n";
     readonly passes: [{
         readonly filter: true;
     }];

package/dist/modules/postprocessing/image-adjust-filters/brightnesscontrast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"brightnesscontrast.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-adjust-filters/brightnesscontrast.ts"],"names":[],"mappings":"AA6BA,MAAM,MAAM,uBAAuB,GAAG;IACpC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;CAYyB,CAAC"}
+{"version":3,"file":"brightnesscontrast.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-adjust-filters/brightnesscontrast.ts"],"names":[],"mappings":"AA4BA,MAAM,MAAM,uBAAuB,GAAG;IACpC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG,uBAAuB,CAAC;AAEjE;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;oBAChB,uBAAuB;uBACpB,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;CAaY,CAAC"}

package/dist/modules/postprocessing/image-adjust-filters/brightnesscontrast.js

@@ -1,23 +1,25 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
-const fs = `\
+const fs = /* glsl */ `\
+
 uniform brightnessContrastUniforms {
-float brightness;
-float contrast;
+  float brightness;
+  float contrast;
 } brightnessContrast;
+
 vec4 brightnessContrast_filterColor(vec4 color) {
-color.rgb += brightnessContrast.brightness;
-if (brightnessContrast.contrast > 0.0) {
-color.rgb = (color.rgb - 0.5) / (1.0 - brightnessContrast.contrast) + 0.5;
-} else {
-color.rgb = (color.rgb - 0.5) * (1.0 + brightnessContrast.contrast) + 0.5;
-}
-return color;
+  color.rgb += brightnessContrast.brightness;
+  if (brightnessContrast.contrast > 0.0) {
+    color.rgb = (color.rgb - 0.5) / (1.0 - brightnessContrast.contrast) + 0.5;
+  } else {
+    color.rgb = (color.rgb - 0.5) * (1.0 + brightnessContrast.contrast) + 0.5;
+  }
+  return color;
 }
+
 vec4 brightnessContrast_filterColor(vec4 color, vec2 texSize, vec2 texCoords) {
-return brightnessContrast_filterColor(color);
+  return brightnessContrast_filterColor(color);
 }
 `;
 /**
@@ -27,6 +29,8 @@ return brightnessContrast_filterColor(color);
  * @param contrast   -1 to 1 (-1 is solid gray, 0 is no change, and 1 is maximum contrast)
  */
 export const brightnessContrast = {
+    props: {},
+    uniforms: {},
     name: 'brightnessContrast',
     uniformTypes: {
         brightness: 'f32',

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

@@ -11,12 +11,15 @@ export type DenoiseProps = {
      */
     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";
@@ -29,7 +32,7 @@ export declare const denoise: {
             readonly max: 1;
         };
     };
-    readonly fs: string;
+    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;
     }, {

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

@@ -1 +1 @@
-{"version":3,"file":"denoise.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-adjust-filters/denoise.ts"],"names":[],"mappings":"AAiCA;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;CAWyB,CAAC"}
+{"version":3,"file":"denoise.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-adjust-filters/denoise.ts"],"names":[],"mappings":"AAgCA;;;;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;;;;;;;;;;;;;;;;;;;CAY6B,CAAC"}

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

@@ -1,27 +1,29 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
 // Do a 9x9 bilateral box filter
-const fs = `\
+const fs = /* glsl */ `\
 uniform denoiseUniforms {
-float strength;
+  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;
+  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;
 }
 `;
 /**
@@ -30,6 +32,8 @@ return color / total;
  * weighted by color intensity, similar to a bilateral filter.
  */
 export const denoise = {
+    props: {},
+    uniforms: {},
     name: 'denoise',
     uniformTypes: {
         strength: 'f32'

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

@@ -5,9 +5,10 @@ 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;
-    /** @param saturation -1 to 1 (-1 is solid gray, 0 is no change, and 1 is maximum contrast) */
+    /** -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
@@ -18,7 +19,10 @@ export type HueSaturationProps = {
  * or away from the average color channel value.
  */
 export declare const hueSaturation: {
+    readonly props: HueSaturationProps;
+    readonly uniforms: HueSaturationUniforms;
     readonly name: "hueSaturation";
+    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(vec4 color, vec2 texSize, vec2 texCoord) {\n  return hueSaturation_filterColor(color);\n}\n";
     readonly uniformTypes: {
         readonly hue: "f32";
         readonly saturation: "f32";
@@ -35,7 +39,6 @@ export declare const hueSaturation: {
             readonly max: 1;
         };
     };
-    readonly fs: string;
     readonly passes: [{
         readonly filter: true;
     }];

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

@@ -1 +1 @@
-{"version":3,"file":"huesaturation.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-adjust-filters/huesaturation.ts"],"names":[],"mappings":"AAyCA;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B;iEAC6D;IAC7D,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,8FAA8F;IAC9F,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;CAYyB,CAAC"}
+{"version":3,"file":"huesaturation.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-adjust-filters/huesaturation.ts"],"names":[],"mappings":"AAwCA;;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;uBACf,qBAAqB;;;;;;;;;;;;;;;;;;;;;;CAcY,CAAC"}

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

@@ -1,32 +1,37 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
-const fs = `\
+const fs = /* glsl */ `\
 uniform hueSaturationUniforms {
-float hue;
-float saturation;
+  float hue;
+  float saturation;
 } hueSaturation;
+
 vec4 hueSaturation_filterColor(vec4 color) {
-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)
-);
-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;
+  // 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(vec4 color, vec2 texSize, vec2 texCoord) {
-return hueSaturation_filterColor(color);
+  return hueSaturation_filterColor(color);
 }
 `;
 /**
@@ -39,7 +44,10 @@ return hueSaturation_filterColor(color);
  * or away from the average color channel value.
  */
 export const hueSaturation = {
+    props: {},
+    uniforms: {},
     name: 'hueSaturation',
+    fs,
     uniformTypes: {
         hue: 'f32',
         saturation: 'f32'
@@ -48,6 +56,5 @@ export const hueSaturation = {
         hue: { value: 0, min: -1, max: 1 },
         saturation: { value: 0, min: -1, max: 1 }
     },
-    fs,
     passes: [{ filter: true }]
 };

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

@@ -5,11 +5,14 @@ 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";
@@ -21,7 +24,7 @@ export declare const noise: {
             readonly max: 1;
         };
     };
-    readonly fs: string;
+    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(vec4 color, 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\nvec4 noise_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  return noise_filterColor(color, texCoord);\n}\n";
     readonly passes: [{
         readonly filter: true;
     }];

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

@@ -1 +1 @@
-{"version":3,"file":"noise.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-adjust-filters/noise.ts"],"names":[],"mappings":"AA6BA;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,qDAAqD;IACrD,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;CAUqC,CAAC"}
+{"version":3,"file":"noise.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-adjust-filters/noise.ts"],"names":[],"mappings":"AA4BA;;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;;;;;;;;;;;;;;;;CAWwB,CAAC"}

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

@@ -1,23 +1,25 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
-const fs = `\
+const fs = /* glsl */ `\
 uniform noiseUniforms {
-float amount;
+  float amount;
 } noise;
+
 float rand(vec2 co) {
-return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
+  return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
 }
+
 vec4 noise_filterColor(vec4 color, vec2 texCoord) {
-float diff = (rand(texCoord) - 0.5) * noise.amount;
-color.r += diff;
-color.g += diff;
-color.b += diff;
-return color;
+  float diff = (rand(texCoord) - 0.5) * noise.amount;
+  color.r += diff;
+  color.g += diff;
+  color.b += diff;
+  return color;
 }
+
 vec4 noise_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
-return noise_filterColor(color, texCoord);
+  return noise_filterColor(color, texCoord);
 }
 `;
 /**
@@ -25,6 +27,8 @@ return noise_filterColor(color, texCoord);
  * Adds black and white noise to the image.
  */
 export const noise = {
+    props: {},
+    uniforms: {},
     name: 'noise',
     uniformTypes: {
         amount: 'f32'

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

@@ -1,12 +1,15 @@
 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";
@@ -18,7 +21,7 @@ export declare const sepia: {
             readonly max: 1;
         };
     };
-    readonly fs: string;
+    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(vec4 color, vec2 texSize, vec2 texCoord) {\n  return sepia_filterColor(color);\n}\n";
     readonly passes: [{
         readonly filter: true;
     }];

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

@@ -1 +1 @@
-{"version":3,"file":"sepia.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-adjust-filters/sepia.ts"],"names":[],"mappings":"AA8BA,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;CAUqC,CAAC"}
+{"version":3,"file":"sepia.d.ts","sourceRoot":"","sources":["../../../../src/modules/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/modules/postprocessing/image-adjust-filters/sepia.js

@@ -1,23 +1,26 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
-const fs = `\
+const fs = /* glsl */ `\
 uniform sepiaUniforms {
-float amount;
+  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;
+  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(vec4 color, vec2 texSize, vec2 texCoord) {
-return sepia_filterColor(color);
+  return sepia_filterColor(color);
 }
 `;
 /**
@@ -26,6 +29,8 @@ return sepia_filterColor(color);
  * @param amount   0 to 1 (0 for no effect, 1 for full sepia coloring)
  */
 export const sepia = {
+    props: {},
+    uniforms: {},
     name: 'sepia',
     uniformTypes: {
         amount: 'f32'

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

@@ -5,8 +5,11 @@ 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 uniformPropTypes: {
         readonly amount: {
@@ -15,7 +18,7 @@ export declare const vibrance: {
             readonly max: 1;
         };
     };
-    readonly fs: string;
+    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(vec4 color, vec2 texSize, vec2 texCoord) {\n  return vibrance_filterColor(color);\n}\n";
     readonly passes: [{
         readonly filter: true;
     }];

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

@@ -1 +1 @@
-{"version":3,"file":"vibrance.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-adjust-filters/vibrance.ts"],"names":[],"mappings":"AAyBA;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,kFAAkF;IAClF,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,qGAAqG;AACrG,eAAO,MAAM,QAAQ;;;;;;;;;;;;;CAOwC,CAAC"}
+{"version":3,"file":"vibrance.d.ts","sourceRoot":"","sources":["../../../../src/modules/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;;;;;;;;;;;;;CAO2B,CAAC"}

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

@@ -1,24 +1,27 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
-const fs = `\
+const fs = /* glsl */ `\
 uniform vibranceUniforms {
-float amount;
+  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;
+  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(vec4 color, vec2 texSize, vec2 texCoord) {
-return vibrance_filterColor(color);
+  return vibrance_filterColor(color);
 }
 `;
 /** Vibrance - Modifies the saturation of desaturated colors, leaving saturated colors unmodified. */
 export const vibrance = {
+    props: {},
+    uniforms: {},
     name: 'vibrance',
     uniformPropTypes: {
         amount: { value: 0, min: -1, max: 1 }

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

@@ -7,13 +7,15 @@ export type VignetteProps = {
     /** 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 fs: string;
     readonly uniformTypes: {
         readonly radius: "f32";
         readonly amount: "f32";
@@ -33,5 +35,6 @@ export declare const vignette: {
     readonly passes: [{
         readonly filter: true;
     }];
+    readonly fs: "uniform vignetteUniforms {\n  float radius;\n  float amount;\n} vignette;\n\nvec4 vignette_filterColor(vec4 color, 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\nvec4 vignette_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  return vignette_filterColor(color, texCoord);\n}\n";
 };
 //# sourceMappingURL=vignette.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"vignette.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-adjust-filters/vignette.ts"],"names":[],"mappings":"AAwBA;;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;;;GAGG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;CAYwC,CAAC"}
+{"version":3,"file":"vignette.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-adjust-filters/vignette.ts"],"names":[],"mappings":"AAuBA;;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;;;;;;;;;;;;;;;;;;;;;;CAgB2B,CAAC"}

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

@@ -1,19 +1,20 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
-const fs = `\
+const fs = /* glsl */ `\
 uniform vignetteUniforms {
-float radius;
-float amount;
+  float radius;
+  float amount;
 } vignette;
+
 vec4 vignette_filterColor(vec4 color, 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);
+  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);
 }
+
 vec4 vignette_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
-return vignette_filterColor(color, texCoord);
+  return vignette_filterColor(color, texCoord);
 }
 `;
 /**
@@ -21,8 +22,9 @@ return vignette_filterColor(color, texCoord);
  * Adds a simulated lens edge darkening effect.
  */
 export const vignette = {
+    props: {},
+    uniforms: {},
     name: 'vignette',
-    fs,
     uniformTypes: {
         radius: 'f32',
         amount: 'f32'
@@ -31,5 +33,6 @@ export const vignette = {
         radius: { value: 0.5, min: 0, max: 1 },
         amount: { value: 0.5, min: 0, max: 1 }
     },
-    passes: [{ filter: true }]
+    passes: [{ filter: true }],
+    fs
 };