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

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

@@ -0,0 +1,50 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const fs = /* glsl */ `\
+uniform dotScreenUniforms {
+  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;
+}
+
+vec4 dotScreen_filterColor_ext(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);
+}
+`;
+/**
+ * Dot Screen -
+ * Simulates a black and white halftone rendering of the image by multiplying
+ * pixel values with a rotated 2D sine wave pattern.
+ */
+export const dotScreen = {
+    props: {},
+    uniforms: {},
+    name: 'dotScreen',
+    uniformTypes: {
+        center: 'vec2<f32>',
+        angle: 'f32',
+        size: 'f32'
+    },
+    propTypes: {
+        center: { value: [0.5, 0.5] },
+        angle: { value: 1.1, softMin: 0, softMax: Math.PI / 2 },
+        size: { value: 3, min: 1, softMin: 3, softMax: 20 }
+    },
+    fs,
+    passes: [{ filter: true }]
+};
+//# sourceMappingURL=dotscreen.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dotscreen.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/dotscreen.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;CAuBrB,CAAC;AAkBF;;;;GAIG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,KAAK,EAAE,EAAoB;IAC3B,QAAQ,EAAE,EAAuB;IAEjC,IAAI,EAAE,WAAW;IACjB,YAAY,EAAE;QACZ,MAAM,EAAE,WAAW;QACnB,KAAK,EAAE,KAAK;QACZ,IAAI,EAAE,KAAK;KACZ;IACD,SAAS,EAAE;QACT,MAAM,EAAE,EAAC,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAC;QAC3B,KAAK,EAAE,EAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,GAAG,CAAC,EAAC;QACrD,IAAI,EAAE,EAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAC;KAClD;IACD,EAAE;IACF,MAAM,EAAE,CAAC,EAAC,MAAM,EAAE,IAAI,EAAC,CAAC;CACqC,CAAC"}

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

@@ -0,0 +1,54 @@
+/**
+ * Edge Work -
+ * Picks out different frequencies in the image by subtracting two
+ * copies of the image blurred with different radii.
+ */
+export type EdgeWorkProps = {
+    /** radius The radius of the effect in pixels. */
+    radius?: number;
+    /** @deprecated xy or RGB */
+    mode?: 0 | 1;
+};
+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  int mode;\n} edgeWork;\n\nvec4 edgeWork_sampleColorRGB(sampler2D source, vec2 texSize, vec2 texCoord, vec2 delta) {\n  vec2 relativeDelta = edgeWork.radius * delta / texSize;\n\n  vec2 color = vec2(0.0);\n  vec2 total = vec2(0.0);\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec3 sampleColor = texture(source, texCoord + relativeDelta * percent).rgb;\n    float average = (sampleColor.r + sampleColor.g + sampleColor.b) / 3.0;\n    color.x += average * weight;\n    total.x += weight;\n    if (abs(t) < 15.0) {\n      weight = weight * 2.0 - 1.0;\n      color.y += average * weight;\n      total.y += weight;\n    }\n  }\n  return vec4(color / total, 0.0, 1.0);\n}\n\nvec4 edgeWork_sampleColorXY(sampler2D source, vec2 texSize, vec2 texCoord, vec2 delta) {\n  vec2 relativeDelta = edgeWork.radius * delta / texSize;\n\n  vec2 color = vec2(0.0);\n  vec2 total = vec2(0.0);\n\n  /* randomize the lookup values to hide the fixed number of samples */\n  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n\n  for (float t = -30.0; t <= 30.0; t++) {\n    float percent = (t + offset - 0.5) / 30.0;\n    float weight = 1.0 - abs(percent);\n    vec2 sampleColor = texture(source, texCoord + relativeDelta * percent).xy;\n    color.x += sampleColor.x * weight;\n    total.x += weight;\n    if (abs(t) < 15.0) {\n      weight = weight * 2.0 - 1.0;\n      color.y += sampleColor.y * weight;\n      total.y += weight;\n    }\n  }\n  float c = clamp(10000.0 * (color.y / total.y - color.x / total.x) + 0.5, 0.0, 1.0);\n  return vec4(c, c, c, 1.0);\n}\n\nvec4 edgeWork_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  switch (edgeWork.mode) {\n    case 0: \n    return edgeWork_sampleColorRGB(source, texSize, texCoord, vec2(1., 0.));\n    case 1: \n    default:\n      return edgeWork_sampleColorXY(source, texSize, texCoord, vec2(0., 1.));\n  }\n}\n";
+    readonly uniformTypes: {
+        readonly radius: "f32";
+        readonly mode: "i32";
+    };
+    readonly propTypes: {
+        readonly radius: {
+            readonly value: 2;
+            readonly min: 1;
+            readonly softMax: 50;
+        };
+        readonly mode: {
+            readonly value: 0;
+            readonly private: true;
+        };
+    };
+    readonly passes: [{
+        readonly sampler: true;
+        readonly uniforms: {
+            readonly mode: 0;
+        };
+    }, {
+        readonly sampler: true;
+        readonly uniforms: {
+            readonly mode: 1;
+        };
+    }];
+};
+//# sourceMappingURL=edgework.d.ts.map

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

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

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

