shaders-oneshot 0.0.81-shared.1

package/dist/shaders/heatmap.js

@@ -0,0 +1,384 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ *                    Paper Shaders                    *
+ *       https://github.com/paper-design/shaders       *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+const heatmapMeta = {
+  maxColorCount: 10
+};
+const heatmapFragmentShader = `#version 300 es
+precision highp float;
+
+in mediump vec2 v_imageUV;
+in mediump vec2 v_objectUV;
+out vec4 fragColor;
+
+uniform sampler2D u_image;
+uniform float u_time;
+
+uniform vec4 u_colorBack;
+uniform vec4 u_colors[${heatmapMeta.maxColorCount}];
+uniform float u_colorsCount;
+
+uniform float u_angle;
+uniform float u_noise;
+uniform float u_innerGlow;
+uniform float u_outerGlow;
+uniform float u_contour;
+
+#define TWO_PI 6.28318530718
+#define PI 3.14159265358979323846
+
+float getImgFrame(vec2 uv, float th) {
+  float frame = 1.;
+  frame *= smoothstep(0., th, uv.y);
+  frame *= 1. - smoothstep(1. - th, 1., uv.y);
+  frame *= smoothstep(0., th, uv.x);
+  frame *= 1. - smoothstep(1. - th, 1., uv.x);
+  return frame;
+}
+
+float circle(vec2 uv, vec2 c, vec2 r) {
+  return 1. - smoothstep(r[0], r[1], length(uv - c));
+}
+
+float lst(float edge0, float edge1, float x) {
+  return clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);
+}
+
+float sst(float edge0, float edge1, float x) {
+  return smoothstep(edge0, edge1, x);
+}
+
+float shadowShape(vec2 uv, float t, float contour) {
+  vec2 scaledUV = uv;
+
+  // base shape tranjectory
+  float posY = mix(-1., 2., t);
+
+  // scaleX when it's moving down
+  scaledUV.y -= .5;
+  float mainCircleScale = sst(0., .8, posY) * lst(1.4, .9, posY);
+  scaledUV *= vec2(1., 1. + 1.5 * mainCircleScale);
+  scaledUV.y += .5;
+
+  // base shape
+  float innerR = .4;
+  float outerR = 1. - .3 * (sst(.1, .2, t) * (1. - sst(.2, .5, t)));
+  float s = circle(scaledUV, vec2(.5, posY - .2), vec2(innerR, outerR));
+  float shapeSizing = sst(.2, .3, t) * sst(.6, .3, t);
+  s = pow(s, 1.4);
+  s *= 1.2;
+
+  // flat gradient to take over the shadow shape
+  float topFlattener = 0.;
+  {
+    float pos = posY - uv.y;
+    float edge = 1.2;
+    topFlattener = lst(-.4, 0., pos) * (1. - sst(.0, edge, pos));
+    topFlattener = pow(topFlattener, 3.);
+    float topFlattenerMixer = (1. - sst(.0, .3, pos));
+    s = mix(topFlattener, s, topFlattenerMixer);
+  }
+
+  // apple right circle
+  {
+    float visibility = sst(.6, .7, t) * (1. - sst(.8, .9, t));
+    float angle = -2. -t * TWO_PI;
+    float rightCircle = circle(uv, vec2(.95 - .2 * cos(angle), .4 - .1 * sin(angle)), vec2(.15, .3));
+    rightCircle *= visibility;
+    s = mix(s, 0., rightCircle);
+  }
+
+  // apple top circle
+  {
+    float topCircle = circle(uv, vec2(.5, .19), vec2(.05, .25));
+    topCircle += 2. * contour * circle(uv, vec2(.5, .19), vec2(.2, .5));
+    float visibility = .55 * sst(.2, .3, t) * (1. - sst(.3, .45, t));
+    topCircle *= visibility;
+    s = mix(s, 0., topCircle);
+  }
+
+  float leafMask = circle(uv, vec2(.53, .13), vec2(.08, .19));
+  leafMask = mix(leafMask, 0., 1. - sst(.4, .54, uv.x));
+  leafMask = mix(0., leafMask, sst(.0, .2, uv.y));
+  leafMask *= (sst(.5, 1.1, posY) * sst(1.5, 1.3, posY));
+  s += leafMask;
+
+  // apple bottom circle
+  {
+    float visibility = sst(.0, .4, t) * (1. - sst(.6, .8, t));
+    s = mix(s, 0., visibility * circle(uv, vec2(.52, .92), vec2(.09, .25)));
+  }
+
+  // random balls that are invisible if apple logo is selected
+  {
+    float pos = sst(.0, .6, t) * (1. - sst(.6, 1., t));
+    s = mix(s, .5, circle(uv, vec2(.0, 1.2 - .5 * pos), vec2(.1, .3)));
+    s = mix(s, .0, circle(uv, vec2(1., .5 + .5 * pos), vec2(.1, .3)));
+
+    s = mix(s, 1., circle(uv, vec2(.95, .2 + .2 * sst(.3, .4, t) * sst(.7, .5, t)), vec2(.07, .22)));
+    s = mix(s, 1., circle(uv, vec2(.95, .2 + .2 * sst(.3, .4, t) * (1. - sst(.5, .7, t))), vec2(.07, .22)));
+    s /= max(1e-4, sst(1., .85, uv.y));
+  }
+
+  s = clamp(0., 1., s);
+  return s;
+}
+
+float blurEdge3x3(sampler2D tex, vec2 uv, vec2 dudx, vec2 dudy, float radius, float centerSample) {
+  vec2 texel = 1.0 / vec2(textureSize(tex, 0));
+  vec2 r = radius * texel;
+
+  float w1 = 1.0, w2 = 2.0, w4 = 4.0;
+  float norm = 16.0;
+  float sum = w4 * centerSample;
+
+  sum += w2 * textureGrad(tex, uv + vec2(0.0, -r.y), dudx, dudy).g;
+  sum += w2 * textureGrad(tex, uv + vec2(0.0, r.y), dudx, dudy).g;
+  sum += w2 * textureGrad(tex, uv + vec2(-r.x, 0.0), dudx, dudy).g;
+  sum += w2 * textureGrad(tex, uv + vec2(r.x, 0.0), dudx, dudy).g;
+
+  sum += w1 * textureGrad(tex, uv + vec2(-r.x, -r.y), dudx, dudy).g;
+  sum += w1 * textureGrad(tex, uv + vec2(r.x, -r.y), dudx, dudy).g;
+  sum += w1 * textureGrad(tex, uv + vec2(-r.x, r.y), dudx, dudy).g;
+  sum += w1 * textureGrad(tex, uv + vec2(r.x, r.y), dudx, dudy).g;
+
+  return sum / norm;
+}
+
+void main() {
+  vec2 uv = v_objectUV + .5;
+  uv.y = 1. - uv.y;
+
+  vec2 imgUV = v_imageUV;
+  imgUV -= .5;
+  imgUV *= 0.5714285714285714;
+  imgUV += .5;
+  float imgSoftFrame = getImgFrame(imgUV, .03);
+
+  vec4 img = texture(u_image, imgUV);
+  vec2 dudx = dFdx(imgUV);
+  vec2 dudy = dFdy(imgUV);
+
+  if (img.a == 0.) {
+    fragColor = u_colorBack;
+    return;
+  }
+
+  float t = .1 * u_time;
+  t -= .3;
+
+  float tCopy = t + 1. / 3.;
+  float tCopy2 = t + 2. / 3.;
+
+  t = mod(t, 1.);
+  tCopy = mod(tCopy, 1.);
+  tCopy2 = mod(tCopy2, 1.);
+
+  vec2 animationUV = imgUV - vec2(.5);
+  float angle = -u_angle * PI / 180.;
+  float cosA = cos(angle);
+  float sinA = sin(angle);
+  animationUV = vec2(
+  animationUV.x * cosA - animationUV.y * sinA,
+  animationUV.x * sinA + animationUV.y * cosA
+  ) + vec2(.5);
+
+  float shape = img[0];
+
+  img[1] = blurEdge3x3(u_image, imgUV, dudx, dudy, 8., img[1]);
+
+  float outerBlur = 1. - mix(1., img[1], shape);
+  float innerBlur = mix(img[1], 0., shape);
+  float contour = mix(img[2], 0., shape);
+
+  outerBlur *= imgSoftFrame;
+
+  float shadow = shadowShape(animationUV, t, innerBlur);
+  float shadowCopy = shadowShape(animationUV, tCopy, innerBlur);
+  float shadowCopy2 = shadowShape(animationUV, tCopy2, innerBlur);
+
+  float inner = .8 + .8 * innerBlur;
+  inner = mix(inner, 0., shadow);
+  inner = mix(inner, 0., shadowCopy);
+  inner = mix(inner, 0., shadowCopy2);
+
+  inner *= mix(0., 2., u_innerGlow);
+
+  inner += (u_contour * 2.) * contour;
+  inner = min(1., inner);
+  inner *= (1. - shape);
+
+  float outer = 0.;
+  {
+    t *= 3.;
+    t = mod(t - .1, 1.);
+
+    outer = .9 * pow(outerBlur, .8);
+    float y = mod(animationUV.y - t, 1.);
+    float animatedMask = sst(.3, .65, y) * (1. - sst(.65, 1., y));
+    animatedMask = .5 + animatedMask;
+    outer *= animatedMask;
+    outer *= mix(0., 5., pow(u_outerGlow, 2.));
+    outer *= imgSoftFrame;
+  }
+
+  inner = pow(inner, 1.2);
+  float heat = clamp(inner + outer, 0., 1.);
+
+  heat += (.005 + .35 * u_noise) * (fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453123) - .5);
+
+  float mixer = heat * u_colorsCount;
+  vec4 gradient = u_colors[0];
+  gradient.rgb *= gradient.a;
+  float outerShape = 0.;
+  for (int i = 1; i < ${heatmapMeta.maxColorCount + 1}; i++) {
+    if (i > int(u_colorsCount)) break;
+    float m = clamp(mixer - float(i - 1), 0., 1.);
+    if (i == 1) {
+      outerShape = m;
+    }
+    vec4 c = u_colors[i - 1];
+    c.rgb *= c.a;
+    gradient = mix(gradient, c, m);
+  }
+
+  vec3 color = gradient.rgb * outerShape;
+  float opacity = gradient.a * outerShape;
+
+  vec3 bgColor = u_colorBack.rgb * u_colorBack.a;
+  color = color + bgColor * (1.0 - opacity);
+  opacity = opacity + u_colorBack.a * (1.0 - opacity);
+
+  color += .02 * (fract(sin(dot(uv + 1., vec2(12.9898, 78.233))) * 43758.5453123) - .5);
+
+  fragColor = vec4(color, opacity);
+}
+`;
+function toProcessedHeatmap(file) {
+  const canvas = document.createElement("canvas");
+  const canvasSize = 1e3;
+  return new Promise((resolve, reject) => {
+    const image = new Image();
+    image.crossOrigin = "anonymous";
+    image.addEventListener("load", () => {
+      if (typeof file === "string" ? file.endsWith(".svg") : file.type === "image/svg+xml") {
+        image.width = canvasSize;
+        image.height = canvasSize;
+      }
+      const ratio = image.naturalWidth / image.naturalHeight;
+      const maxBlur = Math.floor(canvasSize * 0.15);
+      const padding = Math.ceil(maxBlur * 2.5);
+      let imgWidth = canvasSize;
+      let imgHeight = canvasSize;
+      if (ratio > 1) {
+        imgHeight = Math.floor(canvasSize / ratio);
+      } else {
+        imgWidth = Math.floor(canvasSize * ratio);
+      }
+      canvas.width = imgWidth + 2 * padding;
+      canvas.height = imgHeight + 2 * padding;
+      const ctx = canvas.getContext("2d", { willReadFrequently: true });
+      if (!ctx) {
+        throw new Error("Failed to get canvas 2d context");
+      }
+      ctx.fillStyle = "white";
+      ctx.fillRect(0, 0, canvas.width, canvas.height);
+      ctx.drawImage(image, padding, padding, imgWidth, imgHeight);
+      const { width, height } = canvas;
+      const srcImageData = ctx.getImageData(0, 0, width, height);
+      const src = srcImageData.data;
+      const totalPixels = width * height;
+      const gray = new Uint8ClampedArray(totalPixels);
+      for (let i = 0; i < totalPixels; i++) {
+        const px = i * 4;
+        const r = src[px] ?? 0;
+        const g = src[px + 1] ?? 0;
+        const b = src[px + 2] ?? 0;
+        gray[i] = 0.299 * r + 0.587 * g + 0.114 * b | 0;
+      }
+      const bigBlurRadius = maxBlur;
+      const innerBlurRadius = Math.max(1, Math.round(0.12 * maxBlur));
+      const contourRadius = 5;
+      const bigBlurGray = multiPassBlurGray(gray, width, height, bigBlurRadius, 3);
+      const innerBlurGray = multiPassBlurGray(gray, width, height, innerBlurRadius, 3);
+      const contourGray = multiPassBlurGray(gray, width, height, contourRadius, 1);
+      const processedImageData = ctx.createImageData(width, height);
+      const dst = processedImageData.data;
+      for (let i = 0; i < totalPixels; i++) {
+        const px = i * 4;
+        dst[px] = contourGray[i] ?? 0;
+        dst[px + 1] = bigBlurGray[i] ?? 0;
+        dst[px + 2] = innerBlurGray[i] ?? 0;
+        dst[px + 3] = 255;
+      }
+      ctx.putImageData(processedImageData, 0, 0);
+      canvas.toBlob((blob) => {
+        if (!blob) {
+          reject(new Error("Failed to create PNG blob"));
+          return;
+        }
+        resolve({ blob });
+      }, "image/png");
+    });
+    image.addEventListener("error", () => {
+      reject(new Error("Failed to load image"));
+    });
+    image.src = typeof file === "string" ? file : URL.createObjectURL(file);
+  });
+}
+function blurGray(gray, width, height, radius) {
+  if (radius <= 0) {
+    return gray.slice();
+  }
+  const out = new Uint8ClampedArray(width * height);
+  const integral = new Uint32Array(width * height);
+  for (let y = 0; y < height; y++) {
+    let rowSum = 0;
+    for (let x = 0; x < width; x++) {
+      const idx = y * width + x;
+      const v = gray[idx] ?? 0;
+      rowSum += v;
+      integral[idx] = rowSum + (y > 0 ? integral[idx - width] ?? 0 : 0);
+    }
+  }
+  for (let y = 0; y < height; y++) {
+    const y1 = Math.max(0, y - radius);
+    const y2 = Math.min(height - 1, y + radius);
+    for (let x = 0; x < width; x++) {
+      const x1 = Math.max(0, x - radius);
+      const x2 = Math.min(width - 1, x + radius);
+      const idxA = y2 * width + x2;
+      const idxB = y2 * width + (x1 - 1);
+      const idxC = (y1 - 1) * width + x2;
+      const idxD = (y1 - 1) * width + (x1 - 1);
+      const A = integral[idxA] ?? 0;
+      const B = x1 > 0 ? integral[idxB] ?? 0 : 0;
+      const C = y1 > 0 ? integral[idxC] ?? 0 : 0;
+      const D = x1 > 0 && y1 > 0 ? integral[idxD] ?? 0 : 0;
+      const sum = A - B - C + D;
+      const area = (x2 - x1 + 1) * (y2 - y1 + 1);
+      out[y * width + x] = Math.round(sum / area);
+    }
+  }
+  return out;
+}
+function multiPassBlurGray(gray, width, height, radius, passes) {
+  if (radius <= 0 || passes <= 1) {
+    return blurGray(gray, width, height, radius);
+  }
+  let input = gray;
+  let tmp = gray;
+  for (let p = 0; p < passes; p++) {
+    tmp = blurGray(input, width, height, radius);
+    input = tmp;
+  }
+  return tmp;
+}
+export {
+  heatmapFragmentShader,
+  heatmapMeta,
+  toProcessedHeatmap
+};
+//# sourceMappingURL=heatmap.js.map

