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

package/dist/modules/postprocessing/image-blur-filters/triangleblur.js

@@ -1,29 +1,40 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
 import { random } from "../..//math/random/random.js";
-const fs = `\
+const fs = /* glsl */ `\
 uniform triangleBlurUniforms {
-float radius;
-vec2 delta;
+  float radius;
+  vec2 delta;
 } triangleBlur;
+
 vec4 triangleBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
-vec2 adjustedDelta = triangleBlur.delta * triangleBlur.radius / texSize;
-vec4 color = vec4(0.0);
-float total = 0.0;
-float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);
-for (float t = -30.0; t <= 30.0; t++) {
-float percent = (t + offset - 0.5) / 30.0;
-float weight = 1.0 - abs(percent);
-vec4 offsetColor = texture(source, texCoord + adjustedDelta * percent);
-offsetColor.rgb *= offsetColor.a;
-color += offsetColor * weight;
-total += weight;
-}
-color = color / total;
-color.rgb /= color.a + 0.00001;
-return color;
+  vec2 adjustedDelta = triangleBlur.delta * triangleBlur.radius / texSize;
+
+  vec4 color = vec4(0.0);
+  float total = 0.0;
+
+  /* randomize the lookup values to hide the fixed number of samples */
+  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);
+
+  for (float t = -30.0; t <= 30.0; t++) {
+    float percent = (t + offset - 0.5) / 30.0;
+    float weight = 1.0 - abs(percent);
+    vec4 offsetColor = texture(source, texCoord + adjustedDelta * percent);
+
+    /* switch to pre-multiplied alpha to correctly blur transparent images */
+    offsetColor.rgb *= offsetColor.a;
+
+    color += offsetColor * weight;
+    total += weight;
+  }
+
+  color = color / total;
+
+  /* switch back from pre-multiplied alpha */
+  color.rgb /= color.a + 0.00001;
+
+  return color;
 }
 `;
 /**
@@ -33,6 +44,8 @@ return color;
  *               perpendicular triangle filters.
  */
 export const triangleBlur = {
+    props: {},
+    uniforms: {},
     name: 'triangleBlur',
     uniformTypes: {
         radius: 'f32',

package/dist/modules/postprocessing/image-blur-filters/zoomblur.d.ts

@@ -7,11 +7,14 @@ export type ZoomBlurProps = {
     /** - The strength of the blur. Values in the range 0 to 1 are usually sufficient, where 0 doesn't change the image and 1 creates a highly blurred image. */
     strength?: number;
 };
+export type ZoomBlurUniforms = ZoomBlurProps;
 /**
  * Zoom Blur
  * Blurs the image away from a certain point, which looks like radial motion blur.
  */
 export declare const zoomBlur: {
+    readonly props: ZoomBlurProps;
+    readonly uniforms: ZoomBlurUniforms;
     readonly name: "zoomBlur";
     readonly uniformTypes: {
         readonly center: "vec2<f32>";
@@ -30,7 +33,7 @@ export declare const zoomBlur: {
     readonly fs: "\nuniform zoomBlurUniforms {\n  vec2 center;\n  float strength;\n} zoomBlur;\n\nvec4 zoomBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec4 color = vec4(0.0);\n  float total = 0.0;\n  vec2 toCenter = zoomBlur.center * texSize - texCoord * texSize;\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = 0.0; t <= 40.0; t++) {\n    float percent = (t + offset) / 40.0;\n    float weight = 4.0 * (percent - percent * percent);\n    vec4 offsetColor = texture(source, texCoord + toCenter * percent * zoomBlur.strength / texSize);\n\n    /* switch to pre-multiplied alpha to correctly blur transparent images */\n    offsetColor.rgb *= offsetColor.a;\n\n    color += offsetColor * weight;\n    total += weight;\n  }\n\n  color = color / total;\n\n  /* switch back from pre-multiplied alpha */\n  color.rgb /= color.a + 0.00001;\n\n  return color;\n}\n";
     readonly dependencies: [{
         readonly name: "random";
-        readonly fs: string;
+        readonly fs: "float random(vec3 scale, float seed) {\n  /* use the fragment position for a different seed per-pixel */\n  return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);\n}\n";
     }];
     readonly passes: [{
         readonly sampler: true;

package/dist/modules/postprocessing/image-blur-filters/zoomblur.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zoomblur.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-blur-filters/zoomblur.ts"],"names":[],"mappings":"AA0CA;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,gDAAgD;IAChD,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,4JAA4J;IAC5J,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;CAawC,CAAC"}
+{"version":3,"file":"zoomblur.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-blur-filters/zoomblur.ts"],"names":[],"mappings":"AA0CA;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,gDAAgD;IAChD,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,4JAA4J;IAC5J,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC;AAE7C;;;GAGG;AACH,eAAO,MAAM,QAAQ;oBACN,aAAa;uBACV,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;CAc2B,CAAC"}

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

@@ -41,6 +41,8 @@ vec4 zoomBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
  * Blurs the image away from a certain point, which looks like radial motion blur.
  */
 export const zoomBlur = {
+    props: {},
+    uniforms: {},
     name: 'zoomBlur',
     uniformTypes: {
         center: 'vec2<f32>',

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

@@ -12,6 +12,7 @@ export type ColorHalftoneProps = {
     /** The diameter of a dot in pixels. */
     size?: number;
 };
+export type ColorHalftoneUniforms = ColorHalftoneProps;
 /**
  * Color Halftone -
  * Simulates a CMYK halftone rendering of the image by multiplying pixel values
@@ -19,6 +20,8 @@ export type ColorHalftoneProps = {
  * and black.
  */
 export declare const colorHalftone: {
+    readonly props: ColorHalftoneProps;
+    readonly uniforms: ColorHalftoneUniforms;
     readonly name: "colorHalftone";
     readonly uniformTypes: {
         readonly center: "vec2<f32>";
@@ -41,7 +44,7 @@ export declare const colorHalftone: {
             readonly softMax: 20;
         };
     };
-    readonly fs: string;
+    readonly fs: "uniform colorHalftoneUniforms {\n  vec2 center;\n  float angle;\n  float size;\n} colorHalftone;\n\nfloat pattern(float angle, float scale, vec2 texSize, vec2 texCoord) {\n  float s = sin(angle), c = cos(angle);\n  vec2 tex = texCoord * texSize - colorHalftone.center * texSize;\n  vec2 point = vec2(\n\tc * tex.x - s * tex.y,\n\ts * tex.x + c * tex.y\n  ) * scale;\n  return (sin(point.x) * sin(point.y)) * 4.0;\n}\n\nvec4 colorHalftone_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  float scale = 3.1514 / colorHalftone.size;\n  vec3 cmy = 1.0 - color.rgb;\n  float k = min(cmy.x, min(cmy.y, cmy.z));\n\n  cmy = (cmy - k) / (1.0 - k);\n  cmy = clamp(\n\t  cmy * 10.0 - 3.0 + vec3(\n      pattern(colorHalftone.angle + 0.26179, scale, texSize, texCoord),\n\t    pattern(colorHalftone.angle + 1.30899, scale, texSize, texCoord),\n      pattern(colorHalftone.angle, scale, texSize, texCoord)\n    ),\n\t  0.0,\n\t  1.0\n  );\n  k = clamp(k * 10.0 - 5.0 + pattern(colorHalftone.angle + 0.78539, scale, texSize, texCoord), 0.0, 1.0);\n  return vec4(1.0 - cmy - k, color.a);\n}\n";
     readonly passes: [{
         readonly filter: true;
     }];

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

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

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

@@ -1,39 +1,41 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
 // TODO pass texCoord to angle
-const fs = `\
+const fs = /* glsl */ `\
 uniform colorHalftoneUniforms {
-vec2 center;
-float angle;
-float size;
+  vec2 center;
+  float angle;
+  float size;
 } colorHalftone;
+
 float pattern(float angle, float scale, vec2 texSize, vec2 texCoord) {
-float s = sin(angle), c = cos(angle);
-vec2 tex = texCoord * texSize - colorHalftone.center * texSize;
-vec2 point = vec2(
-c * tex.x - s * tex.y,
-s * tex.x + c * tex.y
-) * scale;
-return (sin(point.x) * sin(point.y)) * 4.0;
+  float s = sin(angle), c = cos(angle);
+  vec2 tex = texCoord * texSize - colorHalftone.center * texSize;
+  vec2 point = vec2(
+	c * tex.x - s * tex.y,
+	s * tex.x + c * tex.y
+  ) * scale;
+  return (sin(point.x) * sin(point.y)) * 4.0;
 }
+
 vec4 colorHalftone_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
-float scale = 3.1514 / colorHalftone.size;
-vec3 cmy = 1.0 - color.rgb;
-float k = min(cmy.x, min(cmy.y, cmy.z));
-cmy = (cmy - k) / (1.0 - k);
-cmy = clamp(
-cmy * 10.0 - 3.0 + vec3(
-pattern(colorHalftone.angle + 0.26179, scale, texSize, texCoord),
-pattern(colorHalftone.angle + 1.30899, scale, texSize, texCoord),
-pattern(colorHalftone.angle, scale, texSize, texCoord)
-),
-0.0,
-1.0
-);
-k = clamp(k * 10.0 - 5.0 + pattern(colorHalftone.angle + 0.78539, scale, texSize, texCoord), 0.0, 1.0);
-return vec4(1.0 - cmy - k, color.a);
+  float scale = 3.1514 / colorHalftone.size;
+  vec3 cmy = 1.0 - color.rgb;
+  float k = min(cmy.x, min(cmy.y, cmy.z));
+
+  cmy = (cmy - k) / (1.0 - k);
+  cmy = clamp(
+	  cmy * 10.0 - 3.0 + vec3(
+      pattern(colorHalftone.angle + 0.26179, scale, texSize, texCoord),
+	    pattern(colorHalftone.angle + 1.30899, scale, texSize, texCoord),
+      pattern(colorHalftone.angle, scale, texSize, texCoord)
+    ),
+	  0.0,
+	  1.0
+  );
+  k = clamp(k * 10.0 - 5.0 + pattern(colorHalftone.angle + 0.78539, scale, texSize, texCoord), 0.0, 1.0);
+  return vec4(1.0 - cmy - k, color.a);
 }
 `;
 /**
@@ -43,6 +45,8 @@ return vec4(1.0 - cmy - k, color.a);
  * and black.
  */
 export const colorHalftone = {
+    props: {},
+    uniforms: {},
     name: 'colorHalftone',
     uniformTypes: {
         center: 'vec2<f32>',

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

@@ -11,12 +11,15 @@ export type DotScreenProps = {
     /** The diameter of a dot in pixels. */
     size?: number;
 };
+export type DotScreenUniforms = DotScreenProps;
 /**
  * Dot Screen -
  * Simulates a black and white halftone rendering of the image by multiplying
  * pixel values with a rotated 2D sine wave pattern.
  */
 export declare const dotScreen: {
+    readonly props: DotScreenProps;
+    readonly uniforms: DotScreenUniforms;
     readonly name: "dotScreen";
     readonly uniformTypes: {
         readonly center: "vec2<f32>";
@@ -39,7 +42,7 @@ export declare const dotScreen: {
             readonly softMax: 20;
         };
     };
-    readonly fs: string;
+    readonly fs: "uniform dotScreenUniforms {\n  vec2 center;\n  float angle;\n  float size;\n} dotScreen;\n\nfloat pattern(vec2 texSize, vec2 texCoord) {\n  float scale = 3.1415 / dotScreen.size;\n\n  float s = sin(dotScreen.angle), c = cos(dotScreen.angle);\n  vec2 tex = texCoord * texSize - dotScreen.center * texSize;\n  vec2 point = vec2(\n    c * tex.x - s * tex.y,\n    s * tex.x + c * tex.y\n  ) * scale;\n  return (sin(point.x) * sin(point.y)) * 4.0;\n}\n\nvec4 dotScreen_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {\n  float average = (color.r + color.g + color.b) / 3.0;\n  return vec4(vec3(average * 10.0 - 5.0 + pattern(texSize, texCoord)), color.a);\n}\n";
     readonly passes: [{
         readonly filter: true;
     }];

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

@@ -1 +1 @@
-{"version":3,"file":"dotscreen.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-fun-filters/dotscreen.ts"],"names":[],"mappings":"AAgCA;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,8CAA8C;IAC9C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uCAAuC;IACvC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;CAcyC,CAAC"}
+{"version":3,"file":"dotscreen.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-fun-filters/dotscreen.ts"],"names":[],"mappings":"AA+BA;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,8CAA8C;IAC9C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uCAAuC;IACvC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,cAAc,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,SAAS;oBACP,cAAc;uBACX,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAe4B,CAAC"}

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

@@ -1,26 +1,28 @@
 // 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 dotScreenUniforms {
-vec2 center;
-float angle;
-float size;
+  vec2 center;
+  float angle;
+  float size;
 } dotScreen;
