@swf2es/render 0.0.0-stage → 0.1.1

package/src/filter-shaders.ts

@@ -0,0 +1,360 @@
+// The fragment shaders of Flash's filters, as adl draws them (docs/architecture/compositing.md,
+// "Filters"), which the renderer's passes (webgl/filters.ts) run, so that their
+// exactness rules live in one place. GLSL ES 3 bodies, with no version or precision
+// line; each reads vTextureCoord, its input's texture coordinate, and writes finalColor.
+
+/** Truncated to 8 bits, as adl's each pass is: a hair over, so that an exact value stays. */
+export const TRUNCATE = "floor(c * 255.0 + 0.001) / 255.0";
+
+/**
+ * One run of the box one way: `uWidth` texels wide, its end texels weighted
+ * by their part; `uDirection` a texel's step in the input's pixels, which
+ * uInputSize gives the coordinates in.
+ */
+export const BOX = `in vec2 vTextureCoord;
+out vec4 finalColor;
+uniform sampler2D uTexture;
+// As the vertex shader has it, which is highp: a program's uniforms agree.
+uniform highp vec4 uInputSize;
+uniform vec2 uDirection;
+uniform float uWidth;
+void main(void) {
+  float half_ = uWidth * 0.5;
+  int reach = int(ceil(half_));
+  vec4 sum = vec4(0.0);
+  // As far as 255 pixels at 4 texels a pixel, each way.
+  for (int i = 0; i <= 2040; i++) {
+    if (i > 2 * reach) { break; }
+    float f = float(i - reach);
+    float weight = max(0.0, min(f + 0.5, half_) - max(f - 0.5, -half_));
+    sum += texture(uTexture, vTextureCoord + uDirection * uInputSize.zw * f) * weight;
+  }
+  vec4 c = sum / uWidth;
+  finalColor = ${TRUNCATE};
+}`;
+
+// The mean of the uFactor.x by uFactor.y texels of the input that a texel of the output covers,
+// the output that many times narrower and lower (blurShrink). Two texels each way a read: a linear read midway between texel centres is their mean, so a
+// block takes a quarter of the reads. An odd factor's last column or row is read alone, weighted
+// by the texels each read stands for. A pool texture has no levels but its base.
+export const SHRINK = `in vec2 vTextureCoord;
+out vec4 finalColor;
+uniform sampler2D uTexture;
+uniform highp vec4 uInputPixel;
+uniform vec2 uFactor;
+void main(void) {
+  vec4 sum = vec4(0.0);
+  vec2 centre = (uFactor - 1.0) * 0.5;
+  for (int j = 0; j < 16; j += 2) {
+    float y = float(j);
+    if (y >= uFactor.y) { break; }
+    float ny = min(2.0, uFactor.y - y);
+    for (int i = 0; i < 16; i += 2) {
+      float x = float(i);
+      if (x >= uFactor.x) { break; }
+      float nx = min(2.0, uFactor.x - x);
+      vec2 at = vec2(x, y) + (vec2(nx, ny) - 1.0) * 0.5 - centre;
+      sum += texture(uTexture, vTextureCoord + at * uInputPixel.zw) * (nx * ny);
+    }
+  }
+  finalColor = sum / (uFactor.x * uFactor.y);
+}`;
+
+/** A blur's runs, done coarser (blurred), drawn back between their texels over the input's frame. */
+export const READ_BACK = `in vec2 vTextureCoord;
+out vec4 finalColor;
+uniform sampler2D uBlurred;
+uniform vec2 uBlurredScale;
+void main(void) {
+  finalColor = texture(uBlurred, vTextureCoord * uBlurredScale);
+}`;
+
+/**
+ * A glow or a shadow: the input's blurred alpha (uBlurred), from `uOffset`
+ * texels back for a shadow, times strength and alpha, in its colour; behind
+ * the object, or inside it for an inner one; the object kept, or not.
+ */
+export const GLOW = `in vec2 vTextureCoord;
+out vec4 finalColor;
+uniform sampler2D uTexture;
+uniform sampler2D uBlurred;
+uniform highp vec4 uInputSize;
+uniform vec3 uColor;
+uniform float uAlpha;
+uniform float uStrength;
+uniform vec2 uOffset;
+uniform vec2 uBlurredScale;
+uniform float uInner;
+uniform float uKnockout;
+uniform float uHide;
+void main(void) {
+  vec4 src = texture(uTexture, vTextureCoord);
+  float a = texture(uBlurred, (vTextureCoord - uOffset * uInputSize.zw) * uBlurredScale).a;
+  vec4 c;
+  if (uInner > 0.5) {
+    float g = clamp((1.0 - a) * uStrength, 0.0, 1.0) * uAlpha * src.a;
+    vec4 glow = vec4(uColor * g, g);
+    c = uKnockout > 0.5 ? glow : glow + src * (1.0 - g);
+  } else {
+    float g = clamp(a * uStrength, 0.0, 1.0) * uAlpha;
+    vec4 glow = vec4(uColor * g, g);
+    c = uKnockout > 0.5 ? glow * (1.0 - src.a) : uHide > 0.5 ? glow : src + glow * (1.0 - src.a);
+  }
+  finalColor = ${TRUNCATE};
+}`;
+
+/**
+ * A bevel: the input's blurred alpha (uBlurred) from uOffset texels on and
+ * back; their difference times strength, clamped, times the colour's alpha,
+ * the highlight where on is more and the shadow where it is less. Inner
+ * (uType 0) atop the object, outer (1) behind it, full (2) over it;
+ * knocked out, alone, masked to where the object is (inner) or is not
+ * (outer).
+ */
+export const BEVEL = `in vec2 vTextureCoord;
+out vec4 finalColor;
+uniform sampler2D uTexture;
+uniform sampler2D uBlurred;
+uniform highp vec4 uInputSize;
+uniform vec3 uHighlight;
+uniform vec3 uShadow;
+uniform float uHighlightAlpha;
+uniform float uShadowAlpha;
+uniform float uStrength;
+uniform vec2 uOffset;
+uniform float uType;
+uniform float uKnockout;
+void main(void) {
+  // Keep source samples sharp; the bevel reads alpha at a stage pixel's centre.
+  vec2 at = (floor(vTextureCoord * uInputSize.xy) + 0.5) * uInputSize.zw;
+  vec4 src = texture(uTexture, vTextureCoord);
+  vec2 step_ = uOffset * uInputSize.zw;
+  // In 255ths, each read truncated, as adl's are.
+  float on = floor(texture(uBlurred, at + step_).a * 255.0 + 0.001);
+  float back = floor(texture(uBlurred, at - step_).a * 255.0 + 0.001);
+  float d = on - back;
+  bool lit = d > 0.0;
+  float strong = min(255.0, floor(abs(d) * uStrength + 0.001));
+  float la = floor(strong * (lit ? uHighlightAlpha : uShadowAlpha) + 0.5) / 255.0;
+  float m = uType < 0.5 ? src.a : (uType < 1.5 && uKnockout > 0.5 ? 1.0 - src.a : 1.0);
+  vec4 layer = vec4((lit ? uHighlight : uShadow) * la, la) * m;
+  vec4 c;
+  if (uKnockout > 0.5) {
+    c = layer;
+  } else if (uType > 0.5 && uType < 1.5) {
+    c = src + layer * (1.0 - src.a);
+  } else {
+    c = layer + src * (1.0 - (uType < 0.5 ? la : layer.a));
+  }
+  finalColor = ${TRUNCATE};
+}`;
+
+/**
+ * How a bevel or a gradient filter places its layer (premultiplied) on the
+ * object's pixel, as bitmap/filters' placer does: masked to where the
+ * object is (uType 0, inner) or, knocked out, is not (1, outer); inner
+ * atop it, outer behind it, full (2) over it, knocked out alone.
+ */
+export const PLACE = `vec4 place(vec4 src, vec4 layer) {
+  float m = uType < 0.5 ? src.a : (uType < 1.5 && uKnockout > 0.5 ? 1.0 - src.a : 1.0);
+  vec4 masked = layer * m;
+  if (uKnockout > 0.5) {
+    return masked;
+  }
+  if (uType > 0.5 && uType < 1.5) {
+    return src + masked * (1.0 - src.a);
+  }
+  return masked + src * (1.0 - (uType < 0.5 ? layer.a : masked.a));
+}`;
+
+/**
+ * A gradient glow: the input's blurred alpha (uBlurred) from uOffset back,
+ * as a shadow reads it, times strength, picking a texel of the gradient
+ * (uGradient, 256 wide); a gradient bevel (uBevel 1): the difference of
+ * that alpha on and back, the middle of the gradient where they agree.
+ * Each pixel is evaluated once, at its centre, in 255ths truncated.
+ */
+export const GRADIENT = `in vec2 vTextureCoord;
+out vec4 finalColor;
+uniform sampler2D uTexture;
+uniform sampler2D uBlurred;
+uniform sampler2D uGradient;
+uniform highp vec4 uInputSize;
+uniform float uStrength;
+uniform vec2 uOffset;
+uniform float uType;
+uniform float uKnockout;
+uniform float uBevel;
+uniform vec4 uRegion;
+${PLACE}
+float alphaAt(vec2 at) {
+  return floor(texture(uBlurred, at).a * 255.0 + 0.001);
+}
+void main(void) {
+  vec2 p = floor(vTextureCoord * uInputSize.xy) + 0.5;
+  // Past the filter's rect it draws nothing, though its gradient may have colour at 0.
+  if (any(lessThan(p, uRegion.xy)) || any(greaterThanEqual(p, uRegion.zw))) {
+    finalColor = vec4(0.0);
+    return;
+  }
+  vec2 at = p * uInputSize.zw;
+  vec4 src = texture(uTexture, at);
+  vec2 step_ = uOffset * uInputSize.zw;
+  float index;
+  if (uBevel > 0.5) {
+    float d = clamp(floor((alphaAt(at + step_) - alphaAt(at - step_)) * uStrength), -255.0, 255.0);
+    index = floor((d + 256.0) / 2.0);
+  } else {
+    index = min(255.0, floor(alphaAt(at - step_) * uStrength + 0.001));
+  }
+  vec4 layer = texture(uGradient, vec2((index + 0.5) / 256.0, 0.5));
+  vec4 c = place(src, layer);
+  finalColor = ${TRUNCATE};
+}`;
+
+/**
+ * A displacement map, in the input's pixels from its frame's corner: each
+ * pixel of the object's (uBox) where the map lies (uMapAt, uMapSize) takes
+ * the input at itself moved by the map's channel (uComponents picks one
+ * for x, one for y) less 128, times scale, in 256ths toward 0, between
+ * pixels with weights in 256ths; past the object's pixels as uMode says:
+ * 0 wrap, 1 clamp, 2 its own place, 3 uColor, which also fills uGrow pixels
+ * round the object, as adl's drawing of it does. Each pixel once, at its
+ * centre.
+ */
+export const DISPLACE = `in vec2 vTextureCoord;
+out vec4 finalColor;
+uniform sampler2D uTexture;
+uniform sampler2D uMap;
+uniform highp vec4 uInputSize;
+uniform vec4 uBox;
+uniform vec4 uMapAt;
+uniform vec4 uComponentX;
+uniform vec4 uComponentY;
+uniform vec2 uScale;
+uniform float uMode;
+uniform vec4 uColor;
+uniform vec2 uGrow;
+vec4 read(vec2 at, vec2 own) {
+  vec2 size = uBox.zw - uBox.xy;
+  vec2 i = at - uBox.xy;
+  if (any(lessThan(i, vec2(0.0))) || any(greaterThanEqual(i, size))) {
+    if (uMode < 0.5) {
+      i = mod(i, size);
+    } else if (uMode < 2.5) {
+      i = clamp(i, vec2(0.0), size - 1.0);
+    } else {
+      return uColor;
+    }
+  }
+  return texture(uTexture, (uBox.xy + i + 0.5) * uInputSize.zw);
+}
+void main(void) {
+  vec2 p = floor(vTextureCoord * uInputSize.xy);
+  vec4 own = texture(uTexture, (p + 0.5) * uInputSize.zw);
+  vec2 m = p - uMapAt.xy;
+  if (any(lessThan(p, uBox.xy)) || any(greaterThanEqual(p, uBox.zw))) {
+    bool near = all(greaterThanEqual(p, uBox.xy - uGrow)) && all(lessThan(p, uBox.zw + uGrow));
+    finalColor = uMode > 2.5 && near ? uColor : vec4(0.0);
+    return;
+  }
+  if (any(lessThan(m, vec2(0.0))) || any(greaterThanEqual(m, uMapAt.zw))) {
+    finalColor = own;
+    return;
+  }
+  vec4 map = texture(uMap, (m + 0.5) / uMapAt.zw);
+  vec4 straight = map.a > 0.0 ? vec4(map.rgb / map.a, map.a) : vec4(0.0);
+  vec2 c = floor(vec2(dot(straight, uComponentX), dot(straight, uComponentY)) * 255.0 + 0.5);
+  // None picked: no move.
+  c = vec2(uComponentX == vec4(0.0) ? 128.0 : c.x, uComponentY == vec4(0.0) ? 128.0 : c.y);
+  // Toward 0, without trunc, which GLSL ES 1 has not.
+  vec2 moved = (c - 128.0) * uScale;
+  vec2 q = p * 256.0 + sign(moved) * floor(abs(moved));
+  vec2 whole = floor(q / 256.0);
+  vec2 f = q - whole * 256.0;
+  if (uMode > 1.5 && uMode < 2.5) {
+    vec2 i = whole - uBox.xy;
+    vec2 size = uBox.zw - uBox.xy;
+    whole = vec2(i.x < 0.0 || i.x >= size.x ? p.x : whole.x, i.y < 0.0 || i.y >= size.y ? p.y : whole.y);
+  }
+  float w00 = floor((256.0 - f.x) * (256.0 - f.y) / 256.0);
+  float w10 = floor(f.x * (256.0 - f.y) / 256.0);
+  float w01 = floor((256.0 - f.x) * f.y / 256.0);
+  float w11 = floor(f.x * f.y / 256.0);
+  vec4 v = read(whole, p) * w00 + read(whole + vec2(1.0, 0.0), p) * w10 +
+    read(whole + vec2(0.0, 1.0), p) * w01 + read(whole + vec2(1.0, 1.0), p) * w11;
+  vec4 c8 = floor(v * 255.0 / 256.0 + 0.001) / 255.0;
+  finalColor = c8;
+}`;
+
+/** A colour matrix of a pixel's straight colour, its offsets in 255ths, transparent pixels too. */
+export const MATRIX = `in vec2 vTextureCoord;
+out vec4 finalColor;
+uniform sampler2D uTexture;
+uniform mat4 uMatrix;
+uniform vec4 uOffset;
+void main(void) {
+  vec4 src = texture(uTexture, vTextureCoord);
+  vec4 straight = src.a > 0.0 ? vec4(src.rgb / src.a, src.a) : vec4(0.0);
+  vec4 s = clamp(uMatrix * straight + uOffset, 0.0, 1.0);
+  vec4 c = vec4(s.rgb * s.a, s.a);
+  finalColor = ${TRUNCATE};
+}`;
+
+/**
+ * A convolution, in 255ths: the taps' straight colour over uBox, the
+ * object's pixels as adl filters them, in the input's pixels from its
+ * frame's corner; past it the nearest edge's or uEdge; summed, divided,
+ * biased, clamped and premultiplied as bitmap/filters' convolve does, the
+ * fixed-point way too (uReciprocal not 0) where every tap lies in the box.
+ */
+export const CONVOLUTION = `in vec2 vTextureCoord;
+out vec4 finalColor;
+uniform sampler2D uTexture;
+uniform highp vec4 uInputSize;
+uniform vec4 uMatrix[57];
+uniform vec2 uSize;
+uniform vec4 uBox;
+uniform vec4 uEdge;
+uniform float uDivisor;
+uniform float uReciprocal;
+uniform float uBias;
+uniform float uClamp;
+uniform float uPreserve;
+vec4 straight(vec2 p) {
+  if (any(lessThan(p, uBox.xy)) || any(greaterThanEqual(p, uBox.zw))) {
+    if (uClamp < 0.5) { return uEdge; }
+    p = clamp(p, floor(uBox.xy) + 0.5, floor(uBox.zw) - 0.5);
+  }
+  vec4 c = texture(uTexture, p * uInputSize.zw);
+  return c.a > 0.0 ? floor(vec4(c.rgb / c.a, c.a) * 255.0 + 0.5) : vec4(0.0);
+}
+void main(void) {
+  // The pixel's centre, which all its texels read alike, as adl's one pixel.
+  vec2 p = floor(vTextureCoord * uInputSize.xy) + 0.5;
+  vec2 reach = floor(uSize * 0.5);
+  if (any(lessThan(p, uBox.xy - reach)) || any(greaterThanEqual(p, uBox.zw + reach))) {
+    finalColor = vec4(0.0);
+    return;
+  }
+  bool fixed_ = uReciprocal != 0.0 && all(greaterThanEqual(p - 1.0, uBox.xy)) &&
+    all(lessThan(p + 1.0, uBox.zw));
+  int cols = int(uSize.x);
+  int count = cols * int(uSize.y);
+  vec4 sum = vec4(0.0);
+  // One loop, its index alone indexing the weights, as GLSL ES 1 allows.
+  for (int k = 0; k < 225; k++) {
+    if (k >= count) { break; }
+    float w = dot(uMatrix[k / 4], vec4(equal(vec4(float(k - k / 4 * 4)), vec4(0.0, 1.0, 2.0, 3.0))));
+    if (w != 0.0) {
+      int j = k / cols;
+      vec2 at = vec2(float(k - j * cols), float(j)) - reach;
+      sum += straight(fixed_ && k == 8 ? p : p + at) * w;
+    }
+  }
+  sum = fixed_ ? floor(sum * uReciprocal) : sum / uDivisor;
+  vec4 v = floor(clamp(sum + uBias, 0.0, 255.0) + 0.0001);
+  float a = uPreserve > 0.5 ? straight(p).a : v.a;
+  vec3 c = fixed_ ? floor(v.rgb * a / 255.0) : floor((v.rgb * a + 127.0) / 255.0);
+  finalColor = vec4(c, a) / 255.0;
+}`;