@@ -0,0 +1,101 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { random } from '@luma.gl/shadertools';
+const fs = /* glsl */ `\
+uniform edgeWorkUniforms {
+  float radius;
+  int mode;
+} edgeWork;
+
+vec4 edgeWork_sampleColorRGB(sampler2D source, vec2 texSize, vec2 texCoord, vec2 delta) {
+  vec2 relativeDelta = edgeWork.radius * 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_sampleColorXY(sampler2D source, vec2 texSize, vec2 texCoord, vec2 delta) {
+  vec2 relativeDelta = edgeWork.radius * 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);
+}
+
+vec4 edgeWork_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
+  switch (edgeWork.mode) {
+    case 0: 
+    return edgeWork_sampleColorRGB(source, texSize, texCoord, vec2(1., 0.));
+    case 1: 
+    default:
+      return edgeWork_sampleColorXY(source, texSize, texCoord, vec2(0., 1.));
+  }
+}
+`;
+/**
+ * Edge Work -
+ * Picks out different frequencies in the image by subtracting two
+ * copies of the image blurred with different radii.
+ */
+export const edgeWork = {
+    props: {},
+    uniforms: {},
+    name: 'edgeWork',
+    dependencies: [random],
+    fs,
+    uniformTypes: {
+        radius: 'f32',
+        mode: 'i32'
+    },
+    propTypes: {
+        radius: { value: 2, min: 1, softMax: 50 },
+        mode: { value: 0, private: true }
+    },
+    passes: [
+        {
+            sampler: true,
+            uniforms: { mode: 0 }
+        },
+        {
+            sampler: true,
+            uniforms: { mode: 1 }
+        }
+    ]
+};
+//# sourceMappingURL=edgework.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"edgework.js","sourceRoot":"","sources":["../../../../src/passes/postprocessing/image-fun-filters/edgework.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAGpC,OAAO,EAAC,MAAM,EAAC,MAAM,sBAAsB,CAAC;AAE5C,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiErB,CAAC;AAgBF;;;;GAIG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,KAAK,EAAE,EAAmB;IAC1B,QAAQ,EAAE,EAAmB;IAE7B,IAAI,EAAE,UAAU;IAChB,YAAY,EAAE,CAAC,MAAM,CAAC;IACtB,EAAE;IACF,YAAY,EAAE;QACZ,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,KAAK;KACZ;IACD,SAAS,EAAE;QACT,MAAM,EAAE,EAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAC;QACvC,IAAI,EAAE,EAAC,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,IAAI,EAAC;KAChC;IAED,MAAM,EAAE;QACN;YACE,OAAO,EAAE,IAAI;YACb,QAAQ,EAAE,EAAC,IAAI,EAAE,CAAC,EAAC;SACpB;QACD;YACE,OAAO,EAAE,IAAI;YACb,QAAQ,EAAE,EAAC,IAAI,EAAE,CAAC,EAAC;SACpB;KACF;CAC0D,CAAC"}

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

