@swf2es/render 0.0.0-stage → 0.1.1

package/dist/kernel-shaders.js

@@ -0,0 +1,323 @@
+// Pixel Bender kernels where Flash draws with them, as fragment shaders
+// around a kernel's GLSL (the player's scene/pixel-bender-glsl.ts, which
+// defines `vec4 pbKernel(vec2 outCoord)` and calls `pbNearest<t>` and
+// `pbLinear<t>` for each texture `t` it samples). What is here is how
+// each use reads its images and writes what the kernel gives, as adl
+// does (docs/architecture/bitmaps.md, "Pixel Bender"): an image read as
+// its premultiplied bytes times the float nearest 1/255, linearly in
+// 256ths with each step's byte cut down; floats as they are, linearly in
+// the same 256ths; as the CPU interpreter reads them. GLSL ES 3, each a
+// whole fragment shader.
+/** A byte's float as adl samples one: times the float nearest 1/255, not divided. */
+const BYTE = "0.003921568859368563";
+/** Each fragment shader's first lines, so that one is the whole source a program cache keys by. */
+const HEADER = "#version 300 es\nprecision highp float;\n";
+/** The most images a kernel's program binds besides its layer's: one with more is not drawn. */
+export const KERNEL_IMAGES = 8;
+/** Whether `images` bind no more textures of their own than a program takes (KERNEL_IMAGES). */
+export function kernelImagesFit(images) {
+    let own = 0;
+    for (let k = 0; k < images.length; k++) {
+        if (!images[k].layer) {
+            own++;
+        }
+    }
+    return own <= KERNEL_IMAGES;
+}
+/**
+ * Precision, as ints default to mediump in a fragment shader; a texel
+ * coordinate as a texel's index, NaN as 0 and far past the edges kept in
+ * int's range; a texel's bytes from 0 to 255, read exactly from the 8-bit
+ * texture; and a kernel's output as adl writes it into a bitmap: clamped,
+ * NaN as 0, rounded to a byte a half to the even, each colour at most its
+ * alpha.
+ */
+const PRELUDE = `precision highp int;
+precision highp sampler2D;
+ivec2 pbFloor(vec2 x) {
+  x = mix(x, vec2(0.0), isnan(x));
+  return ivec2(clamp(floor(x), -1.0e9, 1.0e9));
+}
+vec4 pbBytes(vec4 v) {
+  return floor(v * 255.0 + 0.5);
+}
+vec4 pbOutput(vec4 c) {
+  c = mix(vec4(0.0), min(c, 1.0), greaterThan(c, vec4(0.0)));
+  c = roundEven(c * 255.0) / 255.0;
+  return vec4(min(c.rgb, c.a), c.a);
+}
+`;
+/**
+ * Image `t`'s sampling from `pbTexel<t>`, its texel at an index (bytes from
+ * 0 to 255, or floats), at the texel coordinates `at` gives for a kernel's.
+ */
+function sampling(t, at, float) {
+    if (float) {
+        // The interpreter's floats: their texels as they are, linearly in 256ths, nothing cut.
+        return `vec4 pbNearest${t}(vec2 p) {
+  return pbTexel${t}(pbFloor(${at}));
+}
+vec4 pbLinear${t}(vec2 p) {
+  vec2 f = ${at} - 0.5;
+  vec2 below = floor(f);
+  vec2 w = floor((f - below) * 256.0 + 0.5) / 256.0;
+  w = mix(w, vec2(0.0), isnan(w));
+  ivec2 a = pbFloor(below);
+  vec4 row0 = pbTexel${t}(a) * (1.0 - w.x) + pbTexel${t}(a + ivec2(1, 0)) * w.x;
+  vec4 row1 = pbTexel${t}(a + ivec2(0, 1)) * (1.0 - w.x) + pbTexel${t}(a + 1) * w.x;
+  return row0 * (1.0 - w.y) + row1 * w.y;
+}
+`;
+    }
+    return `vec4 pbNearest${t}(vec2 p) {
+  return pbTexel${t}(pbFloor(${at})) * ${BYTE};
+}
+vec4 pbLinear${t}(vec2 p) {
+  vec2 f = ${at} - 0.5;
+  vec2 below = floor(f);
+  vec2 w = floor((f - below) * 256.0 + 0.5);
+  w = mix(w, vec2(0.0), isnan(w));
+  ivec2 a = pbFloor(below);
+  vec4 row0 = floor((pbTexel${t}(a) * (256.0 - w.x) + pbTexel${t}(a + ivec2(1, 0)) * w.x) / 256.0);
+  vec4 row1 = floor((pbTexel${t}(a + ivec2(0, 1)) * (256.0 - w.x) + pbTexel${t}(a + 1) * w.x) / 256.0);
+  return floor((row0 * (256.0 - w.y) + row1 * w.y) / 256.0) * ${BYTE};
+}
+`;
+}
+/**
+ * Image `t`, a texture of its own (`pbImage<t>`), clamped to its edges as
+ * adl clamps a kernel's input: its sampler, its texels and its sampling, in
+ * its own pixels.
+ */
+function ownImage(t, float) {
+    const texel = `texelFetch(pbImage${t}, clamp(at, ivec2(0), size - 1), 0)`;
+    return `uniform sampler2D pbImage${t};
+vec4 pbTexel${t}(ivec2 at) {
+  ivec2 size = textureSize(pbImage${t}, 0);
+  return ${float ? texel : `pbBytes(${texel})`};
+}
+${sampling(t, "p", float)}`;
+}
+/**
+ * The kernel's GLSL with what every use puts round it: PRELUDE, then each
+ * image, by `layerTexel` for the layer's, its texel at an index, and
+ * ownImage for the others; `layerAt` takes a kernel's coordinate to the
+ * layer's texels.
+ */
+export function withImages(kernel, images, layerTexel, layerAt) {
+    const parts = [PRELUDE];
+    for (const { texture: t, layer, float, back } of images) {
+        parts.push(layer
+            ? `${layerTexel(t, back ?? false)}\n${sampling(t, layerAt, false)}`
+            : ownImage(t, float));
+    }
+    parts.push(kernel);
+    return parts.join("\n");
+}
+/** The most kernels whose shaders a use keeps made (madeOnce), emptied when more come. */
+const MADE = 64;
+/** A kernel's shader for its images, made once: a frame asks for it again on each of its uses. */
+export function madeOnce(made, kernel, images, make) {
+    let key = "";
+    for (let k = 0; k < images.length; k++) {
+        const i = images[k];
+        key += `${i.texture}${i.layer ? (i.back ? "B" : "L") : ""}${i.float ? "F" : ""},`;
+    }
+    let byImages = made.get(kernel);
+    if (!byImages) {
+        if (made.size >= MADE) {
+            made.clear();
+        }
+        byImages = new Map();
+        made.set(kernel, byImages);
+    }
+    let source = byImages.get(key);
+    if (source === undefined) {
+        source = make();
+        byImages.set(key, source);
+    }
+    return source;
+}
+const madeFilters = new Map();
+/**
+ * A ShaderFilter's pass (filter-plan.ts, KERNEL_PASS), run as the
+ * filters' other passes are (webgl/filters.ts): the kernel's output over
+ * the input's frame, `outCoord` its pixel's centre in stage pixels from
+ * the corner of the bitmap the filter reads, `uKernelAt.xy` texels in from
+ * the frame's, which starts at `uOutputAt` in the target drawn into, at
+ * `uKernelAt.z` texels a stage pixel. The layer's image is the input
+ * (uTexture, within uTextureRect), transparent past the frame,
+ * `uKernelFrame` texels, as adl reads a filter's source; the others clamp
+ * to their edges. The output is as adl writes it (pbOutput), and
+ * transparent outside `uKernelRegion`, that bitmap grown by the filter's
+ * extensions, in stage pixels.
+ */
+export function filterKernel(kernel, images) {
+    return madeOnce(madeFilters, kernel, images, () => filterSource(kernel, images));
+}
+function filterSource(kernel, images) {
+    const layer = (t) => `vec4 pbTexel${t}(ivec2 at) {
+  if (any(lessThan(at, ivec2(0))) || any(greaterThanEqual(at, ivec2(uKernelFrame)))) {
+    return vec4(0.0);
+  }
+  return pbBytes(texelFetch(uTexture, ivec2(uTextureRect.xy) + at, 0));
+}`;
+    return `${HEADER}in vec2 vTextureCoord;
+out vec4 finalColor;
+uniform sampler2D uTexture;
+uniform highp vec4 uInputPixel;
+uniform vec4 uTextureRect;
+uniform vec3 uKernelAt;
+uniform vec2 uKernelFrame;
+uniform vec4 uKernelRegion;
+uniform vec2 uOutputAt;
+${withImages(kernel, images, layer, "p * uKernelAt.z + uKernelAt.xy")}
+void main(void) {
+  // From the fragment's centre, exact, where an interpolated coordinate is a hair off a half.
+  vec2 outCoord = (gl_FragCoord.xy - uOutputAt - uKernelAt.xy) / uKernelAt.z;
+  if (any(lessThan(outCoord, uKernelRegion.xy)) || any(greaterThanEqual(outCoord, uKernelRegion.zw))) {
+    finalColor = vec4(0.0);
+    return;
+  }
+  finalColor = pbOutput(pbKernel(outCoord));
+}
+`;
+}
+const madeBlends = new Map();
+/**
+ * A blend shader's composite (webgl/composite.ts), drawn as the composite
+ * program is (programs.ts, compositeFragment), its uniforms the same: as
+ * adl runs one, a pixel at a time, each where the layer covers anything
+ * and nothing where it does not, or over its whole rectangle (uWhole),
+ * the kernel's coordinate (0.5, 0.5) and its first two inputs that pixel
+ * of what is below and of the layer, coloured, whatever coordinate it
+ * samples them at; its result in place of what was below, as adl writes
+ * it (pbOutput). `rows` is the colour transform's reading of uRows
+ * (programs.ts, LAYER_COLOR).
+ */
+export function blendKernel(kernel, images, rows) {
+    return madeOnce(madeBlends, kernel, images, () => blendSource(kernel, images, rows));
+}
+function blendSource(kernel, images, rows) {
+    const pixel = (t, back) => `vec4 pbTexel${t}(ivec2 at) {
+  return pbBytes(${back ? "pbBack" : "pbFront"});
+}`;
+    return `${HEADER}uniform sampler2D uLayer;
+uniform sampler2D uBack;
+uniform highp sampler2D uRows;
+uniform int uRow;
+uniform ivec2 uOffset;
+uniform bool uFlip;
+uniform ivec2 uBackOffset;
+uniform bool uWhole;
+out vec4 finalColor;
+vec4 pbFront;
+vec4 pbBack;
+${withImages(kernel, images, pixel, "p")}
+void main(void) {
+  ivec2 frag = ivec2(gl_FragCoord.xy);
+  ivec2 at = ivec2(frag.x - uOffset.x, uFlip ? uOffset.y - frag.y : frag.y - uOffset.y);
+  vec4 front = texelFetch(uLayer, at, 0);
+${rows}
+  pbBack = texelFetch(uBack, frag - uBackOffset, 0);
+  if (!uWhole && pbBytes(front).a == 0.0) {
+    finalColor = pbBack;
+    return;
+  }
+  pbFront = front;
+  finalColor = pbOutput(pbKernel(vec2(0.5)));
+}
+`;
+}
+/**
+ * The layer shrunk to a texel a stage pixel for a kernel run once a pixel
+ * (filter-plan.ts): each output texel the mean of the `uDown.x` by
+ * `uDown.x` texels of the pixel it stands for, the grid from `uDown.yz`
+ * texels past the input's corner, which may be less than 0; the texels of
+ * a pixel past the frame, `uKernelFrame`, left out of the mean.
+ */
+export const PIXELS_DOWN = `${HEADER}precision highp int;
+in vec2 vTextureCoord;
+out vec4 finalColor;
+uniform sampler2D uTexture;
+uniform vec4 uTextureRect;
+uniform vec3 uDown;
+uniform vec2 uKernelFrame;
+uniform vec2 uOutputAt;
+void main(void) {
+  int n = int(uDown.x);
+  ivec2 from = ivec2(gl_FragCoord.xy - uOutputAt) * n + ivec2(uDown.yz);
+  ivec2 frame = ivec2(uKernelFrame);
+  vec4 sum = vec4(0.0);
+  float count = 0.0;
+  for (int j = 0; j < 16; j++) {
+    if (j >= n) { break; }
+    for (int i = 0; i < 16; i++) {
+      if (i >= n) { break; }
+      ivec2 at = from + ivec2(i, j);
+      if (all(greaterThanEqual(at, ivec2(0))) && all(lessThan(at, frame))) {
+        sum += texelFetch(uTexture, ivec2(uTextureRect.xy) + at, 0);
+        count += 1.0;
+      }
+    }
+  }
+  finalColor = count > 0.0 ? sum / count : vec4(0.0);
+}
+`;
+/**
+ * A kernel's output, run a texel a stage pixel, drawn back over the
+ * layer's frame: each texel its pixel's, the grid as PIXELS_DOWN had it.
+ */
+export const PIXELS_BACK = `${HEADER}precision highp int;
+in vec2 vTextureCoord;
+out vec4 finalColor;
+uniform sampler2D uTexture;
+uniform vec4 uTextureRect;
+uniform vec3 uDown;
+uniform vec2 uOutputAt;
+void main(void) {
+  ivec2 at = (ivec2(gl_FragCoord.xy - uOutputAt) - ivec2(uDown.yz)) / int(uDown.x);
+  at = clamp(at, ivec2(0), ivec2(uTextureRect.zw) - 1);
+  finalColor = texelFetch(uTexture, ivec2(uTextureRect.xy) + at, 0);
+}
+`;
+const madeFills = new Map();
+/**
+ * A shader fill's program, after the mesh's vertex shader (programs.ts,
+ * meshVertex), which carries the kernel's coordinates in vUVT with a depth
+ * of 1: the kernel run once a pixel of Flash's, at its centre (uFrag as the
+ * mesh's has it), its images clamped to their edges; its colours left
+ * past its alpha, as adl composites them, but under a colour transform,
+ * which takes them straight.
+ */
+export function fillKernel(kernel, images) {
+    return madeOnce(madeFills, kernel, images, () => fillSource(kernel, images));
+}
+function fillSource(kernel, images) {
+    return `${HEADER}in vec3 vUVT;
+flat in vec4 vMul;
+flat in vec4 vAdd;
+uniform vec4 uFrag;
+out vec4 finalColor;
+${withImages(kernel, images, () => "", "p")}
+void main(void) {
+  float pixel = uFrag.w;
+  vec2 f = vec2(gl_FragCoord.x + uFrag.x, uFrag.y + uFrag.z * gl_FragCoord.y);
+  vec2 centre = (floor(f / pixel) + 0.5) * pixel;
+  vec3 at = vUVT + dFdx(vUVT) * (centre.x - f.x) + dFdy(vUVT) * ((centre.y - f.y) * uFrag.z);
+  vec4 c = pbKernel(at.xy / at.z);
+  c = mix(vec4(0.0), min(c, 1.0), greaterThan(c, vec4(0.0)));
+  if (vMul == vec4(1.0) && vAdd == vec4(0.0)) {
+    finalColor = c;
+    return;
+  }
+  if (c.a == 0.0) {
+    finalColor = vec4(0.0);
+    return;
+  }
+  vec4 s = clamp(vec4(c.rgb / c.a, c.a) * vMul + vAdd, 0.0, 1.0);
+  finalColor = vec4(s.rgb * s.a, s.a);
+}
+`;
+}
+//# sourceMappingURL=kernel-shaders.js.map