package/src/filters.ts

@@ -0,0 +1,220 @@
+// Flash's filters as passes a layer takes before it is composited: what
+// each kind reads, as the floats a frame's filter list holds for it, and
+// the rules its passes keep to match adl (docs/architecture/compositing.md,
+// "Filters"), which the backend's runner (webgl/filters.ts) follows.
+// Offsets and insets are in the target's units, its pixels over the
+// resolution, as the shaders read their input's size in.
+
+/** A blur: blurX, blurY, quality, units (the target's units a stage pixel). */
+export const BLUR = 1;
+/**
+ * A glow or a drop shadow: blurX, blurY, quality, units; its colour's red,
+ * green and blue from 0 to 1, alpha, strength; the offset x and y it is
+ * cast by; inner, knockout and hide object, 1 or 0.
+ */
+export const GLOW = 2;
+/**
+ * A bevel: blurX, blurY, quality, units; the highlight's red, green and
+ * blue, the shadow's, the highlight's alpha, the shadow's, strength; the
+ * offset x and y; its type (0 inner, 1 outer, 2 full), knockout.
+ */
+export const BEVEL = 3;
+/**
+ * A gradient glow or bevel, its texture the gradient's 256 colours: blurX,
+ * blurY, quality, units, strength; the offset x and y; type, knockout,
+ * bevel (1, else a glow); how far in the object's pixels start; how far
+ * its rect grows past them in stage pixels, left, top, right and bottom.
+ */
+export const GRADIENT = 4;
+/** A colour matrix: its 4 by 4 part by columns, then its offsets over 255. */
+export const COLOR_MATRIX = 5;
+/**
+ * A convolution: its columns and rows; the edge colour's red, green, blue
+ * and alpha in 255ths; divisor, the fixed-point reciprocal over 65536 (0
+ * for none), bias, clamp, preserve alpha; how far in the object's pixels
+ * start; then the matrix by rows.
+ */
+export const CONVOLUTION = 6;
+/**
+ * A displacement map, its texture the map's pixels: the channel that
+ * moves x, picked by four weights for red, green, blue and alpha, and the
+ * one that moves y; scale x and y; its mode (0 wrap, 1 clamp, 2 ignore, 3
+ * colour), the colour's red, green, blue and alpha, premultiplied, and how
+ * far round the object it fills, x and y; how far in the object's pixels
+ * start; the map's point, and its width and height.
+ */
+export const DISPLACEMENT = 7;
+/**
+ * A ShaderFilter, its kernel's GLSL the filter's kernel (kernel-shaders.ts):
+ * units; how far in from its input's corner the filter's input starts, and
+ * how far the first filter's, the object's bitmap, is from that, both in
+ * units; its extensions left, top, right and bottom in stage pixels; how
+ * many images it samples, then each one's texture number, the texture of
+ * the frame's it reads (-1 for the layer) and whether its texels are
+ * floats; how many floats its parameters take, then them. Its parameters'
+ * ints are the filter's ints (Filters.ints).
+ */
+export const SHADER = 8;
+/**
+ * A blend shader, alone in a chain a layer's KERNEL mode names, which no
+ * filter pass runs: its values as SHADER's, its images' textures -1 for
+ * what is below and -2 for the layer, but its first, 1 where it blends
+ * the layer's whole rectangle rather than where the layer covers anything.
+ */
+export const BLEND = 9;
+/**
+ * A shader fill, alone in a chain a SHADED draw names (scene.ts), which no
+ * filter pass runs: its values as SHADER's, every image a texture.
+ */
+export const FILL_SHADER = 10;
+
+/**
+ * A frame's filters in chains, one a filtered layer: each filter its kind,
+ * its values and the texture it reads (-1 for none), written in order and
+ * closed into a chain the layer's end names.
+ */
+export class Filters {
+  kind = new Uint8Array(64);
+  texture = new Int32Array(64);
+  /** A ShaderFilter's kernel, its GLSL, by the filter; null for the others. */
+  kernels: (string | null)[] = [];
+  /** Where each filter's values start in `values`, and where the next one's do. */
+  start = new Int32Array(65);
+  values = new Float32Array(1024);
+  /** Each filter's ints, which floats would round: from `intStart` on, as values are. */
+  intStart = new Int32Array(65);
+  ints = new Int32Array(256);
+  count = 0;
+  /** Where each chain's filters start, and where the next one's do: the first's, 0. */
+  chains = new Int32Array(17);
+  chainCount = 0;
+
+  /** Moves on at each reset: a chain number is good while it is the same. */
+  generation = 0;
+
+  reset(): void {
+    this.count = 0;
+    this.chainCount = 0;
+    this.kernels.length = 0;
+    this.generation++;
+  }
+
+  /** A filter of `kind` added to the chain open: its values, the texture it reads, its kernel and its ints. */
+  add(
+    kind: number,
+    values: ArrayLike<number>,
+    texture = -1,
+    kernel: string | null = null,
+    ints: ArrayLike<number> = NO_INTS,
+  ): void {
+    const at = this.count++;
+    if (this.count >= this.kind.length) {
+      this.kind = grow(this.kind);
+      this.texture = grow(this.texture);
+      this.start = grow(this.start);
+      this.intStart = grow(this.intStart);
+    }
+
+    const intFrom = at > 0 ? this.intStart[at] : 0;
+    if (intFrom + ints.length > this.ints.length) {
+      const grown = new Int32Array(Math.max(this.ints.length * 2, intFrom + ints.length));
+      grown.set(this.ints);
+      this.ints = grown;
+    }
+
+    this.intStart[at] = intFrom;
+    this.ints.set(ints, intFrom);
+    this.intStart[at + 1] = intFrom + ints.length;
+
+    const from = at > 0 ? this.start[at] : 0;
+    if (from + values.length > this.values.length) {
+      const grown = new Float32Array(Math.max(this.values.length * 2, from + values.length));
+      grown.set(this.values);
+      this.values = grown;
+    }
+
+    this.kind[at] = kind;
+    this.texture[at] = texture;
+    this.kernels[at] = kernel;
+    this.start[at] = from;
+    this.values.set(values, from);
+    this.start[at + 1] = from + values.length;
+  }
+
+  /** The filters added since the last chain closed, as a chain: its number. */
+  close(): number {
+    const chain = this.chainCount++;
+    if (this.chainCount >= this.chains.length) {
+      this.chains = grow(this.chains);
+    }
+
+    this.chains[chain + 1] = this.count;
+    return chain;
+  }
+}
+
+const NO_INTS = new Int32Array(0);
+
+function grow<T extends Int32Array | Uint8Array>(array: T): T {
+  const grown = new (array.constructor as new (length: number) => T)(array.length * 2);
+  grown.set(array);
+  return grown;
+}
+
+/**
+ * The fewest texels a shrunk run spans, for each time a glow's strength
+ * multiplies its alpha. Under it the bound below fails: an edge's ramp a
+ * few coarse texels long bends sharply where a box ends, and drawn back
+ * linearly between them a glow 8 wide at strength 2.37 shrunk three times
+ * was off by 10 levels; a glow's strength multiplies that too.
+ */
+const SHRUNK_TEXELS = 8;
+
+/** The most, in 255ths of alpha times strength, that drawing a shrunk blur back may be off by. */
+const SHRUNK_ERROR = 2;
+
+/**
+ * The strongest glow or shadow a shrunk blur serves. Each run truncates to
+ * a 255th, and drawn back between coarser texels a level's step moves by up
+ * to a texel: off by a level the strength multiplies, however wide the blur.
+ */
+const SHRUNK_STRENGTH = 3;
+
+/**
+ * How many times coarser than its input a blur's runs one way may go: none
+ * at a texel a stage pixel or under, nor where it does not blur that way;
+ * otherwise whole times, to a texel a stage pixel at most, the run still
+ * SHRUNK_TEXELS wide for each time strength multiplies it. A run reads a
+ * texel for each of its width, so at three texels a stage pixel a glow 68
+ * wide read 204 for each texel of an area nine times the stage's; shrunk
+ * three times each way, it reads 68 for each of the stage's. Drawn back
+ * between the coarser texels, what it blurred is off where it bends: at the
+ * ends of a single box's ramp by a quarter of a coarse texel's rise, and
+ * where two boxes or more bend smoothly by a sixth of the coarse texel
+ * squared over the box's width squared; times the strength a glow multiplies
+ * its alpha by, that stays within SHRUNK_ERROR. Each way is its own: a
+ * streak 68 wide and 5 high goes coarser across alone.
+ */
+export function blurShrink(
+  blur: number,
+  quality: number,
+  strength: number,
+  texels: number,
+): number {
+  if (!(blur > 1 && quality > 0) || strength > SHRUNK_STRENGTH) {
+    return 1;
+  }
+
+  const box = blur * texels;
+  const amplified = 255 * Math.max(1, strength);
+  const error =
+    quality === 1
+      ? (4 * SHRUNK_ERROR * box) / amplified
+      : box * Math.sqrt((6 * SHRUNK_ERROR) / amplified);
+  const most = Math.min(
+    16,
+    Math.floor(texels + 1e-6),
+    Math.floor(box / (SHRUNK_TEXELS * Math.max(1, strength))),
+  );
+  return Math.max(1, Math.min(most, Math.floor(error)));
+}