package/dist/shaders/heatmap.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/shaders/heatmap.ts"],
+  "sourcesContent": ["import type { vec4 } from '../types.js';\r\nimport type { ShaderMotionParams } from '../shader-mount.js';\r\nimport type { ShaderSizingParams, ShaderSizingUniforms } from '../shader-sizing.js';\r\n\r\nexport const heatmapMeta = {\r\n  maxColorCount: 10,\r\n} as const;\r\n\r\n/**\r\n * A glowing gradient of colors flowing through an input shape.\r\n * The effect creates a smoothly animated wave of intensity across the image.\r\n *\r\n * Fragment shader uniforms:\r\n * - u_time (float): Animation time\r\n * - u_image (sampler2D): Pre-processed source image texture (R = contour, G = outer blur, B = inner blur)\r\n * - u_colorBack (vec4): Background color in RGBA\r\n * - u_colors (vec4[]): Up to 10 heatmap colors in RGBA\r\n * - u_colorsCount (float): Number of active colors\r\n * - u_contour (float): Heat intensity near the edges of the input shape (0 to 1)\r\n * - u_angle (float): Direction of the heatwaves in degrees, needs innerGlow or outerGlow > 0 (0 to 360)\r\n * - u_noise (float): Grain applied across the entire graphic (0 to 1)\r\n * - u_innerGlow (float): Size of the heated area inside the input shape (0 to 1)\r\n * - u_outerGlow (float): Size of the heated area outside the input shape (0 to 1)\r\n *\r\n * Vertex shader outputs (used in fragment shader):\r\n * - v_imageUV (vec2): UV coordinates for sampling the source image, with fit, scale, rotation, and offset applied\r\n * - v_objectUV (vec2): Object box UV coordinates with global sizing (scale, rotation, offsets, etc) applied\r\n *\r\n * Vertex shader uniforms:\r\n * - u_resolution (vec2): Canvas resolution in pixels\r\n * - u_pixelRatio (float): Device pixel ratio\r\n * - u_originX (float): Reference point for positioning world width in the canvas (0 to 1)\r\n * - u_originY (float): Reference point for positioning world height in the canvas (0 to 1)\r\n * - u_worldWidth (float): Virtual width of the graphic before it's scaled to fit the canvas\r\n * - u_worldHeight (float): Virtual height of the graphic before it's scaled to fit the canvas\r\n * - u_fit (float): How to fit the rendered shader into the canvas dimensions (0 = none, 1 = contain, 2 = cover)\r\n * - u_scale (float): Overall zoom level of the graphics (0.1 to 4)\r\n * - u_rotation (float): Overall rotation angle of the graphics in degrees (0 to 360)\r\n * - u_offsetX (float): Horizontal offset of the graphics center (-1 to 1)\r\n * - u_offsetY (float): Vertical offset of the graphics center (-1 to 1)\r\n * - u_imageAspectRatio (float): Aspect ratio of the source image\r\n *\r\n */\r\n\r\n// language=GLSL\r\nexport const heatmapFragmentShader: string = `#version 300 es\r\nprecision highp float;\r\n\r\nin mediump vec2 v_imageUV;\r\nin mediump vec2 v_objectUV;\r\nout vec4 fragColor;\r\n\r\nuniform sampler2D u_image;\r\nuniform float u_time;\r\n\r\nuniform vec4 u_colorBack;\r\nuniform vec4 u_colors[${ heatmapMeta.maxColorCount }];\r\nuniform float u_colorsCount;\r\n\r\nuniform float u_angle;\r\nuniform float u_noise;\r\nuniform float u_innerGlow;\r\nuniform float u_outerGlow;\r\nuniform float u_contour;\r\n\r\n#define TWO_PI 6.28318530718\r\n#define PI 3.14159265358979323846\r\n\r\nfloat getImgFrame(vec2 uv, float th) {\r\n  float frame = 1.;\r\n  frame *= smoothstep(0., th, uv.y);\r\n  frame *= 1. - smoothstep(1. - th, 1., uv.y);\r\n  frame *= smoothstep(0., th, uv.x);\r\n  frame *= 1. - smoothstep(1. - th, 1., uv.x);\r\n  return frame;\r\n}\r\n\r\nfloat circle(vec2 uv, vec2 c, vec2 r) {\r\n  return 1. - smoothstep(r[0], r[1], length(uv - c));\r\n}\r\n\r\nfloat lst(float edge0, float edge1, float x) {\r\n  return clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);\r\n}\r\n\r\nfloat sst(float edge0, float edge1, float x) {\r\n  return smoothstep(edge0, edge1, x);\r\n}\r\n\r\nfloat shadowShape(vec2 uv, float t, float contour) {\r\n  vec2 scaledUV = uv;\r\n\r\n  // base shape tranjectory\r\n  float posY = mix(-1., 2., t);\r\n\r\n  // scaleX when it's moving down\r\n  scaledUV.y -= .5;\r\n  float mainCircleScale = sst(0., .8, posY) * lst(1.4, .9, posY);\r\n  scaledUV *= vec2(1., 1. + 1.5 * mainCircleScale);\r\n  scaledUV.y += .5;\r\n\r\n  // base shape\r\n  float innerR = .4;\r\n  float outerR = 1. - .3 * (sst(.1, .2, t) * (1. - sst(.2, .5, t)));\r\n  float s = circle(scaledUV, vec2(.5, posY - .2), vec2(innerR, outerR));\r\n  float shapeSizing = sst(.2, .3, t) * sst(.6, .3, t);\r\n  s = pow(s, 1.4);\r\n  s *= 1.2;\r\n\r\n  // flat gradient to take over the shadow shape\r\n  float topFlattener = 0.;\r\n  {\r\n    float pos = posY - uv.y;\r\n    float edge = 1.2;\r\n    topFlattener = lst(-.4, 0., pos) * (1. - sst(.0, edge, pos));\r\n    topFlattener = pow(topFlattener, 3.);\r\n    float topFlattenerMixer = (1. - sst(.0, .3, pos));\r\n    s = mix(topFlattener, s, topFlattenerMixer);\r\n  }\r\n\r\n  // apple right circle\r\n  {\r\n    float visibility = sst(.6, .7, t) * (1. - sst(.8, .9, t));\r\n    float angle = -2. -t * TWO_PI;\r\n    float rightCircle = circle(uv, vec2(.95 - .2 * cos(angle), .4 - .1 * sin(angle)), vec2(.15, .3));\r\n    rightCircle *= visibility;\r\n    s = mix(s, 0., rightCircle);\r\n  }\r\n\r\n  // apple top circle\r\n  {\r\n    float topCircle = circle(uv, vec2(.5, .19), vec2(.05, .25));\r\n    topCircle += 2. * contour * circle(uv, vec2(.5, .19), vec2(.2, .5));\r\n    float visibility = .55 * sst(.2, .3, t) * (1. - sst(.3, .45, t));\r\n    topCircle *= visibility;\r\n    s = mix(s, 0., topCircle);\r\n  }\r\n\r\n  float leafMask = circle(uv, vec2(.53, .13), vec2(.08, .19));\r\n  leafMask = mix(leafMask, 0., 1. - sst(.4, .54, uv.x));\r\n  leafMask = mix(0., leafMask, sst(.0, .2, uv.y));\r\n  leafMask *= (sst(.5, 1.1, posY) * sst(1.5, 1.3, posY));\r\n  s += leafMask;\r\n\r\n  // apple bottom circle\r\n  {\r\n    float visibility = sst(.0, .4, t) * (1. - sst(.6, .8, t));\r\n    s = mix(s, 0., visibility * circle(uv, vec2(.52, .92), vec2(.09, .25)));\r\n  }\r\n\r\n  // random balls that are invisible if apple logo is selected\r\n  {\r\n    float pos = sst(.0, .6, t) * (1. - sst(.6, 1., t));\r\n    s = mix(s, .5, circle(uv, vec2(.0, 1.2 - .5 * pos), vec2(.1, .3)));\r\n    s = mix(s, .0, circle(uv, vec2(1., .5 + .5 * pos), vec2(.1, .3)));\r\n\r\n    s = mix(s, 1., circle(uv, vec2(.95, .2 + .2 * sst(.3, .4, t) * sst(.7, .5, t)), vec2(.07, .22)));\r\n    s = mix(s, 1., circle(uv, vec2(.95, .2 + .2 * sst(.3, .4, t) * (1. - sst(.5, .7, t))), vec2(.07, .22)));\r\n    s /= max(1e-4, sst(1., .85, uv.y));\r\n  }\r\n\r\n  s = clamp(0., 1., s);\r\n  return s;\r\n}\r\n\r\nfloat blurEdge3x3(sampler2D tex, vec2 uv, vec2 dudx, vec2 dudy, float radius, float centerSample) {\r\n  vec2 texel = 1.0 / vec2(textureSize(tex, 0));\r\n  vec2 r = radius * texel;\r\n\r\n  float w1 = 1.0, w2 = 2.0, w4 = 4.0;\r\n  float norm = 16.0;\r\n  float sum = w4 * centerSample;\r\n\r\n  sum += w2 * textureGrad(tex, uv + vec2(0.0, -r.y), dudx, dudy).g;\r\n  sum += w2 * textureGrad(tex, uv + vec2(0.0, r.y), dudx, dudy).g;\r\n  sum += w2 * textureGrad(tex, uv + vec2(-r.x, 0.0), dudx, dudy).g;\r\n  sum += w2 * textureGrad(tex, uv + vec2(r.x, 0.0), dudx, dudy).g;\r\n\r\n  sum += w1 * textureGrad(tex, uv + vec2(-r.x, -r.y), dudx, dudy).g;\r\n  sum += w1 * textureGrad(tex, uv + vec2(r.x, -r.y), dudx, dudy).g;\r\n  sum += w1 * textureGrad(tex, uv + vec2(-r.x, r.y), dudx, dudy).g;\r\n  sum += w1 * textureGrad(tex, uv + vec2(r.x, r.y), dudx, dudy).g;\r\n\r\n  return sum / norm;\r\n}\r\n\r\nvoid main() {\r\n  vec2 uv = v_objectUV + .5;\r\n  uv.y = 1. - uv.y;\r\n\r\n  vec2 imgUV = v_imageUV;\r\n  imgUV -= .5;\r\n  imgUV *= 0.5714285714285714;\r\n  imgUV += .5;\r\n  float imgSoftFrame = getImgFrame(imgUV, .03);\r\n\r\n  vec4 img = texture(u_image, imgUV);\r\n  vec2 dudx = dFdx(imgUV);\r\n  vec2 dudy = dFdy(imgUV);\r\n\r\n  if (img.a == 0.) {\r\n    fragColor = u_colorBack;\r\n    return;\r\n  }\r\n\r\n  float t = .1 * u_time;\r\n  t -= .3;\r\n\r\n  float tCopy = t + 1. / 3.;\r\n  float tCopy2 = t + 2. / 3.;\r\n\r\n  t = mod(t, 1.);\r\n  tCopy = mod(tCopy, 1.);\r\n  tCopy2 = mod(tCopy2, 1.);\r\n\r\n  vec2 animationUV = imgUV - vec2(.5);\r\n  float angle = -u_angle * PI / 180.;\r\n  float cosA = cos(angle);\r\n  float sinA = sin(angle);\r\n  animationUV = vec2(\r\n  animationUV.x * cosA - animationUV.y * sinA,\r\n  animationUV.x * sinA + animationUV.y * cosA\r\n  ) + vec2(.5);\r\n\r\n  float shape = img[0];\r\n\r\n  img[1] = blurEdge3x3(u_image, imgUV, dudx, dudy, 8., img[1]);\r\n\r\n  float outerBlur = 1. - mix(1., img[1], shape);\r\n  float innerBlur = mix(img[1], 0., shape);\r\n  float contour = mix(img[2], 0., shape);\r\n\r\n  outerBlur *= imgSoftFrame;\r\n\r\n  float shadow = shadowShape(animationUV, t, innerBlur);\r\n  float shadowCopy = shadowShape(animationUV, tCopy, innerBlur);\r\n  float shadowCopy2 = shadowShape(animationUV, tCopy2, innerBlur);\r\n\r\n  float inner = .8 + .8 * innerBlur;\r\n  inner = mix(inner, 0., shadow);\r\n  inner = mix(inner, 0., shadowCopy);\r\n  inner = mix(inner, 0., shadowCopy2);\r\n\r\n  inner *= mix(0., 2., u_innerGlow);\r\n\r\n  inner += (u_contour * 2.) * contour;\r\n  inner = min(1., inner);\r\n  inner *= (1. - shape);\r\n\r\n  float outer = 0.;\r\n  {\r\n    t *= 3.;\r\n    t = mod(t - .1, 1.);\r\n\r\n    outer = .9 * pow(outerBlur, .8);\r\n    float y = mod(animationUV.y - t, 1.);\r\n    float animatedMask = sst(.3, .65, y) * (1. - sst(.65, 1., y));\r\n    animatedMask = .5 + animatedMask;\r\n    outer *= animatedMask;\r\n    outer *= mix(0., 5., pow(u_outerGlow, 2.));\r\n    outer *= imgSoftFrame;\r\n  }\r\n\r\n  inner = pow(inner, 1.2);\r\n  float heat = clamp(inner + outer, 0., 1.);\r\n\r\n  heat += (.005 + .35 * u_noise) * (fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453123) - .5);\r\n\r\n  float mixer = heat * u_colorsCount;\r\n  vec4 gradient = u_colors[0];\r\n  gradient.rgb *= gradient.a;\r\n  float outerShape = 0.;\r\n  for (int i = 1; i < ${ heatmapMeta.maxColorCount + 1 }; i++) {\r\n    if (i > int(u_colorsCount)) break;\r\n    float m = clamp(mixer - float(i - 1), 0., 1.);\r\n    if (i == 1) {\r\n      outerShape = m;\r\n    }\r\n    vec4 c = u_colors[i - 1];\r\n    c.rgb *= c.a;\r\n    gradient = mix(gradient, c, m);\r\n  }\r\n\r\n  vec3 color = gradient.rgb * outerShape;\r\n  float opacity = gradient.a * outerShape;\r\n\r\n  vec3 bgColor = u_colorBack.rgb * u_colorBack.a;\r\n  color = color + bgColor * (1.0 - opacity);\r\n  opacity = opacity + u_colorBack.a * (1.0 - opacity);\r\n\r\n  color += .02 * (fract(sin(dot(uv + 1., vec2(12.9898, 78.233))) * 43758.5453123) - .5);\r\n\r\n  fragColor = vec4(color, opacity);\r\n}\r\n`;\r\n\r\nexport function toProcessedHeatmap(file: File | string): Promise<{ blob: Blob }> {\r\n  const canvas = document.createElement('canvas');\r\n  const canvasSize = 1000;\r\n\r\n  return new Promise((resolve, reject) => {\r\n    const image = new Image();\r\n    image.crossOrigin = 'anonymous';\r\n\r\n    image.addEventListener('load', () => {\r\n      if (typeof file === 'string' ? file.endsWith('.svg') : file.type === 'image/svg+xml') {\r\n        // Force SVG to load at a high fidelity size if it's an SVG\r\n        image.width = canvasSize;\r\n        image.height = canvasSize;\r\n      }\r\n\r\n      const ratio = image.naturalWidth / image.naturalHeight;\r\n\r\n      const maxBlur = Math.floor(canvasSize * 0.15);\r\n      const padding = Math.ceil(maxBlur * 2.5);\r\n      let imgWidth = canvasSize;\r\n      let imgHeight = canvasSize;\r\n      if (ratio > 1) {\r\n        imgHeight = Math.floor(canvasSize / ratio);\r\n      } else {\r\n        imgWidth = Math.floor(canvasSize * ratio);\r\n      }\r\n\r\n      canvas.width = imgWidth + 2 * padding;\r\n      canvas.height = imgHeight + 2 * padding;\r\n\r\n      const ctx = canvas.getContext('2d', { willReadFrequently: true });\r\n      if (!ctx) {\r\n        throw new Error('Failed to get canvas 2d context');\r\n      }\r\n\r\n      // 1) Draw original image once, no filters\r\n      ctx.fillStyle = 'white';\r\n      ctx.fillRect(0, 0, canvas.width, canvas.height);\r\n      ctx.drawImage(image, padding, padding, imgWidth, imgHeight);\r\n\r\n      const { width, height } = canvas;\r\n      const srcImageData = ctx.getImageData(0, 0, width, height);\r\n      const src = srcImageData.data; // RGBA\r\n\r\n      // 2) Build grayscale array (luma)\r\n      const totalPixels = width * height;\r\n      const gray = new Uint8ClampedArray(totalPixels);\r\n      for (let i = 0; i < totalPixels; i++) {\r\n        const px = i * 4;\r\n        const r = src[px] ?? 0;\r\n        const g = src[px + 1] ?? 0;\r\n        const b = src[px + 2] ?? 0;\r\n        // Standard luma conversion\r\n        gray[i] = (0.299 * r + 0.587 * g + 0.114 * b) | 0;\r\n      }\r\n\r\n      // 3) Blur grayscale for each \"filter\" you previously used\r\n      const bigBlurRadius = maxBlur;\r\n      const innerBlurRadius = Math.max(1, Math.round(0.12 * maxBlur));\r\n      const contourRadius = 5;\r\n\r\n      const bigBlurGray = multiPassBlurGray(gray, width, height, bigBlurRadius, 3);\r\n      const innerBlurGray = multiPassBlurGray(gray, width, height, innerBlurRadius, 3);\r\n      const contourGray = multiPassBlurGray(gray, width, height, contourRadius, 1);\r\n\r\n      // 4) Combine into final ImageData\r\n      const processedImageData = ctx.createImageData(width, height);\r\n      const dst = processedImageData.data;\r\n\r\n      for (let i = 0; i < totalPixels; i++) {\r\n        const px = i * 4;\r\n        dst[px] = contourGray[i] ?? 0;\r\n        dst[px + 1] = bigBlurGray[i] ?? 0;\r\n        dst[px + 2] = innerBlurGray[i] ?? 0;\r\n        dst[px + 3] = 255;\r\n      }\r\n\r\n      ctx.putImageData(processedImageData, 0, 0);\r\n\r\n      canvas.toBlob((blob) => {\r\n        if (!blob) {\r\n          reject(new Error('Failed to create PNG blob'));\r\n          return;\r\n        }\r\n        resolve({ blob });\r\n      }, 'image/png');\r\n    });\r\n\r\n    image.addEventListener('error', () => {\r\n      reject(new Error('Failed to load image'));\r\n    });\r\n\r\n    image.src = typeof file === 'string' ? file : URL.createObjectURL(file);\r\n  });\r\n}\r\n\r\n/**\r\n * Fast box blur for grayscale images using an integral image.\r\n * gray: Uint8ClampedArray of length width * height\r\n * radius: blur radius in pixels\r\n */\r\nfunction blurGray(gray: Uint8ClampedArray, width: number, height: number, radius: number): Uint8ClampedArray {\r\n  if (radius <= 0) {\r\n    return gray.slice();\r\n  }\r\n\r\n  const out = new Uint8ClampedArray(width * height);\r\n  const integral = new Uint32Array(width * height);\r\n\r\n  // Build integral image\r\n  for (let y = 0; y < height; y++) {\r\n    let rowSum = 0;\r\n    for (let x = 0; x < width; x++) {\r\n      const idx = y * width + x;\r\n      const v = gray[idx] ?? 0;\r\n      rowSum += v;\r\n      integral[idx] = rowSum + (y > 0 ? (integral[idx - width] ?? 0) : 0);\r\n    }\r\n  }\r\n\r\n  // Blur using integral image\r\n  for (let y = 0; y < height; y++) {\r\n    const y1 = Math.max(0, y - radius);\r\n    const y2 = Math.min(height - 1, y + radius);\r\n    for (let x = 0; x < width; x++) {\r\n      const x1 = Math.max(0, x - radius);\r\n      const x2 = Math.min(width - 1, x + radius);\r\n\r\n      const idxA = y2 * width + x2;\r\n      const idxB = y2 * width + (x1 - 1);\r\n      const idxC = (y1 - 1) * width + x2;\r\n      const idxD = (y1 - 1) * width + (x1 - 1);\r\n\r\n      const A = integral[idxA] ?? 0;\r\n      const B = x1 > 0 ? (integral[idxB] ?? 0) : 0;\r\n      const C = y1 > 0 ? (integral[idxC] ?? 0) : 0;\r\n      const D = x1 > 0 && y1 > 0 ? (integral[idxD] ?? 0) : 0;\r\n\r\n      const sum = A - B - C + D;\r\n      const area = (x2 - x1 + 1) * (y2 - y1 + 1);\r\n      out[y * width + x] = Math.round(sum / area);\r\n    }\r\n  }\r\n\r\n  return out;\r\n}\r\n\r\nfunction multiPassBlurGray(\r\n  gray: Uint8ClampedArray,\r\n  width: number,\r\n  height: number,\r\n  radius: number,\r\n  passes: number\r\n): Uint8ClampedArray {\r\n  if (radius <= 0 || passes <= 1) {\r\n    return blurGray(gray, width, height, radius);\r\n  }\r\n\r\n  let input = gray;\r\n  let tmp: Uint8ClampedArray = gray;\r\n\r\n  for (let p = 0; p < passes; p++) {\r\n    tmp = blurGray(input, width, height, radius);\r\n    input = tmp;\r\n  }\r\n\r\n  return tmp;\r\n}\r\n\r\nexport interface HeatmapUniforms extends ShaderSizingUniforms {\r\n  u_image: HTMLImageElement | string;\r\n  u_contour: number;\r\n  u_angle: number;\r\n  u_noise: number;\r\n  u_innerGlow: number;\r\n  u_outerGlow: number;\r\n  u_colorBack: [number, number, number, number];\r\n  u_colors: vec4[];\r\n  u_colorsCount: number;\r\n}\r\n\r\nexport interface HeatmapParams extends ShaderSizingParams, ShaderMotionParams {\r\n  image: HTMLImageElement | string;\r\n  contour?: number;\r\n  angle?: number;\r\n  noise?: number;\r\n  innerGlow?: number;\r\n  outerGlow?: number;\r\n  colorBack?: string;\r\n  colors?: string[];\r\n}\r\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/shaders/image-dithering.d.ts

@@ -0,0 +1,64 @@
+import type { ShaderMotionParams } from '../shader-mount.js';
+import { type ShaderSizingParams, type ShaderSizingUniforms } from '../shader-sizing.js';
+/**
+ * A dithering image filter with support for 4 dithering modes and multiple color palettes
+ * (2-color, 3-color, and multicolor options, using either predefined colors or colors sampled
+ * from the original image).
+ *
+ * SIZING NOTE: This shader performs sizing in the fragment shader (not vertex shader) to keep
+ * u_pxSize in consistent actual pixels. The pixel grid is computed from gl_FragCoord before any
+ * transforms, so scaling/rotating only affects the underlying image.
+ * No vertex shader outputs (v_imageUV, v_objectUV, etc.) are used.
+ *
+ * Fragment shader uniforms:
+ * - u_resolution (vec2): Canvas resolution in pixels
+ * - u_pixelRatio (float): Device pixel ratio
+ * - u_originX (float): Reference point for positioning world width in the canvas (0 to 1)
+ * - u_originY (float): Reference point for positioning world height in the canvas (0 to 1)
+ * - u_fit (float): How to fit the rendered shader into the canvas dimensions (0 = none, 1 = contain, 2 = cover)
+ * - u_scale (float): Overall zoom level of the graphics (0.1 to 4)
+ * - u_rotation (float): Overall rotation angle of the graphics in degrees (0 to 360)
+ * - u_offsetX (float): Horizontal offset of the graphics center (-1 to 1)
+ * - u_offsetY (float): Vertical offset of the graphics center (-1 to 1)
+ * - u_image (sampler2D): Source image texture
+ * - u_imageAspectRatio (float): Aspect ratio of the source image
+ * - u_colorFront (vec4): Foreground color in RGBA, needs originalColors off
+ * - u_colorBack (vec4): Background color in RGBA, needs originalColors off
+ * - u_colorHighlight (vec4): Secondary foreground color in RGBA (set same as colorFront for classic 2-color dithering), needs originalColors off
+ * - u_originalColors (bool): Use the original colors of the image instead of the color palette
+ * - u_inverted (bool): Inverts the image luminance, doesn't affect the color scheme
+ * - u_type (float): Dithering type (1 = random, 2 = 2x2 Bayer, 3 = 4x4 Bayer, 4 = 8x8 Bayer)
+ * - u_pxSize (float): Pixel size of dithering grid (0.5 to 20)
+ * - u_colorSteps (float): Number of colors to use, applies to both color modes (1 to 7)
+ *
+ */
+export declare const imageDitheringFragmentShader: string;
+export interface ImageDitheringUniforms extends ShaderSizingUniforms {
+    u_image: HTMLImageElement | string;
+    u_colorFront: [number, number, number, number];
+    u_colorBack: [number, number, number, number];
+    u_colorHighlight: [number, number, number, number];
+    u_type: (typeof DitheringTypes)[DitheringType];
+    u_pxSize: number;
+    u_colorSteps: number;
+    u_originalColors: boolean;
+    u_inverted: boolean;
+}
+export interface ImageDitheringParams extends ShaderSizingParams, ShaderMotionParams {
+    image: HTMLImageElement | string;
+    colorFront?: string;
+    colorBack?: string;
+    colorHighlight?: string;
+    type?: DitheringType;
+    size?: number;
+    colorSteps?: number;
+    originalColors?: boolean;
+    inverted?: boolean;
+}
+export declare const DitheringTypes: {
+    readonly random: 1;
+    readonly '2x2': 2;
+    readonly '4x4': 3;
+    readonly '8x8': 4;
+};
+export type DitheringType = keyof typeof DitheringTypes;