package/dist/kernel-shaders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel-shaders.js","sourceRoot":"","sources":["../src/kernel-shaders.ts"],"names":[],"mappings":"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"}

package/dist/measure.d.ts

@@ -0,0 +1,56 @@
+import type { Geometries } from "./geometry.js";
+import { type Rows } from "./rows.js";
+import { type SceneList } from "./scene.js";
+/**
+ * What measuring a frame's layers needs of its target: its size in pixels,
+ * its pixels a stage pixel, and its pixels a unit of its own (resolution),
+ * which a filtered layer is padded in.
+ */
+export interface MeasureTarget {
+    width: number;
+    height: number;
+    scale: number;
+    resolution: number;
+}
+/**
+ * Each layer's rectangle of the target (SceneList.layerRect), from what is
+ * drawn in it: its draws' geometries placed by their rows, a mask's own
+ * draws apart, what a mask clips cut to that mask's draws as it pops, and
+ * the rectangles of the layers in it; out to whole pixels and a pixel more
+ * each way, cut to the target. An alpha mask's layer is no part of the
+ * unfiltered layer it ends, which it cuts to its own rectangle instead, as
+ * nothing of that layer shows past it. What is drawn is what is measured,
+ * so a layer covers its draws however they came to be where they are. A
+ * filtered layer is measured as PixiJS's filter system measures it, which
+ * the filters' exactness rules were found with: cut to the target, out to
+ * whole pixels, then padded, not cut again; where nothing is drawn in it,
+ * it draws nothing.
+ */
+export declare function measureLayers(scene: SceneList, rows: Rows, geometries: Geometries, target: MeasureTarget): void;
+/**
+ * The rectangle a filtered layer padded by `pad` units covers, from its
+ * area (least x and y, greatest x and y in target pixels, from `area[at]`)
+ * as PixiJS's filter system has it (FilterSystem's _calculateFilterArea): in
+ * units, the area cut to the target, out to whole pixels at the
+ * resolution, or to whole stage pixels as `whole` says (SceneList.wholes),
+ * padded; nothing where it has no size then; its edges snapped to the
+ * pixels they lie on. Into `out` from `to`: x, y, width, height, of no
+ * size for nothing. A whole layer's object, uncut, goes into `objects` at
+ * `to` too (SceneList.objects).
+ */
+export declare function filteredRect(area: ArrayLike<number>, at: number, pad: number, target: MeasureTarget, out: Int32Array, to: number, whole?: number, objects?: Float64Array | null): void;
+/**
+ * Flash's bitmap of an object of bounds x0, y0 to x1, y1 in stage pixels:
+ * the bounds out to twips, then antialiased (WHOLE_SMOOTH) the pixels its
+ * edges touch and one more right and down where an edge lies on one,
+ * aliased (WHOLE_ALIASED) those whose centres it covers.
+ */
+export declare function wholeBitmap(x0: number, y0: number, x1: number, y1: number, whole: number): number[];
+/**
+ * The area of the target the draws from entry `from` on cover, at `scale`
+ * target pixels a stage pixel, masks' own draws apart and nothing cut by
+ * the masks: into `out`, its least x and y, then its greatest, in target
+ * pixels; nothing drawn leaves the least past the greatest.
+ */
+export declare function drawnArea(scene: SceneList, rows: Rows, geometries: Geometries, from: number, scale: number, out: number[]): void;
+//# sourceMappingURL=measure.d.ts.map