+
 float pattern(vec2 texSize, vec2 texCoord) {
-float scale = 3.1415 / dotScreen.size;
-float s = sin(dotScreen.angle), c = cos(dotScreen.angle);
-vec2 tex = texCoord * texSize - dotScreen.center * texSize;
-vec2 point = vec2(
-c * tex.x - s * tex.y,
-s * tex.x + c * tex.y
-) * scale;
-return (sin(point.x) * sin(point.y)) * 4.0;
+  float scale = 3.1415 / dotScreen.size;
+
+  float s = sin(dotScreen.angle), c = cos(dotScreen.angle);
+  vec2 tex = texCoord * texSize - dotScreen.center * texSize;
+  vec2 point = vec2(
+    c * tex.x - s * tex.y,
+    s * tex.x + c * tex.y
+  ) * scale;
+  return (sin(point.x) * sin(point.y)) * 4.0;
 }
+
 vec4 dotScreen_filterColor(vec4 color, vec2 texSize, vec2 texCoord) {
-float average = (color.r + color.g + color.b) / 3.0;
-return vec4(vec3(average * 10.0 - 5.0 + pattern(texSize, texCoord)), color.a);
+  float average = (color.r + color.g + color.b) / 3.0;
+  return vec4(vec3(average * 10.0 - 5.0 + pattern(texSize, texCoord)), color.a);
 }
 `;
 /**
@@ -29,6 +31,8 @@ return vec4(vec3(average * 10.0 - 5.0 + pattern(texSize, texCoord)), color.a);
  * pixel values with a rotated 2D sine wave pattern.
  */
 export const dotScreen = {
+    props: {},
+    uniforms: {},
     name: 'dotScreen',
     uniformTypes: {
         center: 'vec2<f32>',

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

@@ -9,13 +9,21 @@ export type EdgeWorkProps = {
     /** @deprecated internal */
     delta?: number;
 };
+export type EdgeWorkUniforms = EdgeWorkProps;
 /**
  * Edge Work -
  * Picks out different frequencies in the image by subtracting two
  * copies of the image blurred with different radii.
  */
 export declare const edgeWork: {
+    readonly props: EdgeWorkProps;
+    readonly uniforms: EdgeWorkProps;
     readonly name: "edgeWork";
+    readonly dependencies: [{
+        readonly name: "random";
+        readonly fs: "float random(vec3 scale, float seed) {\n  /* use the fragment position for a different seed per-pixel */\n  return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);\n}\n";
+    }];
+    readonly fs: "uniform edgeWorkUniforms {\n  float radius;\n  vec2 delta;\n} edgeWork;\n\nvec4 edgeWork_sampleColor1(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 relativeDelta = edgeWork.radius * edgeWork.delta / texSize;\n\n  vec2 color = vec2(0.0);\n  vec2 total = vec2(0.0);\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec3 sampleColor = texture(source, texCoord + relativeDelta * percent).rgb;\n    float average = (sampleColor.r + sampleColor.g + sampleColor.b) / 3.0;\n    color.x += average * weight;\n    total.x += weight;\n    if (abs(t) < 15.0) {\n      weight = weight * 2.0 - 1.0;\n      color.y += average * weight;\n      total.y += weight;\n    }\n  }\n  return vec4(color / total, 0.0, 1.0);\n}\n\nvec4 edgeWork_sampleColor2(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 relativeDelta = edgeWork.radius * edgeWork.delta / texSize;\n\n  vec2 color = vec2(0.0);\n  vec2 total = vec2(0.0);\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec2 sampleColor = texture(source, texCoord + relativeDelta * percent).xy;\n    color.x += sampleColor.x * weight;\n    total.x += weight;\n    if (abs(t) < 15.0) {\n      weight = weight * 2.0 - 1.0;\n      color.y += sampleColor.y * weight;\n      total.y += weight;\n    }\n  }\n  float c = clamp(10000.0 * (color.y / total.y - color.x / total.x) + 0.5, 0.0, 1.0);\n  return vec4(c, c, c, 1.0);\n}\n";
     readonly uniformPropTypes: {
         readonly radius: {
             readonly value: 2;
@@ -27,11 +35,6 @@ export declare const edgeWork: {
             readonly private: true;
         };
     };
-    readonly fs: string;
-    readonly dependencies: [{
-        readonly name: "random";
-        readonly fs: string;
-    }];
     readonly passes: [{
         readonly sampler: "edgeWork_sampleColor1";
         readonly uniformPropTypes: {

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

@@ -1 +1 @@
-{"version":3,"file":"edgework.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-fun-filters/edgework.ts"],"names":[],"mappings":"AAiEA;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,2BAA2B;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBwC,CAAC"}
+{"version":3,"file":"edgework.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-fun-filters/edgework.ts"],"names":[],"mappings":"AAgEA;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,2BAA2B;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC;AAE7C;;;;GAIG;AACH,eAAO,MAAM,QAAQ;oBACN,aAAa;uBACV,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuB8B,CAAC"}

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

@@ -1,52 +1,61 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
 import { random } from "../../math/random/random.js";
-const fs = `\
+const fs = /* glsl */ `\
 uniform edgeWorkUniforms {
-float radius;
-vec2 delta;
+  float radius;
+  vec2 delta;
 } edgeWork;
+
 vec4 edgeWork_sampleColor1(sampler2D source, vec2 texSize, vec2 texCoord) {
-vec2 relativeDelta = edgeWork.radius * edgeWork.delta / texSize;
-vec2 color = vec2(0.0);
-vec2 total = vec2(0.0);
-float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);
-for (float t = -30.0; t <= 30.0; t++) {
-float percent = (t + offset - 0.5) / 30.0;
-float weight = 1.0 - abs(percent);
-vec3 sampleColor = texture(source, texCoord + relativeDelta * percent).rgb;
-float average = (sampleColor.r + sampleColor.g + sampleColor.b) / 3.0;
-color.x += average * weight;
-total.x += weight;
-if (abs(t) < 15.0) {
-weight = weight * 2.0 - 1.0;
-color.y += average * weight;
-total.y += weight;
-}
-}
-return vec4(color / total, 0.0, 1.0);
+  vec2 relativeDelta = edgeWork.radius * edgeWork.delta / texSize;
+
+  vec2 color = vec2(0.0);
+  vec2 total = vec2(0.0);
+
+  /* randomize the lookup values to hide the fixed number of samples */
+  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);
+
+  for (float t = -30.0; t <= 30.0; t++) {
+    float percent = (t + offset - 0.5) / 30.0;
+    float weight = 1.0 - abs(percent);
+    vec3 sampleColor = texture(source, texCoord + relativeDelta * percent).rgb;
+    float average = (sampleColor.r + sampleColor.g + sampleColor.b) / 3.0;
+    color.x += average * weight;
+    total.x += weight;
+    if (abs(t) < 15.0) {
+      weight = weight * 2.0 - 1.0;
+      color.y += average * weight;
+      total.y += weight;
+    }
+  }
+  return vec4(color / total, 0.0, 1.0);
 }
+
 vec4 edgeWork_sampleColor2(sampler2D source, vec2 texSize, vec2 texCoord) {
-vec2 relativeDelta = edgeWork.radius * edgeWork.delta / texSize;
-vec2 color = vec2(0.0);
-vec2 total = vec2(0.0);
-float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);
-for (float t = -30.0; t <= 30.0; t++) {
-float percent = (t + offset - 0.5) / 30.0;
-float weight = 1.0 - abs(percent);
-vec2 sampleColor = texture(source, texCoord + relativeDelta * percent).xy;
-color.x += sampleColor.x * weight;
-total.x += weight;
-if (abs(t) < 15.0) {
-weight = weight * 2.0 - 1.0;
-color.y += sampleColor.y * weight;
-total.y += weight;
-}
-}
-float c = clamp(10000.0 * (color.y / total.y - color.x / total.x) + 0.5, 0.0, 1.0);
-return vec4(c, c, c, 1.0);
+  vec2 relativeDelta = edgeWork.radius * edgeWork.delta / texSize;
+
+  vec2 color = vec2(0.0);
+  vec2 total = vec2(0.0);
+
+  /* randomize the lookup values to hide the fixed number of samples */
+  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);
+
+  for (float t = -30.0; t <= 30.0; t++) {
+    float percent = (t + offset - 0.5) / 30.0;
+    float weight = 1.0 - abs(percent);
+    vec2 sampleColor = texture(source, texCoord + relativeDelta * percent).xy;
+    color.x += sampleColor.x * weight;
+    total.x += weight;
+    if (abs(t) < 15.0) {
+      weight = weight * 2.0 - 1.0;
+      color.y += sampleColor.y * weight;
+      total.y += weight;
+    }
+  }
+  float c = clamp(10000.0 * (color.y / total.y - color.x / total.x) + 0.5, 0.0, 1.0);
+  return vec4(c, c, c, 1.0);
 }
 `;
 /**
@@ -55,13 +64,15 @@ return vec4(c, c, c, 1.0);
  * copies of the image blurred with different radii.
  */
 export const edgeWork = {
+    props: {},
+    uniforms: {},
     name: 'edgeWork',
+    dependencies: [random],
+    fs,
     uniformPropTypes: {
         radius: { value: 2, min: 1, softMax: 50 },
         delta: { value: [1, 0], private: true }
     },
-    fs,
-    dependencies: [random],
     passes: [
         {
             // @ts-expect-error

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

@@ -9,12 +9,15 @@ export type HexagonalPixelateProps = {
     /** The width of an individual tile, in pixels. */
     scale?: number;
 };
+export type HexagonalPixelateUniforms = HexagonalPixelateProps;
 /**
  * Hexagonal Pixelate
  * Renders the image using a pattern of hexagonal tiles. Tile colors
  * are nearest-neighbor sampled from the centers of the tiles.
  */
 export declare const hexagonalPixelate: {
+    readonly props: HexagonalPixelateProps;
+    readonly uniforms: HexagonalPixelateUniforms;
     readonly name: "hexagonalPixelate";
     readonly uniformTypes: {
         readonly center: "vec2<f32>";
@@ -32,7 +35,7 @@ export declare const hexagonalPixelate: {
             readonly softMax: 50;
         };
     };
-    readonly fs: string;
+    readonly fs: "uniform hexagonalPixelateUniforms {\n  vec2 center;\n  float scale;\n} hexagonalPixelate;\n\nvec4 hexagonalPixelate_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 tex = (texCoord * texSize - hexagonalPixelate.center * texSize) / hexagonalPixelate.scale;\n  tex.y /= 0.866025404;\n  tex.x -= tex.y * 0.5;\n\n  vec2 a;\n  if (tex.x + tex.y - floor(tex.x) - floor(tex.y) < 1.0) {\n    a = vec2(floor(tex.x), floor(tex.y));\n  }\n  else a = vec2(ceil(tex.x), ceil(tex.y));\n  vec2 b = vec2(ceil(tex.x), floor(tex.y));\n  vec2 c = vec2(floor(tex.x), ceil(tex.y));\n\n  vec3 TEX = vec3(tex.x, tex.y, 1.0 - tex.x - tex.y);\n  vec3 A = vec3(a.x, a.y, 1.0 - a.x - a.y);\n  vec3 B = vec3(b.x, b.y, 1.0 - b.x - b.y);\n  vec3 C = vec3(c.x, c.y, 1.0 - c.x - c.y);\n\n  float alen = length(TEX - A);\n  float blen = length(TEX - B);\n  float clen = length(TEX - C);\n\n  vec2 choice;\n  if (alen < blen) {\n    if (alen < clen) choice = a;\n    else choice = c;\n  } else {\n    if (blen < clen) choice = b;\n    else choice = c;\n  }\n\n  choice.x += choice.y * 0.5;\n  choice.y *= 0.866025404;\n  choice *= hexagonalPixelate.scale / texSize;\n\n  return texture(source, choice + hexagonalPixelate.center);\n}\n";
     readonly passes: [{
         readonly sampler: true;
     }];

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

@@ -1 +1 @@
-{"version":3,"file":"hexagonalpixelate.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-fun-filters/hexagonalpixelate.ts"],"names":[],"mappings":"AAoDA;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,oDAAoD;IACpD,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,kDAAkD;IAClD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;CAYiD,CAAC"}
+{"version":3,"file":"hexagonalpixelate.d.ts","sourceRoot":"","sources":["../../../../src/modules/postprocessing/image-fun-filters/hexagonalpixelate.ts"],"names":[],"mappings":"AAmDA;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,oDAAoD;IACpD,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,kDAAkD;IAClD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,sBAAsB,CAAC;AAE/D;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;oBACf,sBAAsB;uBACnB,yBAAyB;;;;;;;;;;;;;;;;;;;;;;CAaoC,CAAC"}

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

@@ -1,42 +1,48 @@
 // 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 hexagonalPixelateUniforms {
-vec2 center;
-float scale;
+  vec2 center;
+  float scale;
 } hexagonalPixelate;
+
 vec4 hexagonalPixelate_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
-vec2 tex = (texCoord * texSize - hexagonalPixelate.center * texSize) / hexagonalPixelate.scale;
-tex.y /= 0.866025404;
-tex.x -= tex.y * 0.5;
-vec2 a;
-if (tex.x + tex.y - floor(tex.x) - floor(tex.y) < 1.0) {
-a = vec2(floor(tex.x), floor(tex.y));
-}
-else a = vec2(ceil(tex.x), ceil(tex.y));
-vec2 b = vec2(ceil(tex.x), floor(tex.y));
-vec2 c = vec2(floor(tex.x), ceil(tex.y));
-vec3 TEX = vec3(tex.x, tex.y, 1.0 - tex.x - tex.y);
-vec3 A = vec3(a.x, a.y, 1.0 - a.x - a.y);
-vec3 B = vec3(b.x, b.y, 1.0 - b.x - b.y);
-vec3 C = vec3(c.x, c.y, 1.0 - c.x - c.y);
-float alen = length(TEX - A);
-float blen = length(TEX - B);
-float clen = length(TEX - C);
-vec2 choice;
-if (alen < blen) {
-if (alen < clen) choice = a;
-else choice = c;
-} else {
-if (blen < clen) choice = b;
-else choice = c;
-}
-choice.x += choice.y * 0.5;
-choice.y *= 0.866025404;
-choice *= hexagonalPixelate.scale / texSize;
-return texture(source, choice + hexagonalPixelate.center);
+  vec2 tex = (texCoord * texSize - hexagonalPixelate.center * texSize) / hexagonalPixelate.scale;
+  tex.y /= 0.866025404;
+  tex.x -= tex.y * 0.5;
+
+  vec2 a;
+  if (tex.x + tex.y - floor(tex.x) - floor(tex.y) < 1.0) {
+    a = vec2(floor(tex.x), floor(tex.y));
+  }
+  else a = vec2(ceil(tex.x), ceil(tex.y));
+  vec2 b = vec2(ceil(tex.x), floor(tex.y));
+  vec2 c = vec2(floor(tex.x), ceil(tex.y));
+
+  vec3 TEX = vec3(tex.x, tex.y, 1.0 - tex.x - tex.y);
+  vec3 A = vec3(a.x, a.y, 1.0 - a.x - a.y);
+  vec3 B = vec3(b.x, b.y, 1.0 - b.x - b.y);
+  vec3 C = vec3(c.x, c.y, 1.0 - c.x - c.y);
+
+  float alen = length(TEX - A);
+  float blen = length(TEX - B);
+  float clen = length(TEX - C);
+
+  vec2 choice;
+  if (alen < blen) {
+    if (alen < clen) choice = a;
+    else choice = c;
+  } else {
+    if (blen < clen) choice = b;
+    else choice = c;
+  }
+
+  choice.x += choice.y * 0.5;
+  choice.y *= 0.866025404;
+  choice *= hexagonalPixelate.scale / texSize;
+
+  return texture(source, choice + hexagonalPixelate.center);
 }
 `;
 /**
@@ -45,6 +51,8 @@ return texture(source, choice + hexagonalPixelate.center);
  * are nearest-neighbor sampled from the centers of the tiles.
  */
 export const hexagonalPixelate = {
+    props: {},
+    uniforms: {},
     name: 'hexagonalPixelate',
     uniformTypes: {
         center: 'vec2<f32>',

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

@@ -11,6 +11,7 @@ export type InkProps = {
      */
     strength?: number;
 };
+export type InkUniforms = InkProps;
 /**
  * Ink -
  * Simulates outlining the image in ink by darkening edges stronger than a
@@ -18,7 +19,10 @@ export type InkProps = {
  * copies of the image, each blurred using a blur of a different radius.
  */
 export declare const ink: {
+    readonly props: InkProps;
+    readonly uniforms: InkUniforms;
     readonly name: "ink";
+    readonly fs: "uniform inkUniforms {\n  float strength;\n} ink;\n\nvec4 ink_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 dx = vec2(1.0 / texSize.x, 0.0);\n  vec2 dy = vec2(0.0, 1.0 / texSize.y);\n  vec4 color = texture(source, texCoord);\n  float bigTotal = 0.0;\n  float smallTotal = 0.0;\n  vec3 bigAverage = vec3(0.0);\n  vec3 smallAverage = vec3(0.0);\n  for (float x = -2.0; x <= 2.0; x += 1.0) {\n    for (float y = -2.0; y <= 2.0; y += 1.0) {\n      vec3 offsetColor = texture(source, texCoord + dx * x + dy * y).rgb;\n      bigAverage += offsetColor;\n      bigTotal += 1.0;\n      if (abs(x) + abs(y) < 2.0) {\n        smallAverage += offsetColor;\n        smallTotal += 1.0;\n      }\n    }\n  }\n  vec3 edge = max(vec3(0.0), bigAverage / bigTotal - smallAverage / smallTotal);\n  float power = ink.strength * ink.strength * ink.strength * ink.strength * ink.strength;\n  return vec4(color.rgb - dot(edge, edge) * power * 100000.0, color.a);\n}\n";
     readonly uniformTypes: {
         readonly strength: "f32";
     };
@@ -29,7 +33,6 @@ export declare const ink: {
             readonly softMax: 1;
         };
     };
-    readonly fs: string;
     readonly passes: [{
         readonly sampler: true;
     }];

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

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