@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/player/display/filters.js

@@ -0,0 +1,285 @@
+const IDENTITY_MATRIX = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0];
+/**
+ * A kind's values as a new filter object of it has them in adl: made for
+ * the kind alone, as a timeline that writes a filter on each frame asks
+ * for one each time.
+ */
+export function filterDefaults(kind) {
+    return { kind, ...kindDefaults(kind) };
+}
+function kindDefaults(kind) {
+    const shadow = () => ({
+        angle: 45,
+        blurX: 4,
+        blurY: 4,
+        distance: 4,
+        knockout: false,
+        quality: 1,
+    });
+    switch (kind) {
+        case "blur":
+            return { blurX: 4, blurY: 4, quality: 1 };
+        case "glow":
+            return {
+                alpha: 1,
+                blurX: 6,
+                blurY: 6,
+                color: 0xff0000,
+                inner: false,
+                knockout: false,
+                quality: 1,
+                strength: 2,
+            };
+        case "dropShadow":
+            return {
+                ...shadow(),
+                alpha: 1,
+                color: 0,
+                hideObject: false,
+                inner: false,
+                strength: 1,
+            };
+        case "bevel":
+            return {
+                ...shadow(),
+                highlightAlpha: 1,
+                highlightColor: 0xffffff,
+                shadowAlpha: 1,
+                shadowColor: 0,
+                strength: 1,
+                type: "inner",
+            };
+        case "gradientGlow":
+        case "gradientBevel":
+            return { ...shadow(), strength: 1, type: "inner", colors: [], alphas: [], ratios: [] };
+        case "colorMatrix":
+            return { matrix: [...IDENTITY_MATRIX] };
+        case "convolution":
+            return {
+                alpha: 0,
+                bias: 0,
+                clamp: true,
+                color: 0,
+                divisor: 1,
+                matrix: [],
+                matrixX: 0,
+                matrixY: 0,
+                preserveAlpha: true,
+            };
+        case "displacementMap":
+            return {
+                alpha: 0,
+                color: 0,
+                componentX: 0,
+                componentY: 0,
+                mapBitmap: null,
+                mapPoint: [0, 0],
+                mode: "wrap",
+                scaleX: 0,
+                scaleY: 0,
+            };
+        case "shader":
+            return { shader: null, extensions: [0, 0, 0, 0] };
+    }
+}
+/** A copy of a record, its lists its own. */
+export function copyFilter(f) {
+    const copy = { ...f };
+    for (const key of ["colors", "alphas", "ratios", "matrix", "mapPoint", "extensions"]) {
+        if (key in f) {
+            copy[key] = [...f[key]];
+        }
+    }
+    return copy;
+}
+const DEGREES = 180 / Math.PI;
+/** A PlaceObject3 filter as the record its object reads back. */
+export function filterOfSwf(f) {
+    switch (f.type) {
+        case "blur":
+            return { ...filterDefaults("blur"), blurX: f.blurX, blurY: f.blurY, quality: f.passes };
+        case "glow":
+            return {
+                ...filterDefaults("glow"),
+                color: f.color.rgb,
+                alpha: f.color.alpha / 255,
+                blurX: f.blurX,
+                blurY: f.blurY,
+                strength: f.strength,
+                inner: f.inner,
+                knockout: f.knockout,
+                quality: f.passes,
+            };
+        case "dropShadow":
+            return {
+                ...filterDefaults("dropShadow"),
+                color: f.color.rgb,
+                alpha: f.color.alpha / 255,
+                blurX: f.blurX,
+                blurY: f.blurY,
+                angle: f.angle * DEGREES,
+                distance: f.distance,
+                strength: f.strength,
+                inner: f.inner,
+                knockout: f.knockout,
+                hideObject: !f.composite,
+                quality: f.passes,
+            };
+        case "bevel":
+        case "gradientGlow":
+        case "gradientBevel": {
+            const shared = {
+                blurX: f.blurX,
+                blurY: f.blurY,
+                angle: f.angle * DEGREES,
+                distance: f.distance,
+                strength: f.strength,
+                knockout: f.knockout,
+                quality: f.passes,
+                type: f.inner ? "inner" : f.onTop ? "full" : "outer",
+            };
+            if (f.type === "bevel") {
+                const [shadow, highlight] = f.colors;
+                return {
+                    ...filterDefaults("bevel"),
+                    ...shared,
+                    shadowColor: shadow.rgb,
+                    shadowAlpha: shadow.alpha / 255,
+                    highlightColor: highlight.rgb,
+                    highlightAlpha: highlight.alpha / 255,
+                };
+            }
+            return {
+                ...filterDefaults(f.type),
+                ...shared,
+                colors: f.colors.map((c) => c.rgb),
+                alphas: f.colors.map((c) => c.alpha / 255),
+                ratios: [...f.ratios],
+            };
+        }
+        case "convolution":
+            return {
+                ...filterDefaults("convolution"),
+                matrixX: f.matrixX,
+                matrixY: f.matrixY,
+                divisor: f.divisor,
+                bias: f.bias,
+                matrix: [...f.matrix],
+                color: f.color.rgb,
+                alpha: f.color.alpha / 255,
+                clamp: f.clamp,
+                preserveAlpha: f.preserveAlpha,
+            };
+        case "colorMatrix":
+            return { ...filterDefaults("colorMatrix"), matrix: [...f.matrix] };
+    }
+}
+/**
+ * Whether two lists of filter records hold the same values, which draw the
+ * same: a timeline's tween writes its filters again on each frame, and a
+ * script may set them from their own. A map is the same only as the same
+ * object, so that a displacement's map taken anew is drawn anew.
+ */
+export function sameFilterRecords(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    // Compared each frame for every object a tween filters, so without allocating.
+    for (let i = 0; i < a.length; i++) {
+        const x = a[i];
+        const y = b[i];
+        let keys = 0;
+        for (const key in x) {
+            keys++;
+            if (!(key in y) || !sameValue(x[key], y[key])) {
+                return false;
+            }
+        }
+        for (const _ in y) {
+            keys--;
+        }
+        if (keys !== 0) {
+            return false;
+        }
+    }
+    return true;
+}
+function sameValue(u, v) {
+    if (!Array.isArray(u) || !Array.isArray(v)) {
+        return Object.is(u, v);
+    }
+    if (u.length !== v.length) {
+        return false;
+    }
+    for (let k = 0; k < u.length; k++) {
+        if (!Object.is(u[k], v[k])) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * A convolution with no taps as adl draws it, a copy moved up and left by
+ * the half of the other size: one tap there, of 1, the edges transparent.
+ */
+export function emptyKernel(f) {
+    const hx = f.matrixX >> 1;
+    const hy = f.matrixY >> 1;
+    const matrixX = 2 * hx + 1;
+    const matrixY = 2 * hy + 1;
+    const matrix = new Array(matrixX * matrixY).fill(0);
+    matrix[matrix.length - 1] = 1;
+    return {
+        ...f,
+        matrixX,
+        matrixY,
+        matrix,
+        divisor: 1,
+        bias: 0,
+        clamp: false,
+        color: 0,
+        alpha: 0,
+        preserveAlpha: false,
+    };
+}
+/** A filter's offset into `out`, `distance` stage pixels at its angle, in `units` a stage pixel. */
+export function filterOffset(out, f, distance, units) {
+    const radians = ((f.angle || 0) * Math.PI) / 180;
+    out[0] = distance * Math.cos(radians) * units;
+    out[1] = distance * Math.sin(radians) * units;
+}
+/**
+ * How far either side of a display object its filters may pad, in the
+ * target's units: what a texture `limit` texels a side holds at
+ * `resolution` texels a unit, past the object's area on the target
+ * (`width` by `height` units, cut to it) and a little.
+ */
+export function filterRoom(limit, resolution, width, height) {
+    return Math.floor((limit / resolution - Math.max(width, height, 0)) / 2) - 2;
+}
+/**
+ * The most any one filter pads, where their paddings as their reach asks
+ * (`wanted`) together pass `room`: cut alike from the furthest reaching
+ * down to what fits, as a shadow cast 1e9 away, or Infinity, asks;
+ * Infinity where they fit. What is cut lies past the screen, but for an
+ * object off it whose shadow is not.
+ */
+export function paddingCap(wanted, room) {
+    let total = 0;
+    for (const p of wanted) {
+        total += p;
+    }
+    if (total <= room) {
+        return Number.POSITIVE_INFINITY;
+    }
+    const sorted = [...wanted].sort((a, b) => a - b);
+    let below = 0;
+    for (let i = 0; i < sorted.length; i++) {
+        const level = Math.floor((Math.max(0, room) - below) / (sorted.length - i));
+        if (level <= sorted[i]) {
+            return Math.max(0, level);
+        }
+        below += sorted[i];
+    }
+    return 0;
+}

package/dist/thread/player/display/geometry.js

@@ -0,0 +1,189 @@
+export function isProjective(m) {
+    return m.w !== undefined;
+}
+/** `m` then `p`, either projective. */
+function concatProjective(m, p) {
+    const [mu, mv, mw] = isProjective(m) ? [m.u, m.v, m.w] : [0, 0, 1];
+    const [pu, pv, pw] = isProjective(p) ? [p.u, p.v, p.w] : [0, 0, 1];
+    return {
+        a: p.a * m.a + p.c * m.b + p.tx * mu,
+        b: p.b * m.a + p.d * m.b + p.ty * mu,
+        c: p.a * m.c + p.c * m.d + p.tx * mv,
+        d: p.b * m.c + p.d * m.d + p.ty * mv,
+        tx: p.a * m.tx + p.c * m.ty + p.tx * mw,
+        ty: p.b * m.tx + p.d * m.ty + p.ty * mw,
+        u: pu * m.a + pv * m.b + pw * mu,
+        v: pu * m.c + pv * m.d + pw * mv,
+        w: pu * m.tx + pv * m.ty + pw * mw,
+    };
+}
+/** The inverse of a projective matrix, by its adjugate, or null for one that flattens the plane. */
+function invertProjective(m) {
+    const { a, b, c, d, tx, ty, u, v, w } = m;
+    const A = d * w - ty * v;
+    const B = -(b * w - ty * u);
+    const C = b * v - d * u;
+    const det = a * A + c * B + tx * C;
+    if (det === 0 || !Number.isFinite(det)) {
+        return null;
+    }
+    return {
+        a: A / det,
+        b: B / det,
+        u: C / det,
+        c: -(c * w - tx * v) / det,
+        d: (a * w - tx * u) / det,
+        v: -(a * v - c * u) / det,
+        tx: (c * ty - tx * d) / det,
+        ty: -(a * ty - tx * b) / det,
+        w: (a * d - c * b) / det,
+    };
+}
+/** `m` then `p`: the matrix that applies `m` and then `p`, as a child's in its parent's. */
+export function concat(m, p) {
+    if (isProjective(m) || isProjective(p)) {
+        return concatProjective(m, p);
+    }
+    return {
+        a: m.a * p.a + m.b * p.c,
+        b: m.a * p.b + m.b * p.d,
+        c: m.c * p.a + m.d * p.c,
+        d: m.c * p.b + m.d * p.d,
+        tx: m.tx * p.a + m.ty * p.c + p.tx,
+        ty: m.tx * p.b + m.ty * p.d + p.ty,
+    };
+}
+/** The inverse, or null for a matrix that flattens the plane. */
+export function invert(m) {
+    if (isProjective(m)) {
+        return invertProjective(m);
+    }
+    const det = m.a * m.d - m.b * m.c;
+    if (det === 0) {
+        return null;
+    }
+    return {
+        a: m.d / det,
+        b: -m.b / det,
+        c: -m.c / det,
+        d: m.a / det,
+        tx: (m.c * m.ty - m.d * m.tx) / det,
+        ty: (m.b * m.tx - m.a * m.ty) / det,
+    };
+}
+export function apply(m, x, y) {
+    if (isProjective(m)) {
+        const q = m.u * x + m.v * y + m.w;
+        return [(m.a * x + m.c * y + m.tx) / q, (m.b * x + m.d * y + m.ty) / q];
+    }
+    return [m.a * x + m.c * y + m.tx, m.b * x + m.d * y + m.ty];
+}
+/**
+ * The rectangle around `r`'s four corners through `m`. Through a
+ * projective one, out to whole pixels, as Flash reports a 3D object's;
+ * and a point at the origin where a corner is behind the eye, where Flash
+ * draws nothing.
+ */
+export function transformRect(r, m) {
+    if (isProjective(m)) {
+        return projectRect(r, m);
+    }
+    // The corners as apply places them, without its arrays: every bounds, width and hitTest asks.
+    const x0 = m.a * r.xMin + m.c * r.yMin + m.tx;
+    const y0 = m.b * r.xMin + m.d * r.yMin + m.ty;
+    const x1 = m.a * r.xMax + m.c * r.yMin + m.tx;
+    const y1 = m.b * r.xMax + m.d * r.yMin + m.ty;
+    const x2 = m.a * r.xMin + m.c * r.yMax + m.tx;
+    const y2 = m.b * r.xMin + m.d * r.yMax + m.ty;
+    const x3 = m.a * r.xMax + m.c * r.yMax + m.tx;
+    const y3 = m.b * r.xMax + m.d * r.yMax + m.ty;
+    return {
+        xMin: Math.min(x0, x1, x2, x3),
+        yMin: Math.min(y0, y1, y2, y3),
+        xMax: Math.max(x0, x1, x2, x3),
+        yMax: Math.max(y0, y1, y2, y3),
+    };
+}
+/** How far past a whole pixel a projected edge may go and still be bounded by it. */
+const SLACK = 0.125;
+function projectRect(r, m) {
+    let xMin = Number.POSITIVE_INFINITY;
+    let yMin = Number.POSITIVE_INFINITY;
+    let xMax = Number.NEGATIVE_INFINITY;
+    let yMax = Number.NEGATIVE_INFINITY;
+    for (let i = 0; i < 4; i++) {
+        const x = i & 1 ? r.xMax : r.xMin;
+        const y = i & 2 ? r.yMax : r.yMin;
+        const q = m.u * x + m.v * y + m.w;
+        if (!(q > 0)) {
+            return { xMin: 0, yMin: 0, xMax: 0, yMax: 0 };
+        }
+        const px = (m.a * x + m.c * y + m.tx) / q;
+        const py = (m.b * x + m.d * y + m.ty) / q;
+        xMin = Math.min(xMin, px);
+        yMin = Math.min(yMin, py);
+        xMax = Math.max(xMax, px);
+        yMax = Math.max(yMax, py);
+    }
+    // Out to whole pixels, but for an eighth of one: an edge that passes a pixel by less is not
+    // counted to the next, as adl reports (the `three-d-bounds` case).
+    return {
+        xMin: Math.floor(xMin + SLACK),
+        yMin: Math.floor(yMin + SLACK),
+        xMax: Math.ceil(xMax - SLACK),
+        yMax: Math.ceil(yMax - SLACK),
+    };
+}
+/** The rectangle around `r`'s four corners through `m`, each divided where `m` is projective: not out to whole pixels. */
+export function boxThrough(r, m) {
+    let xMin = Number.POSITIVE_INFINITY;
+    let yMin = Number.POSITIVE_INFINITY;
+    let xMax = Number.NEGATIVE_INFINITY;
+    let yMax = Number.NEGATIVE_INFINITY;
+    for (let i = 0; i < 4; i++) {
+        const [x, y] = apply(m, i & 1 ? r.xMax : r.xMin, i & 2 ? r.yMax : r.yMin);
+        xMin = Math.min(xMin, x);
+        yMin = Math.min(yMin, y);
+        xMax = Math.max(xMax, x);
+        yMax = Math.max(yMax, y);
+    }
+    return { xMin, yMin, xMax, yMax };
+}
+/** Whether a corner of `r` goes behind the eye through `m`, or onto its plane: Flash then draws none of it. */
+export function behindEye(r, m) {
+    if (!isProjective(m)) {
+        return false;
+    }
+    for (let i = 0; i < 4; i++) {
+        const q = m.u * (i & 1 ? r.xMax : r.xMin) + m.v * (i & 2 ? r.yMax : r.yMin) + m.w;
+        if (!(q > 0)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function union(a, b) {
+    if (!a || !b) {
+        return a ?? b;
+    }
+    return {
+        xMin: Math.min(a.xMin, b.xMin),
+        yMin: Math.min(a.yMin, b.yMin),
+        xMax: Math.max(a.xMax, b.xMax),
+        yMax: Math.max(a.yMax, b.yMax),
+    };
+}
+export function contains(r, x, y) {
+    return x >= r.xMin && x <= r.xMax && y >= r.yMin && y <= r.yMax;
+}
+export function overlaps(a, b) {
+    return a.xMin <= b.xMax && b.xMin <= a.xMax && a.yMin <= b.yMax && b.yMin <= a.yMax;
+}
+/** `m` after a shift of (-left, -top) of `r`: a scrolled object's, its scroll's corner at its origin. */
+export function shifted(m, r) {
+    return {
+        ...m,
+        tx: m.tx - m.a * r.xMin - m.c * r.yMin,
+        ty: m.ty - m.b * r.xMin - m.d * r.yMin,
+    };
+}

package/dist/thread/player/display/gradients.js

@@ -0,0 +1,117 @@
+/** A ramp's stops in order of use: Flash fills the ramp from each stop to the next, skipping any that go back. */
+export function ramp(stops, linearRgb) {
+    const out = new Uint32Array(256);
+    if (stops.length === 0) {
+        out.fill(0xff000000);
+        return out;
+    }
+    // The first colour up to the first stop, each stop's span after it in
+    // order (none for a stop before where the ramp has got to), the last
+    // colour on to the end. In linear RGB the ends go through linear light
+    // too, which takes 255 to 254 as Flash does.
+    let at = 0;
+    const first = premultiplied(mix(stops[0].color, stops[0].color, 0, linearRgb));
+    for (; at <= stops[0].ratio && at < 256; at++) {
+        out[at] = first;
+    }
+    for (let k = 1; k < stops.length; k++) {
+        const from = stops[k - 1];
+        const to = stops[k];
+        for (; at <= to.ratio && at < 256; at++) {
+            const f = (at - from.ratio) / (to.ratio - from.ratio);
+            out[at] = premultiplied(mix(from.color, to.color, f, linearRgb));
+        }
+    }
+    const lastStop = stops[stops.length - 1].color;
+    const last = premultiplied(mix(lastStop, lastStop, 0, linearRgb));
+    for (; at < 256; at++) {
+        out[at] = last;
+    }
+    return out;
+}
+/** Straight ARGB premultiplied, each channel times alpha + 1 over 256. */
+function premultiplied(argb) {
+    const a = argb >>> 24;
+    const r = (((argb >>> 16) & 0xff) * (a + 1)) >> 8;
+    const g = (((argb >>> 8) & 0xff) * (a + 1)) >> 8;
+    const b = ((argb & 0xff) * (a + 1)) >> 8;
+    return ((a << 24) | (r << 16) | (g << 8) | b) >>> 0;
+}
+/** a to b by f, each channel truncated; colours in linear light for linear RGB, alpha straight. */
+function mix(a, b, f, linearRgb) {
+    return (((channel(a, b, f, 24, false) << 24) |
+        (channel(a, b, f, 16, linearRgb) << 16) |
+        (channel(a, b, f, 8, linearRgb) << 8) |
+        channel(a, b, f, 0, linearRgb)) >>>
+        0);
+}
+/** The channel at `shift` of a to b by f, truncated, through linear light if `light`. */
+function channel(a, b, f, shift, light) {
+    const x = (a >>> shift) & 0xff;
+    const y = (b >>> shift) & 0xff;
+    if (!light) {
+        return Math.floor(x + (y - x) * f);
+    }
+    const l = (1 - f) * toLinear(x / 255) + f * toLinear(y / 255);
+    return Math.floor(255 * toSrgb(l));
+}
+function toLinear(c) {
+    return c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+}
+function toSrgb(l) {
+    return l <= 0.0031308 ? 12.92 * l : 1.055 * l ** (1 / 2.4) - 0.055;
+}
+/** The most texels a radial gradient's texture has a side; a larger region is sampled more coarsely. */
+export const RADIAL_MAX = 512;
+/**
+ * A radial gradient over `region` of the shape, `columns` by `rows` texels,
+ * as premultiplied ARGB: each texel the ramp's entry at its top left
+ * corner, where Flash samples a pixel, so that a texel of an unscaled
+ * shape is its pixel exactly. `m` maps the gradient square to the shape.
+ */
+export function radialPixels(colors, m, focal, spread, region, columns, rows) {
+    const out = new Uint32Array(columns * rows);
+    const f = Math.max(-1, Math.min(1, focal));
+    // The inverse, from the shape to the unit circle (the square is 819.2 a half side).
+    const det = m.a * m.d - m.b * m.c;
+    const ia = m.d / det / 819.2;
+    const ib = -m.b / det / 819.2;
+    const ic = -m.c / det / 819.2;
+    const id = m.a / det / 819.2;
+    for (let j = 0; j < rows; j++) {
+        for (let i = 0; i < columns; i++) {
+            const x = region.x + (i * region.width) / columns - m.tx;
+            const y = region.y + (j * region.height) / rows - m.ty;
+            out[j * columns + i] = colors[index(place(ia * x + ic * y, ib * x + id * y, f), spread)];
+        }
+    }
+    return out;
+}
+/** Where (px, py) lies from the focal point (f, 0) to the unit circle along the ray through it: 0 at the focus, 1 on the circle. */
+function place(px, py, f) {
+    const dx = px - f;
+    const dy = py;
+    const dd = dx * dx + dy * dy;
+    // At a focal point off the centre Flash draws the last stop, as though it
+    // were on the circle; at the centre of one centred, the first. Within
+    // rounding, as the point comes through the matrix's inverse.
+    if (dd < 1e-12) {
+        return f !== 0 ? 1 : 0;
+    }
+    // The ray f + s (p - f) meets the circle where s solves |f + s d|^2 = 1.
+    const fd = f * dx;
+    const s = (-fd + Math.sqrt(fd * fd - dd * (f * f - 1))) / dd;
+    return s > 0 ? 1 / s : 1;
+}
+/** The ramp's entry for place t, spread: 0 pad, 1 reflect, 2 repeat. */
+export function index(t, spread) {
+    const p = Math.floor(t * 256);
+    if (spread === 2) {
+        return ((p % 256) + 256) % 256;
+    }
+    if (spread === 1) {
+        const m = ((p % 512) + 512) % 512;
+        return m < 256 ? m : 511 - m;
+    }
+    return Math.max(0, Math.min(255, p));
+}