@@ -0,0 +1,43 @@
+/**
+ * Hexagonal Pixelate
+ * Renders the image using a pattern of hexagonal tiles.
+ * Tile colors are nearest-neighbor sampled from the centers of the tiles.
+ */
+export type HexagonalPixelateProps = {
+    /** The [x, y] coordinates of the pattern center. */
+    center?: [number, number];
+    /** 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>";
+        readonly scale: "f32";
+    };
+    readonly propTypes: {
+        readonly center: {
+            readonly value: readonly [0.5, 0.5];
+            readonly hint: "screenspace";
+        };
+        readonly scale: {
+            readonly value: 10;
+            readonly min: 1;
+            readonly softMin: 5;
+            readonly softMax: 50;
+        };
+    };
+    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;
+    }];
+};
+//# sourceMappingURL=hexagonalpixelate.d.ts.map

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

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

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

@@ -0,0 +1,68 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const fs = /* glsl */ `\
+uniform hexagonalPixelateUniforms {
+  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);
+}
+`;
+/**
+ * Hexagonal Pixelate
+ * Renders the image using a pattern of hexagonal tiles. Tile colors
+ * are nearest-neighbor sampled from the centers of the tiles.
+ */
+export const hexagonalPixelate = {
+    props: {},
+    uniforms: {},
+    name: 'hexagonalPixelate',
+    uniformTypes: {
+        center: 'vec2<f32>',
+        scale: 'f32'
+    },
+    propTypes: {
+        center: { value: [0.5, 0.5], hint: 'screenspace' },
+        scale: { value: 10, min: 1, softMin: 5, softMax: 50 }
+    },
+    fs,
+    passes: [{ sampler: true }]
+};
+//# sourceMappingURL=hexagonalpixelate.js.map

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

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

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

@@ -0,0 +1,40 @@
+/**
+ * Ink -
+ * Simulates outlining the image in ink by darkening edges stronger than a
+ * certain threshold. The edge detection value is the difference of two
+ * copies of the image, each blurred using a blur of a different radius.
+ */
+export type InkProps = {
+    /** The multiplicative scale of the ink edges.
+     * Values in the range 0 to 1 are usually sufficient, where 0 doesn't change the image and 1 adds lots of black edges.
+     * Negative strength values will create white ink edges instead of black ones.
+     */
+    strength?: number;
+};
+export type InkUniforms = InkProps;
+/**
+ * Ink -
+ * Simulates outlining the image in ink by darkening edges stronger than a
+ * certain threshold. The edge detection value is the difference of two
+ * 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";
+    };
+    readonly propTypes: {
+        readonly strength: {
+            readonly value: 0.25;
+            readonly min: 0;
+            readonly softMax: 1;
+        };
+    };
+    readonly passes: [{
+        readonly sampler: true;
+    }];
+};
+//# sourceMappingURL=ink.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ink.d.ts","sourceRoot":"","sources":["../../../../src/passes/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"}

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

@@ -0,0 +1,52 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const fs = /* glsl */ `\
+uniform inkUniforms {
+  float strength;
+} ink;
+
+vec4 ink_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
+  vec2 dx = vec2(1.0 / texSize.x, 0.0);
+  vec2 dy = vec2(0.0, 1.0 / texSize.y);
+  vec4 color = texture(source, texCoord);
+  float bigTotal = 0.0;
+  float smallTotal = 0.0;
+  vec3 bigAverage = vec3(0.0);
+  vec3 smallAverage = vec3(0.0);
+  for (float x = -2.0; x <= 2.0; x += 1.0) {
+    for (float y = -2.0; y <= 2.0; y += 1.0) {
+      vec3 offsetColor = texture(source, texCoord + dx * x + dy * y).rgb;
+      bigAverage += offsetColor;
+      bigTotal += 1.0;
+      if (abs(x) + abs(y) < 2.0) {
+        smallAverage += offsetColor;
+        smallTotal += 1.0;
+      }
+    }
+  }
+  vec3 edge = max(vec3(0.0), bigAverage / bigTotal - smallAverage / smallTotal);
+  float power = ink.strength * ink.strength * ink.strength * ink.strength * ink.strength;
+  return vec4(color.rgb - dot(edge, edge) * power * 100000.0, color.a);
+}
+`;
+/**
+ * Ink -
+ * Simulates outlining the image in ink by darkening edges stronger than a
+ * certain threshold. The edge detection value is the difference of two
+ * copies of the image, each blurred using a blur of a different radius.
+ */
+export const ink = {
+    props: {},
+    uniforms: {},
+    name: 'ink',
+    fs,
+    uniformTypes: {
+        strength: 'f32'
+    },
+    propTypes: {
+        strength: { value: 0.25, min: 0, softMax: 1 }
+    },
+    passes: [{ sampler: true }]
+};
+//# sourceMappingURL=ink.js.map

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

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

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

@@ -0,0 +1,45 @@
+/**
+ * Magnify - display a circle with magnify effect applied to surrounding the pixels given position
+ */
+export type MagnifyProps = {
+    /** x, y position in screen coords, both x and y is normalized and in range `[0, 1]`. `[0, 0]` is the up left corner, `[1, 1]` is the bottom right corner. Default value is `[0, 0]`. */
+    screenXY?: [number, number];
+    /** effect radius in pixels. Default value is `100`. */
+    radiusPixels?: number;
+    /** magnify level. Default value is `2`. */
+    zoom?: number;
+    /** border width of the effect circle, will not show border if value <= 0.0. Default value is `0`. */
+    borderWidthPixels?: number;
+    /** border color of the effect circle. Default value is `[255, 255, 255, 255]`. */
+    borderColor?: [number, number, number, number];
+};
+export type MagnifyUniforms = MagnifyProps;
+/**
+ * Magnify - display a circle with magnify effect applied to surrounding the pixels given position
+ */
+export declare const magnify: {
+    readonly name: "magnify";
+    readonly uniformTypes: {
+        readonly screenXY: "vec2<f32>";
+        readonly radiusPixels: "f32";
+        readonly zoom: "f32";
+        readonly borderWidthPixels: "f32";
+        readonly borderColor: "vec4<f32>";
+    };
+    readonly propTypes: {
+        readonly screenXY: {
+            readonly value: readonly [0, 0];
+        };
+        readonly radiusPixels: 200;
+        readonly zoom: 2;
+        readonly borderWidthPixels: 0;
+        readonly borderColor: {
+            readonly value: readonly [255, 255, 255, 255];
+        };
+    };
+    readonly fs: "uniform magnifyUniforms {\n  vec2 screenXY;\n  float radiusPixels;\n  float zoom;\n  float borderWidthPixels;\n  vec4 borderColor;\n} magnify;\n\nvec4 magnify_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 pos = vec2(magnify.screenXY.x, 1.0 - magnify.screenXY.y);\n  float dist = distance(texCoord * texSize, pos * texSize);\n  if (dist < magnify.radiusPixels) {\n    return texture(source, (texCoord - pos) / magnify.zoom + pos);\n  }\n\n  if (dist <= magnify.radiusPixels + magnify.borderWidthPixels) {\n    return magnify.borderColor;\n  }\n  return texture(source, texCoord);\n}\n";
+    readonly passes: [{
+        readonly sampler: true;
+    }];
+};
+//# sourceMappingURL=magnify.d.ts.map

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

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

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

@@ -0,0 +1,49 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const fs = /* glsl */ `\
+uniform magnifyUniforms {
+  vec2 screenXY;
+  float radiusPixels;
+  float zoom;
+  float borderWidthPixels;
+  vec4 borderColor;
+} magnify;
+
+vec4 magnify_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
+  vec2 pos = vec2(magnify.screenXY.x, 1.0 - magnify.screenXY.y);
+  float dist = distance(texCoord * texSize, pos * texSize);
+  if (dist < magnify.radiusPixels) {
+    return texture(source, (texCoord - pos) / magnify.zoom + pos);
+  }
+
+  if (dist <= magnify.radiusPixels + magnify.borderWidthPixels) {
+    return magnify.borderColor;
+  }
+  return texture(source, texCoord);
+}
+`;
+/**
+ * Magnify - display a circle with magnify effect applied to surrounding the pixels given position
+ */
+export const magnify = {
+    name: 'magnify',
+    uniformTypes: {
+        screenXY: 'vec2<f32>',
+        radiusPixels: 'f32',
+        zoom: 'f32',
+        borderWidthPixels: 'f32',
+        borderColor: 'vec4<f32>'
+    },
+    propTypes: {
+        // range 0 to 1
+        screenXY: { value: [0, 0] },
+        radiusPixels: 200,
+        zoom: 2.0,
+        borderWidthPixels: 0.0,
+        borderColor: { value: [255, 255, 255, 255] }
+    },
+    fs,
+    passes: [{ sampler: true }]
+};
+//# sourceMappingURL=magnify.js.map

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

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

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

@@ -0,0 +1,49 @@
+/** Bulges or pinches the image in a circle. */
+export type BulgePinchProps = {
+    /** The [x, y] coordinates of the center of the circle of effect. */
+    center?: [number, number];
+    /** The radius of the circle of effect. */
+    radius?: number;
+    /** strength -1 to 1 (-1 is strong pinch, 0 is no effect, 1 is strong bulge) */
+    strength?: number;
+};
+export type BulgePinchUniforms = BulgePinchProps;
+/**
+ * Bulge / Pinch -
+ * Bulges or pinches the image in a circle.
+ */
+export declare const bulgePinch: {
+    readonly props: BulgePinchProps;
+    readonly uniforms: BulgePinchUniforms;
+    readonly name: "bulgePinch";
+    readonly dependencies: [{
+        readonly name: "warp";
+        readonly passes: [];
+        readonly fs: "vec4 warp_sampleColor(sampler2D source, vec2 texSize, vec2 coord) {\n  vec4 color = texture(source, coord / texSize);\n  vec2 clampedCoord = clamp(coord, vec2(0.0), texSize);\n  if (coord != clampedCoord) {\n    /* fade to transparent if we are outside the image */\n    color.a *= max(0.0, 1.0 - length(coord - clampedCoord));\n  }\n\n  return color;\n}\n";
+    }];
+    readonly fs: "uniform bulgePinchUniforms {\n  float radius;\n  float strength;\n  vec2 center;\n} bulgePinch;\n\nvec2 bulgePinch_warp(vec2 coord, vec2 texCenter) {\n  coord -= texCenter;\n  float distance = length(coord);\n  if (distance < bulgePinch.radius) {\n    float percent = distance / bulgePinch.radius;\n    if (bulgePinch.strength > 0.0) {\n      coord *= mix(1.0, smoothstep(0.0, bulgePinch.radius / distance, percent), bulgePinch.strength * 0.75);\n    } else {\n      coord *= mix(1.0, pow(percent, 1.0 + bulgePinch.strength * 0.75) * bulgePinch.radius / distance, 1.0 - percent);\n    }\n  }\n  coord += texCenter;\n  return coord;\n}\n\nvec4 bulgePinch_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {\n  vec2 coord = texCoord * texSize;\n  coord = bulgePinch_warp(coord, bulgePinch.center * texSize);\n\n  return warp_sampleColor(source, texSize, coord);\n}\n";
+    readonly uniformTypes: {
+        readonly center: "vec2<f32>";
+        readonly radius: "f32";
+        readonly strength: "f32";
+    };
+    readonly propTypes: {
+        readonly center: {
+            readonly value: readonly [0.5, 0.5];
+        };
+        readonly radius: {
+            readonly value: 200;
+            readonly min: 1;
+            readonly softMax: 600;
+        };
+        readonly strength: {
+            readonly value: 0.5;
+            readonly min: -1;
+            readonly max: 1;
+        };
+    };
+    readonly passes: [{
+        readonly sampler: true;
+    }];
+};
+//# sourceMappingURL=bulgepinch.d.ts.map

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

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

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

@@ -0,0 +1,56 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { warp } from "./warp.js";
+const fs = /* glsl */ `\
+uniform bulgePinchUniforms {
+  float radius;
+  float strength;
+  vec2 center;
+} bulgePinch;
+
+vec2 bulgePinch_warp(vec2 coord, vec2 texCenter) {
+  coord -= texCenter;
+  float distance = length(coord);
+  if (distance < bulgePinch.radius) {
+    float percent = distance / bulgePinch.radius;
+    if (bulgePinch.strength > 0.0) {
+      coord *= mix(1.0, smoothstep(0.0, bulgePinch.radius / distance, percent), bulgePinch.strength * 0.75);
+    } else {
+      coord *= mix(1.0, pow(percent, 1.0 + bulgePinch.strength * 0.75) * bulgePinch.radius / distance, 1.0 - percent);
+    }
+  }
+  coord += texCenter;
+  return coord;
+}
+
+vec4 bulgePinch_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
+  vec2 coord = texCoord * texSize;
+  coord = bulgePinch_warp(coord, bulgePinch.center * texSize);
+
+  return warp_sampleColor(source, texSize, coord);
+}
+`;
+/**
+ * Bulge / Pinch -
+ * Bulges or pinches the image in a circle.
+ */
+export const bulgePinch = {
+    props: {},
+    uniforms: {},
+    name: 'bulgePinch',
+    dependencies: [warp],
+    fs,
+    uniformTypes: {
+        center: 'vec2<f32>',
+        radius: 'f32',
+        strength: 'f32'
+    },
+    propTypes: {
+        center: { value: [0.5, 0.5] },
+        radius: { value: 200, min: 1, softMax: 600 },
+        strength: { value: 0.5, min: -1, max: 1 }
+    },
+    passes: [{ sampler: true }]
+};
+//# sourceMappingURL=bulgepinch.js.map

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

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