package/dist/measure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"measure.d.ts","sourceRoot":"","sources":["../src/measure.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAc,KAAK,IAAI,EAAE,MAAM,WAAW,CAAC;AAClD,OAAO,EAUL,KAAK,SAAS,EAEf,MAAM,YAAY,CAAC;AAEpB;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;CACpB;AAYD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,SAAS,EAChB,IAAI,EAAE,IAAI,EACV,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,aAAa,GACpB,IAAI,CAqIN;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,EACvB,EAAE,EAAE,MAAM,EACV,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,aAAa,EACrB,GAAG,EAAE,UAAU,EACf,EAAE,EAAE,MAAM,EACV,KAAK,SAAW,EAChB,OAAO,GAAE,YAAY,GAAG,IAAW,GAClC,IAAI,CA2DN;AAKD;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,GACZ,MAAM,EAAE,CAkBV;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,SAAS,EAChB,IAAI,EAAE,IAAI,EACV,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EAAE,GACZ,IAAI,CAoBN"}

package/dist/measure.js

@@ -0,0 +1,287 @@
+import { ROW_FLOATS } from "./rows.js";
+import { ALPHA_MASK, DRAW, KEPT, LAYER_BEGIN, LAYER_END, MASK_BEGIN, MASK_POP, MASK_USE, NO_WHOLE, WHOLE_ALIASED, } from "./scene.js";
+/** A hair, which keeps a padded edge on the pixel it lies on at any resolution. */
+const TEXEL_SNAP = 1e-6;
+// Scratch stacks, four numbers an open area: least x and y, greatest x and y, in target pixels.
+const areas = [];
+const clips = [];
+const open = [];
+// Each open layer's cut, four numbers as an area's: an alpha mask's rectangle in it (ALPHA_MASK).
+const cuts = [];
+/**
+ * Each layer's rectangle of the target (SceneList.layerRect), from what is
+ * drawn in it: its draws' geometries placed by their rows, a mask's own
+ * draws apart, what a mask clips cut to that mask's draws as it pops, and
+ * the rectangles of the layers in it; out to whole pixels and a pixel more
+ * each way, cut to the target. An alpha mask's layer is no part of the
+ * unfiltered layer it ends, which it cuts to its own rectangle instead, as
+ * nothing of that layer shows past it. What is drawn is what is measured,
+ * so a layer covers its draws however they came to be where they are. A
+ * filtered layer is measured as PixiJS's filter system measures it, which
+ * the filters' exactness rules were found with: cut to the target, out to
+ * whole pixels, then padded, not cut again; where nothing is drawn in it,
+ * it draws nothing.
+ */
+export function measureLayers(scene, rows, geometries, target) {
+    if (scene.layerCount === 0) {
+        return;
+    }
+    areas.length = 0;
+    clips.length = 0;
+    open.length = 0;
+    cuts.length = 0;
+    pushEmpty(areas);
+    const k = target.scale;
+    const box = geometries.box;
+    const m = rows.data;
+    for (let i = 0; i < scene.length; i++) {
+        switch (scene.kind[i]) {
+            case DRAW:
+                placeDraw(scene, i, box, m, k, areas);
+                break;
+            case MASK_BEGIN:
+                // The mask's own draws, measured apart.
+                pushEmpty(areas);
+                break;
+            case LAYER_BEGIN:
+                open.push(scene.geometry[i]);
+                pushEmpty(areas);
+                cuts.push(Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY);
+                break;
+            case MASK_USE:
+                // The mask's draws clip what follows, measured apart till it pops.
+                moveTop(areas, clips);
+                pushEmpty(areas);
+                break;
+            case MASK_POP: {
+                const n = areas.length;
+                const c = clips.length;
+                const left = Math.max(areas[n - 4], clips[c - 4]);
+                const top = Math.max(areas[n - 3], clips[c - 3]);
+                const right = Math.min(areas[n - 2], clips[c - 2]);
+                const bottom = Math.min(areas[n - 1], clips[c - 1]);
+                areas.length = n - 4;
+                clips.length = c - 4;
+                if (right > left && bottom > top) {
+                    unionTop(left, top, right, bottom);
+                }
+                break;
+            }
+            case LAYER_END: {
+                const n = areas.length;
+                const layer = open.pop();
+                const pad = scene.pads[layer];
+                const c = cuts.length - 4;
+                if (pad < 0) {
+                    const left = Math.max(0, Math.floor(areas[n - 4]) - 1, cuts[c]);
+                    const top = Math.max(0, Math.floor(areas[n - 3]) - 1, cuts[c + 1]);
+                    const right = Math.min(target.width, Math.ceil(areas[n - 2]) + 1, cuts[c + 2]);
+                    const bottom = Math.min(target.height, Math.ceil(areas[n - 1]) + 1, cuts[c + 3]);
+                    areas.length = n - 4;
+                    cuts.length = c;
+                    if (scene.geometry[i] === ALPHA_MASK) {
+                        // Not taken into the layer it ends, which it cuts to its rectangle: to nothing, where it
+                        // has none.
+                        if (right > left && bottom > top) {
+                            scene.layerRect(layer, left, top, right - left, bottom - top);
+                        }
+                        const p = c - 4;
+                        if (p >= 0) {
+                            cuts[p] = Math.max(cuts[p], left);
+                            cuts[p + 1] = Math.max(cuts[p + 1], top);
+                            cuts[p + 2] = Math.min(cuts[p + 2], right);
+                            cuts[p + 3] = Math.min(cuts[p + 3], bottom);
+                        }
+                        break;
+                    }
+                    if (right > left && bottom > top) {
+                        scene.layerRect(layer, left, top, right - left, bottom - top);
+                        unionTop(left, top, right, bottom);
+                    }
+                    break;
+                }
+                // The view puts no alpha mask straight in a filtered layer, which would run its filters on
+                // what the mask left (cuts).
+                cuts.length = c;
+                const kept = scene.areas;
+                for (let k = 0; k < 4; k++) {
+                    kept[layer * 4 + k] = areas[n - 4 + k];
+                }
+                filteredRect(scene.areas, layer * 4, pad, target, scene.layers, layer * 4, scene.wholes[layer], scene.objects);
+                areas.length = n - 4;
+                const r = scene.layers;
+                const at = layer * 4;
+                if (r[at + 2] > 0) {
+                    unionTop(r[at], r[at + 1], r[at] + r[at + 2], r[at + 1] + r[at + 3]);
+                }
+                break;
+            }
+            case KEPT: {
+                // A kept output covers its rectangle, which its owner placed.
+                const r = scene.layers;
+                const at = scene.geometry[i] * 4;
+                if (r[at + 2] > 0 && r[at + 3] > 0) {
+                    unionTop(r[at], r[at + 1], r[at] + r[at + 2], r[at + 1] + r[at + 3]);
+                }
+                break;
+            }
+        }
+    }
+}
+/**
+ * The rectangle a filtered layer padded by `pad` units covers, from its
+ * area (least x and y, greatest x and y in target pixels, from `area[at]`)
+ * as PixiJS's filter system has it (FilterSystem's _calculateFilterArea): in
+ * units, the area cut to the target, out to whole pixels at the
+ * resolution, or to whole stage pixels as `whole` says (SceneList.wholes),
+ * padded; nothing where it has no size then; its edges snapped to the
+ * pixels they lie on. Into `out` from `to`: x, y, width, height, of no
+ * size for nothing. A whole layer's object, uncut, goes into `objects` at
+ * `to` too (SceneList.objects).
+ */
+export function filteredRect(area, at, pad, target, out, to, whole = NO_WHOLE, objects = null) {
+    const res = target.resolution;
+    let x0 = area[at] / res;
+    let y0 = area[at + 1] / res;
+    let x1 = area[at + 2] / res;
+    let y1 = area[at + 3] / res;
+    out[to] = 0;
+    out[to + 1] = 0;
+    out[to + 2] = 0;
+    out[to + 3] = 0;
+    if (!(x1 > x0 && y1 > y0)) {
+        return;
+    }
+    if (whole !== NO_WHOLE) {
+        // Flash's bitmap of the object, of whole stage pixels, whatever the stage's scale; cut to the
+        // target only after.
+        const k = target.scale;
+        const object = wholeBitmap(area[at] / k, area[at + 1] / k, area[at + 2] / k, area[at + 3] / k, whole);
+        const ox0 = object[0] * k;
+        const oy0 = object[1] * k;
+        const ox1 = object[2] * k;
+        const oy1 = object[3] * k;
+        if (objects) {
+            objects[to] = ox0;
+            objects[to + 1] = oy0;
+            objects[to + 2] = ox1 - ox0;
+            objects[to + 3] = oy1 - oy0;
+        }
+        x0 = Math.max(ox0, 0) / res - pad;
+        y0 = Math.max(oy0, 0) / res - pad;
+        x1 = Math.min(ox1, target.width) / res + pad;
+        y1 = Math.min(oy1, target.height) / res + pad;
+    }
+    else {
+        // Each edge moved in alone, as Bounds.fitBounds does: an area off the target turns inside out,
+        // and its padding may yet give it a size.
+        x0 = Math.floor(Math.max(x0, 0) * res) / res - pad;
+        y0 = Math.floor(Math.max(y0, 0) * res) / res - pad;
+        x1 = Math.ceil(Math.min(x1, target.width / res) * res) / res + pad;
+        y1 = Math.ceil(Math.min(y1, target.height / res) * res) / res + pad;
+    }
+    if (!(x1 - x0 > 0 && y1 - y0 > 0)) {
+        return;
+    }
+    const left = Math.floor(x0 * res + TEXEL_SNAP);
+    const top = Math.floor(y0 * res + TEXEL_SNAP);
+    out[to] = left;
+    out[to + 1] = top;
+    out[to + 2] = Math.ceil(x1 * res - TEXEL_SNAP) - left;
+    out[to + 3] = Math.ceil(y1 * res - TEXEL_SNAP) - top;
+}
+/** What wholeBitmap gives, read before it is asked again. */
+const bitmap = [0, 0, 0, 0];
+/**
+ * Flash's bitmap of an object of bounds x0, y0 to x1, y1 in stage pixels:
+ * the bounds out to twips, then antialiased (WHOLE_SMOOTH) the pixels its
+ * edges touch and one more right and down where an edge lies on one,
+ * aliased (WHOLE_ALIASED) those whose centres it covers.
+ */
+export function wholeBitmap(x0, y0, x1, y1, whole) {
+    x0 = Math.floor(x0 * 20 + TEXEL_SNAP) / 20;
+    y0 = Math.floor(y0 * 20 + TEXEL_SNAP) / 20;
+    x1 = Math.ceil(x1 * 20 - TEXEL_SNAP) / 20;
+    y1 = Math.ceil(y1 * 20 - TEXEL_SNAP) / 20;
+    if (whole === WHOLE_ALIASED) {
+        bitmap[0] = Math.ceil(x0 - 0.5);
+        bitmap[1] = Math.ceil(y0 - 0.5);
+        bitmap[2] = Math.ceil(x1 - 0.5);
+        bitmap[3] = Math.ceil(y1 - 0.5);
+    }
+    else {
+        bitmap[0] = Math.floor(x0);
+        bitmap[1] = Math.floor(y0);
+        bitmap[2] = Math.floor(x1) + 1;
+        bitmap[3] = Math.floor(y1) + 1;
+    }
+    return bitmap;
+}
+/**
+ * The area of the target the draws from entry `from` on cover, at `scale`
+ * target pixels a stage pixel, masks' own draws apart and nothing cut by
+ * the masks: into `out`, its least x and y, then its greatest, in target
+ * pixels; nothing drawn leaves the least past the greatest.
+ */
+export function drawnArea(scene, rows, geometries, from, scale, out) {
+    out.length = 0;
+    pushEmpty(out);
+    let defining = 0;
+    for (let i = from; i < scene.length; i++) {
+        switch (scene.kind[i]) {
+            case DRAW:
+                if (defining === 0) {
+                    placeDraw(scene, i, geometries.box, rows.data, scale, out);
+                }
+                break;
+            case MASK_BEGIN:
+                defining++;
+                break;
+            case MASK_USE:
+                defining--;
+                break;
+        }
+    }
+}
+/** Entry `i`'s geometry box placed by its row at `k` target pixels a stage pixel, taken into the area atop `stack`. */
+function placeDraw(scene, i, box, m, k, stack) {
+    const g = scene.geometry[i] * 4;
+    const x0 = box[g];
+    const y0 = box[g + 1];
+    const x1 = box[g + 2];
+    const y1 = box[g + 3];
+    if (!(x1 >= x0 && y1 >= y0)) {
+        return;
+    }
+    const r = scene.row[i] * ROW_FLOATS;
+    const a = m[r] * k;
+    const b = m[r + 1] * k;
+    const c = m[r + 2] * k;
+    const d = m[r + 3] * k;
+    const tx = m[r + 4] * k;
+    const ty = m[r + 5] * k;
+    // The box's corners placed: each of the least and greatest a coordinate takes, by sign.
+    const n = stack.length;
+    stack[n - 4] = Math.min(stack[n - 4], tx + Math.min(a * x0, a * x1) + Math.min(c * y0, c * y1));
+    stack[n - 3] = Math.min(stack[n - 3], ty + Math.min(b * x0, b * x1) + Math.min(d * y0, d * y1));
+    stack[n - 2] = Math.max(stack[n - 2], tx + Math.max(a * x0, a * x1) + Math.max(c * y0, c * y1));
+    stack[n - 1] = Math.max(stack[n - 1], ty + Math.max(b * x0, b * x1) + Math.max(d * y0, d * y1));
+}
+function pushEmpty(stack) {
+    stack.push(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY);
+}
+/** The top area of `from` moved onto `to`. */
+function moveTop(from, to) {
+    const n = from.length;
+    to.push(from[n - 4], from[n - 3], from[n - 2], from[n - 1]);
+    from.length = n - 4;
+}
+/** The open area on top grown to take in the rectangle. */
+function unionTop(left, top, right, bottom) {
+    const n = areas.length;
+    areas[n - 4] = Math.min(areas[n - 4], left);
+    areas[n - 3] = Math.min(areas[n - 3], top);
+    areas[n - 2] = Math.max(areas[n - 2], right);
+    areas[n - 1] = Math.max(areas[n - 1], bottom);
+}
+//# sourceMappingURL=measure.js.map